Thuban/UI/projlist.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""List control for projections"""

__version__ = "$Revision$"
# $Source$
# $Id$

from wxPython.wx import *

from Thuban import _

from Thuban.Lib.connector import Publisher

from Thuban.Model.messages import PROJECTION_ADDED, PROJECTION_REMOVED, \
     PROJECTION_REPLACED


PROJ_SELECTION_CHANGED = "PROJ_SELECTION_CHANGED"


class ProjectionList(wxListCtrl, Publisher):

    """A ListCtrl that shows a list of projections

    The list control is effectively a view on two ProjFile instances and
    a specific 'original' projection (e.g. the projection of the current
    map). The list control subscribes to the change messages of the
    ProjFile instances to update the list whenever they change.

    When the selection changes the instance sends a
    PROJ_SELECTION_CHANGED message.
    """

    def __init__(self, parent, system_projs, user_projs, orig_proj, ID = -1):
        """Initialize the ProjectionList

        Parameters:

        parent -- The parent widget
        system_projs, user_projs -- the system and user ProjFiles
        orig_proj -- The projection originally selected in the map/layer
        """
        wxListCtrl.__init__(self, parent, ID, style=wxLC_REPORT|wxLC_VIRTUAL)

        self.InsertColumn(0, _("Available Projections"))
        self.system_projs = system_projs
        self.user_projs = user_projs
        self.orig_proj = orig_proj
        self.projections = []
        self.proj_map = {}
        self.needs_update = False
        self.update_projections()
        EVT_SIZE(self, self.OnSize)
        EVT_LEFT_UP(self, self.mouse_left_up)
        EVT_LIST_ITEM_SELECTED(self, self.GetId(), self.item_selected)
        EVT_LIST_ITEM_DESELECTED(self, self.GetId(), self.item_deselected)
        EVT_IDLE(self, self.OnIdle)
        for pf in (self.system_projs, self.user_projs):
            pf.Subscribe(PROJECTION_ADDED, self.pf_projection_added)
            pf.Subscribe(PROJECTION_REMOVED, self.pf_projection_removed)
            pf.Subscribe(PROJECTION_REPLACED, self.pf_projection_replaced)

    def __del__(self):
        wxListCtrl.__del__()
        Publisher.__del__()

    def Destroy(self):
        wxListCtrl.Destroy()
        Publisher.Destroy()

    def update_on_idle(self):
        self.needs_update = True

    def OnIdle(self, evt):
        if self.needs_update:
            self.needs_update = False
            self.update_projections()
        evt.Skip()

    def update_projections(self):
        """Update the internal list of projection information"""

        # Remember which projections are selected so that we can select
        # them again after the update
        selection = {}
        for p in self.selected_projections():
            selection[id(p[0])] = 1
        old_length = len(self.projections)

        # Build the new projection list
        projections = [(_("<None>"), None, None)]
        for pf in (self.user_projs, self.system_projs):
            for p in pf.GetProjections():
                projections.append((p.Label(), p, pf))
        if self.orig_proj is not None:
            projections.append((_("%s (current)") % self.orig_proj.Label(),
                                self.orig_proj, None))
        self.projections = projections
        self.projections.sort()

        # Deselect all items with indices higher than the new length
        # before settign the new item count This is a work-around for a
        # bug in the listctrl which doesn't updat the selection count
        # correctly in a call to SetItemCount if items have been
        # selected with indices higher than the new count.
        if len(self.projections) < old_length:
            for i in xrange(len(self.projections), old_length):
                self.SetItemState(i, 0, wxLIST_STATE_SELECTED)

        self.SetItemCount(len(self.projections))

        # Reselect the projections that had been selected before.
        get = selection.get
        count = 0
        for i in xrange(len(self.projections)):
            p = self.projections[i][1]
            if get(id(p)):
                state = wxLIST_STATE_SELECTED
                count += 1
            else:
                state = 0
            self.SetItemState(i, state, wxLIST_STATE_SELECTED)

        # If the selection changed send a PROJ_SELECTION_CHANGED message
        if count != len(selection):
            self._issue_proj_selection_changed()

    def pf_projection_added(self, proj):
        """Subscribed to the projfile's PROJECTION_ADDED messages

        Request an update the projection list in idle time.
        """
        self.update_on_idle()

    def pf_projection_removed(self, proj):
        """Subscribed to the projfile's PROJECTION_REMOVED messages

        Request an update the projection list in idle time.
        """
        self.update_on_idle()

    def pf_projection_replaced(self, old, new):
        """Subscribed to the projfile's PROJECTION_REPLACED messages

        Request an update the projection list in idle time.
        """
        self.update_on_idle()

    def OnSize(self, evt):
        self.SetColumnWidth(0, evt.GetSize().width)
        evt.Skip()

    def SelectProjection(self, proj):
        """Select the projection and deselect all others."""
        for i in range(len(self.projections)):
            p = self.projections[i][1]
            self.SetItemState(i, p is proj and wxLIST_STATE_SELECTED or 0,
                              wxLIST_STATE_SELECTED)

    def ClearSelection(self):
        """Deselect all projections."""
        for i in range(len(self.projections)):
            self.SetItemState(i, 0, wxLIST_STATE_SELECTED)

    def OnGetItemText(self, item, col):
        """Callback for the virtual ListCtrl mode"""
        return self.projections[item][0]

    def OnGetItemAttr(self, item):
        """Callback for the virtual ListCtrl mode"""
        return None

    def OnGetItemImage(self, item):
        """Callback for the virtual ListCtrl mode"""
        return -1

    def selected_projections(self):
        """Return a list with all selected projection infos

        The return value is a list of (proj, proj_file) pairs. proj_file
        is the projection file object the projection was read from, if
        any. Both proj and proj_file may be None, but if proj_file is
        not None proj will also not be None.
        """
        return [self.projections[i][1:]
                    for i in range(len(self.projections))
                        if self.GetItemState(i, wxLIST_STATE_SELECTED)]

    def _issue_proj_selection_changed(self):
        """Internal: Issue a PROJ_SELECTION_CHANGED message"""
        self.issue(PROJ_SELECTION_CHANGED, self.selected_projections())

    def item_selected(self, evt):
        """Handler for EVT_LIST_ITEM_SELECTED"""
        self._issue_proj_selection_changed()

    def item_deselected(self, evt):
        #"""Handler for EVT_LIST_ITEM_DESELECTED"""
        self._issue_proj_selection_changed()

    def mouse_left_up(self, evt):
        """Handle EVT_LEFT_UP events. Issue a selection message.

        It's not clear whether the selection really has changed but the
        selection events send by the list ctrl don't cover selecting
        ranges of items :(.
        """
        self._issue_proj_selection_changed()
1	# Copyright (C) 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with the software for details.
7
8	"""List control for projections"""
9
10	__version__ = "$Revision$"
11	# $Source$
12	# $Id$
13
14	from wxPython.wx import *
15
16	from Thuban import _
17
18	from Thuban.Lib.connector import Publisher
19
20	from Thuban.Model.messages import PROJECTION_ADDED, PROJECTION_REMOVED, \
21	PROJECTION_REPLACED
22
23
24	PROJ_SELECTION_CHANGED = "PROJ_SELECTION_CHANGED"
25
26
27	class ProjectionList(wxListCtrl, Publisher):
28
29	"""A ListCtrl that shows a list of projections
30
31	The list control is effectively a view on two ProjFile instances and
32	a specific 'original' projection (e.g. the projection of the current
33	map). The list control subscribes to the change messages of the
34	ProjFile instances to update the list whenever they change.
35
36	When the selection changes the instance sends a
37	PROJ_SELECTION_CHANGED message.
38	"""
39
40	def __init__(self, parent, system_projs, user_projs, orig_proj, ID = -1):
41	"""Initialize the ProjectionList
42
43	Parameters:
44
45	parent -- The parent widget
46	system_projs, user_projs -- the system and user ProjFiles
47	orig_proj -- The projection originally selected in the map/layer
48	"""
49	wxListCtrl.__init__(self, parent, ID, style=wxLC_REPORT\|wxLC_VIRTUAL)
50
51	self.InsertColumn(0, _("Available Projections"))
52	self.system_projs = system_projs
53	self.user_projs = user_projs
54	self.orig_proj = orig_proj
55	self.projections = []
56	self.proj_map = {}
57	self.needs_update = False
58	self.update_projections()
59	EVT_SIZE(self, self.OnSize)
60	EVT_LEFT_UP(self, self.mouse_left_up)
61	EVT_LIST_ITEM_SELECTED(self, self.GetId(), self.item_selected)
62	EVT_LIST_ITEM_DESELECTED(self, self.GetId(), self.item_deselected)
63	EVT_IDLE(self, self.OnIdle)
64	for pf in (self.system_projs, self.user_projs):
65	pf.Subscribe(PROJECTION_ADDED, self.pf_projection_added)
66	pf.Subscribe(PROJECTION_REMOVED, self.pf_projection_removed)
67	pf.Subscribe(PROJECTION_REPLACED, self.pf_projection_replaced)
68
69	def __del__(self):
70	wxListCtrl.__del__()
71	Publisher.__del__()
72
73	def Destroy(self):
74	wxListCtrl.Destroy()
75	Publisher.Destroy()
76
77	def update_on_idle(self):
78	self.needs_update = True
79
80	def OnIdle(self, evt):
81	if self.needs_update:
82	self.needs_update = False
83	self.update_projections()
84	evt.Skip()
85
86	def update_projections(self):
87	"""Update the internal list of projection information"""
88
89	# Remember which projections are selected so that we can select
90	# them again after the update
91	selection = {}
92	for p in self.selected_projections():
93	selection[id(p[0])] = 1
94	old_length = len(self.projections)
95
96	# Build the new projection list
97	projections = [(_("<None>"), None, None)]
98	for pf in (self.user_projs, self.system_projs):
99	for p in pf.GetProjections():
100	projections.append((p.Label(), p, pf))
101	if self.orig_proj is not None:
102	projections.append((_("%s (current)") % self.orig_proj.Label(),
103	self.orig_proj, None))
104	self.projections = projections
105	self.projections.sort()
106
107	# Deselect all items with indices higher than the new length
108	# before settign the new item count This is a work-around for a
109	# bug in the listctrl which doesn't updat the selection count
110	# correctly in a call to SetItemCount if items have been
111	# selected with indices higher than the new count.
112	if len(self.projections) < old_length:
113	for i in xrange(len(self.projections), old_length):
114	self.SetItemState(i, 0, wxLIST_STATE_SELECTED)
115
116	self.SetItemCount(len(self.projections))
117
118	# Reselect the projections that had been selected before.
119	get = selection.get
120	count = 0
121	for i in xrange(len(self.projections)):
122	p = self.projections[i][1]
123	if get(id(p)):
124	state = wxLIST_STATE_SELECTED
125	count += 1
126	else:
127	state = 0
128	self.SetItemState(i, state, wxLIST_STATE_SELECTED)
129
130	# If the selection changed send a PROJ_SELECTION_CHANGED message
131	if count != len(selection):
132	self._issue_proj_selection_changed()
133
134	def pf_projection_added(self, proj):
135	"""Subscribed to the projfile's PROJECTION_ADDED messages
136
137	Request an update the projection list in idle time.
138	"""
139	self.update_on_idle()
140
141	def pf_projection_removed(self, proj):
142	"""Subscribed to the projfile's PROJECTION_REMOVED messages
143
144	Request an update the projection list in idle time.
145	"""
146	self.update_on_idle()
147
148	def pf_projection_replaced(self, old, new):
149	"""Subscribed to the projfile's PROJECTION_REPLACED messages
150
151	Request an update the projection list in idle time.
152	"""
153	self.update_on_idle()
154
155	def OnSize(self, evt):
156	self.SetColumnWidth(0, evt.GetSize().width)
157	evt.Skip()
158
159	def SelectProjection(self, proj):
160	"""Select the projection and deselect all others."""
161	for i in range(len(self.projections)):
162	p = self.projections[i][1]
163	self.SetItemState(i, p is proj and wxLIST_STATE_SELECTED or 0,
164	wxLIST_STATE_SELECTED)
165
166	def ClearSelection(self):
167	"""Deselect all projections."""
168	for i in range(len(self.projections)):
169	self.SetItemState(i, 0, wxLIST_STATE_SELECTED)
170
171	def OnGetItemText(self, item, col):
172	"""Callback for the virtual ListCtrl mode"""
173	return self.projections[item][0]
174
175	def OnGetItemAttr(self, item):
176	"""Callback for the virtual ListCtrl mode"""
177	return None
178
179	def OnGetItemImage(self, item):
180	"""Callback for the virtual ListCtrl mode"""
181	return -1
182
183	def selected_projections(self):
184	"""Return a list with all selected projection infos
185
186	The return value is a list of (proj, proj_file) pairs. proj_file
187	is the projection file object the projection was read from, if
188	any. Both proj and proj_file may be None, but if proj_file is
189	not None proj will also not be None.
190	"""
191	return [self.projections[i][1:]
192	for i in range(len(self.projections))
193	if self.GetItemState(i, wxLIST_STATE_SELECTED)]
194
195	def _issue_proj_selection_changed(self):
196	"""Internal: Issue a PROJ_SELECTION_CHANGED message"""
197	self.issue(PROJ_SELECTION_CHANGED, self.selected_projections())
198
199	def item_selected(self, evt):
200	"""Handler for EVT_LIST_ITEM_SELECTED"""
201	self._issue_proj_selection_changed()
202
203	def item_deselected(self, evt):
204	#"""Handler for EVT_LIST_ITEM_DESELECTED"""
205	self._issue_proj_selection_changed()
206
207	def mouse_left_up(self, evt):
208	"""Handle EVT_LEFT_UP events. Issue a selection message.
209
210	It's not clear whether the selection really has changed but the
211	selection events send by the list ctrl don't cover selecting
212	ranges of items :(.
213	"""
214	self._issue_proj_selection_changed()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision