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 _

import resource

from wxPython.wx import *

from Thuban.Model.layer import Layer
from Thuban.Model.map import Map
from Thuban.Model.scalebar import ScaleBar
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_RAISE = 4001
ID_LEGEND_LOWER = 4002
ID_LEGEND_TREE = 4003
ID_LEGEND_PROPS = 4004
ID_LEGEND_SHOWLAYER = 4005
ID_LEGEND_HIDELAYER = 4006

BMP_SIZE_W = 30
BMP_SIZE_H = 15

RAISE_BMP = "raise_layer"
LOWER_BMP = "lower_layer"
SHOW_BMP  = "show_layer"
HIDE_BMP  = "hide_layer"
PROPS_BMP = "layer_properties"


class LegendPanel(DockPanel):

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

        self.mainWindow = mainWindow
        self.parent = parent

        self.buttons = []

        panelBox = wxBoxSizer(wxVERTICAL)

        self.toolBar = wxToolBar(self, -1)
        self.toolBar.SetToolBitmapSize(wxSize(24, 24))

        bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_RAISE, bmp, 
            shortHelpString=_("Raise Layer"))

        bmp = resource.GetBitmapResource(LOWER_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_LOWER, bmp, 
            shortHelpString=_("Lower Layer"))

        bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp, 
            shortHelpString=_("Show Layer"))

        bmp = resource.GetBitmapResource(HIDE_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_HIDELAYER, bmp, 
            shortHelpString=_("Hide Layer"))

        bmp = resource.GetBitmapResource(PROPS_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_PROPS, bmp, 
            shortHelpString=_("Edit Layer Properties"))

        self.toolBar.Realize()
        panelBox.Add(self.toolBar, 0, wxGROW, 0)

        EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
        EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
        EVT_TOOL(self, ID_LEGEND_PROPS, self._OnProperties)
        EVT_TOOL(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
        EVT_TOOL(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)

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

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

        self.scalebarbitmap = ScaleBarBitmap(self, map, mainWindow) 
        panelBox.Add(self.scalebarbitmap, 0, wxGROW, 0)

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


        self.panelBox = panelBox

        self.__EnableButtons(False)

        self.Create()

        EVT_CLOSE(self, self._OnClose)


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

    def SetMap(self, map):
        self.tree.SetMap(map)
        self.scalebarbitmap.SetCanvas(self.mainWindow.canvas)

    def DoOnSelChanged(self, layer, group):

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

        self.mainWindow.SelectLayer(layer)

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

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

    def Destroy(self):
        self.__Close()

    def _OnProperties(self, event):
        self.DoOnProperties()

    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):
        self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
        self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
        self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER,  on)
        self.toolBar.EnableTool(ID_LEGEND_HIDELAYER,  on)
        self.toolBar.EnableTool(ID_LEGEND_PROPS, 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):
        layer, group = self.GetSelectedHierarchy()

        if layer is not None:
            self.map.RaiseLayer(layer)
        else:
            assert False, "Shouldn't be allowed."
            pass

    def MoveCurrentItemDown(self):
        layer, group = self.GetSelectedHierarchy()

        if layer is not None:
            self.map.LowerLayer(layer)
        else:
            assert False, "Shouldn't be allowed."
            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 Sort(self):
        self.SortChildren(self.GetRootItem())

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

        if not id.IsOk():
            return (None, None)

        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 _OnMsgMapsChanged(self):
        #print self.map is self.mainWindow.Map()
        self.SetMap(self.mainWindow.Map())
        
    def _OnSelChanged(self, event):
        self.__UpdateSelection()

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

    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.__UpdateSelection()
        #self.__FillTreeLayer(id)

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

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

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

        self.__FillTree(self.map)
        self.__UpdateSelection()

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

        self.__ShowHideLayer(layer)
        self.__UpdateSelection()

    def _OnMsgLayerTitleChanged(self, layer):

        id = self.layer2id[layer]
        if id.IsOk():
            self.SetItemText(id, layer.Title())
        self.__UpdateSelection()

    def __UpdateSelection(self):
        layer, group = self.GetSelectedHierarchy()
        self.parent.DoOnSelChanged(layer, group)
        
    def __FillTree(self, 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)
                l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
                self.SetPyData(id, l)
                self.__SetVisibilityStyle(l.Visible(), id)

                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()

        show = layer.Visible()
        for g in clazz:
            if g.IsVisible():
                id = self.AppendItem(pid, g.GetDisplayText())
                self.SetPyData(id, g)
                self.__SetVisibilityStyle(show, id)

                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):

        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)
            layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)

        self.DeleteAllItems()

    def __SetVisibilityStyle(self, visible, id):
        font = self.GetItemFont(id)

        if visible:
            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()

        visible = layer.Visible()

        self.__SetVisibilityStyle(visible, parent)

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

        while id.IsOk():
            self.__SetVisibilityStyle(visible, id)
            id, cookie = self.GetNextChild(parent, cookie)
            
