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 = {}

        #
        # The image list used by the wxTreeCtrl causes problems when
        # we remove layers and/or change a classification because it
        # changes the image indices if you remove images from the list.
        # Rather than removing unused images we use this list to keep 
        # track of which indices are available in the image list 
        # (because of a previous removal) and then  replace those indices 
        # with new images rather than appending to the end of the image 
        # list (assuming there are any that are available).
        #
        self.availImgListIndices = []

        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._OnMsgMapLayersAdded),
                    (MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]

        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.MoveLayerToTop(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.MoveLayerToBottom(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):
        layer, group = self.GetSelectedHierarchy()
        layer.SetVisible(True)

    def DoOnHideLayer(self):
        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()

        self.__FillTreeLayer(id)
        self.__UpdateSelection()

    def _OnMsgMapStackingChanged(self, *args):
        self.Sort()
        id = self.GetSelection()

        if id.IsOk():
            self.EnsureVisible(id)
        self.__UpdateSelection()

    def _OnMsgMapLayersAdded(self, map):
        assert map is self.map

        root = self.GetRootItem()

        i = 0
        for l in map.Layers():
            if not self.layer2id.has_key(l):
                self.__AddLayer(i, l)

        self.__UpdateSelection()

    def _OnMsgMapLayersRemoved(self, map):
        assert map is self.map

        layer, group = self.GetSelectedHierarchy()

        if layer is None:
            assert False, "Shouldn't be allowed."
            return

        layers = map.Layers()

        for layer, id in self.layer2id.items():
            if layer not in layers:
                if id.IsOk():
                    self.__RemoveLayer(id)

        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():
            root = self.GetRootItem()
            for l in map.Layers():
                self.__AddLayer(0, l)

        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:
                        if self.availImgListIndices:
                            i = self.availImgListIndices.pop(0)
                            self.image_list.Replace(i, bmp)
                        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):

        pid = self.GetRootItem()

        id, cookie = self.GetFirstChild(pid, 123)
        while id.IsOk():
            self.__RemoveLayer(id)
            id, cookie = self.GetNextChild(pid, cookie)

        wxTreeCtrl.DeleteAllItems(self)

    def __AddLayer(self, before, l):
        root = self.GetRootItem()
        id = self.InsertItemBefore(root, before,
                            l.Title(), 
                            self.mapImageIndex,
                            self.mapImageIndex)

        self.SetPyData(id, l)
        self.__SetVisibilityStyle(l.Visible(), id)

        self.layer2id[l] = id

        self.__FillTreeLayer(id)
        self.Expand(id)

        l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
        l.Subscribe(LAYER_VISIBILITY_CHANGED, 
                    self._OnMsgLayerVisibilityChanged)
        l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)

    def __RemoveLayer(self, id):
        self.DeleteChildren(id)

        layer = self.GetPyData(id)
        layer.Unsubscribe(LAYER_CHANGED, 
                          self._OnMsgLayerChanged)
        layer.Unsubscribe(LAYER_VISIBILITY_CHANGED, 
                          self._OnMsgLayerVisibilityChanged)
        layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)

        self.Delete(id)
        del self.layer2id[layer]

    def DeleteChildren(self, pid):
        id, cookie = self.GetFirstChild(pid, 123)
        while id.IsOk():
            self.availImgListIndices.append(self.GetItemImage(id))
            id, cookie = self.GetNextChild(pid, cookie)
        wxTreeCtrl.DeleteChildren(self, pid)

    def GetRootItem(self):
        root = wxTreeCtrl.GetRootItem(self)

        if not root.IsOk():
            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("")

        return root

    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	jonathan	1102	#
207			# The image list used by the wxTreeCtrl causes problems when
208			# we remove layers and/or change a classification because it
209			# changes the image indices if you remove images from the list.
210			# Rather than removing unused images we use this list to keep
211			# track of which indices are available in the image list
212			# (because of a previous removal) and then replace those indices
213			# with new images rather than appending to the end of the image
214			# list (assuming there are any that are available).
215			#
216			self.availImgListIndices = []
217
218	jonathan	542	self.image_list = None
219			self.emptyImageIndex = 0
220
221			self.previewer = ClassDataPreviewer()
222
223			EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
224			EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
225
226	jonathan	572	EVT_CLOSE(self, self._OnClose)
227
228	jonathan	562	self.SetMap(map)
229	jonathan	542
230	jonathan	572	def _OnClose(self, event):
231			self.SetMap(None)
232
233	jonathan	562	def GetMap(self):
234			return self.map
235	jonathan	542
236	jonathan	562	def SetMap(self, map):
237
238			sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
239	jonathan	1102	(MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
240			(MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
241	jonathan	562
242			if self.map is not None:
243			for msg, func in sub_list: self.map.Unsubscribe(msg, func)
244	jonathan	572	#self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
245			#self._OnMsgMapsChanged)
246			#try:
247			#self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
248			#self._OnMsgMapsChanged)
249			#except ConnectorError:
250			#pass
251	jonathan	1102	self.DeleteAllItems()
252	jonathan	562
253			self.map = map
254
255			if self.map is not None:
256			for msg, func in sub_list: self.map.Subscribe(msg, func)
257	jonathan	572	#self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
258			#self._OnMsgMapsChanged)
259			#self.mainWindow.application.Subscribe(SESSION_REPLACED,
260			#self._OnMsgMapsChanged)
261	jonathan	562	self.__FillTree(self.map)
262
263	frank	990	def MoveCurrentItemTop(self):
264			layer, group = self.GetSelectedHierarchy()
265
266			if layer is not None:
267	jonathan	1102	self.map.MoveLayerToTop(layer)
268	frank	990	else:
269			assert False, "Shouldn't be allowed."
270			pass
271
272	jonathan	542	def MoveCurrentItemUp(self):
273	jonathan	795	layer, group = self.GetSelectedHierarchy()
274	jonathan	542
275	jonathan	795	if layer is not None:
276			self.map.RaiseLayer(layer)
277	jonathan	542	else:
278	jonathan	795	assert False, "Shouldn't be allowed."
279	jonathan	542	pass
280
281			def MoveCurrentItemDown(self):
282	jonathan	795	layer, group = self.GetSelectedHierarchy()
283	jonathan	542
284	jonathan	795	if layer is not None:
285			self.map.LowerLayer(layer)
286	jonathan	542	else:
287	jonathan	795	assert False, "Shouldn't be allowed."
288	jonathan	542	pass
289
290	frank	990	def MoveCurrentItemBottom(self):
291			layer, group = self.GetSelectedHierarchy()
292
293			if layer is not None:
294	jonathan	1102	self.map.MoveLayerToBottom(layer)
295	frank	990	else:
296			assert False, "Shouldn't be allowed."
297			pass
298
299	jonathan	542	def OnCompareItems(self, item1, item2):
300
301			data1 = self.GetPyData(item1)
302			data2 = self.GetPyData(item2)
303
304	jonathan	936	if isinstance(data1, BaseLayer):
305	jonathan	542	layers = self.map.Layers()
306			return layers.index(data2) - layers.index(data1)
307			else:
308			return wxTreeCtrl.OnCompareItems(self, item1, item2)
309
310			def DoOnShowLayer(self):
311	jonathan	572	layer, group = self.GetSelectedHierarchy()
312			layer.SetVisible(True)
313	jonathan	542
314			def DoOnHideLayer(self):
315	jonathan	572	layer, group = self.GetSelectedHierarchy()
316			layer.SetVisible(False)
317	jonathan	542
318			def Sort(self):
319			self.SortChildren(self.GetRootItem())
320
321	jonathan	655	def GetSelectedHierarchy(self):
322			id = self.GetSelection()
323
324			if not id.IsOk():
325			return (None, None)
326
327			layer = self.GetPyData(id)
328			group = None
329
330			if isinstance(layer, ClassGroup):
331			id = self.GetItemParent(id)
332			assert id.IsOk()
333			group = layer
334			layer = self.GetPyData(id)
335
336			return (layer, group)
337
338	jonathan	572	def _OnMsgMapsChanged(self):
339	jonathan	639	#print self.map is self.mainWindow.Map()
340	jonathan	572	self.SetMap(self.mainWindow.Map())
341
342	jonathan	542	def _OnSelChanged(self, event):
343	jonathan	655	self.__UpdateSelection()
344	jonathan	542
345			def _OnItemActivated(self, event):
346	jonathan	639	self.parent.DoOnProperties()
347	jonathan	542
348			def _OnMsgLayerChanged(self, layer):
349	jonathan	936	assert isinstance(layer, BaseLayer)
350	jonathan	542
351			id = self.layer2id[layer]
352	jonathan	605	assert id.IsOk()
353	jonathan	542
354	jonathan	1102	self.__FillTreeLayer(id)
355	jonathan	655	self.__UpdateSelection()
356	jonathan	542
357			def _OnMsgMapStackingChanged(self, *args):
358			self.Sort()
359	jonathan	562	id = self.GetSelection()
360	jonathan	542
361	jonathan	562	if id.IsOk():
362			self.EnsureVisible(id)
363	jonathan	655	self.__UpdateSelection()
364	jonathan	562
365	jonathan	1102	def _OnMsgMapLayersAdded(self, map):
366	jonathan	605	assert map is self.map
367	jonathan	542
368	jonathan	1102	root = self.GetRootItem()
369
370			i = 0
371			for l in map.Layers():
372			if not self.layer2id.has_key(l):
373			self.__AddLayer(i, l)
374
375	jonathan	655	self.__UpdateSelection()
376	jonathan	542
377	jonathan	1102	def _OnMsgMapLayersRemoved(self, map):
378			assert map is self.map
379
380			layer, group = self.GetSelectedHierarchy()
381
382			if layer is None:
383			assert False, "Shouldn't be allowed."
384			return
385
386			layers = map.Layers()
387
388			for layer, id in self.layer2id.items():
389			if layer not in layers:
390			if id.IsOk():
391			self.__RemoveLayer(id)
392
393			self.__UpdateSelection()
394
395	jonathan	572	def _OnMsgLayerVisibilityChanged(self, layer):
396	jonathan	936	assert isinstance(layer, BaseLayer)
397	jonathan	572
398			self.__ShowHideLayer(layer)
399	jonathan	655	self.__UpdateSelection()
400	jonathan	572
401	jonathan	652	def _OnMsgLayerTitleChanged(self, layer):
402
403			id = self.layer2id[layer]
404			if id.IsOk():
405			self.SetItemText(id, layer.Title())
406	jonathan	655	self.__UpdateSelection()
407	jonathan	652
408	jonathan	655	def __UpdateSelection(self):
409			layer, group = self.GetSelectedHierarchy()
410			self.parent.DoOnSelChanged(layer, group)
411
412	jonathan	542	def __FillTree(self, map):
413
414			self.Freeze()
415
416	jonathan	1102	self.DeleteAllItems()
417	jonathan	542
418			if map.HasLayers():
419	jonathan	1102	root = self.GetRootItem()
420	jonathan	542	for l in map.Layers():
421	jonathan	1102	self.__AddLayer(0, l)
422	frank	1050
423	jonathan	542	self.Thaw()
424
425			def __FillTreeLayer(self, pid):
426			layer = self.GetPyData(pid)
427
428			self.Freeze()
429
430			self.DeleteChildren(pid)
431
432	jonathan	936	if layer.HasClassification():
433	jonathan	542
434	jonathan	936	clazz = layer.GetClassification()
435	jonathan	542
436	jonathan	936	shapeType = layer.ShapeType()
437	jonathan	542
438	jonathan	936	show = layer.Visible()
439			for g in clazz:
440			if g.IsVisible():
441			id = self.AppendItem(pid, g.GetDisplayText())
442			self.SetPyData(id, g)
443			self.__SetVisibilityStyle(show, id)
444	jonathan	542
445	jonathan	936	bmp = self.__BuildGroupImage(g, shapeType)
446	jonathan	542
447	jonathan	936	if bmp is None:
448	frank	1050	self.SetItemImage(id, -1)
449			self.SetItemSelectedImage(id, -1)
450	jonathan	936	else:
451	jonathan	1102	if self.availImgListIndices:
452			i = self.availImgListIndices.pop(0)
453			self.image_list.Replace(i, bmp)
454			else:
455			i = self.image_list.Add(bmp)
456
457	jonathan	936	self.SetItemImage(id, i)
458	frank	1050	self.SetItemSelectedImage(id, i)
459	jonathan	936
460	jonathan	542	self.Thaw()
461
462			def __BuildGroupImage(self, group, shapeType):
463
464			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
465			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
466			dc = wxMemoryDC()
467			dc.SelectObject(bmp)
468			dc.Clear()
469
470			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
471
472			return bmp
473
474	jonathan	1102	def DeleteAllItems(self):
475	jonathan	542
476	jonathan	1102	pid = self.GetRootItem()
477	jonathan	542
478	jonathan	1102	id, cookie = self.GetFirstChild(pid, 123)
479			while id.IsOk():
480			self.__RemoveLayer(id)
481			id, cookie = self.GetNextChild(pid, cookie)
482	jonathan	578
483	jonathan	1102	wxTreeCtrl.DeleteAllItems(self)
484
485			def __AddLayer(self, before, l):
486			root = self.GetRootItem()
487			id = self.InsertItemBefore(root, before,
488			l.Title(),
489			self.mapImageIndex,
490			self.mapImageIndex)
491
492			self.SetPyData(id, l)
493			self.__SetVisibilityStyle(l.Visible(), id)
494
495			self.layer2id[l] = id
496
497			self.__FillTreeLayer(id)
498			self.Expand(id)
499
500			l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
501			l.Subscribe(LAYER_VISIBILITY_CHANGED,
502			self._OnMsgLayerVisibilityChanged)
503			l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
504
505			def __RemoveLayer(self, id):
506			self.DeleteChildren(id)
507
508			layer = self.GetPyData(id)
509			layer.Unsubscribe(LAYER_CHANGED,
510			self._OnMsgLayerChanged)
511			layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
512			self._OnMsgLayerVisibilityChanged)
513			layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
514
515			self.Delete(id)
516			del self.layer2id[layer]
517
518			def DeleteChildren(self, pid):
519			id, cookie = self.GetFirstChild(pid, 123)
520			while id.IsOk():
521			self.availImgListIndices.append(self.GetItemImage(id))
522			id, cookie = self.GetNextChild(pid, cookie)
523			wxTreeCtrl.DeleteChildren(self, pid)
524
525			def GetRootItem(self):
526			root = wxTreeCtrl.GetRootItem(self)
527
528			if not root.IsOk():
529			self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
530
531			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
532			dc = wxMemoryDC()
533			dc.SelectObject(bmp)
534			dc.SetBrush(wxBLACK_BRUSH)
535			dc.Clear()
536			dc.SelectObject(wxNullBitmap)
537
538			self.emptyImageIndex = \
539			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
540
541			bmp = resource.GetBitmapResource("legend_icon_layer",
542			wxBITMAP_TYPE_XPM)
543			self.mapImageIndex = \
544			self.image_list.Add(bmp)
545
546			self.AssignImageList(self.image_list)
547
548			root = self.AddRoot("")
549
550			return root
551
552	jonathan	632	def __SetVisibilityStyle(self, visible, id):
553	jonathan	572	font = self.GetItemFont(id)
554	jonathan	542
555	jonathan	632	if visible:
556	jonathan	572	font.SetStyle(wxNORMAL)
557			color = wxBLACK
558			else:
559	frank	980	#font.SetStyle(wxITALIC)
560			font.SetStyle(wxNORMAL)
561	jonathan	572	color = wxLIGHT_GREY
562	jonathan	542
563	jonathan	572	self.SetItemTextColour(id, color)
564			self.SetItemFont(id, font)
565
566			def __ShowHideLayer(self, layer):
567			parent = self.layer2id[layer]
568	jonathan	605	assert parent.IsOk()
569	jonathan	542
570	jonathan	632	visible = layer.Visible()
571	jonathan	542
572	jonathan	632	self.__SetVisibilityStyle(visible, parent)
573	jonathan	542
574	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
575	jonathan	542
576	jonathan	572	while id.IsOk():
577	jonathan	632	self.__SetVisibilityStyle(visible, id)
578	jonathan	572	id, cookie = self.GetNextChild(parent, cookie)
579
580	frank	854	class ScaleBarBitmap(wxBoxSizer):
581
582			def __init__(self, parent, map, mainWindow):
583			# While the width is fixed, get the height _now_.
584			dc = wxMemoryDC()
585			textwidth, textheight = dc.GetTextExtent("%d"%0)
586	frank	990	self.width = 210
587	frank	854	self.height = textheight + 3*2 + 8
588
589			wxBoxSizer.__init__(self, wxVERTICAL)
590			bmp=wxEmptyBitmap(self.width, self.height)
591			self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
592			self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER\|wxLEFT\|wxTOP\|wxRIGHT, 1)
593
594			self.mainWindow = mainWindow
595			self.parent = parent
596			self.canvas = None
597			self.SetCanvas(self.mainWindow.canvas)
598
599			def SetCanvas(self, canvas):
600			sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
601
602			if self.canvas is not None:
603			for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
604
605			self.canvas = canvas
606	frank	858	self.scalebar = ScaleBar(canvas.map)
607	frank	854
608			if self.canvas is not None:
609			for msg, func in sub_list: self.canvas.Subscribe(msg, func)
610			self.__SetScale(self.canvas.scale)
611
612			def _OnMsgScaleChanged(self, scale):
613			self.__SetScale(scale)
614
615			def __SetScale(self, scale):
616			bmp = wxEmptyBitmap(self.width, self.height)
617			dc = wxMemoryDC()
618			dc.SelectObject(bmp)
619			dc.Clear()
620
621	frank	914	self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
622	frank	854
623			self.scalebarBitmap.SetBitmap(bmp)
624
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision