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.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 find_layer(self, layer):
        """Return the tree item for the layer"""
        root = self.GetRootItem()
        id, cookie = self.GetFirstChild(root, 0)
        while id.IsOk():
            if self.GetPyData(id) is layer:
                return id
            id, cookie = self.GetNextChild(root, cookie)
        return None

    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.find_layer(layer)
        assert id is not None

        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

        # Build a dict with all layers known by the the tree as keys
        layers = {}
        root = self.GetRootItem()
        id, cookie = self.GetFirstChild(root, 0)
        while id.IsOk():
            layers[self.GetPyData(id)] = 1
            id, cookie = self.GetNextChild(root, cookie)

        # Add layers in the map but not in the dict
        i = 0
        for l in map.Layers():
            if not l in layers:
                self.__AddLayer(i, l)

        self.__UpdateSelection()

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

        layers = map.Layers()

        root = self.GetRootItem()
        id, cookie = self.GetFirstChild(root, 0)
        while id.IsOk():
            if self.GetPyData(id) not in layers:
                self.__RemoveLayer(id)
            id, cookie = self.GetNextChild(root, cookie)


        self.__UpdateSelection()

    def _OnMsgLayerVisibilityChanged(self, layer):
        assert isinstance(layer, BaseLayer)

        self.__ShowHideLayer(layer)
        self.__UpdateSelection()

    def _OnMsgLayerTitleChanged(self, layer):

        id = self.find_layer(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.__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)

    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.find_layer(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()

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