class ScaleBarBitmap(wxBoxSizer):

    def __init__(self, parent, map, mainWindow):
        # While the width is fixed, get the height _now_.
        dc = wxMemoryDC()
        textwidth, textheight = dc.GetTextExtent("%d"%0)
        self.width = 200
        self.height = textheight + 3*2 + 8

        wxBoxSizer.__init__(self, wxVERTICAL)
        bmp=wxEmptyBitmap(self.width, self.height)
        self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
        self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER|wxLEFT|wxTOP|wxRIGHT, 1)

        self.mainWindow = mainWindow
        self.parent = parent
        self.canvas = None
        self.scalebar = ScaleBar(map)
        self.SetCanvas(self.mainWindow.canvas)

    def SetCanvas(self, canvas):
        sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]

        if self.canvas is not None:
            for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
        
        self.canvas = canvas

        if self.canvas is not None:
            for msg, func in sub_list: self.canvas.Subscribe(msg, func)
            self.__SetScale(self.canvas.scale)

    def _OnMsgScaleChanged(self, scale):
        self.__SetScale(scale)

    def __SetScale(self, scale):
        bmp = wxEmptyBitmap(self.width, self.height)
        dc = wxMemoryDC()
        dc.SelectObject(bmp)
        dc.Clear()

        self.scalebar.DrawScalebar(scale, dc)

        self.scalebarBitmap.SetBitmap(bmp)

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	jonathan	652	import resource
13
14	jonathan	542	from wxPython.wx import *
15
16			from Thuban.Model.layer import Layer
17			from Thuban.Model.map import Map
18	frank	854	from Thuban.Model.scalebar import ScaleBar
19	jonathan	542	from Thuban.Model.messages import *
20			from Thuban.Model.classification import ClassGroup
21
22	jonathan	572	from Thuban.UI.messages import *
23	jonathan	542	from Thuban.UI.classifier import ClassDataPreviewer
24	jonathan	562	from Thuban.UI.dock import DockPanel
25	jonathan	542
26	jonathan	572	from Thuban.Lib.connector import ConnectorError
27
28	jonathan	652	ID_LEGEND_RAISE = 4001
29			ID_LEGEND_LOWER = 4002
30	jonathan	542	ID_LEGEND_TREE = 4003
31	jonathan	639	ID_LEGEND_PROPS = 4004
32	jonathan	542	ID_LEGEND_SHOWLAYER = 4005
33			ID_LEGEND_HIDELAYER = 4006
34
35			BMP_SIZE_W = 30
36			BMP_SIZE_H = 15
37
38	jonathan	652	RAISE_BMP = "raise_layer"
39			LOWER_BMP = "lower_layer"
40			SHOW_BMP = "show_layer"
41			HIDE_BMP = "hide_layer"
42			PROPS_BMP = "layer_properties"
43
44
45	jonathan	562	class LegendPanel(DockPanel):
46
47			def __init__(self, parent, map, mainWindow):
48			DockPanel.__init__(self, parent, -1)
49
50			self.mainWindow = mainWindow
51			self.parent = parent
52
53	jonathan	652	self.buttons = []
54
55	jonathan	542	panelBox = wxBoxSizer(wxVERTICAL)
56
57	jonathan	652	self.toolBar = wxToolBar(self, -1)
58	jonathan	658	self.toolBar.SetToolBitmapSize(wxSize(24, 24))
59	jonathan	542
60	jonathan	652	bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)
61			self.toolBar.AddTool(ID_LEGEND_RAISE, bmp,
62			shortHelpString=_("Raise Layer"))
63	jonathan	542
64	jonathan	652	bmp = resource.GetBitmapResource(LOWER_BMP, wxBITMAP_TYPE_XPM)
65			self.toolBar.AddTool(ID_LEGEND_LOWER, bmp,
66			shortHelpString=_("Lower Layer"))
67	jonathan	542
68	jonathan	652	bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)
69			self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp,
70			shortHelpString=_("Show Layer"))
71	jonathan	542
72	jonathan	652	bmp = resource.GetBitmapResource(HIDE_BMP, wxBITMAP_TYPE_XPM)
73			self.toolBar.AddTool(ID_LEGEND_HIDELAYER, bmp,
74			shortHelpString=_("Hide Layer"))
75	jonathan	542
76	jonathan	652	bmp = resource.GetBitmapResource(PROPS_BMP, wxBITMAP_TYPE_XPM)
77			self.toolBar.AddTool(ID_LEGEND_PROPS, bmp,
78			shortHelpString=_("Edit Layer Properties"))
79	jonathan	542
80	jonathan	652	self.toolBar.Realize()
81	jonathan	668	panelBox.Add(self.toolBar, 0, wxGROW, 0)
82	jonathan	542
83	jonathan	652	EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
84			EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
85			EVT_TOOL(self, ID_LEGEND_PROPS, self._OnProperties)
86			EVT_TOOL(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
87			EVT_TOOL(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)
88	jonathan	542
89	jonathan	562	self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
90	jonathan	542
91	jonathan	658	panelBox.Add(self.tree, 1, wxGROW, 0)
92	jonathan	542
93	frank	854	self.scalebarbitmap = ScaleBarBitmap(self, map, mainWindow)
94			panelBox.Add(self.scalebarbitmap, 0, wxGROW, 0)
95
96	jonathan	562	self.SetAutoLayout(True)
97			self.SetSizer(panelBox)
98	jonathan	542	panelBox.SetSizeHints(self)
99
100	jonathan	658
101	jonathan	562	self.panelBox = panelBox
102	jonathan	542
103	jonathan	652	self.__EnableButtons(False)
104
105	jonathan	658	self.Create()
106
107	jonathan	572	EVT_CLOSE(self, self._OnClose)
108
109
110	jonathan	562	def GetMap(self):
111			return self.tree.GetMap()
112
113			def SetMap(self, map):
114			self.tree.SetMap(map)
115	frank	854	self.scalebarbitmap.SetCanvas(self.mainWindow.canvas)
116	jonathan	562
117	jonathan	572	def DoOnSelChanged(self, layer, group):
118	jonathan	542
119	jonathan	572	ok = isinstance(layer, Layer)
120			self.__EnableButtons(ok)
121
122	jonathan	655	self.mainWindow.SelectLayer(layer)
123	jonathan	568
124	jonathan	639	def DoOnProperties(self):
125	jonathan	572	list = self.tree.GetSelectedHierarchy()
126
127			ok = isinstance(list[0], Layer)
128			if ok:
129	jonathan	639	self.mainWindow.OpenLayerProperties(list[0], list[1])
130	jonathan	572
131	jonathan	578	def Destroy(self):
132			self.__Close()
133
134	jonathan	639	def _OnProperties(self, event):
135			self.DoOnProperties()
136	jonathan	542
137			def _OnMoveUp(self, event):
138			self.tree.MoveCurrentItemUp()
139
140			def _OnMoveDown(self, event):
141			self.tree.MoveCurrentItemDown()
142
143			def _OnShowLayer(self, event):
144			self.tree.DoOnShowLayer()
145			pass
146
147	jonathan	578	#def Close(self, force = False):
148			#DockPanel.Close(self, force)
149
150	jonathan	572	def _OnClose(self, event):
151	jonathan	578	self.__Close()
152	jonathan	572
153	jonathan	542	def _OnHideLayer(self, event):
154			self.tree.DoOnHideLayer()
155			pass
156
157			def __EnableButtons(self, on):
158	jonathan	652	self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
159			self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
160			self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER, on)
161			self.toolBar.EnableTool(ID_LEGEND_HIDELAYER, on)
162			self.toolBar.EnableTool(ID_LEGEND_PROPS, on)
163	jonathan	542
164	jonathan	578	def __Close(self):
165			self.tree.Close()
166
167	jonathan	542	class LegendTree(wxTreeCtrl):
168
169	jonathan	562	def __init__(self, parent, id, map, mainWindow):
170	jonathan	542	wxTreeCtrl.__init__(self, parent, id,
171			style = wxTR_DEFAULT_STYLE \| wxTR_HIDE_ROOT,
172			size = (200, 200))
173
174	jonathan	572	self.mainWindow = mainWindow
175	jonathan	562	self.map = None
176	jonathan	542	self.parent = parent
177	jonathan	572	self.layer2id = {}
178	jonathan	542
179			self.image_list = None
180			self.emptyImageIndex = 0
181
182			self.previewer = ClassDataPreviewer()
183
184			EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
185			EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
186
187	jonathan	572	EVT_CLOSE(self, self._OnClose)
188
189	jonathan	562	self.SetMap(map)
190	jonathan	542
191	jonathan	572	def _OnClose(self, event):
192			self.SetMap(None)
193
194	jonathan	562	def GetMap(self):
195			return self.map
196	jonathan	542
197	jonathan	562	def SetMap(self, map):
198
199			sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
200			(MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),
201			(MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]
202
203			if self.map is not None:
204			for msg, func in sub_list: self.map.Unsubscribe(msg, func)
205	jonathan	572	#self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
206			#self._OnMsgMapsChanged)
207			#try:
208			#self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
209			#self._OnMsgMapsChanged)
210			#except ConnectorError:
211			#pass
212	jonathan	562	self.__DeleteAllItems()
213
214			self.map = map
215
216			if self.map is not None:
217			for msg, func in sub_list: self.map.Subscribe(msg, func)
218	jonathan	572	#self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
219			#self._OnMsgMapsChanged)
220			#self.mainWindow.application.Subscribe(SESSION_REPLACED,
221			#self._OnMsgMapsChanged)
222	jonathan	562	self.__FillTree(self.map)
223
224	jonathan	542	def MoveCurrentItemUp(self):
225	jonathan	795	layer, group = self.GetSelectedHierarchy()
226	jonathan	542
227	jonathan	795	if layer is not None:
228			self.map.RaiseLayer(layer)
229	jonathan	542	else:
230	jonathan	795	assert False, "Shouldn't be allowed."
231	jonathan	542	pass
232
233			def MoveCurrentItemDown(self):
234	jonathan	795	layer, group = self.GetSelectedHierarchy()
235	jonathan	542
236	jonathan	795	if layer is not None:
237			self.map.LowerLayer(layer)
238	jonathan	542	else:
239	jonathan	795	assert False, "Shouldn't be allowed."
240	jonathan	542	pass
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			def Sort(self):
265			self.SortChildren(self.GetRootItem())
266
267	jonathan	655	def GetSelectedHierarchy(self):
268			id = self.GetSelection()
269
270			if not id.IsOk():
271			return (None, None)
272
273			layer = self.GetPyData(id)
274			group = None
275
276			if isinstance(layer, ClassGroup):
277			id = self.GetItemParent(id)
278			assert id.IsOk()
279			group = layer
280			layer = self.GetPyData(id)
281
282			return (layer, group)
283
284	jonathan	572	def _OnMsgMapsChanged(self):
285	jonathan	639	#print self.map is self.mainWindow.Map()
286	jonathan	572	self.SetMap(self.mainWindow.Map())
287
288	jonathan	542	def _OnSelChanged(self, event):
289	jonathan	655	self.__UpdateSelection()
290	jonathan	542
291			def _OnItemActivated(self, event):
292	jonathan	639	self.parent.DoOnProperties()
293	jonathan	542
294			def _OnMsgLayerChanged(self, layer):
295	jonathan	605	assert isinstance(layer, Layer)
296	jonathan	542
297			id = self.layer2id[layer]
298	jonathan	605	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	jonathan	655	self.__UpdateSelection()
306	jonathan	578	#self.__FillTreeLayer(id)
307	jonathan	542
308			def _OnMsgMapStackingChanged(self, *args):
309			self.Sort()
310	jonathan	562	id = self.GetSelection()
311	jonathan	542
312	jonathan	562	if id.IsOk():
313			self.EnsureVisible(id)
314	jonathan	655	self.__UpdateSelection()
315	jonathan	562
316			def _OnMsgMapLayersAddedRemoved(self, map):
317	jonathan	605	assert map is self.map
318	jonathan	542
319			self.__FillTree(self.map)
320	jonathan	655	self.__UpdateSelection()
321	jonathan	542
322	jonathan	572	def _OnMsgLayerVisibilityChanged(self, layer):
323	jonathan	605	assert isinstance(layer, Layer)
324	jonathan	572
325			self.__ShowHideLayer(layer)
326	jonathan	655	self.__UpdateSelection()
327	jonathan	572
328	jonathan	652	def _OnMsgLayerTitleChanged(self, layer):
329
330			id = self.layer2id[layer]
331			if id.IsOk():
332			self.SetItemText(id, layer.Title())
333	jonathan	655	self.__UpdateSelection()
334	jonathan	652
335	jonathan	655	def __UpdateSelection(self):
336			layer, group = self.GetSelectedHierarchy()
337			self.parent.DoOnSelChanged(layer, group)
338
339	jonathan	542	def __FillTree(self, map):
340
341			self.Freeze()
342
343			self.__DeleteAllItems()
344
345			if map.HasLayers():
346
347			self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
348
349			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
350			dc = wxMemoryDC()
351			dc.SelectObject(bmp)
352			dc.SetBrush(wxBLACK_BRUSH)
353			dc.Clear()
354			dc.SelectObject(wxNullBitmap)
355
356			self.emptyImageIndex = \
357			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
358
359			self.AssignImageList(self.image_list)
360
361			root = self.AddRoot("")
362
363			for l in map.Layers():
364			id = self.PrependItem(root, l.Title())
365			l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
366	jonathan	572	l.Subscribe(LAYER_VISIBILITY_CHANGED,
367			self._OnMsgLayerVisibilityChanged)
368	jonathan	652	l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
369	jonathan	542	self.SetPyData(id, l)
370	jonathan	632	self.__SetVisibilityStyle(l.Visible(), id)
371	jonathan	542
372			self.layer2id[l] = id
373
374			self.__FillTreeLayer(id)
375			self.Expand(id)
376
377			self.Thaw()
378
379			def __FillTreeLayer(self, pid):
380			layer = self.GetPyData(pid)
381
382			self.Freeze()
383
384			self.DeleteChildren(pid)
385
386			clazz = layer.GetClassification()
387
388			shapeType = layer.ShapeType()
389
390	jonathan	632	show = layer.Visible()
391	jonathan	542	for g in clazz:
392	jonathan	639	if g.IsVisible():
393			id = self.AppendItem(pid, g.GetDisplayText())
394			self.SetPyData(id, g)
395			self.__SetVisibilityStyle(show, id)
396	jonathan	542
397	jonathan	639	bmp = self.__BuildGroupImage(g, shapeType)
398	jonathan	542
399	jonathan	639	if bmp is None:
400			self.SetItemImage(id, self.emptyImageIndex)
401			else:
402			i = self.image_list.Add(bmp)
403			self.SetItemImage(id, i)
404	jonathan	542
405			self.Thaw()
406
407			def __BuildGroupImage(self, group, shapeType):
408
409			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
410			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
411			dc = wxMemoryDC()
412			dc.SelectObject(bmp)
413			dc.Clear()
414
415			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
416
417			return bmp
418
419			def __DeleteAllItems(self):
420
421	jonathan	572	while len(self.layer2id) > 0:
422			layer, id = self.layer2id.popitem()
423			layer.Unsubscribe(LAYER_CHANGED,
424			self._OnMsgLayerChanged)
425			layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
426			self._OnMsgLayerVisibilityChanged)
427	jonathan	652	layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
428	jonathan	542
429	jonathan	578	self.DeleteAllItems()
430
431	jonathan	632	def __SetVisibilityStyle(self, visible, id):
432	jonathan	572	font = self.GetItemFont(id)
433	jonathan	542
434	jonathan	632	if visible:
435	jonathan	572	font.SetStyle(wxNORMAL)
436			color = wxBLACK
437			else:
438			font.SetStyle(wxITALIC)
439			color = wxLIGHT_GREY
440	jonathan	542
441	jonathan	572	self.SetItemTextColour(id, color)
442			self.SetItemFont(id, font)
443
444			def __ShowHideLayer(self, layer):
445			parent = self.layer2id[layer]
446	jonathan	605	assert parent.IsOk()
447	jonathan	542
448	jonathan	632	visible = layer.Visible()
449	jonathan	542
450	jonathan	632	self.__SetVisibilityStyle(visible, parent)
451	jonathan	542
452	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
453	jonathan	542
454	jonathan	572	while id.IsOk():
455	jonathan	632	self.__SetVisibilityStyle(visible, id)
456	jonathan	572	id, cookie = self.GetNextChild(parent, cookie)
457
458	frank	854	class ScaleBarBitmap(wxBoxSizer):
459
460			def __init__(self, parent, map, mainWindow):
461			# While the width is fixed, get the height _now_.
462			dc = wxMemoryDC()
463			textwidth, textheight = dc.GetTextExtent("%d"%0)
464			self.width = 200
465			self.height = textheight + 3*2 + 8
466
467			wxBoxSizer.__init__(self, wxVERTICAL)
468			bmp=wxEmptyBitmap(self.width, self.height)
469			self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
470			self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER\|wxLEFT\|wxTOP\|wxRIGHT, 1)
471
472			self.mainWindow = mainWindow
473			self.parent = parent
474			self.canvas = None
475			self.scalebar = ScaleBar(map)
476			self.SetCanvas(self.mainWindow.canvas)
477
478			def SetCanvas(self, canvas):
479			sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
480
481			if self.canvas is not None:
482			for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
483
484			self.canvas = canvas
485
486			if self.canvas is not None:
487			for msg, func in sub_list: self.canvas.Subscribe(msg, func)
488			self.__SetScale(self.canvas.scale)
489
490			def _OnMsgScaleChanged(self, scale):
491			self.__SetScale(scale)
492
493			def __SetScale(self, scale):
494			bmp = wxEmptyBitmap(self.width, self.height)
495			dc = wxMemoryDC()
496			dc.SelectObject(bmp)
497			dc.Clear()
498
499			self.scalebar.DrawScalebar(scale, dc)
500
501			self.scalebarBitmap.SetBitmap(bmp)
502
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision