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 BaseLayer
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, BaseLayer)
        self.__EnableButtons(ok)

        self.mainWindow.SelectLayer(layer)

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

        ok = isinstance(list[0], BaseLayer)
        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, BaseLayer):
            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, BaseLayer)

        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, BaseLayer)

        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)

        if layer.HasClassification():

            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	jonathan	936	from Thuban.Model.layer import BaseLayer
18	jonathan	542	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	936	ok = isinstance(layer, BaseLayer)
125	jonathan	572	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	jonathan	936	ok = isinstance(list[0], BaseLayer)
133	jonathan	572	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	jonathan	936	if isinstance(data1, BaseLayer):
253	jonathan	542	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	936	assert isinstance(layer, BaseLayer)
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	936	assert isinstance(layer, BaseLayer)
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	jonathan	936	if layer.HasClassification():
391	jonathan	542
392	jonathan	936	clazz = layer.GetClassification()
393	jonathan	542
394	jonathan	936	shapeType = layer.ShapeType()
395	jonathan	542
396	jonathan	936	show = layer.Visible()
397			for g in clazz:
398			if g.IsVisible():
399			id = self.AppendItem(pid, g.GetDisplayText())
400			self.SetPyData(id, g)
401			self.__SetVisibilityStyle(show, id)
402	jonathan	542
403	jonathan	936	bmp = self.__BuildGroupImage(g, shapeType)
404	jonathan	542
405	jonathan	936	if bmp is None:
406			self.SetItemImage(id, self.emptyImageIndex)
407			else:
408			i = self.image_list.Add(bmp)
409			self.SetItemImage(id, i)
410
411	jonathan	542	self.Thaw()
412
413			def __BuildGroupImage(self, group, shapeType):
414
415			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
416			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
417			dc = wxMemoryDC()
418			dc.SelectObject(bmp)
419			dc.Clear()
420
421			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
422
423			return bmp
424
425			def __DeleteAllItems(self):
426
427	jonathan	572	while len(self.layer2id) > 0:
428			layer, id = self.layer2id.popitem()
429			layer.Unsubscribe(LAYER_CHANGED,
430			self._OnMsgLayerChanged)
431			layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
432			self._OnMsgLayerVisibilityChanged)
433	jonathan	652	layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
434	jonathan	542
435	jonathan	578	self.DeleteAllItems()
436
437	jonathan	632	def __SetVisibilityStyle(self, visible, id):
438	jonathan	572	font = self.GetItemFont(id)
439	jonathan	542
440	jonathan	632	if visible:
441	jonathan	572	font.SetStyle(wxNORMAL)
442			color = wxBLACK
443			else:
444			font.SetStyle(wxITALIC)
445			color = wxLIGHT_GREY
446	jonathan	542
447	jonathan	572	self.SetItemTextColour(id, color)
448			self.SetItemFont(id, font)
449
450			def __ShowHideLayer(self, layer):
451			parent = self.layer2id[layer]
452	jonathan	605	assert parent.IsOk()
453	jonathan	542
454	jonathan	632	visible = layer.Visible()
455	jonathan	542
456	jonathan	632	self.__SetVisibilityStyle(visible, parent)
457	jonathan	542
458	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
459	jonathan	542
460	jonathan	572	while id.IsOk():
461	jonathan	632	self.__SetVisibilityStyle(visible, id)
462	jonathan	572	id, cookie = self.GetNextChild(parent, cookie)
463
464	frank	854	class ScaleBarBitmap(wxBoxSizer):
465
466			def __init__(self, parent, map, mainWindow):
467			# While the width is fixed, get the height _now_.
468			dc = wxMemoryDC()
469			textwidth, textheight = dc.GetTextExtent("%d"%0)
470			self.width = 200
471			self.height = textheight + 3*2 + 8
472
473			wxBoxSizer.__init__(self, wxVERTICAL)
474			bmp=wxEmptyBitmap(self.width, self.height)
475			self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
476			self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER\|wxLEFT\|wxTOP\|wxRIGHT, 1)
477
478			self.mainWindow = mainWindow
479			self.parent = parent
480			self.canvas = None
481			self.SetCanvas(self.mainWindow.canvas)
482
483			def SetCanvas(self, canvas):
484			sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
485
486			if self.canvas is not None:
487			for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
488
489			self.canvas = canvas
490	frank	858	self.scalebar = ScaleBar(canvas.map)
491	frank	854
492			if self.canvas is not None:
493			for msg, func in sub_list: self.canvas.Subscribe(msg, func)
494			self.__SetScale(self.canvas.scale)
495
496			def _OnMsgScaleChanged(self, scale):
497			self.__SetScale(scale)
498
499			def __SetScale(self, scale):
500			bmp = wxEmptyBitmap(self.width, self.height)
501			dc = wxMemoryDC()
502			dc.SelectObject(bmp)
503			dc.Clear()
504
505	frank	914	self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
506	frank	854
507			self.scalebarBitmap.SetBitmap(bmp)
508
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision