Thuban/UI/legend.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
# Frank Koormann <[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.classification import ClassGroup

from Thuban.Model.messages import \
    MAP_STACKING_CHANGED, MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED, LAYER_CHANGED,\
    LAYER_VISIBILITY_CHANGED, TITLE_CHANGED

from Thuban.UI.messages import SCALE_CHANGED

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, (0,0), dc.GetSizeTuple())

        self.scalebarBitmap.SetBitmap(bmp)

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