Thuban/UI/legend.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

from Thuban import _

from wxPython.wx import *

from Thuban.Model.layer import Layer
from Thuban.Model.map import Map
from Thuban.Model.messages import *
from Thuban.Model.classification import ClassGroup

from Thuban.UI.messages import *
from Thuban.UI.classifier import ClassDataPreviewer
from Thuban.UI.dock import DockPanel

from Thuban.Lib.connector import ConnectorError

ID_LEGEND_MOVEUP = 4001
ID_LEGEND_MOVEDOWN = 4002
ID_LEGEND_TREE = 4003
ID_LEGEND_CLASSIFY = 4004
ID_LEGEND_SHOWLAYER = 4005
ID_LEGEND_HIDELAYER = 4006

BMP_SIZE_W = 30
BMP_SIZE_H = 15

class LegendPanel(DockPanel):

    def __init__(self, parent, map, mainWindow): 
        DockPanel.__init__(self, parent, -1)

        self.mainWindow = mainWindow
        self.parent = parent

        panelBox = wxBoxSizer(wxVERTICAL)

        buttonBox = wxGridSizer(2, 3, 0, 0)

        self.buttons = []

        button = wxButton(self, ID_LEGEND_MOVEUP, _("Move Up"))
        buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)
        self.buttons.append(button)

        button = wxButton(self, ID_LEGEND_SHOWLAYER, _("Show Layer"))
        buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)
        self.buttons.append(button)

        button = wxButton(self, ID_LEGEND_CLASSIFY, _("Classify"))
        buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)
        self.buttons.append(button)

        button = wxButton(self, ID_LEGEND_MOVEDOWN, _("Move Down"))
        buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)
        self.buttons.append(button)

        button = wxButton(self, ID_LEGEND_HIDELAYER, _("Hide Layer"))
        buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)
        self.buttons.append(button)

        EVT_BUTTON(self, ID_LEGEND_MOVEUP, self._OnMoveUp)
        EVT_BUTTON(self, ID_LEGEND_MOVEDOWN, self._OnMoveDown)
        EVT_BUTTON(self, ID_LEGEND_CLASSIFY, self._OnClassify)
        EVT_BUTTON(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
        EVT_BUTTON(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)

        panelBox.Add(buttonBox, 0, 0, 4)

        self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)

        panelBox.Add(self.tree, 1, wxGROW, 4)

        panelBox.Fit(self)

        self.SetAutoLayout(True)
        self.SetSizer(panelBox)
        panelBox.SetSizeHints(self)

        #panelBox.SetSizeHints(self.parent)

        self.panelBox = panelBox

        EVT_CLOSE(self, self._OnClose)


    def GetMap(self):
        return self.tree.GetMap()

    def SetMap(self, map):
        self.tree.SetMap(map)

    def DoOnSelChanged(self, layer, group):

        ok = isinstance(layer, Layer)
        self.__EnableButtons(ok)

        if ok:
            self.mainWindow.SelectLayer(layer)

    def DoOnClassify(self):
        list = self.tree.GetSelectedHierarchy()

        ok = isinstance(list[0], Layer)
        if ok:
            self.mainWindow.OpenClassifier(list[0], list[1])

    def Destroy(self):
        self.__Close()

    def _OnClassify(self, event):
        self.DoOnClassify()

    def _OnMoveUp(self, event): 
        self.tree.MoveCurrentItemUp()

    def _OnMoveDown(self, event):
        self.tree.MoveCurrentItemDown()

    def _OnShowLayer(self, event):
        self.tree.DoOnShowLayer()
        pass

    #def Close(self, force = False):
        #DockPanel.Close(self, force)
        
    def _OnClose(self, event):
        self.__Close()

    def _OnHideLayer(self, event):
        self.tree.DoOnHideLayer()
        pass

    def __EnableButtons(self, on):
        for b in self.buttons:
            b.Enable(on)

    def __Close(self):
        self.tree.Close()

class LegendTree(wxTreeCtrl):

    def __init__(self, parent, id, map, mainWindow):
        wxTreeCtrl.__init__(self, parent, id,
                            style = wxTR_DEFAULT_STYLE | wxTR_HIDE_ROOT,
                            size = (200, 200))

        self.mainWindow = mainWindow
        self.map = None
        self.parent = parent
        self.layer2id = {}

        self.image_list = None
        self.emptyImageIndex = 0

        self.previewer = ClassDataPreviewer()

        EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
        EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)

        EVT_CLOSE(self, self._OnClose)

        self.SetMap(map)

    def _OnClose(self, event):
        self.SetMap(None)

    def GetMap(self):
        return self.map

    def SetMap(self, map):

        sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
                    (MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),
                    (MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]

        if self.map is not None:
            for msg, func in sub_list: self.map.Unsubscribe(msg, func)
            #self.mainWindow.application.Unsubscribe(SESSION_REPLACED, 
                #self._OnMsgMapsChanged)
            #try:
                #self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED, 
                    #self._OnMsgMapsChanged)
            #except ConnectorError:
                #pass
            self.__DeleteAllItems()
        
        self.map = map

        if self.map is not None:
            for msg, func in sub_list: self.map.Subscribe(msg, func)
            #self.mainWindow.application.session.Subscribe(MAPS_CHANGED, 
                #self._OnMsgMapsChanged)
            #self.mainWindow.application.Subscribe(SESSION_REPLACED, 
                #self._OnMsgMapsChanged)
            self.__FillTree(self.map)

            
    def MoveCurrentItemUp(self):
        cur_id = self.GetSelection()
        assert(cur_id.IsOk())

        cur_data = self.GetPyData(cur_id)

        #prev_id = self.GetPrevSibling(cur_id)

        #
        # Get out if there's nowhere to go
        #
        #if prev_id == INVALID_TREE_ID: return

        if isinstance(cur_data, Layer):
            self.map.RaiseLayer(cur_data)
        elif isinstance(cur_data, ClassGroup):
            pass
        else:
            assert(False, "Shouldn't be here.")
            pass

    def MoveCurrentItemDown(self):
        cur_id = self.GetSelection()
        assert(cur_id.IsOk())

        cur_data = self.GetPyData(cur_id)

        if isinstance(cur_data, Layer):
            self.map.LowerLayer(cur_data)
        elif isinstance(cur_data, ClassGroup):
            pass
        else:
            assert(False, "Shouldn't be here.")
            pass


    def OnCompareItems(self, item1, item2):

        data1 = self.GetPyData(item1)
        data2 = self.GetPyData(item2)

        if isinstance(data1, Layer):
            layers = self.map.Layers()
            return layers.index(data2) - layers.index(data1)
        else:
            return wxTreeCtrl.OnCompareItems(self, item1, item2)


    def DoOnShowLayer(self):
        #self.__ShowHideLayer(True)
        layer, group = self.GetSelectedHierarchy()
        layer.SetVisible(True)

    def DoOnHideLayer(self):
        #self.__ShowHideLayer(False)
        layer, group = self.GetSelectedHierarchy()
        layer.SetVisible(False)

#   def DoOnClassify(self):
#       id = self.GetSelection()
#       assert(id.IsOk())

#       item = self.GetPyData(id)
#       if isinstance(item, ClassGroup):
#           id = self.GetItemParent(id)
#           assert(id.IsOk())
#           item = self.GetPyData(id)

#       # XXX: THIS IS SUCH AWFUL STYLE! YUCK!
#       self.parent.mainWindow.OpenClassifier(item)
#       #assert(False, "XXX: FIXME HERE")

    def Sort(self):
        self.SortChildren(self.GetRootItem())

    def _OnMsgMapsChanged(self):
        print "ADfsadfsadfsadfsa"
        print self.map is self.mainWindow.Map()
        self.SetMap(self.mainWindow.Map())
        
    def _OnSelChanged(self, event):

        layer, group = self.GetSelectedHierarchy()
        self.parent.DoOnSelChanged(layer, group)

    def _OnItemActivated(self, event):
        self.parent.DoOnClassify()

    def _OnMsgLayerChanged(self, layer):
        assert(isinstance(layer, Layer))

        id = self.layer2id[layer]
        assert(id.IsOk())

        # XXX: yikes! this is so bad, we should be doing what is 
        #      commented out, but there is a problem with keeping
        #      track of the images in the image list when we replace
        #      a layer. it ends up causing a seg fault.
        self.__FillTree(self.map)
        #self.__FillTreeLayer(id)

    def _OnMsgMapStackingChanged(self, *args):
        self.Sort()
        id = self.GetSelection()

        if id.IsOk():
            self.EnsureVisible(id)

    def _OnMsgMapLayersAddedRemoved(self, map):
        assert(map is self.map)

        self.__FillTree(self.map)

    def _OnMsgLayerVisibilityChanged(self, layer):
        assert(isinstance(layer, Layer))

        self.__ShowHideLayer(layer)

    def GetSelectedHierarchy(self):
        id = self.GetSelection()
        assert(id.IsOk())

        layer = self.GetPyData(id)
        group = None

        if isinstance(layer, ClassGroup):
            id = self.GetItemParent(id)
            assert(id.IsOk())
            group = layer
            layer = self.GetPyData(id)

        return (layer, group)

    def __FillTree(self, map):

        assert(isinstance(map, Map))

        self.Freeze()

        self.__DeleteAllItems()

        if map.HasLayers():

            self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
                                                                                
            bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
            dc = wxMemoryDC()
            dc.SelectObject(bmp)
            dc.SetBrush(wxBLACK_BRUSH)
            dc.Clear()
            dc.SelectObject(wxNullBitmap)
                                                                                
            self.emptyImageIndex = \
                self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
                                                                                
            self.AssignImageList(self.image_list)

            root = self.AddRoot("")

            for l in map.Layers():
                id = self.PrependItem(root, l.Title())
                l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
                l.Subscribe(LAYER_VISIBILITY_CHANGED, 
                            self._OnMsgLayerVisibilityChanged)
                self.SetPyData(id, l)
                font = self.GetItemFont(id)
                if not l.Visible():
                    font.SetStyle(wxITALIC)
                    self.SetItemFont(id, font)

                self.layer2id[l] = id

                self.__FillTreeLayer(id)
                self.Expand(id)

        self.Thaw()

    def __FillTreeLayer(self, pid):
        layer = self.GetPyData(pid)

        self.Freeze()

        self.DeleteChildren(pid)

        clazz = layer.GetClassification()

        shapeType = layer.ShapeType()

        for g in clazz:
            id = self.AppendItem(pid, g.GetDisplayText())
            self.SetPyData(id, g)

            bmp = self.__BuildGroupImage(g, shapeType)

            if bmp is None:
                self.SetItemImage(id, self.emptyImageIndex)
            else:
                i = self.image_list.Add(bmp)
                self.SetItemImage(id, i)

        self.Thaw()

    def __BuildGroupImage(self, group, shapeType):
        assert(isinstance(group, ClassGroup))

        bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
        #brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
        dc = wxMemoryDC()
        dc.SelectObject(bmp)
        dc.Clear()

        self.previewer.Draw(dc, None, group.GetProperties(), shapeType)

        return bmp

    def __DeleteAllItems(self):

        while len(self.layer2id) > 0:
            layer, id = self.layer2id.popitem()
            layer.Unsubscribe(LAYER_CHANGED, 
                              self._OnMsgLayerChanged)
            layer.Unsubscribe(LAYER_VISIBILITY_CHANGED, 
                              self._OnMsgLayerVisibilityChanged)

        self.DeleteAllItems()

    def __ShowHideHelper(self, show, id):
        font = self.GetItemFont(id)

        if show:
            font.SetStyle(wxNORMAL)
            color = wxBLACK
        else:
            font.SetStyle(wxITALIC)
            color = wxLIGHT_GREY

        self.SetItemTextColour(id, color)
        self.SetItemFont(id, font)
        
    def __ShowHideLayer(self, layer):
        parent = self.layer2id[layer]
        assert(parent.IsOk())

        show = layer.Visible()


        self.__ShowHideHelper(show, parent)

        id, cookie = self.GetFirstChild(parent, 123)

        while id.IsOk():
            self.__ShowHideHelper(show, id)
            id, cookie = self.GetNextChild(parent, cookie)
            
1	jonathan	542	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2			# Authors:
3			# Jonathan Coles <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			__version__ = "$Revision$"
9
10			from Thuban import _
11
12			from wxPython.wx import *
13
14			from Thuban.Model.layer import Layer
15			from Thuban.Model.map import Map
16			from Thuban.Model.messages import *
17			from Thuban.Model.classification import ClassGroup
18
19	jonathan	572	from Thuban.UI.messages import *
20	jonathan	542	from Thuban.UI.classifier import ClassDataPreviewer
21	jonathan	562	from Thuban.UI.dock import DockPanel
22	jonathan	542
23	jonathan	572	from Thuban.Lib.connector import ConnectorError
24
25	jonathan	542	ID_LEGEND_MOVEUP = 4001
26			ID_LEGEND_MOVEDOWN = 4002
27			ID_LEGEND_TREE = 4003
28			ID_LEGEND_CLASSIFY = 4004
29			ID_LEGEND_SHOWLAYER = 4005
30			ID_LEGEND_HIDELAYER = 4006
31
32			BMP_SIZE_W = 30
33			BMP_SIZE_H = 15
34
35	jonathan	562	class LegendPanel(DockPanel):
36
37			def __init__(self, parent, map, mainWindow):
38			DockPanel.__init__(self, parent, -1)
39
40			self.mainWindow = mainWindow
41			self.parent = parent
42
43	jonathan	542	panelBox = wxBoxSizer(wxVERTICAL)
44
45			buttonBox = wxGridSizer(2, 3, 0, 0)
46
47			self.buttons = []
48
49			button = wxButton(self, ID_LEGEND_MOVEUP, _("Move Up"))
50			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
51			self.buttons.append(button)
52
53			button = wxButton(self, ID_LEGEND_SHOWLAYER, _("Show Layer"))
54			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
55			self.buttons.append(button)
56
57			button = wxButton(self, ID_LEGEND_CLASSIFY, _("Classify"))
58			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
59			self.buttons.append(button)
60
61			button = wxButton(self, ID_LEGEND_MOVEDOWN, _("Move Down"))
62			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
63			self.buttons.append(button)
64
65			button = wxButton(self, ID_LEGEND_HIDELAYER, _("Hide Layer"))
66			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
67			self.buttons.append(button)
68
69			EVT_BUTTON(self, ID_LEGEND_MOVEUP, self._OnMoveUp)
70			EVT_BUTTON(self, ID_LEGEND_MOVEDOWN, self._OnMoveDown)
71			EVT_BUTTON(self, ID_LEGEND_CLASSIFY, self._OnClassify)
72			EVT_BUTTON(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
73			EVT_BUTTON(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)
74
75			panelBox.Add(buttonBox, 0, 0, 4)
76
77	jonathan	562	self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
78	jonathan	542
79			panelBox.Add(self.tree, 1, wxGROW, 4)
80
81	jonathan	572	panelBox.Fit(self)
82
83	jonathan	562	self.SetAutoLayout(True)
84			self.SetSizer(panelBox)
85	jonathan	542	panelBox.SetSizeHints(self)
86
87	jonathan	562	#panelBox.SetSizeHints(self.parent)
88	jonathan	542
89	jonathan	562	self.panelBox = panelBox
90	jonathan	542
91	jonathan	572	EVT_CLOSE(self, self._OnClose)
92
93
94	jonathan	562	def GetMap(self):
95			return self.tree.GetMap()
96
97			def SetMap(self, map):
98			self.tree.SetMap(map)
99
100	jonathan	572	def DoOnSelChanged(self, layer, group):
101	jonathan	542
102	jonathan	572	ok = isinstance(layer, Layer)
103			self.__EnableButtons(ok)
104
105			if ok:
106	jonathan	568	self.mainWindow.SelectLayer(layer)
107
108	jonathan	572	def DoOnClassify(self):
109			list = self.tree.GetSelectedHierarchy()
110
111			ok = isinstance(list[0], Layer)
112			if ok:
113			self.mainWindow.OpenClassifier(list[0], list[1])
114
115	jonathan	578	def Destroy(self):
116			self.__Close()
117
118	jonathan	542	def _OnClassify(self, event):
119	jonathan	572	self.DoOnClassify()
120	jonathan	542
121			def _OnMoveUp(self, event):
122			self.tree.MoveCurrentItemUp()
123
124			def _OnMoveDown(self, event):
125			self.tree.MoveCurrentItemDown()
126
127			def _OnShowLayer(self, event):
128			self.tree.DoOnShowLayer()
129			pass
130
131	jonathan	578	#def Close(self, force = False):
132			#DockPanel.Close(self, force)
133
134	jonathan	572	def _OnClose(self, event):
135	jonathan	578	self.__Close()
136	jonathan	572
137	jonathan	542	def _OnHideLayer(self, event):
138			self.tree.DoOnHideLayer()
139			pass
140
141			def __EnableButtons(self, on):
142			for b in self.buttons:
143			b.Enable(on)
144
145	jonathan	578	def __Close(self):
146			self.tree.Close()
147
148	jonathan	542	class LegendTree(wxTreeCtrl):
149
150	jonathan	562	def __init__(self, parent, id, map, mainWindow):
151	jonathan	542	wxTreeCtrl.__init__(self, parent, id,
152			style = wxTR_DEFAULT_STYLE \| wxTR_HIDE_ROOT,
153			size = (200, 200))
154
155	jonathan	572	self.mainWindow = mainWindow
156	jonathan	562	self.map = None
157	jonathan	542	self.parent = parent
158	jonathan	572	self.layer2id = {}
159	jonathan	542
160			self.image_list = None
161			self.emptyImageIndex = 0
162
163			self.previewer = ClassDataPreviewer()
164
165			EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
166			EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
167
168	jonathan	572	EVT_CLOSE(self, self._OnClose)
169
170	jonathan	562	self.SetMap(map)
171	jonathan	542
172	jonathan	572	def _OnClose(self, event):
173			self.SetMap(None)
174
175	jonathan	562	def GetMap(self):
176			return self.map
177	jonathan	542
178	jonathan	562	def SetMap(self, map):
179
180			sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
181			(MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),
182			(MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]
183
184			if self.map is not None:
185			for msg, func in sub_list: self.map.Unsubscribe(msg, func)
186	jonathan	572	#self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
187			#self._OnMsgMapsChanged)
188			#try:
189			#self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
190			#self._OnMsgMapsChanged)
191			#except ConnectorError:
192			#pass
193	jonathan	562	self.__DeleteAllItems()
194
195			self.map = map
196
197			if self.map is not None:
198			for msg, func in sub_list: self.map.Subscribe(msg, func)
199	jonathan	572	#self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
200			#self._OnMsgMapsChanged)
201			#self.mainWindow.application.Subscribe(SESSION_REPLACED,
202			#self._OnMsgMapsChanged)
203	jonathan	562	self.__FillTree(self.map)
204
205
206	jonathan	542	def MoveCurrentItemUp(self):
207			cur_id = self.GetSelection()
208			assert(cur_id.IsOk())
209
210			cur_data = self.GetPyData(cur_id)
211
212			#prev_id = self.GetPrevSibling(cur_id)
213
214			#
215			# Get out if there's nowhere to go
216			#
217			#if prev_id == INVALID_TREE_ID: return
218
219			if isinstance(cur_data, Layer):
220			self.map.RaiseLayer(cur_data)
221			elif isinstance(cur_data, ClassGroup):
222			pass
223			else:
224			assert(False, "Shouldn't be here.")
225			pass
226
227			def MoveCurrentItemDown(self):
228			cur_id = self.GetSelection()
229			assert(cur_id.IsOk())
230
231			cur_data = self.GetPyData(cur_id)
232
233			if isinstance(cur_data, Layer):
234			self.map.LowerLayer(cur_data)
235			elif isinstance(cur_data, ClassGroup):
236			pass
237			else:
238			assert(False, "Shouldn't be here.")
239			pass
240
241
242			def OnCompareItems(self, item1, item2):
243
244			data1 = self.GetPyData(item1)
245			data2 = self.GetPyData(item2)
246
247			if isinstance(data1, Layer):
248			layers = self.map.Layers()
249			return layers.index(data2) - layers.index(data1)
250			else:
251			return wxTreeCtrl.OnCompareItems(self, item1, item2)
252
253
254			def DoOnShowLayer(self):
255	jonathan	572	#self.__ShowHideLayer(True)
256			layer, group = self.GetSelectedHierarchy()
257			layer.SetVisible(True)
258	jonathan	542
259			def DoOnHideLayer(self):
260	jonathan	572	#self.__ShowHideLayer(False)
261			layer, group = self.GetSelectedHierarchy()
262			layer.SetVisible(False)
263	jonathan	542
264	jonathan	572	# def DoOnClassify(self):
265			# id = self.GetSelection()
266			# assert(id.IsOk())
267	jonathan	542
268	jonathan	572	# item = self.GetPyData(id)
269			# if isinstance(item, ClassGroup):
270			# id = self.GetItemParent(id)
271			# assert(id.IsOk())
272			# item = self.GetPyData(id)
273	jonathan	542
274	jonathan	572	# # XXX: THIS IS SUCH AWFUL STYLE! YUCK!
275			# self.parent.mainWindow.OpenClassifier(item)
276			# #assert(False, "XXX: FIXME HERE")
277	jonathan	542
278			def Sort(self):
279			self.SortChildren(self.GetRootItem())
280
281	jonathan	572	def _OnMsgMapsChanged(self):
282			print "ADfsadfsadfsadfsa"
283			print self.map is self.mainWindow.Map()
284			self.SetMap(self.mainWindow.Map())
285
286	jonathan	542	def _OnSelChanged(self, event):
287
288	jonathan	572	layer, group = self.GetSelectedHierarchy()
289	jonathan	568	self.parent.DoOnSelChanged(layer, group)
290
291	jonathan	542	def _OnItemActivated(self, event):
292	jonathan	572	self.parent.DoOnClassify()
293	jonathan	542
294			def _OnMsgLayerChanged(self, layer):
295			assert(isinstance(layer, Layer))
296
297			id = self.layer2id[layer]
298	jonathan	578	assert(id.IsOk())
299	jonathan	542
300	jonathan	578	# XXX: yikes! this is so bad, we should be doing what is
301			# commented out, but there is a problem with keeping
302			# track of the images in the image list when we replace
303			# a layer. it ends up causing a seg fault.
304			self.__FillTree(self.map)
305			#self.__FillTreeLayer(id)
306	jonathan	542
307			def _OnMsgMapStackingChanged(self, *args):
308			self.Sort()
309	jonathan	562	id = self.GetSelection()
310	jonathan	542
311	jonathan	562	if id.IsOk():
312			self.EnsureVisible(id)
313
314			def _OnMsgMapLayersAddedRemoved(self, map):
315	jonathan	572	assert(map is self.map)
316	jonathan	542
317			self.__FillTree(self.map)
318
319	jonathan	572	def _OnMsgLayerVisibilityChanged(self, layer):
320			assert(isinstance(layer, Layer))
321
322			self.__ShowHideLayer(layer)
323
324			def GetSelectedHierarchy(self):
325			id = self.GetSelection()
326			assert(id.IsOk())
327
328			layer = self.GetPyData(id)
329			group = None
330
331			if isinstance(layer, ClassGroup):
332			id = self.GetItemParent(id)
333			assert(id.IsOk())
334			group = layer
335			layer = self.GetPyData(id)
336
337			return (layer, group)
338
339	jonathan	542	def __FillTree(self, map):
340
341			assert(isinstance(map, Map))
342
343			self.Freeze()
344
345			self.__DeleteAllItems()
346
347			if map.HasLayers():
348
349			self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
350
351			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
352			dc = wxMemoryDC()
353			dc.SelectObject(bmp)
354			dc.SetBrush(wxBLACK_BRUSH)
355			dc.Clear()
356			dc.SelectObject(wxNullBitmap)
357
358			self.emptyImageIndex = \
359			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
360
361			self.AssignImageList(self.image_list)
362
363			root = self.AddRoot("")
364
365			for l in map.Layers():
366			id = self.PrependItem(root, l.Title())
367			l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
368	jonathan	572	l.Subscribe(LAYER_VISIBILITY_CHANGED,
369			self._OnMsgLayerVisibilityChanged)
370	jonathan	542	self.SetPyData(id, l)
371			font = self.GetItemFont(id)
372			if not l.Visible():
373			font.SetStyle(wxITALIC)
374			self.SetItemFont(id, font)
375
376			self.layer2id[l] = id
377
378			self.__FillTreeLayer(id)
379			self.Expand(id)
380
381			self.Thaw()
382
383			def __FillTreeLayer(self, pid):
384			layer = self.GetPyData(pid)
385
386			self.Freeze()
387
388			self.DeleteChildren(pid)
389
390			clazz = layer.GetClassification()
391
392			shapeType = layer.ShapeType()
393
394			for g in clazz:
395			id = self.AppendItem(pid, g.GetDisplayText())
396			self.SetPyData(id, g)
397
398			bmp = self.__BuildGroupImage(g, shapeType)
399
400			if bmp is None:
401			self.SetItemImage(id, self.emptyImageIndex)
402			else:
403			i = self.image_list.Add(bmp)
404			self.SetItemImage(id, i)
405
406			self.Thaw()
407
408			def __BuildGroupImage(self, group, shapeType):
409			assert(isinstance(group, ClassGroup))
410
411			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
412			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
413			dc = wxMemoryDC()
414			dc.SelectObject(bmp)
415			dc.Clear()
416
417			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
418
419			return bmp
420
421			def __DeleteAllItems(self):
422
423	jonathan	572	while len(self.layer2id) > 0:
424			layer, id = self.layer2id.popitem()
425			layer.Unsubscribe(LAYER_CHANGED,
426			self._OnMsgLayerChanged)
427			layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
428			self._OnMsgLayerVisibilityChanged)
429	jonathan	542
430	jonathan	578	self.DeleteAllItems()
431
432	jonathan	572	def __ShowHideHelper(self, show, id):
433			font = self.GetItemFont(id)
434	jonathan	542
435	jonathan	572	if show:
436			font.SetStyle(wxNORMAL)
437			color = wxBLACK
438			else:
439			font.SetStyle(wxITALIC)
440			color = wxLIGHT_GREY
441	jonathan	542
442	jonathan	572	self.SetItemTextColour(id, color)
443			self.SetItemFont(id, font)
444
445			def __ShowHideLayer(self, layer):
446			parent = self.layer2id[layer]
447			assert(parent.IsOk())
448	jonathan	542
449	jonathan	572	show = layer.Visible()
450	jonathan	542
451
452	jonathan	572	self.__ShowHideHelper(show, parent)
453	jonathan	542
454	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
455	jonathan	542
456	jonathan	572	while id.IsOk():
457			self.__ShowHideHelper(show, id)
458			id, cookie = self.GetNextChild(parent, cookie)
459
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision