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

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