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.classifier import ClassDataPreviewer
from Thuban.UI.dock import DockPanel

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)

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

        #panelBox.SetSizeHints(self.parent)

        self.panelBox = panelBox

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

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

    def DoOnSelChanged(self, layer, group = None):
        sel = self.tree.GetSelection()
        self.__EnableButtons(sel.IsOk())

        if sel.IsOk():
            self.mainWindow.SelectLayer(layer)

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

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

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

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

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

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

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.map = None
        self.parent = parent
        self.layer2id = None


        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)

        self.SetMap(map)

    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.__DeleteAllItems()
        
        self.map = map

        if self.map is not None:
            for msg, func in sub_list: self.map.Subscribe(msg, func)
            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)

    def DoOnHideLayer(self):
        self.__ShowHideLayer(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 _OnSelChanged(self, event):
        id = self.GetSelection()
        assert(id.IsOk())

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

        self.parent.DoOnSelChanged(layer, group)

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

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

        id = self.layer2id[layer]

        self.__FillTreeLayer(id)

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

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

    def _OnMsgMapLayersAddedRemoved(self, map):
        assert(id(map) == id(self.map))

        self.__FillTree(self.map)

    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)
                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.layer2id[g] = id

        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):
        self.DeleteAllItems()
        self.layer2id = {}


    def __ShowHideLayer(self, show):
        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)


        if show != item.Visible():

            item.SetVisible(show)

            font = self.GetItemFont(id)
            if show:
                font.SetStyle(wxNORMAL)
                self.SetItemFont(id, font)
            else:
                font.SetStyle(wxITALIC)
                self.SetItemFont(id, font)


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			from Thuban.UI.classifier import ClassDataPreviewer
20	jonathan	562	from Thuban.UI.dock import DockPanel
21	jonathan	542
22			ID_LEGEND_MOVEUP = 4001
23			ID_LEGEND_MOVEDOWN = 4002
24			ID_LEGEND_TREE = 4003
25			ID_LEGEND_CLASSIFY = 4004
26			ID_LEGEND_SHOWLAYER = 4005
27			ID_LEGEND_HIDELAYER = 4006
28
29			BMP_SIZE_W = 30
30			BMP_SIZE_H = 15
31
32	jonathan	562	class LegendPanel(DockPanel):
33
34			def __init__(self, parent, map, mainWindow):
35			DockPanel.__init__(self, parent, -1)
36
37			self.mainWindow = mainWindow
38			self.parent = parent
39
40	jonathan	542	panelBox = wxBoxSizer(wxVERTICAL)
41
42			buttonBox = wxGridSizer(2, 3, 0, 0)
43
44			self.buttons = []
45
46			button = wxButton(self, ID_LEGEND_MOVEUP, _("Move Up"))
47			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
48			self.buttons.append(button)
49
50			button = wxButton(self, ID_LEGEND_SHOWLAYER, _("Show Layer"))
51			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
52			self.buttons.append(button)
53
54			button = wxButton(self, ID_LEGEND_CLASSIFY, _("Classify"))
55			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
56			self.buttons.append(button)
57
58			button = wxButton(self, ID_LEGEND_MOVEDOWN, _("Move Down"))
59			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
60			self.buttons.append(button)
61
62			button = wxButton(self, ID_LEGEND_HIDELAYER, _("Hide Layer"))
63			buttonBox.Add(button, 0, wxGROW \| wxLEFT \| wxRIGHT, 0)
64			self.buttons.append(button)
65
66			EVT_BUTTON(self, ID_LEGEND_MOVEUP, self._OnMoveUp)
67			EVT_BUTTON(self, ID_LEGEND_MOVEDOWN, self._OnMoveDown)
68			EVT_BUTTON(self, ID_LEGEND_CLASSIFY, self._OnClassify)
69			EVT_BUTTON(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
70			EVT_BUTTON(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)
71
72			panelBox.Add(buttonBox, 0, 0, 4)
73
74	jonathan	562	self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
75	jonathan	542
76			panelBox.Add(self.tree, 1, wxGROW, 4)
77
78	jonathan	562	self.SetAutoLayout(True)
79			self.SetSizer(panelBox)
80	jonathan	542	panelBox.SetSizeHints(self)
81
82	jonathan	562	#panelBox.SetSizeHints(self.parent)
83	jonathan	542
84	jonathan	562	self.panelBox = panelBox
85	jonathan	542
86	jonathan	562	def GetMap(self):
87			return self.tree.GetMap()
88
89			def SetMap(self, map):
90			self.tree.SetMap(map)
91
92	jonathan	568	def DoOnSelChanged(self, layer, group = None):
93			sel = self.tree.GetSelection()
94			self.__EnableButtons(sel.IsOk())
95	jonathan	542
96	jonathan	568	if sel.IsOk():
97			self.mainWindow.SelectLayer(layer)
98
99	jonathan	542	def _OnClassify(self, event):
100			self.tree.DoOnClassify()
101
102			def _OnMoveUp(self, event):
103			self.tree.MoveCurrentItemUp()
104
105			def _OnMoveDown(self, event):
106			self.tree.MoveCurrentItemDown()
107
108			def _OnShowLayer(self, event):
109			self.tree.DoOnShowLayer()
110			pass
111
112			def _OnHideLayer(self, event):
113			self.tree.DoOnHideLayer()
114			pass
115
116			def __EnableButtons(self, on):
117			for b in self.buttons:
118			b.Enable(on)
119
120			class LegendTree(wxTreeCtrl):
121
122	jonathan	562	def __init__(self, parent, id, map, mainWindow):
123	jonathan	542	wxTreeCtrl.__init__(self, parent, id,
124			style = wxTR_DEFAULT_STYLE \| wxTR_HIDE_ROOT,
125			size = (200, 200))
126
127	jonathan	562	self.map = None
128	jonathan	542	self.parent = parent
129			self.layer2id = None
130
131
132			self.image_list = None
133			self.emptyImageIndex = 0
134
135			self.previewer = ClassDataPreviewer()
136
137			EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
138			EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
139
140	jonathan	562	self.SetMap(map)
141	jonathan	542
142	jonathan	562	def GetMap(self):
143			return self.map
144	jonathan	542
145	jonathan	562	def SetMap(self, map):
146
147			sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
148			(MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),
149			(MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]
150
151			if self.map is not None:
152			for msg, func in sub_list: self.map.Unsubscribe(msg, func)
153			self.__DeleteAllItems()
154
155			self.map = map
156
157			if self.map is not None:
158			for msg, func in sub_list: self.map.Subscribe(msg, func)
159			self.__FillTree(self.map)
160
161
162	jonathan	542	def MoveCurrentItemUp(self):
163			cur_id = self.GetSelection()
164			assert(cur_id.IsOk())
165
166			cur_data = self.GetPyData(cur_id)
167
168			#prev_id = self.GetPrevSibling(cur_id)
169
170			#
171			# Get out if there's nowhere to go
172			#
173			#if prev_id == INVALID_TREE_ID: return
174
175			if isinstance(cur_data, Layer):
176			self.map.RaiseLayer(cur_data)
177			elif isinstance(cur_data, ClassGroup):
178			pass
179			else:
180			assert(False, "Shouldn't be here.")
181			pass
182
183			def MoveCurrentItemDown(self):
184			cur_id = self.GetSelection()
185			assert(cur_id.IsOk())
186
187			cur_data = self.GetPyData(cur_id)
188
189			if isinstance(cur_data, Layer):
190			self.map.LowerLayer(cur_data)
191			elif isinstance(cur_data, ClassGroup):
192			pass
193			else:
194			assert(False, "Shouldn't be here.")
195			pass
196
197
198			def OnCompareItems(self, item1, item2):
199
200			data1 = self.GetPyData(item1)
201			data2 = self.GetPyData(item2)
202
203			if isinstance(data1, Layer):
204			layers = self.map.Layers()
205			return layers.index(data2) - layers.index(data1)
206			else:
207			return wxTreeCtrl.OnCompareItems(self, item1, item2)
208
209
210			def DoOnShowLayer(self):
211			self.__ShowHideLayer(True)
212
213			def DoOnHideLayer(self):
214			self.__ShowHideLayer(False)
215
216			def DoOnClassify(self):
217			id = self.GetSelection()
218			assert(id.IsOk())
219
220			item = self.GetPyData(id)
221			if isinstance(item, ClassGroup):
222			id = self.GetItemParent(id)
223			assert(id.IsOk())
224			item = self.GetPyData(id)
225
226	jonathan	562	# XXX: THIS IS SUCH AWFUL STYLE! YUCK!
227			self.parent.mainWindow.OpenClassifier(item)
228			#assert(False, "XXX: FIXME HERE")
229	jonathan	542
230			def Sort(self):
231			self.SortChildren(self.GetRootItem())
232
233			def _OnSelChanged(self, event):
234	jonathan	568	id = self.GetSelection()
235			assert(id.IsOk())
236	jonathan	542
237	jonathan	568	group = None
238			layer = self.GetPyData(id)
239			if isinstance(layer, ClassGroup):
240			id = self.GetItemParent(id)
241			assert(id.IsOk())
242			group = layer
243			layer = self.GetPyData(id)
244
245			self.parent.DoOnSelChanged(layer, group)
246
247	jonathan	542	def _OnItemActivated(self, event):
248			self.DoOnClassify()
249
250			def _OnMsgLayerChanged(self, layer):
251			assert(isinstance(layer, Layer))
252
253			id = self.layer2id[layer]
254
255			self.__FillTreeLayer(id)
256
257			def _OnMsgMapStackingChanged(self, *args):
258			self.Sort()
259	jonathan	562	id = self.GetSelection()
260	jonathan	542
261	jonathan	562	if id.IsOk():
262			self.EnsureVisible(id)
263
264			def _OnMsgMapLayersAddedRemoved(self, map):
265	jonathan	542	assert(id(map) == id(self.map))
266
267			self.__FillTree(self.map)
268
269			def __FillTree(self, map):
270
271			assert(isinstance(map, Map))
272
273			self.Freeze()
274
275			self.__DeleteAllItems()
276
277			if map.HasLayers():
278
279			self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
280
281			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
282			dc = wxMemoryDC()
283			dc.SelectObject(bmp)
284			dc.SetBrush(wxBLACK_BRUSH)
285			dc.Clear()
286			dc.SelectObject(wxNullBitmap)
287
288			self.emptyImageIndex = \
289			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
290
291			self.AssignImageList(self.image_list)
292
293			root = self.AddRoot("")
294
295			for l in map.Layers():
296			id = self.PrependItem(root, l.Title())
297			l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
298			self.SetPyData(id, l)
299			font = self.GetItemFont(id)
300			if not l.Visible():
301			font.SetStyle(wxITALIC)
302			self.SetItemFont(id, font)
303
304			self.layer2id[l] = id
305
306			self.__FillTreeLayer(id)
307			self.Expand(id)
308
309			self.Thaw()
310
311			def __FillTreeLayer(self, pid):
312			layer = self.GetPyData(pid)
313
314			self.Freeze()
315
316			self.DeleteChildren(pid)
317
318			clazz = layer.GetClassification()
319
320			shapeType = layer.ShapeType()
321
322			for g in clazz:
323			id = self.AppendItem(pid, g.GetDisplayText())
324			self.SetPyData(id, g)
325
326			bmp = self.__BuildGroupImage(g, shapeType)
327
328			if bmp is None:
329			self.SetItemImage(id, self.emptyImageIndex)
330			else:
331			i = self.image_list.Add(bmp)
332			self.SetItemImage(id, i)
333
334			#self.layer2id[g] = id
335
336			self.Thaw()
337
338			def __BuildGroupImage(self, group, shapeType):
339			assert(isinstance(group, ClassGroup))
340
341			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
342			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
343			dc = wxMemoryDC()
344			dc.SelectObject(bmp)
345			dc.Clear()
346
347			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
348
349			return bmp
350
351			def __DeleteAllItems(self):
352			self.DeleteAllItems()
353			self.layer2id = {}
354
355
356			def __ShowHideLayer(self, show):
357			id = self.GetSelection()
358			assert(id.IsOk())
359
360			item = self.GetPyData(id)
361			if isinstance(item, ClassGroup):
362			id = self.GetItemParent(id)
363			assert(id.IsOk())
364			item = self.GetPyData(id)
365
366
367			if show != item.Visible():
368
369			item.SetVisible(show)
370
371			font = self.GetItemFont(id)
372			if show:
373			font.SetStyle(wxNORMAL)
374			self.SetItemFont(id, font)
375			else:
376			font.SetStyle(wxITALIC)
377			self.SetItemFont(id, font)
378
379
380
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision