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

        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)
            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			layer, group = self.GetSelectedHierarchy()
411
412			if layer is None:
413			assert False, "Shouldn't be allowed."
414			return
415
416			layers = map.Layers()
417
418			for layer, id in self.layer2id.items():
419			if layer not in layers:
420			if id.IsOk():
421			self.__RemoveLayer(id)
422
423			self.__UpdateSelection()
424
425	jonathan	572	def _OnMsgLayerVisibilityChanged(self, layer):
426	jonathan	936	assert isinstance(layer, BaseLayer)
427	jonathan	572
428			self.__ShowHideLayer(layer)
429	jonathan	655	self.__UpdateSelection()
430	jonathan	572
431	jonathan	652	def _OnMsgLayerTitleChanged(self, layer):
432
433			id = self.layer2id[layer]
434			if id.IsOk():
435			self.SetItemText(id, layer.Title())
436	jonathan	655	self.__UpdateSelection()
437	jonathan	652
438	jonathan	655	def __UpdateSelection(self):
439			layer, group = self.GetSelectedHierarchy()
440			self.parent.DoOnSelChanged(layer, group)
441
442	jonathan	542	def __FillTree(self, map):
443
444			self.Freeze()
445
446	jonathan	1102	self.DeleteAllItems()
447	jonathan	542
448			if map.HasLayers():
449	jonathan	1102	root = self.GetRootItem()
450	jonathan	542	for l in map.Layers():
451	jonathan	1102	self.__AddLayer(0, l)
452	frank	1050
453	jonathan	542	self.Thaw()
454
455			def __FillTreeLayer(self, pid):
456			layer = self.GetPyData(pid)
457
458			self.Freeze()
459
460			self.DeleteChildren(pid)
461
462	jonathan	936	if layer.HasClassification():
463	jonathan	542
464	jonathan	936	clazz = layer.GetClassification()
465	jonathan	542
466	jonathan	936	shapeType = layer.ShapeType()
467	jonathan	542
468	jonathan	936	show = layer.Visible()
469			for g in clazz:
470			if g.IsVisible():
471			id = self.AppendItem(pid, g.GetDisplayText())
472			self.SetPyData(id, g)
473			self.__SetVisibilityStyle(show, id)
474	jonathan	542
475	jonathan	936	bmp = self.__BuildGroupImage(g, shapeType)
476	jonathan	542
477	jonathan	936	if bmp is None:
478	frank	1050	self.SetItemImage(id, -1)
479			self.SetItemSelectedImage(id, -1)
480	jonathan	936	else:
481	jonathan	1102	if self.availImgListIndices:
482			i = self.availImgListIndices.pop(0)
483			self.image_list.Replace(i, bmp)
484			else:
485			i = self.image_list.Add(bmp)
486
487	jonathan	936	self.SetItemImage(id, i)
488	frank	1050	self.SetItemSelectedImage(id, i)
489	jonathan	936
490	jonathan	542	self.Thaw()
491
492			def __BuildGroupImage(self, group, shapeType):
493
494			bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
495			#brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
496			dc = wxMemoryDC()
497			dc.SelectObject(bmp)
498			dc.Clear()
499
500			self.previewer.Draw(dc, None, group.GetProperties(), shapeType)
501
502			return bmp
503
504	jonathan	1102	def DeleteAllItems(self):
505	jonathan	542
506	jonathan	1102	pid = self.GetRootItem()
507	jonathan	542
508	jonathan	1102	id, cookie = self.GetFirstChild(pid, 123)
509			while id.IsOk():
510			self.__RemoveLayer(id)
511			id, cookie = self.GetNextChild(pid, cookie)
512	jonathan	578
513	jonathan	1102	wxTreeCtrl.DeleteAllItems(self)
514
515			def __AddLayer(self, before, l):
516			root = self.GetRootItem()
517			id = self.InsertItemBefore(root, before,
518			l.Title(),
519			self.mapImageIndex,
520			self.mapImageIndex)
521
522			self.SetPyData(id, l)
523			self.__SetVisibilityStyle(l.Visible(), id)
524
525			self.layer2id[l] = id
526
527			self.__FillTreeLayer(id)
528			self.Expand(id)
529
530			l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
531			l.Subscribe(LAYER_VISIBILITY_CHANGED,
532			self._OnMsgLayerVisibilityChanged)
533			l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
534
535			def __RemoveLayer(self, id):
536			self.DeleteChildren(id)
537
538			layer = self.GetPyData(id)
539			layer.Unsubscribe(LAYER_CHANGED,
540			self._OnMsgLayerChanged)
541			layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
542			self._OnMsgLayerVisibilityChanged)
543			layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
544
545			self.Delete(id)
546			del self.layer2id[layer]
547
548			def DeleteChildren(self, pid):
549			id, cookie = self.GetFirstChild(pid, 123)
550			while id.IsOk():
551			self.availImgListIndices.append(self.GetItemImage(id))
552			id, cookie = self.GetNextChild(pid, cookie)
553			wxTreeCtrl.DeleteChildren(self, pid)
554
555			def GetRootItem(self):
556			root = wxTreeCtrl.GetRootItem(self)
557
558			if not root.IsOk():
559			self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
560	bh	1115
561	jonathan	1102	bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
562			dc = wxMemoryDC()
563			dc.SelectObject(bmp)
564			dc.SetBrush(wxBLACK_BRUSH)
565			dc.Clear()
566			dc.SelectObject(wxNullBitmap)
567	bh	1115
568	jonathan	1102	self.emptyImageIndex = \
569			self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
570	bh	1115
571	jonathan	1102	bmp = resource.GetBitmapResource("legend_icon_layer",
572			wxBITMAP_TYPE_XPM)
573			self.mapImageIndex = \
574			self.image_list.Add(bmp)
575
576			self.AssignImageList(self.image_list)
577	bh	1115	self.availImgListIndices = []
578	jonathan	1102
579			root = self.AddRoot("")
580
581			return root
582
583	jonathan	632	def __SetVisibilityStyle(self, visible, id):
584	jonathan	572	font = self.GetItemFont(id)
585	jonathan	542
586	jonathan	632	if visible:
587	jonathan	572	font.SetStyle(wxNORMAL)
588			color = wxBLACK
589			else:
590	frank	980	#font.SetStyle(wxITALIC)
591			font.SetStyle(wxNORMAL)
592	jonathan	572	color = wxLIGHT_GREY
593	jonathan	542
594	jonathan	572	self.SetItemTextColour(id, color)
595			self.SetItemFont(id, font)
596
597			def __ShowHideLayer(self, layer):
598			parent = self.layer2id[layer]
599	jonathan	605	assert parent.IsOk()
600	jonathan	542
601	jonathan	632	visible = layer.Visible()
602	jonathan	542
603	jonathan	632	self.__SetVisibilityStyle(visible, parent)
604	jonathan	542
605	jonathan	572	id, cookie = self.GetFirstChild(parent, 123)
606	jonathan	542
607	jonathan	572	while id.IsOk():
608	jonathan	632	self.__SetVisibilityStyle(visible, id)
609	jonathan	572	id, cookie = self.GetNextChild(parent, cookie)
610
611	frank	854	class ScaleBarBitmap(wxBoxSizer):
612
613			def __init__(self, parent, map, mainWindow):
614			# While the width is fixed, get the height _now_.
615			dc = wxMemoryDC()
616			textwidth, textheight = dc.GetTextExtent("%d"%0)
617	frank	990	self.width = 210
618	frank	854	self.height = textheight + 3*2 + 8
619
620			wxBoxSizer.__init__(self, wxVERTICAL)
621			bmp=wxEmptyBitmap(self.width, self.height)
622			self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
623			self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER\|wxLEFT\|wxTOP\|wxRIGHT, 1)
624
625			self.mainWindow = mainWindow
626			self.parent = parent
627			self.canvas = None
628			self.SetCanvas(self.mainWindow.canvas)
629
630			def SetCanvas(self, canvas):
631			sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
632
633			if self.canvas is not None:
634			for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
635
636			self.canvas = canvas
637	frank	858	self.scalebar = ScaleBar(canvas.map)
638	frank	854
639			if self.canvas is not None:
640			for msg, func in sub_list: self.canvas.Subscribe(msg, func)
641			self.__SetScale(self.canvas.scale)
642
643			def _OnMsgScaleChanged(self, scale):
644			self.__SetScale(scale)
645
646			def __SetScale(self, scale):
647			bmp = wxEmptyBitmap(self.width, self.height)
648			dc = wxMemoryDC()
649			dc.SelectObject(bmp)
650			dc.Clear()
651
652	frank	914	self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
653	frank	854
654			self.scalebarBitmap.SetBitmap(bmp)
655
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision