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_TOP = 4001
ID_LEGEND_RAISE = 4002
ID_LEGEND_LOWER = 4003
ID_LEGEND_BOTTOM = 4004
ID_LEGEND_TREE = 4005
ID_LEGEND_PROPS = 4006
ID_LEGEND_SHOWLAYER = 4007
ID_LEGEND_HIDELAYER = 4008

BMP_SIZE_W = 15
BMP_SIZE_H = 15

TOP_BMP = "top_layer"
RAISE_BMP = "raise_layer"
LOWER_BMP = "lower_layer"
BOTTOM_BMP = "bottom_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(TOP_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_TOP, bmp, 
            shortHelpString=_("Top Layer"))

        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(BOTTOM_BMP, wxBITMAP_TYPE_XPM)
        self.toolBar.AddTool(ID_LEGEND_BOTTOM, bmp, 
            shortHelpString=_("Bottom 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_TOP, self._OnMoveTop)
        EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
        EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
        EVT_TOOL(self, ID_LEGEND_BOTTOM, self._OnMoveBottom)
        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 _OnMoveTop(self, event):
        self.tree.MoveCurrentItemTop()
        
    def _OnMoveUp(self, event): 
        self.tree.MoveCurrentItemUp()

    def _OnMoveDown(self, event):
        self.tree.MoveCurrentItemDown()

    def _OnMoveBottom(self, event):
        self.tree.MoveCurrentItemBottom()

    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_TOP, on)
        self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
        self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
        self.toolBar.EnableTool(ID_LEGEND_BOTTOM, 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 MoveCurrentItemTop(self):
        layer, group = self.GetSelectedHierarchy()

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

    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 MoveCurrentItemBottom(self):
        layer, group = self.GetSelectedHierarchy()

        if layer is not None:
            self.map.BottomLayer(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))
                                                                                
            bmp = resource.GetBitmapResource("legend_icon_layer", 
                                              wxBITMAP_TYPE_XPM)
            self.mapImageIndex = \
                self.image_list.Add(bmp)

            self.AssignImageList(self.image_list)

            root = self.AddRoot("")

            for l in map.Layers():
                id = self.PrependItem(root, l.Title())
                self.SetItemImage(id, self.mapImageIndex)
                self.SetItemSelectedImage(id, self.mapImageIndex)

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