Thuban/UI/mainwindow.py

# Copyright (C) 2001, 2002 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]>
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
The main window
"""

__version__ = "$Revision$"

import os

from wxPython.wx import *

import Thuban
from Thuban.Model.session import create_empty_session
from Thuban.Model.layer import Layer
from Thuban.Model.color import Color
from Thuban.Model.proj import Projection

import view
import tree
import proj4dialog
import tableview, identifyview
from menu import Menu

from context import Context
from command import registry, Command
from messages import SELECTED_SHAPE, VIEW_POSITION


# the directory where the toolbar icons are stored
bitmapdir = os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Bitmaps")
bitmapext = ".xpm"


class MainWindow(wxFrame):

    def __init__(self, parent, ID, title, application, interactor,
                 initial_message = None):
        wxFrame.__init__(self, parent, ID, title, wxDefaultPosition,
                         wxSize(400, 300))

        self.application = application
        self.interactor = interactor

        self.CreateStatusBar()
        if initial_message:
            self.SetStatusText(initial_message)

        self.identify_view = None

        self.init_ids()

        # creat the menubar from the main_menu description
        self.SetMenuBar(self.build_menu_bar(main_menu))

        # Similarly, create the toolbar from main_toolbar
        toolbar = self.build_toolbar(main_toolbar)
        # call Realize to make sure that the tools appear.
        toolbar.Realize()

        # Create the map canvas
        canvas = view.MapCanvas(self, -1, interactor)
        canvas.Subscribe(VIEW_POSITION, self.view_position_changed)
        self.canvas = canvas

        self.init_dialogs()

        interactor.Subscribe(SELECTED_SHAPE, self.identify_view_on_demand)

        EVT_CLOSE(self, self.OnClose)

    def init_ids(self):
        """Initialize the ids"""
        self.current_id = 6000
        self.id_to_name = {}
        self.name_to_id = {}
        self.events_bound = {}

    def get_id(self, name):
        """Return the wxWindows id for the command named name.

        Create a new one if there isn't one yet"""
        ID = self.name_to_id.get(name)
        if ID is None:
            ID = self.current_id
            self.current_id = self.current_id + 1
            self.name_to_id[name] = ID
            self.id_to_name[ID] = name
        return ID

    def bind_command_events(self, command, ID):
        """Bind the necessary events for the given command and ID"""
        if not self.events_bound.has_key(ID):
            # the events haven't been bound yet
            EVT_MENU(self, ID, self.invoke_command)
            if command.IsDynamic():
                EVT_UPDATE_UI(self, ID, self.update_command_ui)

    def build_menu_bar(self, menudesc):
        """Build and return the menu bar from the menu description"""
        menu_bar = wxMenuBar()

        for item in menudesc.items:
            # here the items must all be Menu instances themselves
            menu_bar.Append(self.build_menu(item), item.title)

        return menu_bar

    def build_menu(self, menudesc):
        """Build and return a wxMenu from a menudescription"""
        wxmenu = wxMenu()
        last = None
        for item in menudesc.items:
            # here the items must all be Menu instances themselves
            if item is None:
                # a separator. Only add one if the last item was not a
                # separator
                if last is not None:
                    wxmenu.AppendSeparator()
            elif isinstance(item, Menu):
                # a submenu
                wxmenu.AppendMenu(wxNewId(), item.title, self.build_menu(item))
            else:
                # must the name the name of a command
                self.add_menu_command(wxmenu, item)
            last = item
        return wxmenu

    def build_toolbar(self, toolbardesc):
        """Build and return the main toolbar window from a toolbar description

        The parameter should be an instance of the Menu class but it
        should not contain submenus.
        """
        toolbar = self.CreateToolBar(wxTB_3DBUTTONS)

        # set the size of the tools' bitmaps. Not needed on wxGTK, but
        # on Windows, although it doesn't work very well there. It seems
        # that only 16x16 icons are really supported on windows.
        # We probably shouldn't hardwire the bitmap size here.
        toolbar.SetToolBitmapSize(wxSize(24, 24))

        for item in toolbardesc.items:
            if item is None:
                toolbar.AddSeparator()
            else:
                # assume it's a string.
                self.add_toolbar_command(toolbar, item)

        return toolbar

    def add_menu_command(self, menu, name):
        """Add the command with name name to the menu menu.

        If name is None, add a separator.
        """
        if name is None:
            menu.AppendSeparator()
        else:
            command = registry.Command(name)
            if command is not None:
                ID = self.get_id(name)
                menu.Append(ID, command.Title(), command.HelpText(),
                            command.IsCheckCommand())
                self.bind_command_events(command, ID)
            else:
                print "Unknown command %s" % name

    def add_toolbar_command(self, toolbar, name):
        """Add the command with name name to the toolbar toolbar.

        If name is None, add a separator.
        """
        # Assume that all toolbar commands are also menu commmands so
        # that we don't have to add the event handlers here
        if name is None:
            toolbar.AddSeparator()
        else:
            command = registry.Command(name)
            if command is not None:
                ID = self.get_id(name)
                filename = os.path.join(bitmapdir, command.Icon()) + bitmapext
                bitmap = wxBitmap(filename, wxBITMAP_TYPE_XPM)
                toolbar.AddTool(ID, bitmap,
                                shortHelpString = command.HelpText(),
                                isToggle = command.IsCheckCommand())
                self.bind_command_events(command, ID)
            else:
                print "Unknown command %s" % name

    def invoke_command(self, event):
        name = self.id_to_name.get(event.GetId())
        if name is not None:
            command = registry.Command(name)
            context = Context(self.application, self.application.Session(),
                              self)
            command.Execute(context)
        else:
            print "Unknown command ID %d" % event.GetId()

    def update_command_ui(self, event):
        #print "update_command_ui", self.id_to_name[event.GetId()]
        context = Context(self.application, self.application.Session(), self)
        command = registry.Command(self.id_to_name[event.GetId()])
        if command is not None:
            event.Enable(command.Sensitive(context))
            event.SetText(command.DynText(context))
            if command.IsCheckCommand():
                event.Check(command.Checked(context))

    def RunMessageBox(self, title, text, flags = wxOK | wxICON_INFORMATION):
        """Run a modal message box with the given text, title and flags
        and return the result"""
        dlg = wxMessageDialog(self, text, title, flags)
        result = dlg.ShowModal()
        dlg.Destroy()
        return result

    def init_dialogs(self):
        """Initialize the dialog handling"""
        # The mainwindow maintains a dict mapping names to open
        # non-modal dialogs. The dialogs are put into this dict when
        # they're created and removed when they're closed
        self.dialogs = {}

    def add_dialog(self, name, dialog):
        if self.dialogs.has_key(name):
            raise RuntimeError("The Dialog named %s is already open" % name)
        self.dialogs[name] = dialog

    def dialog_open(self, name):
        return self.dialogs.has_key(name)

    def remove_dialog(self, name):
        del self.dialogs[name]

    def get_open_dialog(self, name):
        return self.dialogs.get(name)

    def view_position_changed(self):
        pos = self.canvas.CurrentPosition()
        if pos is not None:
            text = "(%10.10g, %10.10g)" % pos
        else:
            text = ""
        self.SetStatusText(text)

    def save_modified_session(self, can_veto = 1):
        """If the current session has been modified, ask the user
        whether to save it and do so if requested. Return the outcome of
        the dialog (either wxID_OK, wxID_CANCEL or wxID_NO). If the
        dialog wasn't run return wxID_NO.

        If the can_veto parameter is true (default) the dialog includes
        a cancel button, otherwise not.
        """
        if self.application.session.WasModified():
            flags = wxYES_NO | wxICON_QUESTION
            if can_veto:
                flags = flags | wxCANCEL
            result = self.RunMessageBox("Exit",
                                        ("The session has been modified."
                                         " Do you want to save it?"),
                                        flags)
            if result == wxID_YES:
                self.SaveSession()
        else:
            result = wxID_NO
        return result

    def NewSession(self):
        self.save_modified_session()
        self.application.SetSession(create_empty_session())

    def OpenSession(self):
        self.save_modified_session()
        dlg = wxFileDialog(self, "Select a session file", ".", "",
                           "*.thuban", wxOPEN)
        if dlg.ShowModal() == wxID_OK:
            self.application.OpenSession(dlg.GetPath())
        dlg.Destroy()

    def SaveSession(self):
        if self.application.session.filename == None:
            self.SaveSessionAs()
        self.application.SaveSession()

    def SaveSessionAs(self):
        dlg = wxFileDialog(self, "Enter a filename for session", ".", "",
                           "*.thuban", wxOPEN)
        if dlg.ShowModal() == wxID_OK:
            self.application.session.SetFilename(dlg.GetPath())
            self.application.SaveSession()
        dlg.Destroy()

    def Exit(self):
        self.Close(false)

    def OnClose(self, event):
        result = self.save_modified_session(can_veto = event.CanVeto())
        if result == wxID_CANCEL:
            event.Veto()
        else:
            self.Destroy()

    def SetMap(self, map):
        self.canvas.SetMap(map)

    def ShowSessionTree(self):
        name = "session_tree"
        dialog = self.get_open_dialog(name)
        if dialog is None:
            dialog = tree.SessionTreeView(self, self.application, name)
            self.add_dialog(name, dialog)
            dialog.Show(true)
        else:
            # FIXME: bring dialog to front here
            pass

    def About(self):
        self.RunMessageBox("About",
                           ("Thuban is a program for\n"
                            "exploring geographic data.\n"
                            "Copyright (C) 2001 Intevation GmbH.\n"
                            "Thuban is licensed under the GPL"),
                           wxOK | wxICON_INFORMATION)

    def AddLayer(self):
        dlg = wxFileDialog(self, "Select a data file", ".", "", "*.*",
                           wxOPEN)
        if dlg.ShowModal() == wxID_OK:
            filename = dlg.GetPath()
            title = os.path.splitext(os.path.basename(filename))[0]
            layer = Layer(title, filename)
            map = self.canvas.Map()
            has_layers = map.HasLayers()
            try:
                map.AddLayer(layer)
            except IOError:
                # the layer couldn't be opened
                self.RunMessageBox("Add Layer",
                                   "Can't open the file '%s'." % filename)
            else:
                if not has_layers:
                    # if we're adding a layer to an empty map, for the
                    # new map to the window
                    self.canvas.FitMapToWindow()
        dlg.Destroy()

    def RemoveLayer(self):
        layer = self.current_layer()
        if layer is not None:
            self.canvas.Map().RemoveLayer(layer)

    def RaiseLayer(self):
        layer = self.current_layer()
        if layer is not None:
            self.canvas.Map().RaiseLayer(layer)

    def LowerLayer(self):
        layer = self.current_layer()
        if layer is not None:
            self.canvas.Map().LowerLayer(layer)

    def current_layer(self):
        """Return the currently selected layer.

        If no layer is selected, return None
        """
        return self.interactor.SelectedLayer()

    def has_selected_layer(self):
        """Return true if a layer is currently selected"""
        return self.interactor.HasSelectedLayer()

    def choose_color(self):
        """Run the color selection dialog and return the selected color.

        If the user cancels, return None.
        """
        dlg = wxColourDialog(self)
        color = None
        if dlg.ShowModal() == wxID_OK:
            data = dlg.GetColourData()
            wxc = data.GetColour()
            color = Color(wxc.Red() / 255.0,
                          wxc.Green() / 255.0,
                          wxc.Blue() / 255.0)
        dlg.Destroy()
        return color

    def LayerFillColor(self):
        layer = self.current_layer()
        if layer is not None:
            color = self.choose_color()
            if color is not None:
                layer.SetFill(color)

    def LayerTransparentFill(self):
        layer = self.current_layer()
        if layer is not None:
            layer.SetFill(None)

    def LayerOutlineColor(self):
        layer = self.current_layer()
        if layer is not None:
            color = self.choose_color()
            if color is not None:
                layer.SetStroke(color)

    def LayerNoOutline(self):
        layer = self.current_layer()
        if layer is not None:
            layer.SetStroke(None)

    def HideLayer(self):
        layer = self.current_layer()
        if layer is not None:
            layer.SetVisible(0)
        
    def ShowLayer(self):
        layer = self.current_layer()
        if layer is not None:
            layer.SetVisible(1)

    def LayerShowTable(self):
        layer = self.current_layer()
        if layer is not None:
            table = layer.table
            name = "table_view" + str(id(table))
            dialog = self.get_open_dialog(name)
            if dialog is None:
                dialog = tableview.TableFrame(self, self.interactor, name,
                                              "Table: %s" % layer.Title(),
                                              layer, table)
                self.add_dialog(name, dialog)
                dialog.Show(true)
            else:
                # FIXME: bring dialog to front here
                pass

    def Projection(self):
        map = self.canvas.Map()
        proj = map.projection
        if proj is None:
            proj4Dlg = proj4dialog.Proj4Dialog(NULL, None, map.BoundingBox())
        else:
            proj4Dlg = proj4dialog.Proj4Dialog(NULL, map.projection.params,
                                               map.BoundingBox())
        if proj4Dlg.ShowModal() == wxID_OK:
            params = proj4Dlg.GetParams()
            if params is not None:
                proj = Projection(params) 
            else:
                proj = None
            map.SetProjection(proj)
        proj4Dlg.Destroy()

    def ZoomInTool(self):
        self.canvas.ZoomInTool()

    def ZoomOutTool(self):
        self.canvas.ZoomOutTool()

    def PanTool(self):
        self.canvas.PanTool()

    def IdentifyTool(self):
        self.canvas.IdentifyTool()
        self.identify_view_on_demand(None, None)

    def LabelTool(self):
        self.canvas.LabelTool()

    def FullExtent(self):
        self.canvas.FitMapToWindow()

    def PrintMap(self):
        self.canvas.Print()

    def identify_view_on_demand(self, layer, shape):
        name = "identify_view"
        if self.canvas.CurrentTool() == "IdentifyTool":
            if not self.dialog_open(name):
                dialog = identifyview.IdentifyView(self, self.interactor, name)
                self.add_dialog(name, dialog)
                dialog.Show(true)
            else:
                # FIXME: bring dialog to front?
                pass

#
# Define all the commands available in the main window
#


# Helper functions to define common command implementations
def call_method(context, methodname, *args):
    """Call the mainwindow's method methodname with args *args"""
    apply(getattr(context.mainwindow, methodname), args)

def _method_command(name, title, method, helptext = "",
                    icon = "", sensitive = None):
    """Add a command implemented by a method of the mainwindow object"""
    registry.Add(Command(name, title, call_method, args=(method,),
                         helptext = helptext, icon = icon,
                         sensitive = sensitive))

def _tool_command(name, title, method, toolname, helptext = "",
                  icon = ""):
    """Add a tool command"""
    def check_current_tool(context, name=toolname):
        return context.mainwindow.canvas.CurrentTool() == name
    registry.Add(Command(name, title, call_method, args=(method,),
                         helptext = helptext, icon = icon,
                         checked = check_current_tool))

def _has_selected_layer(context):
    """Return true if a layer is selected in the context"""
    return context.mainwindow.has_selected_layer()

# File menu
_method_command("new_session", "&New Session", "NewSession")
_method_command("open_session", "&Open Session", "OpenSession")
_method_command("save_session", "&Save Session", "SaveSession")
_method_command("save_session_as", "Save Session &As", "SaveSessionAs")
_method_command("show_session_tree", "Show Session &Tree", "ShowSessionTree")
_method_command("exit", "&Exit", "Exit")

# Help menu
_method_command("help_about", "&About", "About")


# Map menu
_method_command("map_projection", "Pro&jection", "Projection")

_tool_command("map_zoom_in_tool", "&Zoom in", "ZoomInTool", "ZoomInTool",
              helptext = "Switch to map-mode 'zoom-in'", icon = "zoom_in")
_tool_command("map_zoom_out_tool", "Zoom &out", "ZoomOutTool", "ZoomOutTool",
              helptext = "Switch to map-mode 'zoom-out'", icon = "zoom_out")
_tool_command("map_pan_tool", "&Pan", "PanTool", "PanTool",
              helptext = "Switch to map-mode 'pan'", icon = "pan")
_tool_command("map_identify_tool", "&Identify", "IdentifyTool", "IdentifyTool",
              helptext = "Switch to map-mode 'identify'", icon = "identify")
_tool_command("map_label_tool", "&Label", "LabelTool", "LabelTool",
              helptext = "Add/Remove labels", icon = "label")
_method_command("map_full_extent", "&Full extent", "FullExtent",
               helptext = "Full Extent", icon = "fullextent")
_method_command("map_print", "Prin&t", "PrintMap", helptext = "Print the map")

# Layer menu
_method_command("layer_add", "&Add Layer", "AddLayer",
                helptext = "Add a new layer to active map")
_method_command("layer_remove", "&Remove Layer", "RemoveLayer",
                helptext = "Remove selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_fill_color", "&Fill Color", "LayerFillColor",
                helptext = "Set the fill color of selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_transparent_fill", "&Transparent Fill",
                "LayerTransparentFill",
                helptext = "Do not fill the selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_outline_color", "&Outline Color", "LayerOutlineColor",
                helptext = "Set the outline color of selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_no_outline", "&No Outline", "LayerNoOutline",
                helptext = "Do not draw the outline of the selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_raise", "&Raise", "RaiseLayer",
                helptext = "Raise selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_lower", "&Lower", "LowerLayer",
                helptext = "Lower selected layer(s)",
                sensitive = _has_selected_layer)
_method_command("layer_show", "&Show", "ShowLayer",
                helptext = "Make selected layer(s) visible",
                sensitive = _has_selected_layer)
_method_command("layer_hide", "&Hide", "HideLayer",
                helptext = "Make selected layer(s) unvisible",
                sensitive = _has_selected_layer)
_method_command("layer_show_table", "Show Ta&ble", "LayerShowTable",
                helptext = "Show the selected layer's table",
                sensitive = _has_selected_layer)


# the menu structure
main_menu = Menu("<main>", "<main>",
                 [Menu("file", "&File",
                       ["new_session", "open_session", None,
                        "save_session", "save_session_as", None,
                        "show_session_tree", None,
                        "exit"]),
                  Menu("map", "&Map",
                       ["layer_add", "layer_remove",
                        None,
                        "map_projection",
                        None,
                        "map_zoom_in_tool", "map_zoom_out_tool",
                        "map_pan_tool", "map_identify_tool", "map_label_tool",
                        None,
                        "map_full_extent",
                        None,
                        "map_print"]),
                  Menu("layer", "&Layer",
                       ["layer_fill_color", "layer_transparent_fill",
                        "layer_outline_color", "layer_no_outline",
                        None,
                        "layer_raise", "layer_lower",
                        None,
                        "layer_show", "layer_hide",
                        None,
                        "layer_show_table"]),
                  Menu("help", "&Help",
                       ["help_about"])])

# the main toolbar

main_toolbar = Menu("<toolbar>", "<toolbar>",
                    ["map_zoom_in_tool", "map_zoom_out_tool", "map_pan_tool",
                     "map_identify_tool", "map_label_tool", "map_full_extent"])
1	bh	123	# Copyright (C) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Jan-Oliver Wagner <[email protected]>
4			# Bernhard Herzog <[email protected]>
5			#
6			# This program is free software under the GPL (>=v2)
7			# Read the file COPYING coming with Thuban for details.
8
9			"""
10			The main window
11			"""
12
13			__version__ = "$Revision$"
14
15	bh	188	import os
16	bh	6
17			from wxPython.wx import *
18
19			import Thuban
20	bh	188	from Thuban.Model.session import create_empty_session
21	bh	6	from Thuban.Model.layer import Layer
22			from Thuban.Model.color import Color
23			from Thuban.Model.proj import Projection
24
25			import view
26			import tree
27			import proj4dialog
28			import tableview, identifyview
29	bh	188	from menu import Menu
30	bh	6
31	bh	222	from context import Context
32	bh	6	from command import registry, Command
33	bh	123	from messages import SELECTED_SHAPE, VIEW_POSITION
34	bh	6
35
36			# the directory where the toolbar icons are stored
37			bitmapdir = os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Bitmaps")
38			bitmapext = ".xpm"
39
40
41			class MainWindow(wxFrame):
42
43	bh	235	def __init__(self, parent, ID, title, application, interactor,
44			initial_message = None):
45			wxFrame.__init__(self, parent, ID, title, wxDefaultPosition,
46			wxSize(400, 300))
47	bh	6
48	bh	227	self.application = application
49	bh	37	self.interactor = interactor
50
51	bh	6	self.CreateStatusBar()
52	bh	235	if initial_message:
53			self.SetStatusText(initial_message)
54	bh	6
55			self.identify_view = None
56
57			self.init_ids()
58
59	bh	191	# creat the menubar from the main_menu description
60	bh	188	self.SetMenuBar(self.build_menu_bar(main_menu))
61	bh	6
62	bh	191	# Similarly, create the toolbar from main_toolbar
63			toolbar = self.build_toolbar(main_toolbar)
64	bh	13	# call Realize to make sure that the tools appear.
65			toolbar.Realize()
66	bh	6
67			# Create the map canvas
68	bh	24	canvas = view.MapCanvas(self, -1, interactor)
69	bh	123	canvas.Subscribe(VIEW_POSITION, self.view_position_changed)
70	bh	6	self.canvas = canvas
71
72	bh	31	self.init_dialogs()
73
74			interactor.Subscribe(SELECTED_SHAPE, self.identify_view_on_demand)
75
76	bh	6	EVT_CLOSE(self, self.OnClose)
77
78			def init_ids(self):
79			"""Initialize the ids"""
80			self.current_id = 6000
81			self.id_to_name = {}
82			self.name_to_id = {}
83	bh	193	self.events_bound = {}
84	bh	6
85			def get_id(self, name):
86			"""Return the wxWindows id for the command named name.
87
88			Create a new one if there isn't one yet"""
89			ID = self.name_to_id.get(name)
90			if ID is None:
91			ID = self.current_id
92			self.current_id = self.current_id + 1
93			self.name_to_id[name] = ID
94			self.id_to_name[ID] = name
95			return ID
96	bh	188
97	bh	193	def bind_command_events(self, command, ID):
98			"""Bind the necessary events for the given command and ID"""
99			if not self.events_bound.has_key(ID):
100			# the events haven't been bound yet
101			EVT_MENU(self, ID, self.invoke_command)
102			if command.IsDynamic():
103			EVT_UPDATE_UI(self, ID, self.update_command_ui)
104
105	bh	188	def build_menu_bar(self, menudesc):
106			"""Build and return the menu bar from the menu description"""
107			menu_bar = wxMenuBar()
108
109			for item in menudesc.items:
110			# here the items must all be Menu instances themselves
111			menu_bar.Append(self.build_menu(item), item.title)
112
113			return menu_bar
114
115			def build_menu(self, menudesc):
116			"""Build and return a wxMenu from a menudescription"""
117			wxmenu = wxMenu()
118			last = None
119			for item in menudesc.items:
120			# here the items must all be Menu instances themselves
121			if item is None:
122			# a separator. Only add one if the last item was not a
123			# separator
124			if last is not None:
125			wxmenu.AppendSeparator()
126			elif isinstance(item, Menu):
127			# a submenu
128			wxmenu.AppendMenu(wxNewId(), item.title, self.build_menu(item))
129			else:
130			# must the name the name of a command
131			self.add_menu_command(wxmenu, item)
132			last = item
133			return wxmenu
134
135	bh	191	def build_toolbar(self, toolbardesc):
136			"""Build and return the main toolbar window from a toolbar description
137
138			The parameter should be an instance of the Menu class but it
139			should not contain submenus.
140			"""
141			toolbar = self.CreateToolBar(wxTB_3DBUTTONS)
142
143			# set the size of the tools' bitmaps. Not needed on wxGTK, but
144			# on Windows, although it doesn't work very well there. It seems
145			# that only 16x16 icons are really supported on windows.
146			# We probably shouldn't hardwire the bitmap size here.
147			toolbar.SetToolBitmapSize(wxSize(24, 24))
148
149			for item in toolbardesc.items:
150			if item is None:
151			toolbar.AddSeparator()
152			else:
153			# assume it's a string.
154			self.add_toolbar_command(toolbar, item)
155
156			return toolbar
157
158	bh	6	def add_menu_command(self, menu, name):
159			"""Add the command with name name to the menu menu.
160
161			If name is None, add a separator.
162			"""
163			if name is None:
164			menu.AppendSeparator()
165			else:
166			command = registry.Command(name)
167			if command is not None:
168			ID = self.get_id(name)
169			menu.Append(ID, command.Title(), command.HelpText(),
170			command.IsCheckCommand())
171	bh	193	self.bind_command_events(command, ID)
172	bh	6	else:
173			print "Unknown command %s" % name
174
175			def add_toolbar_command(self, toolbar, name):
176			"""Add the command with name name to the toolbar toolbar.
177
178			If name is None, add a separator.
179			"""
180			# Assume that all toolbar commands are also menu commmands so
181			# that we don't have to add the event handlers here
182			if name is None:
183			toolbar.AddSeparator()
184			else:
185			command = registry.Command(name)
186			if command is not None:
187			ID = self.get_id(name)
188			filename = os.path.join(bitmapdir, command.Icon()) + bitmapext
189			bitmap = wxBitmap(filename, wxBITMAP_TYPE_XPM)
190			toolbar.AddTool(ID, bitmap,
191			shortHelpString = command.HelpText(),
192			isToggle = command.IsCheckCommand())
193	bh	193	self.bind_command_events(command, ID)
194	bh	6	else:
195			print "Unknown command %s" % name
196
197			def invoke_command(self, event):
198			name = self.id_to_name.get(event.GetId())
199			if name is not None:
200			command = registry.Command(name)
201	bh	227	context = Context(self.application, self.application.Session(),
202			self)
203			command.Execute(context)
204	bh	6	else:
205			print "Unknown command ID %d" % event.GetId()
206
207			def update_command_ui(self, event):
208			#print "update_command_ui", self.id_to_name[event.GetId()]
209	bh	227	context = Context(self.application, self.application.Session(), self)
210	bh	6	command = registry.Command(self.id_to_name[event.GetId()])
211			if command is not None:
212	bh	222	event.Enable(command.Sensitive(context))
213			event.SetText(command.DynText(context))
214	bh	13	if command.IsCheckCommand():
215	bh	222	event.Check(command.Checked(context))
216	bh	6
217	bh	20	def RunMessageBox(self, title, text, flags = wxOK \| wxICON_INFORMATION):
218	bh	181	"""Run a modal message box with the given text, title and flags
219	bh	20	and return the result"""
220			dlg = wxMessageDialog(self, text, title, flags)
221			result = dlg.ShowModal()
222			dlg.Destroy()
223			return result
224
225	bh	31	def init_dialogs(self):
226			"""Initialize the dialog handling"""
227			# The mainwindow maintains a dict mapping names to open
228			# non-modal dialogs. The dialogs are put into this dict when
229			# they're created and removed when they're closed
230			self.dialogs = {}
231
232			def add_dialog(self, name, dialog):
233			if self.dialogs.has_key(name):
234			raise RuntimeError("The Dialog named %s is already open" % name)
235			self.dialogs[name] = dialog
236
237			def dialog_open(self, name):
238			return self.dialogs.has_key(name)
239
240			def remove_dialog(self, name):
241			del self.dialogs[name]
242
243			def get_open_dialog(self, name):
244			return self.dialogs.get(name)
245
246	bh	123	def view_position_changed(self):
247			pos = self.canvas.CurrentPosition()
248			if pos is not None:
249			text = "(%10.10g, %10.10g)" % pos
250			else:
251			text = ""
252			self.SetStatusText(text)
253
254	bh	58	def save_modified_session(self, can_veto = 1):
255			"""If the current session has been modified, ask the user
256			whether to save it and do so if requested. Return the outcome of
257			the dialog (either wxID_OK, wxID_CANCEL or wxID_NO). If the
258			dialog wasn't run return wxID_NO.
259
260			If the can_veto parameter is true (default) the dialog includes
261			a cancel button, otherwise not.
262			"""
263	bh	227	if self.application.session.WasModified():
264	bh	58	flags = wxYES_NO \| wxICON_QUESTION
265			if can_veto:
266			flags = flags \| wxCANCEL
267			result = self.RunMessageBox("Exit",
268			("The session has been modified."
269			" Do you want to save it?"),
270			flags)
271			if result == wxID_YES:
272			self.SaveSession()
273			else:
274			result = wxID_NO
275			return result
276
277	bh	6	def NewSession(self):
278	bh	58	self.save_modified_session()
279	bh	227	self.application.SetSession(create_empty_session())
280	bh	6
281			def OpenSession(self):
282	bh	58	self.save_modified_session()
283	bh	6	dlg = wxFileDialog(self, "Select a session file", ".", "",
284	bh	130	"*.thuban", wxOPEN)
285	bh	6	if dlg.ShowModal() == wxID_OK:
286	bh	227	self.application.OpenSession(dlg.GetPath())
287	bh	6	dlg.Destroy()
288
289			def SaveSession(self):
290	bh	227	if self.application.session.filename == None:
291	jan	102	self.SaveSessionAs()
292	bh	227	self.application.SaveSession()
293	bh	6
294			def SaveSessionAs(self):
295			dlg = wxFileDialog(self, "Enter a filename for session", ".", "",
296	bh	130	"*.thuban", wxOPEN)
297	bh	6	if dlg.ShowModal() == wxID_OK:
298	bh	227	self.application.session.SetFilename(dlg.GetPath())
299			self.application.SaveSession()
300	bh	6	dlg.Destroy()
301
302			def Exit(self):
303			self.Close(false)
304
305			def OnClose(self, event):
306	bh	58	result = self.save_modified_session(can_veto = event.CanVeto())
307			if result == wxID_CANCEL:
308	bh	6	event.Veto()
309			else:
310			self.Destroy()
311
312			def SetMap(self, map):
313			self.canvas.SetMap(map)
314
315	bh	37	def ShowSessionTree(self):
316			name = "session_tree"
317			dialog = self.get_open_dialog(name)
318			if dialog is None:
319	bh	227	dialog = tree.SessionTreeView(self, self.application, name)
320	bh	37	self.add_dialog(name, dialog)
321			dialog.Show(true)
322			else:
323			# FIXME: bring dialog to front here
324			pass
325
326	bh	6	def About(self):
327	bh	20	self.RunMessageBox("About",
328			("Thuban is a program for\n"
329			"exploring geographic data.\n"
330			"Copyright (C) 2001 Intevation GmbH.\n"
331			"Thuban is licensed under the GPL"),
332			wxOK \| wxICON_INFORMATION)
333	bh	6
334			def AddLayer(self):
335	frank	119	dlg = wxFileDialog(self, "Select a data file", ".", "", ".",
336	bh	6	wxOPEN)
337			if dlg.ShowModal() == wxID_OK:
338			filename = dlg.GetPath()
339			title = os.path.splitext(os.path.basename(filename))[0]
340			layer = Layer(title, filename)
341	bh	18	map = self.canvas.Map()
342			has_layers = map.HasLayers()
343	bh	20	try:
344			map.AddLayer(layer)
345			except IOError:
346			# the layer couldn't be opened
347			self.RunMessageBox("Add Layer",
348			"Can't open the file '%s'." % filename)
349			else:
350			if not has_layers:
351			# if we're adding a layer to an empty map, for the
352			# new map to the window
353			self.canvas.FitMapToWindow()
354	bh	6	dlg.Destroy()
355
356			def RemoveLayer(self):
357			layer = self.current_layer()
358			if layer is not None:
359			self.canvas.Map().RemoveLayer(layer)
360
361			def RaiseLayer(self):
362			layer = self.current_layer()
363			if layer is not None:
364			self.canvas.Map().RaiseLayer(layer)
365	bh	222
366	bh	6	def LowerLayer(self):
367			layer = self.current_layer()
368			if layer is not None:
369			self.canvas.Map().LowerLayer(layer)
370
371			def current_layer(self):
372			"""Return the currently selected layer.
373
374			If no layer is selected, return None
375			"""
376	bh	37	return self.interactor.SelectedLayer()
377	bh	6
378			def has_selected_layer(self):
379			"""Return true if a layer is currently selected"""
380	bh	37	return self.interactor.HasSelectedLayer()
381	bh	6
382			def choose_color(self):
383			"""Run the color selection dialog and return the selected color.
384
385			If the user cancels, return None.
386			"""
387			dlg = wxColourDialog(self)
388			color = None
389			if dlg.ShowModal() == wxID_OK:
390			data = dlg.GetColourData()
391			wxc = data.GetColour()
392			color = Color(wxc.Red() / 255.0,
393			wxc.Green() / 255.0,
394			wxc.Blue() / 255.0)
395			dlg.Destroy()
396			return color
397
398			def LayerFillColor(self):
399			layer = self.current_layer()
400			if layer is not None:
401			color = self.choose_color()
402			if color is not None:
403			layer.SetFill(color)
404
405			def LayerTransparentFill(self):
406			layer = self.current_layer()
407			if layer is not None:
408			layer.SetFill(None)
409
410			def LayerOutlineColor(self):
411			layer = self.current_layer()
412			if layer is not None:
413			color = self.choose_color()
414			if color is not None:
415			layer.SetStroke(color)
416
417			def LayerNoOutline(self):
418			layer = self.current_layer()
419			if layer is not None:
420			layer.SetStroke(None)
421
422			def HideLayer(self):
423			layer = self.current_layer()
424			if layer is not None:
425			layer.SetVisible(0)
426
427			def ShowLayer(self):
428			layer = self.current_layer()
429			if layer is not None:
430			layer.SetVisible(1)
431
432			def LayerShowTable(self):
433			layer = self.current_layer()
434			if layer is not None:
435	bh	31	table = layer.table
436			name = "table_view" + str(id(table))
437			dialog = self.get_open_dialog(name)
438			if dialog is None:
439	bh	37	dialog = tableview.TableFrame(self, self.interactor, name,
440	bh	31	"Table: %s" % layer.Title(),
441	bh	33	layer, table)
442	bh	31	self.add_dialog(name, dialog)
443			dialog.Show(true)
444			else:
445			# FIXME: bring dialog to front here
446			pass
447	bh	6
448			def Projection(self):
449			map = self.canvas.Map()
450			proj = map.projection
451			if proj is None:
452	jan	110	proj4Dlg = proj4dialog.Proj4Dialog(NULL, None, map.BoundingBox())
453	bh	6	else:
454	jan	110	proj4Dlg = proj4dialog.Proj4Dialog(NULL, map.projection.params,
455			map.BoundingBox())
456	bh	6	if proj4Dlg.ShowModal() == wxID_OK:
457			params = proj4Dlg.GetParams()
458			if params is not None:
459			proj = Projection(params)
460			else:
461			proj = None
462			map.SetProjection(proj)
463			proj4Dlg.Destroy()
464
465			def ZoomInTool(self):
466			self.canvas.ZoomInTool()
467
468			def ZoomOutTool(self):
469			self.canvas.ZoomOutTool()
470
471			def PanTool(self):
472			self.canvas.PanTool()
473
474			def IdentifyTool(self):
475			self.canvas.IdentifyTool()
476	bh	49	self.identify_view_on_demand(None, None)
477	bh	6
478			def LabelTool(self):
479			self.canvas.LabelTool()
480
481			def FullExtent(self):
482			self.canvas.FitMapToWindow()
483
484			def PrintMap(self):
485			self.canvas.Print()
486
487	bh	31	def identify_view_on_demand(self, layer, shape):
488			name = "identify_view"
489			if self.canvas.CurrentTool() == "IdentifyTool":
490			if not self.dialog_open(name):
491	bh	37	dialog = identifyview.IdentifyView(self, self.interactor, name)
492	bh	31	self.add_dialog(name, dialog)
493			dialog.Show(true)
494			else:
495	bh	33	# FIXME: bring dialog to front?
496	bh	31	pass
497	bh	6
498			#
499			# Define all the commands available in the main window
500			#
501
502
503			# Helper functions to define common command implementations
504			def call_method(context, methodname, *args):
505	bh	222	"""Call the mainwindow's method methodname with args *args"""
506			apply(getattr(context.mainwindow, methodname), args)
507	bh	6
508	jan	110	def _method_command(name, title, method, helptext = "",
509			icon = "", sensitive = None):
510	bh	222	"""Add a command implemented by a method of the mainwindow object"""
511	bh	6	registry.Add(Command(name, title, call_method, args=(method,),
512	jan	110	helptext = helptext, icon = icon,
513			sensitive = sensitive))
514
515	bh	6	def _tool_command(name, title, method, toolname, helptext = "",
516			icon = ""):
517			"""Add a tool command"""
518			def check_current_tool(context, name=toolname):
519	bh	222	return context.mainwindow.canvas.CurrentTool() == name
520	bh	6	registry.Add(Command(name, title, call_method, args=(method,),
521			helptext = helptext, icon = icon,
522			checked = check_current_tool))
523
524			def _has_selected_layer(context):
525			"""Return true if a layer is selected in the context"""
526	bh	222	return context.mainwindow.has_selected_layer()
527	bh	6
528			# File menu
529			_method_command("new_session", "&New Session", "NewSession")
530			_method_command("open_session", "&Open Session", "OpenSession")
531			_method_command("save_session", "&Save Session", "SaveSession")
532			_method_command("save_session_as", "Save Session &As", "SaveSessionAs")
533	bh	150	_method_command("show_session_tree", "Show Session &Tree", "ShowSessionTree")
534	bh	6	_method_command("exit", "&Exit", "Exit")
535
536			# Help menu
537			_method_command("help_about", "&About", "About")
538
539
540			# Map menu
541			_method_command("map_projection", "Pro&jection", "Projection")
542
543			_tool_command("map_zoom_in_tool", "&Zoom in", "ZoomInTool", "ZoomInTool",
544			helptext = "Switch to map-mode 'zoom-in'", icon = "zoom_in")
545			_tool_command("map_zoom_out_tool", "Zoom &out", "ZoomOutTool", "ZoomOutTool",
546			helptext = "Switch to map-mode 'zoom-out'", icon = "zoom_out")
547			_tool_command("map_pan_tool", "&Pan", "PanTool", "PanTool",
548			helptext = "Switch to map-mode 'pan'", icon = "pan")
549			_tool_command("map_identify_tool", "&Identify", "IdentifyTool", "IdentifyTool",
550			helptext = "Switch to map-mode 'identify'", icon = "identify")
551			_tool_command("map_label_tool", "&Label", "LabelTool", "LabelTool",
552			helptext = "Add/Remove labels", icon = "label")
553	jan	110	_method_command("map_full_extent", "&Full extent", "FullExtent",
554			helptext = "Full Extent", icon = "fullextent")
555	bh	6	_method_command("map_print", "Prin&t", "PrintMap", helptext = "Print the map")
556
557			# Layer menu
558	bh	84	_method_command("layer_add", "&Add Layer", "AddLayer",
559	bh	6	helptext = "Add a new layer to active map")
560	bh	84	_method_command("layer_remove", "&Remove Layer", "RemoveLayer",
561	bh	6	helptext = "Remove selected layer(s)",
562			sensitive = _has_selected_layer)
563			_method_command("layer_fill_color", "&Fill Color", "LayerFillColor",
564			helptext = "Set the fill color of selected layer(s)",
565			sensitive = _has_selected_layer)
566			_method_command("layer_transparent_fill", "&Transparent Fill",
567			"LayerTransparentFill",
568			helptext = "Do not fill the selected layer(s)",
569			sensitive = _has_selected_layer)
570	bh	185	_method_command("layer_outline_color", "&Outline Color", "LayerOutlineColor",
571	bh	6	helptext = "Set the outline color of selected layer(s)",
572			sensitive = _has_selected_layer)
573			_method_command("layer_no_outline", "&No Outline", "LayerNoOutline",
574			helptext = "Do not draw the outline of the selected layer(s)",
575			sensitive = _has_selected_layer)
576			_method_command("layer_raise", "&Raise", "RaiseLayer",
577			helptext = "Raise selected layer(s)",
578			sensitive = _has_selected_layer)
579			_method_command("layer_lower", "&Lower", "LowerLayer",
580			helptext = "Lower selected layer(s)",
581			sensitive = _has_selected_layer)
582			_method_command("layer_show", "&Show", "ShowLayer",
583			helptext = "Make selected layer(s) visible",
584			sensitive = _has_selected_layer)
585			_method_command("layer_hide", "&Hide", "HideLayer",
586			helptext = "Make selected layer(s) unvisible",
587			sensitive = _has_selected_layer)
588			_method_command("layer_show_table", "Show Ta&ble", "LayerShowTable",
589			helptext = "Show the selected layer's table",
590			sensitive = _has_selected_layer)
591	bh	188
592
593			# the menu structure
594			main_menu = Menu("<main>", "<main>",
595			[Menu("file", "&File",
596			["new_session", "open_session", None,
597			"save_session", "save_session_as", None,
598			"show_session_tree", None,
599			"exit"]),
600			Menu("map", "&Map",
601			["layer_add", "layer_remove",
602			None,
603			"map_projection",
604			None,
605			"map_zoom_in_tool", "map_zoom_out_tool",
606			"map_pan_tool", "map_identify_tool", "map_label_tool",
607			None,
608			"map_full_extent",
609			None,
610			"map_print"]),
611			Menu("layer", "&Layer",
612			["layer_fill_color", "layer_transparent_fill",
613			"layer_outline_color", "layer_no_outline",
614			None,
615			"layer_raise", "layer_lower",
616			None,
617			"layer_show", "layer_hide",
618			None,
619			"layer_show_table"]),
620			Menu("help", "&Help",
621			["help_about"])])
622	bh	191
623			# the main toolbar
624
625			main_toolbar = Menu("<toolbar>", "<toolbar>",
626			["map_zoom_in_tool", "map_zoom_out_tool", "map_pan_tool",
627			"map_identify_tool", "map_label_tool", "map_full_extent"])
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision