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.changing_selection = 0

        #
        # 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):
        # If we change the selection from normalize_selection do nothing.
        if self.changing_selection:
            return

        self.normalize_selection()
        self.__UpdateSelection()

    def normalize_selection(self):
        """Select the layer containing currently selected item"""
        # This is really a workaround for a bug in wx where deleting a
        # subtree with DeleteChildren does not update the selection
        # properly and can lead to segfaults later because the return
        # value of GetSelection points to invalid data.
        item = self.GetSelection()
        while item.IsOk():
            object = self.GetPyData(item)
            if isinstance(object, BaseLayer):
                break
            item = self.GetItemParent(item)
        else:
            # No layer was found in the chain of parents, so there's
            # nothing we can do.
            return

        self.changing_selection = 1
        try:
            self.SelectItem(item)
        finally:
            self.changing_selection = 0


    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

        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)
            self.availImgListIndices = []

            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	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Jonathan Coles <[email protected]>
4	# Frank Koormann <[email protected]>
5	#
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	import resource
14
15	from wxPython.wx import *
16
17	from Thuban.Model.layer import BaseLayer
18	from Thuban.Model.map import Map
19	from Thuban.Model.classification import ClassGroup
20
21	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	from Thuban.UI.classifier import ClassDataPreviewer
28	from Thuban.UI.dock import DockPanel
29	from Thuban.UI.scalebar import ScaleBar
30
31	from Thuban.Lib.connector import ConnectorError
32
33	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
42	BMP_SIZE_W = 15
43	BMP_SIZE_H = 15
44
45	TOP_BMP = "top_layer"
46	RAISE_BMP = "raise_layer"
47	LOWER_BMP = "lower_layer"
48	BOTTOM_BMP = "bottom_layer"
49	SHOW_BMP = "show_layer"
50	HIDE_BMP = "hide_layer"
51	PROPS_BMP = "layer_properties"
52
53
54	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	self.buttons = []
63
64	panelBox = wxBoxSizer(wxVERTICAL)
65
66	self.toolBar = wxToolBar(self, -1)
67	self.toolBar.SetToolBitmapSize(wxSize(24, 24))
68
69	bmp = resource.GetBitmapResource(TOP_BMP, wxBITMAP_TYPE_XPM)
70	self.toolBar.AddTool(ID_LEGEND_TOP, bmp,
71	shortHelpString=_("Top Layer"))
72
73	bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)
74	self.toolBar.AddTool(ID_LEGEND_RAISE, bmp,
75	shortHelpString=_("Raise Layer"))
76
77	bmp = resource.GetBitmapResource(LOWER_BMP, wxBITMAP_TYPE_XPM)
78	self.toolBar.AddTool(ID_LEGEND_LOWER, bmp,
79	shortHelpString=_("Lower Layer"))
80
81	bmp = resource.GetBitmapResource(BOTTOM_BMP, wxBITMAP_TYPE_XPM)
82	self.toolBar.AddTool(ID_LEGEND_BOTTOM, bmp,
83	shortHelpString=_("Bottom Layer"))
84
85	bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)
86	self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp,
87	shortHelpString=_("Show Layer"))
88
89	bmp = resource.GetBitmapResource(HIDE_BMP, wxBITMAP_TYPE_XPM)
90	self.toolBar.AddTool(ID_LEGEND_HIDELAYER, bmp,
91	shortHelpString=_("Hide Layer"))
92
93	bmp = resource.GetBitmapResource(PROPS_BMP, wxBITMAP_TYPE_XPM)
94	self.toolBar.AddTool(ID_LEGEND_PROPS, bmp,
95	shortHelpString=_("Edit Layer Properties"))
96
97	self.toolBar.Realize()
98	panelBox.Add(self.toolBar, 0, wxGROW, 0)
99
100	EVT_TOOL(self, ID_LEGEND_TOP, self._OnMoveTop)
101	EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
102	EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
103	EVT_TOOL(self, ID_LEGEND_BOTTOM, self._OnMoveBottom)
104	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
108	self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
109
110	panelBox.Add(self.tree, 1, wxGROW, 0)
111
112	self.scalebarbitmap = ScaleBarBitmap(self, map, mainWindow)
113	panelBox.Add(self.scalebarbitmap, 0, wxGROW, 0)
114
115	self.SetAutoLayout(True)
116	self.SetSizer(panelBox)
117	panelBox.SetSizeHints(self)
118
119
120	self.panelBox = panelBox
121
122	self.__EnableButtons(False)
123
124	self.Create()
125
126	EVT_CLOSE(self, self._OnClose)
127
128
129	def GetMap(self):
130	return self.tree.GetMap()
131
132	def SetMap(self, map):
133	self.tree.SetMap(map)
134	self.scalebarbitmap.SetCanvas(self.mainWindow.canvas)
135
136	def DoOnSelChanged(self, layer, group):
137
138	ok = isinstance(layer, BaseLayer)
139	self.__EnableButtons(ok)
140
141	self.mainWindow.SelectLayer(layer)
142
143	def DoOnProperties(self):
144	list = self.tree.GetSelectedHierarchy()
145
146	ok = isinstance(list[0], BaseLayer)
147	if ok:
148	self.mainWindow.OpenLayerProperties(list[0], list[1])
149
150	def Destroy(self):
151	self.__Close()
152
153	def _OnProperties(self, event):
154	self.DoOnProperties()
155
156	def _OnMoveTop(self, event):
157	self.tree.MoveCurrentItemTop()
158
159	def _OnMoveUp(self, event):
160	self.tree.MoveCurrentItemUp()
161
162	def _OnMoveDown(self, event):
163	self.tree.MoveCurrentItemDown()
164
165	def _OnMoveBottom(self, event):
166	self.tree.MoveCurrentItemBottom()
167
168	def _OnShowLayer(self, event):
169	self.tree.DoOnShowLayer()
170	pass
171
172	#def Close(self, force = False):
173	#DockPanel.Close(self, force)
174
175	def _OnClose(self, event):
176	self.__Close()
177
178	def _OnHideLayer(self, event):
179	self.tree.DoOnHideLayer()
180	pass
181
182	def __EnableButtons(self, on):
183	self.toolBar.EnableTool(ID_LEGEND_TOP, on)
184	self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
185	self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
186	self.toolBar.EnableTool(ID_LEGEND_BOTTOM, on)
187	self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER, on)
188	self.toolBar.EnableTool(ID_LEGEND_HIDELAYER, on)
189	self.toolBar.EnableTool(ID_LEGEND_PROPS, on)
190
191	def __Close(self):
192	self.tree.Close()
193
194	class LegendTree(wxTreeCtrl):
195
196	def __init__(self, parent, id, map, mainWindow):
197	wxTreeCtrl.__init__(self, parent, id,
198	style = wxTR_DEFAULT_STYLE \| wxTR_HIDE_ROOT,
199	size = (200, 200))
200
201	self.mainWindow = mainWindow
202	self.map = None
203	self.parent = parent
204	self.layer2id = {}
205	self.changing_selection = 0
206
207	#
208	# The image list used by the wxTreeCtrl causes problems when
209	# we remove layers and/or change a classification because it
210	# changes the image indices if you remove images from the list.
211	# Rather than removing unused images we use this list to keep
212	# track of which indices are available in the image list
213	# (because of a previous removal) and then replace those indices
214	# with new images rather than appending to the end of the image
215	# list (assuming there are any that are available).
216	#
217	self.availImgListIndices = []
218
219	self.image_list = None
220	self.emptyImageIndex = 0
221
222	self.previewer = ClassDataPreviewer()
223
224	EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
225	EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
226
227	EVT_CLOSE(self, self._OnClose)
228
229	self.SetMap(map)
230
231	def _OnClose(self, event):
232	self.SetMap(None)
233
234	def GetMap(self):
235	return self.map
236
237	def SetMap(self, map):
238
239	sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
240	(MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
241	(MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
242
243	if self.map is not None:
244	for msg, func in sub_list: self.map.Unsubscribe(msg, func)
245	#self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
246	#self._OnMsgMapsChanged)
247	#try:
248	#self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
249	#self._OnMsgMapsChanged)
250	#except ConnectorError:
251	#pass
252	self.DeleteAllItems()
253
254	self.map = map
255
256	if self.map is not None:
257	for msg, func in sub_list: self.map.Subscribe(msg, func)
258	#self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
259	#self._OnMsgMapsChanged)
260	#self.mainWindow.application.Subscribe(SESSION_REPLACED,
261	#self._OnMsgMapsChanged)
262	self.__FillTree(self.map)
263
264	def MoveCurrentItemTop(self):
265	layer, group = self.GetSelectedHierarchy()
266
267	if layer is not None:
268	self.map.MoveLayerToTop(layer)
269	else:
270	assert False, "Shouldn't be allowed."
271	pass
272
273	def MoveCurrentItemUp(self):
274	layer, group = self.GetSelectedHierarchy()
275
276	if layer is not None:
277	self.map.RaiseLayer(layer)
278	else:
279	assert False, "Shouldn't be allowed."
280	pass
281
282	def MoveCurrentItemDown(self):
283	layer, group = self.GetSelectedHierarchy()
284
285	if layer is not None:
286	self.map.LowerLayer(layer)
287	else:
288	assert False, "Shouldn't be allowed."
289	pass
290
291	def MoveCurrentItemBottom(self):
292	layer, group = self.GetSelectedHierarchy()
293
294	if layer is not None:
295	self.map.MoveLayerToBottom(layer)
296	else:
297	assert False, "Shouldn't be allowed."
298	pass
299
300	def OnCompareItems(self, item1, item2):
301
302	data1 = self.GetPyData(item1)
303	data2 = self.GetPyData(item2)
304
305	if isinstance(data1, BaseLayer):
306	layers = self.map.Layers()
307	return layers.index(data2) - layers.index(data1)
308	else:
309	return wxTreeCtrl.OnCompareItems(self, item1, item2)
310
311	def DoOnShowLayer(self):
312	layer, group = self.GetSelectedHierarchy()
313	layer.SetVisible(True)
314
315	def DoOnHideLayer(self):
316	layer, group = self.GetSelectedHierarchy()
317	layer.SetVisible(False)
318
319	def Sort(self):
320	self.SortChildren(self.GetRootItem())
321
322	def GetSelectedHierarchy(self):
323	id = self.GetSelection()
324
325	if not id.IsOk():
326	return (None, None)
327
328	layer = self.GetPyData(id)
329	group = None
330
331	if isinstance(layer, ClassGroup):
332	id = self.GetItemParent(id)
333	assert id.IsOk()
334	group = layer
335	layer = self.GetPyData(id)
336
337	return (layer, group)
338
339	def _OnMsgMapsChanged(self):
340	#print self.map is self.mainWindow.Map()
341	self.SetMap(self.mainWindow.Map())
342
343	def _OnSelChanged(self, event):
344	# If we change the selection from normalize_selection do nothing.
345	if self.changing_selection:
346	return
347
348	self.normalize_selection()
349	self.__UpdateSelection()
350
351	def normalize_selection(self):
352	"""Select the layer containing currently selected item"""
353	# This is really a workaround for a bug in wx where deleting a
354	# subtree with DeleteChildren does not update the selection
355	# properly and can lead to segfaults later because the return
356	# value of GetSelection points to invalid data.
357	item = self.GetSelection()
358	while item.IsOk():
359	object = self.GetPyData(item)
360	if isinstance(object, BaseLayer):
361	break
362	item = self.GetItemParent(item)
363	else:
364	# No layer was found in the chain of parents, so there's
365	# nothing we can do.
366	return
367
368	self.changing_selection = 1
369	try:
370	self.SelectItem(item)
371	finally:
372	self.changing_selection = 0
373
374
375	def _OnItemActivated(self, event):
376	self.parent.DoOnProperties()
377
378	def _OnMsgLayerChanged(self, layer):
379	assert isinstance(layer, BaseLayer)
380
381	id = self.layer2id[layer]
382	assert id.IsOk()
383
384	self.__FillTreeLayer(id)
385	self.__UpdateSelection()
386
387	def _OnMsgMapStackingChanged(self, *args):
388	self.Sort()
389	id = self.GetSelection()
390
391	if id.IsOk():
392	self.EnsureVisible(id)
393	self.__UpdateSelection()
394
395	def _OnMsgMapLayersAdded(self, map):
396	assert map is self.map
397
398	root = self.GetRootItem()
399
400	i = 0
401	for l in map.Layers():
402	if not self.layer2id.has_key(l):
403	self.__AddLayer(i, l)
404
405	self.__UpdateSelection()
406
407	def _OnMsgMapLayersRemoved(self, map):
408	assert map is self.map
409
410	layers = map.Layers()
411
412	for layer, id in self.layer2id.items():
413	if layer not in layers:
414	if id.IsOk():
415	self.__RemoveLayer(id)
416
417	self.__UpdateSelection()
418
419	def _OnMsgLayerVisibilityChanged(self, layer):
420	assert isinstance(layer, BaseLayer)
421
422	self.__ShowHideLayer(layer)
423	self.__UpdateSelection()
424
425	def _OnMsgLayerTitleChanged(self, layer):
426
427	id = self.layer2id[layer]
428	if id.IsOk():
429	self.SetItemText(id, layer.Title())
430	self.__UpdateSelection()
431
432	def __UpdateSelection(self):
433	layer, group = self.GetSelectedHierarchy()
434	self.parent.DoOnSelChanged(layer, group)
435
436	def __FillTree(self, map):
437
438	self.Freeze()
439
440	self.DeleteAllItems()
441
442	if map.HasLayers():
443	root = self.GetRootItem()
444	for l in map.Layers():
445	self.__AddLayer(0, l)
446
447	self.Thaw()
448
449	def __FillTreeLayer(self, pid):
450	layer = self.GetPyData(pid)
451
452	self.Freeze()
453
454	self.DeleteChildren(pid)
455
456	if layer.HasClassification():
457
458	clazz = layer.GetClassification()
459
460	shapeType = layer.ShapeType()
461
462	show = layer.Visible()
463	for g in clazz:
464	if g.IsVisible():
465	id = self.AppendItem(pid, g.GetDisplayText())
466	self.SetPyData(id, g)
467	self.__SetVisibilityStyle(show, id)
468
469	bmp = self.__BuildGroupImage(g, shapeType)
470
471	if bmp is None:
472	self.SetItemImage(id, -1)
473	self.SetItemSelectedImage(id, -1)
474	else:
475	if self.availImgListIndices:
476	i = self.availImgListIndices.pop(0)
477	self.image_list.Replace(i, bmp)
478	else:
479	i = self.image_list.Add(bmp)
480
481	self.SetItemImage(id, i)
482	self.SetItemSelectedImage(id, i)
483
484	self.Thaw()
485
486	def __BuildGroupImage(self, group, shapeType):
487
488	bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
489	#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
490	dc = wxMemoryDC()
491	dc.SelectObject(bmp)
492	dc.Clear()
493
494	self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
495
496	return bmp
497
498	def DeleteAllItems(self):
499
500	pid = self.GetRootItem()
501
502	id, cookie = self.GetFirstChild(pid, 123)
503	while id.IsOk():
504	self.__RemoveLayer(id)
505	id, cookie = self.GetNextChild(pid, cookie)
506
507	wxTreeCtrl.DeleteAllItems(self)
508
509	def __AddLayer(self, before, l):
510	root = self.GetRootItem()
511	id = self.InsertItemBefore(root, before,
512	l.Title(),
513	self.mapImageIndex,
514	self.mapImageIndex)
515
516	self.SetPyData(id, l)
517	self.__SetVisibilityStyle(l.Visible(), id)
518
519	self.layer2id[l] = id
520
521	self.__FillTreeLayer(id)
522	self.Expand(id)
523
524	l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
525	l.Subscribe(LAYER_VISIBILITY_CHANGED,
526	self._OnMsgLayerVisibilityChanged)
527	l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
528
529	def __RemoveLayer(self, id):
530	self.DeleteChildren(id)
531
532	layer = self.GetPyData(id)
533	layer.Unsubscribe(LAYER_CHANGED,
534	self._OnMsgLayerChanged)
535	layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
536	self._OnMsgLayerVisibilityChanged)
537	layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
538
539	self.Delete(id)
540	del self.layer2id[layer]
541
542	def DeleteChildren(self, pid):
543	id, cookie = self.GetFirstChild(pid, 123)
544	while id.IsOk():
545	self.availImgListIndices.append(self.GetItemImage(id))
546	id, cookie = self.GetNextChild(pid, cookie)
547	wxTreeCtrl.DeleteChildren(self, pid)
548
549	def GetRootItem(self):
550	root = wxTreeCtrl.GetRootItem(self)
551
552	if not root.IsOk():
553	self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
554
555	bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
556	dc = wxMemoryDC()
557	dc.SelectObject(bmp)
558	dc.SetBrush(wxBLACK_BRUSH)
559	dc.Clear()
560	dc.SelectObject(wxNullBitmap)
561
562	self.emptyImageIndex = \
563	self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
564
565	bmp = resource.GetBitmapResource("legend_icon_layer",
566	wxBITMAP_TYPE_XPM)
567	self.mapImageIndex = \
568	self.image_list.Add(bmp)
569
570	self.AssignImageList(self.image_list)
571	self.availImgListIndices = []
572
573	root = self.AddRoot("")
574
575	return root
576
577	def __SetVisibilityStyle(self, visible, id):
578	font = self.GetItemFont(id)
579
580	if visible:
581	font.SetStyle(wxNORMAL)
582	color = wxBLACK
583	else:
584	#font.SetStyle(wxITALIC)
585	font.SetStyle(wxNORMAL)
586	color = wxLIGHT_GREY
587
588	self.SetItemTextColour(id, color)
589	self.SetItemFont(id, font)
590
591	def __ShowHideLayer(self, layer):
592	parent = self.layer2id[layer]
593	assert parent.IsOk()
594
595	visible = layer.Visible()
596
597	self.__SetVisibilityStyle(visible, parent)
598
599	id, cookie = self.GetFirstChild(parent, 123)
600
601	while id.IsOk():
602	self.__SetVisibilityStyle(visible, id)
603	id, cookie = self.GetNextChild(parent, cookie)
604
605	class ScaleBarBitmap(wxBoxSizer):
606
607	def __init__(self, parent, map, mainWindow):
608	# While the width is fixed, get the height _now_.
609	dc = wxMemoryDC()
610	textwidth, textheight = dc.GetTextExtent("%d"%0)
611	self.width = 210
612	self.height = textheight + 3*2 + 8
613
614	wxBoxSizer.__init__(self, wxVERTICAL)
615	bmp=wxEmptyBitmap(self.width, self.height)
616	self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
617	self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER\|wxLEFT\|wxTOP\|wxRIGHT, 1)
618
619	self.mainWindow = mainWindow
620	self.parent = parent
621	self.canvas = None
622	self.SetCanvas(self.mainWindow.canvas)
623
624	def SetCanvas(self, canvas):
625	sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
626
627	if self.canvas is not None:
628	for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
629
630	self.canvas = canvas
631	self.scalebar = ScaleBar(canvas.map)
632
633	if self.canvas is not None:
634	for msg, func in sub_list: self.canvas.Subscribe(msg, func)
635	self.__SetScale(self.canvas.scale)
636
637	def _OnMsgScaleChanged(self, scale):
638	self.__SetScale(scale)
639
640	def __SetScale(self, scale):
641	bmp = wxEmptyBitmap(self.width, self.height)
642	dc = wxMemoryDC()
643	dc.SelectObject(bmp)
644	dc.Clear()
645
646	self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
647
648	self.scalebarBitmap.SetBitmap(bmp)
649
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision