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	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	bh	1113	self.changing_selection = 0
206	jonathan	542
207	jonathan	1102	#
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	jonathan	542	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	jonathan	572	EVT_CLOSE(self, self._OnClose)
228
229	jonathan	562	self.SetMap(map)
230	jonathan	542
231	jonathan	572	def _OnClose(self, event):
232			self.SetMap(None)
233
234	jonathan	562	def GetMap(self):
235			return self.map
236	jonathan	542
237	jonathan	562	def SetMap(self, map):
238
239			sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
240	jonathan	1102	(MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
241			(MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
242	jonathan	562
243			if self.map is not None:
244			for msg, func in sub_list: self.map.Unsubscribe(msg, func)
245	jonathan	572	#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	jonathan	1102	self.DeleteAllItems()
253	jonathan	562
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	jonathan	572	#self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
259			#self._OnMsgMapsChanged)
260			#self.mainWindow.application.Subscribe(SESSION_REPLACED,
261			#self._OnMsgMapsChanged)
262	jonathan	562	self.__FillTree(self.map)
263
264	frank	990	def MoveCurrentItemTop(self):
265			layer, group = self.GetSelectedHierarchy()
266
267			if layer is not None:
268	jonathan	1102	self.map.MoveLayerToTop(layer)
269	frank	990	else:
270			assert False, "Shouldn't be allowed."
271			pass
272
273	jonathan	542	def MoveCurrentItemUp(self):
274	jonathan	795	layer, group = self.GetSelectedHierarchy()
275	jonathan	542
276	jonathan	795	if layer is not None:
277			self.map.RaiseLayer(layer)
278	jonathan	542	else:
279	jonathan	795	assert False, "Shouldn't be allowed."
280	jonathan	542	pass
281
282			def MoveCurrentItemDown(self):
283	jonathan	795	layer, group = self.GetSelectedHierarchy()
284	jonathan	542
285	jonathan	795	if layer is not None:
286			self.map.LowerLayer(layer)
287	jonathan	542	else:
288	jonathan	795	assert False, "Shouldn't be allowed."
289	jonathan	542	pass
290
291	frank	990	def MoveCurrentItemBottom(self):
292			layer, group = self.GetSelectedHierarchy()
293
294			if layer is not None:
295	jonathan	1102	self.map.MoveLayerToBottom(layer)
296	frank	990	else:
297			assert False, "Shouldn't be allowed."
298			pass
299
300	jonathan	542	def OnCompareItems(self, item1, item2):
301
302			data1 = self.GetPyData(item1)
303			data2 = self.GetPyData(item2)
304
305	jonathan	936	if isinstance(data1, BaseLayer):
306	jonathan	542	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	jonathan	572	layer, group = self.GetSelectedHierarchy()
313			layer.SetVisible(True)
314	jonathan	542
315			def DoOnHideLayer(self):
316	jonathan	572	layer, group = self.GetSelectedHierarchy()
317			layer.SetVisible(False)
318	jonathan	542
319			def Sort(self):
320			self.SortChildren(self.GetRootItem())
321
322	jonathan	655	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	jonathan	572	def _OnMsgMapsChanged(self):
340	jonathan	639	#print self.map is self.mainWindow.Map()
341	jonathan	572	self.SetMap(self.mainWindow.Map())
342
343	jonathan	542	def _OnSelChanged(self, event):
344	bh	1113	# If we change the selection from normalize_selection do nothing.
345			if self.changing_selection:
346			return
347
348			self.normalize_selection()
349	jonathan	655	self.__UpdateSelection()
350	jonathan	542
351	bh	1113	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	jonathan	542	def _OnItemActivated(self, event):
376	jonathan	639	self.parent.DoOnProperties()
377	jonathan	542
378			def _OnMsgLayerChanged(self, layer):
379	jonathan	936	assert isinstance(layer, BaseLayer)
380	jonathan	542
381			id = self.layer2id[layer]
382	jonathan	605	assert id.IsOk()
383	jonathan	542
384	jonathan	1102	self.__FillTreeLayer(id)
385	jonathan	655	self.__UpdateSelection()
386	jonathan	542
387			def _OnMsgMapStackingChanged(self, *args):
388			self.Sort()
389	jonathan	562	id = self.GetSelection()
390	jonathan	542
391	jonathan	562	if id.IsOk():
392			self.EnsureVisible(id)
393	jonathan	655	self.__UpdateSelection()
394	jonathan	562
395	jonathan	1102	def _OnMsgMapLayersAdded(self, map):
396	jonathan	605	assert map is self.map
397	jonathan	542
398	jonathan	1102	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	jonathan	655	self.__UpdateSelection()
406	jonathan	542
407	jonathan	1102	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	jonathan	572	def _OnMsgLayerVisibilityChanged(self, layer):
420	jonathan	936	assert isinstance(layer, BaseLayer)
421	jonathan	572
422			self.__ShowHideLayer(layer)
423	jonathan	655	self.__UpdateSelection()
424	jonathan	572
425	jonathan	652	def _OnMsgLayerTitleChanged(self, layer):
426
427			id = self.layer2id[layer]
428			if id.IsOk():
429			self.SetItemText(id, layer.Title())
430	jonathan	655	self.__UpdateSelection()
431	jonathan	652
432	jonathan	655	def __UpdateSelection(self):
433			layer, group = self.GetSelectedHierarchy()
434			self.parent.DoOnSelChanged(layer, group)
435
436	jonathan	542	def __FillTree(self, map):
437
438			self.Freeze()
439
440	jonathan	1102	self.DeleteAllItems()
441	jonathan	542
442			if map.HasLayers():
443	jonathan	1102	root = self.GetRootItem()
444	jonathan	542	for l in map.Layers():
445	jonathan	1102	self.__AddLayer(0, l)
446	frank	1050
447	jonathan	542	self.Thaw()
448
449			def __FillTreeLayer(self, pid):
450			layer = self.GetPyData(pid)
451
452			self.Freeze()
453
454			self.DeleteChildren(pid)
455
456	jonathan	936	if layer.HasClassification():
457	jonathan	542
458	jonathan	936	clazz = layer.GetClassification()
459	jonathan	542
460	jonathan	936	shapeType = layer.ShapeType()
461	jonathan	542
462	jonathan	936	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	jonathan	542
469	jonathan	936	bmp = self.__BuildGroupImage(g, shapeType)
470	jonathan	542
471	jonathan	936	if bmp is None:
472	frank	1050	self.SetItemImage(id, -1)
473			self.SetItemSelectedImage(id, -1)
474	jonathan	936	else:
475	jonathan	1102	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	jonathan	936	self.SetItemImage(id, i)
482	frank	1050	self.SetItemSelectedImage(id, i)
483	jonathan	936
484	jonathan	542	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	jonathan	1102	def DeleteAllItems(self):
499	jonathan	542
500	jonathan	1102	pid = self.GetRootItem()
501	jonathan	542
502	jonathan	1102	id, cookie = self.GetFirstChild(pid, 123)
503			while id.IsOk():
504			self.__RemoveLayer(id)
505			id, cookie = self.GetNextChild(pid, cookie)
506	jonathan	578
507	jonathan	1102	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	bh	1115
555	jonathan	1102	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	bh	1115
562	jonathan	1102	self.emptyImageIndex = \
563			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
564	bh	1115
565	jonathan	1102	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	bh	1115	self.availImgListIndices = []
572	jonathan	1102
573			root = self.AddRoot("")
574
575			return root
576
577	jonathan	632	def __SetVisibilityStyle(self, visible, id):
578	jonathan	572	font = self.GetItemFont(id)
579	jonathan	542
580	jonathan	632	if visible:
581	jonathan	572	font.SetStyle(wxNORMAL)
582			color = wxBLACK
583			else:
584	frank	980	#font.SetStyle(wxITALIC)
585			font.SetStyle(wxNORMAL)
586	jonathan	572	color = wxLIGHT_GREY
587	jonathan	542
588	jonathan	572	self.SetItemTextColour(id, color)
589			self.SetItemFont(id, font)
590
591			def __ShowHideLayer(self, layer):
592			parent = self.layer2id[layer]
593	jonathan	605	assert parent.IsOk()
594	jonathan	542
595	jonathan	632	visible = layer.Visible()
596	jonathan	542
597	jonathan	632	self.__SetVisibilityStyle(visible, parent)
598	jonathan	542
599	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
600	jonathan	542
601	jonathan	572	while id.IsOk():
602	jonathan	632	self.__SetVisibilityStyle(visible, id)
603	jonathan	572	id, cookie = self.GetNextChild(parent, cookie)
604
605	frank	854	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	frank	990	self.width = 210
612	frank	854	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	frank	858	self.scalebar = ScaleBar(canvas.map)
632	frank	854
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	frank	914	self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
647	frank	854
648			self.scalebarBitmap.SetBitmap(bmp)
649
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision