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.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.UI.scalebar import ScaleBar

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.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
        self.scalebar = ScaleBar(canvas.map)

        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			from Thuban.Model.messages import *
19			from Thuban.Model.classification import ClassGroup
20
21	jonathan	572	from Thuban.UI.messages import *
22	jonathan	542	from Thuban.UI.classifier import ClassDataPreviewer
23	jonathan	562	from Thuban.UI.dock import DockPanel
24	frank	864	from Thuban.UI.scalebar import ScaleBar
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.SetCanvas(self.mainWindow.canvas)
476
477			def SetCanvas(self, canvas):
478			sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
479
480			if self.canvas is not None:
481			for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
482
483			self.canvas = canvas
484	frank	858	self.scalebar = ScaleBar(canvas.map)
485	frank	854
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