/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/mainwindow.py

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/mainwindow.py

Parent Directory | Revision Log | View Patch Patch

-revision 264 by jan,
Fri Aug 16 17:06:38 2002 UTC
+revision 829 by jonathan,
Tue May  6 12:06:38 2003 UTC
 Line 1
- # Copyright (C) 2001, 2002 by Intevation GmbH
+ # Copyright (C) 2001, 2002, 2003 by Intevation GmbH
  # Authors:
  # Jan-Oliver Wagner <[email protected]>
  # Bernhard Herzog <[email protected]>
 Line 12 
 The main window
  __version__ = "$Revision$"
+ __ThubanVersion__ = "0.2" #"$THUBAN_0_2$"
+ #__BuildDate__ = "$Date$"
  import os
  from wxPython.wx import *
  import Thuban
+ from Thuban import _
  from Thuban.Model.session import create_empty_session
  from Thuban.Model.layer import Layer
  from Thuban.Model.color import Color
-Line 26 
 import view
+Line 30 
 import view
  import tree
  import proj4dialog
  import tableview, identifyview
+ from Thuban.UI.classifier import Classifier
+ import legend
  from menu import Menu
  from context import Context
- from command import registry, Command
+ from command import registry, Command, ToolCommand
- from messages import SELECTED_SHAPE, VIEW_POSITION
+ from messages import LAYER_SELECTED, SHAPES_SELECTED, VIEW_POSITION
+ from Thuban.UI.dock import DockFrame
+ import resource
+ import projdialog
- # the directory where the toolbar icons are stored
- bitmapdir = os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Bitmaps")
- bitmapext = ".xpm"
+ class MainWindow(DockFrame):
- class MainWindow(wxFrame):
+     # Some messages that can be subscribed/unsubscribed directly through
+     # the MapCanvas come in fact from other objects. This is a map to
+     # map those messages to the names of the instance variables they
+     # actually come from. This delegation is implemented in the
+     # Subscribe and unsubscribed methods
+     delegated_messages = {LAYER_SELECTED: "canvas",
+                           SHAPES_SELECTED: "canvas"}
+     # Methods delegated to some instance variables. The delegation is
+     # implemented in the __getattr__ method.
+     delegated_methods = {"SelectLayer": "canvas",
+                          "SelectShapes": "canvas",
+                          }
      def __init__(self, parent, ID, title, application, interactor,
                   initial_message = None, size = wxSize(-1, -1)):
-         wxFrame.__init__(self, parent, ID, title, wxDefaultPosition, size)
+         DockFrame.__init__(self, parent, ID, title, wxDefaultPosition, size)
+         #wxFrame.__init__(self, parent, ID, title, wxDefaultPosition, size)
          self.application = application
-         self.interactor = interactor
          self.CreateStatusBar()
          if initial_message:
-Line 63 
 class MainWindow(wxFrame):
+Line 85 
 class MainWindow(wxFrame):
          # call Realize to make sure that the tools appear.
          toolbar.Realize()
          # Create the map canvas
-         canvas = view.MapCanvas(self, -1, interactor)
+         canvas = view.MapCanvas(self, -1)
          canvas.Subscribe(VIEW_POSITION, self.view_position_changed)
+         canvas.Subscribe(SHAPES_SELECTED, self.identify_view_on_demand)
          self.canvas = canvas
+         self.SetMainWindow(self.canvas)
+         self.SetAutoLayout(True)
          self.init_dialogs()
-         interactor.Subscribe(SELECTED_SHAPE, self.identify_view_on_demand)
+         EVT_CLOSE(self, self._OnClose)
+     def Subscribe(self, channel, *args):
+         """Subscribe a function to a message channel.
+         If channel is one of the delegated messages call the appropriate
+         object's Subscribe method. Otherwise do nothing.
+         """
+         if channel in self.delegated_messages:
+             object = getattr(self, self.delegated_messages[channel])
+             object.Subscribe(channel, *args)
+         else:
+             print "Trying to subscribe to unsupported channel %s" % channel
+     def Unsubscribe(self, channel, *args):
+         """Unsubscribe a function from a message channel.
+         If channel is one of the delegated messages call the appropriate
+         object's Unsubscribe method. Otherwise do nothing.
+         """
+         if channel in self.delegated_messages:
+             object = getattr(self, self.delegated_messages[channel])
+             object.Unsubscribe(channel, *args)
+     def __getattr__(self, attr):
+         """If attr is one of the delegated methods return that method
-         EVT_CLOSE(self, self.OnClose)
+         Otherwise raise AttributeError.
+         """
+         if attr in self.delegated_methods:
+             return getattr(getattr(self, self.delegated_methods[attr]), attr)
+         raise AttributeError(attr)
      def init_ids(self):
          """Initialize the ids"""
-Line 112 
 class MainWindow(wxFrame):
+Line 169 
 class MainWindow(wxFrame):
          return menu_bar
      def build_menu(self, menudesc):
-         """Build and return a wxMenu from a menudescription"""
+         """Return a wxMenu built from the menu description menudesc"""
          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
-Line 169 
 class MainWindow(wxFrame):
+Line 225 
 class MainWindow(wxFrame):
                              command.IsCheckCommand())
                  self.bind_command_events(command, ID)
              else:
-                 print "Unknown command %s" % name
+                 print _("Unknown command %s") % name
      def add_toolbar_command(self, toolbar, name):
          """Add the command with name name to the toolbar toolbar.
-Line 184 
 class MainWindow(wxFrame):
+Line 240 
 class MainWindow(wxFrame):
              command = registry.Command(name)
              if command is not None:
                  ID = self.get_id(name)
-                 filename = os.path.join(bitmapdir, command.Icon()) + bitmapext
+                 bitmap = resource.GetBitmapResource(command.Icon(),
-                 bitmap = wxBitmap(filename, wxBITMAP_TYPE_XPM)
+                                                     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
+                 print _("Unknown command %s") % name
+     def Context(self):
+         """Return the context object for a command invoked from this window
+         """
+         return Context(self.application, self.application.Session(), self)
      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(),
+             command.Execute(self.Context())
-                               self)
-             command.Execute(context)
          else:
-             print "Unknown command ID %d" % event.GetId()
+             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)
+         context = self.Context()
          command = registry.Command(self.id_to_name[event.GetId()])
          if command is not None:
-             event.Enable(command.Sensitive(context))
+             sensitive = command.Sensitive(context)
+             event.Enable(sensitive)
+             if command.IsTool() and not sensitive and command.Checked(context):
+                 # When a checked tool command is disabled deselect all
+                 # tools. Otherwise the tool would remain active but it
+                 # might lead to errors if the tools stays active. This
+                 # problem occurred in GREAT-ER and this fixes it, but
+                 # it's not clear to me whether this is really the best
+                 # way to do it (BH, 20021206).
+                 self.canvas.SelectTool(None)
              event.SetText(command.DynText(context))
              if command.IsCheckCommand():
-                 event.Check(command.Checked(context))
+                     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)
+         dlg.CenterOnParent()
          result = dlg.ShowModal()
          dlg.Destroy()
          return result
-Line 230 
 class MainWindow(wxFrame):
+Line 299 
 class MainWindow(wxFrame):
      def add_dialog(self, name, dialog):
          if self.dialogs.has_key(name):
-             raise RuntimeError("The Dialog named %s is already open" % name)
+             raise RuntimeError(_("The Dialog named %s is already open") % name)
          self.dialogs[name] = dialog
      def dialog_open(self, name):
-Line 248 
 class MainWindow(wxFrame):
+Line 317 
 class MainWindow(wxFrame):
              text = "(%10.10g, %10.10g)" % pos
          else:
              text = ""
+         self.set_position_text(text)
+     def set_position_text(self, text):
+         """Set the statusbar text showing the current position.
+         By default the text is shown in field 0 of the status bar.
+         Override this method in derived classes to put it into a
+         different field of the statusbar.
+         """
          self.SetStatusText(text)
      def save_modified_session(self, can_veto = 1):
-Line 263 
 class MainWindow(wxFrame):
+Line 341 
 class MainWindow(wxFrame):
              flags = wxYES_NO | wxICON_QUESTION
              if can_veto:
                  flags = flags | wxCANCEL
-             result = self.RunMessageBox("Exit",
+             result = self.RunMessageBox(_("Exit"),
-                                         ("The session has been modified."
+                                         _("The session has been modified."
                                           " Do you want to save it?"),
                                          flags)
              if result == wxID_YES:
-Line 273 
 class MainWindow(wxFrame):
+Line 351 
 class MainWindow(wxFrame):
              result = wxID_NO
          return result
+     def prepare_new_session(self):
+         for d in self.dialogs.values():
+             if not isinstance(d, tree.SessionTreeView):
+                 d.Close()
      def NewSession(self):
          self.save_modified_session()
+         self.prepare_new_session()
          self.application.SetSession(create_empty_session())
      def OpenSession(self):
          self.save_modified_session()
-         dlg = wxFileDialog(self, "Select a session file", ".", "",
+         dlg = wxFileDialog(self, _("Open Session"), ".", "", "*.thuban", wxOPEN)
-                            "*.thuban", wxOPEN)
          if dlg.ShowModal() == wxID_OK:
+             self.prepare_new_session()
              self.application.OpenSession(dlg.GetPath())
          dlg.Destroy()
      def SaveSession(self):
          if self.application.session.filename == None:
              self.SaveSessionAs()
-         self.application.SaveSession()
+         else:
+             self.application.SaveSession()
      def SaveSessionAs(self):
-         dlg = wxFileDialog(self, "Enter a filename for session", ".", "",
+         dlg = wxFileDialog(self, _("Save Session As"), ".", "",
-                            "*.thuban", wxOPEN)
+                            "*.thuban", wxSAVE|wxOVERWRITE_PROMPT)
          if dlg.ShowModal() == wxID_OK:
              self.application.session.SetFilename(dlg.GetPath())
              self.application.SaveSession()
          dlg.Destroy()
      def Exit(self):
-         self.Close(false)
+         self.Close(False)
-     def OnClose(self, event):
+     def _OnClose(self, event):
          result = self.save_modified_session(can_veto = event.CanVeto())
          if result == wxID_CANCEL:
              event.Veto()
          else:
+             # FIXME: it would be better to tie the unsubscription to
+             # wx's destroy event, but that isn't implemented for wxGTK
+             # yet.
+             self.canvas.Unsubscribe(VIEW_POSITION, self.view_position_changed)
+             DockFrame._OnClose(self, event)
              self.Destroy()
      def SetMap(self, map):
          self.canvas.SetMap(map)
+         self.__SetTitle(map.Title())
+         dialog = self.FindRegisteredDock("legend")
+         if dialog is not None:
+             dialog.GetPanel().SetMap(self.Map())
+     def Map(self):
+         """Return the map displayed by this mainwindow"""
-     def ShowSessionTree(self):
+         return self.canvas.Map()
+     def ToggleSessionTree(self):
+         """If the session tree is shown close it otherwise create a new tree"""
          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)
+             dialog.Show(True)
          else:
-             # FIXME: bring dialog to front here
+             dialog.Close()
-             pass
+     def SessionTreeShown(self):
+         """Return true iff the session tree is currently shown"""
+         return self.get_open_dialog("session_tree") is not None
      def About(self):
-         self.RunMessageBox("About",
+         self.RunMessageBox(_("About"),
-                            ("Thuban is a program for\n"
+                            _("Thuban v%s\n"
+                             #"Build Date: %s\n"
+                             "\n"
+                             "Thuban is a program for\n"
                              "exploring geographic data.\n"
-                             "Copyright (C) 2001 Intevation GmbH.\n"
+                             "Copyright (C) 2001-2003 Intevation GmbH.\n"
-                             "Thuban is licensed under the GPL"),
+                             "Thuban is licensed under the GNU GPL"
+                            % __ThubanVersion__), #__BuildDate__)),
                             wxOK | wxICON_INFORMATION)
      def AddLayer(self):
-         dlg = wxFileDialog(self, "Select a data file", ".", "", "*.*",
+         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)
+             store = self.application.Session().OpenShapefile(filename)
+             layer = Layer(title, store)
              map = self.canvas.Map()
              has_layers = map.HasLayers()
              try:
                  map.AddLayer(layer)
              except IOError:
                  # the layer couldn't be opened
-                 self.RunMessageBox("Add Layer",
+                 self.RunMessageBox(_("Add Layer"),
-                                    "Can't open the file '%s'." % filename)
+                                    _("Can't open the file '%s'.") % filename)
              else:
                  if not has_layers:
-                     # if we're adding a layer to an empty map, for the
+                     # if we're adding a layer to an empty map, fit the
                      # new map to the window
                      self.canvas.FitMapToWindow()
          dlg.Destroy()
-Line 357 
 class MainWindow(wxFrame):
+Line 466 
 class MainWindow(wxFrame):
          if layer is not None:
              self.canvas.Map().RemoveLayer(layer)
+     def CanRemoveLayer(self):
+         """Return true if the currently selected layer can be deleted.
+         If no layer is selected return False.
+         The return value of this method determines whether the remove
+         layer command is sensitive in menu.
+         """
+         layer = self.current_layer()
+         if layer is not None:
+             return self.canvas.Map().CanRemoveLayer(layer)
+         return False
      def RaiseLayer(self):
          layer = self.current_layer()
          if layer is not None:
-Line 372 
 class MainWindow(wxFrame):
+Line 494 
 class MainWindow(wxFrame):
          If no layer is selected, return None
          """
-         return self.interactor.SelectedLayer()
+         return self.canvas.SelectedLayer()
      def has_selected_layer(self):
          """Return true if a layer is currently selected"""
-         return self.interactor.HasSelectedLayer()
+         return self.canvas.HasSelectedLayer()
+     def has_selected_shapes(self):
+         """Return true if a shape is currently selected"""
+         return self.canvas.HasSelectedShapes()
      def choose_color(self):
          """Run the color selection dialog and return the selected color.
-Line 394 
 class MainWindow(wxFrame):
+Line 520 
 class MainWindow(wxFrame):
          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:
-Line 435 
 class MainWindow(wxFrame):
+Line 537 
 class MainWindow(wxFrame):
              name = "table_view" + str(id(table))
              dialog = self.get_open_dialog(name)
              if dialog is None:
-                 dialog = tableview.TableFrame(self, self.interactor, name,
+                 dialog = tableview.LayerTableFrame(self, name,
-                                               "Table: %s" % layer.Title(),
+                                                _("Table: %s") % layer.Title(),
-                                               layer, table)
+                                                    layer, table)
                  self.add_dialog(name, dialog)
                  dialog.Show(true)
              else:
                  # FIXME: bring dialog to front here
                  pass
-     def Projection(self):
+     def MapProjection(self):
-         map = self.canvas.Map()
-         proj = map.projection
+         name = "map_projection"
-         if proj is None:
+         dialog = self.get_open_dialog(name)
-             proj4Dlg = proj4dialog.Proj4Dialog(NULL, None, map.BoundingBox())
+         if dialog is None:
+             map = self.canvas.Map()
+             dialog = projdialog.ProjFrame(self, name,
+                      _("Map Projection: %s") % map.Title(), map)
+             self.add_dialog(name, dialog)
+             dialog.Show()
+         dialog.Raise()
+     def LayerProjection(self):
+         layer = self.current_layer()
+         name = "layer_projection" + str(id(layer))
+         dialog = self.get_open_dialog(name)
+         if dialog is None:
+             map = self.canvas.Map()
+             dialog = projdialog.ProjFrame(self, name,
+                      _("Layer Projection: %s") % layer.Title(), layer)
+             self.add_dialog(name, dialog)
+             dialog.Show()
+         dialog.Raise()
+     def LayerEditProperties(self):
+         #
+         # the menu option for this should only be available if there
+         # is a current layer, so we don't need to check if the
+         # current layer is None
+         #
+         layer = self.current_layer()
+         self.OpenLayerProperties(layer)
+     def OpenLayerProperties(self, layer, group = None):
+         name = "layer_properties" + str(id(layer))
+         dialog = self.get_open_dialog(name)
+         if dialog is None:
+             dialog = Classifier(self, name, layer, group)
+             self.add_dialog(name, dialog)
+             dialog.Show()
+         dialog.Raise()
+     def ShowLegend(self):
+         if not self.LegendShown():
+             self.ToggleLegend()
+     def ToggleLegend(self):
+         """Show the legend if it's not shown otherwise hide it again"""
+         name = "legend"
+         dialog = self.FindRegisteredDock(name)
+         if dialog is None:
+             dialog = self.CreateDock(name, -1, _("Legend"), wxLAYOUT_LEFT)
+             legend.LegendPanel(dialog, None, self)
+             dialog.Dock()
+             dialog.GetPanel().SetMap(self.Map())
+             dialog.Show()
          else:
-             proj4Dlg = proj4dialog.Proj4Dialog(NULL, map.projection.params,
+             dialog.Show(not dialog.IsShown())
-                                                map.BoundingBox())
-         if proj4Dlg.ShowModal() == wxID_OK:
+     def LegendShown(self):
-             params = proj4Dlg.GetParams()
+         """Return true iff the legend is currently open"""
-             if params is not None:
+         dialog = self.FindRegisteredDock("legend")
-                 proj = Projection(params)
+         return dialog is not None and dialog.IsShown()
-             else:
-                 proj = None
-             map.SetProjection(proj)
-         proj4Dlg.Destroy()
      def ZoomInTool(self):
          self.canvas.ZoomInTool()
-Line 480 
 class MainWindow(wxFrame):
+Line 638 
 class MainWindow(wxFrame):
      def FullExtent(self):
          self.canvas.FitMapToWindow()
+     def FullLayerExtent(self):
+         self.canvas.FitLayerToWindow(self.current_layer())
+     def FullSelectionExtent(self):
+         self.canvas.FitSelectedToWindow()
      def PrintMap(self):
          self.canvas.Print()
-     def identify_view_on_demand(self, layer, shape):
+     def RenameMap(self):
+         dlg = wxTextEntryDialog(self, "Map Title: ", "Rename Map",
+                                 self.Map().Title())
+         if dlg.ShowModal() == wxID_OK:
+             title = dlg.GetValue()
+             if title != "":
+                 self.Map().SetTitle(title)
+                 self.__SetTitle(title)
+         dlg.Destroy()
+     def identify_view_on_demand(self, layer, shapes):
+         """Subscribed to the canvas' SHAPES_SELECTED message
+         If the current tool is the identify tool, at least one shape is
+         selected and the identify dialog is not shown, show the dialog.
+         """
+         # If the selection has become empty we don't need to do
+         # anything. Otherwise it could happen that the dialog was popped
+         # up when the selection became empty, e.g. when a new selection
+         # is opened while the identify tool is active and dialog had
+         # been closed
+         if not shapes:
+             return
          name = "identify_view"
          if self.canvas.CurrentTool() == "IdentifyTool":
              if not self.dialog_open(name):
-                 dialog = identifyview.IdentifyView(self, self.interactor, name)
+                 dialog = identifyview.IdentifyView(self, name)
                  self.add_dialog(name, dialog)
-                 dialog.Show(true)
+                 dialog.Show(True)
              else:
                  # FIXME: bring dialog to front?
                  pass
+     def __SetTitle(self, title):
+         self.SetTitle("Thuban - " + title)
  #
  # Define all the commands available in the main window
  #
-Line 505 
 def call_method(context, methodname, *ar
+Line 696 
 def call_method(context, methodname, *ar
      apply(getattr(context.mainwindow, methodname), args)
  def _method_command(name, title, method, helptext = "",
-                     icon = "", sensitive = None):
+                     icon = "", sensitive = None, checked = 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))
+                          sensitive = sensitive, checked = checked))
- def _tool_command(name, title, method, toolname, helptext = "",
+ def make_check_current_tool(toolname):
-                   icon = ""):
+     """Return a function that tests if the currently active tool is toolname
-     """Add a tool command"""
+     The returned function can be called with the context and returns
+     true iff the currently active tool's name is toolname. It's directly
+     usable as the 'checked' callback of a command.
+     """
      def check_current_tool(context, name=toolname):
          return context.mainwindow.canvas.CurrentTool() == name
-     registry.Add(Command(name, title, call_method, args=(method,),
+     return check_current_tool
-                          helptext = helptext, icon = icon,
-                          checked = check_current_tool))
+ def _tool_command(name, title, method, toolname, helptext = "",
+                   icon = "", sensitive = None):
+     """Add a tool command"""
+     registry.Add(ToolCommand(name, title, call_method, args=(method,),
+                              helptext = helptext, icon = icon,
+                              checked = make_check_current_tool(toolname),
+                              sensitive = sensitive))
  def _has_selected_layer(context):
      """Return true if a layer is selected in the context"""
      return context.mainwindow.has_selected_layer()
+ def _has_selected_shapes(context):
+     """Return true if a layer is selected in the context"""
+     return context.mainwindow.has_selected_shapes()
+ def _can_remove_layer(context):
+     return context.mainwindow.CanRemoveLayer()
  def _has_tree_window_shown(context):
      """Return true if the tree window is shown"""
-     return context.mainwindow.get_open_dialog("session_tree") is None
+     return context.mainwindow.SessionTreeShown()
+ def _has_visible_map(context):
+     """Return true iff theres a visible map in the mainwindow.
+     A visible map is a map with at least one visible layer."""
+     map = context.mainwindow.Map()
+     if map is not None:
+         for layer in map.Layers():
+             if layer.Visible():
+                 return 1
+     return 0
+ def _has_legend_shown(context):
+     """Return true if the legend window is shown"""
+     return context.mainwindow.LegendShown()
  # File menu
- _method_command("new_session", "&New Session", "NewSession")
+ _method_command("new_session", _("&New Session"), "NewSession")
- _method_command("open_session", "&Open Session", "OpenSession")
+ _method_command("open_session", _("&Open Session..."), "OpenSession")
- _method_command("save_session", "&Save Session", "SaveSession")
+ _method_command("save_session", _("&Save Session"), "SaveSession")
- _method_command("save_session_as", "Save Session &As", "SaveSessionAs")
+ _method_command("save_session_as", _("Save Session &As..."), "SaveSessionAs")
- _method_command("show_session_tree", "Show Session &Tree", "ShowSessionTree",
+ _method_command("toggle_session_tree", _("Session &Tree"), "ToggleSessionTree",
-                 sensitive = _has_tree_window_shown)
+                 checked = _has_tree_window_shown)
- _method_command("exit", "&Exit", "Exit")
+ _method_command("toggle_legend", _("Legend"), "ToggleLegend",
+                 checked = _has_legend_shown)
+ _method_command("exit", _("E&xit"), "Exit")
  # Help menu
- _method_command("help_about", "&About", "About")
+ _method_command("help_about", _("&About..."), "About")
  # Map menu
- _method_command("map_projection", "Pro&jection", "Projection")
+ _method_command("map_projection", _("Pro&jection..."), "MapProjection")
- _tool_command("map_zoom_in_tool", "&Zoom in", "ZoomInTool", "ZoomInTool",
+ _tool_command("map_zoom_in_tool", _("&Zoom in"), "ZoomInTool", "ZoomInTool",
-               helptext = "Switch to map-mode 'zoom-in'", icon = "zoom_in")
+               helptext = _("Switch to map-mode 'zoom-in'"), icon = "zoom_in",
- _tool_command("map_zoom_out_tool", "Zoom &out", "ZoomOutTool", "ZoomOutTool",
+               sensitive = _has_visible_map)
-               helptext = "Switch to map-mode 'zoom-out'", icon = "zoom_out")
+ _tool_command("map_zoom_out_tool", _("Zoom &out"), "ZoomOutTool", "ZoomOutTool",
- _tool_command("map_pan_tool", "&Pan", "PanTool", "PanTool",
+               helptext = _("Switch to map-mode 'zoom-out'"), icon = "zoom_out",
-               helptext = "Switch to map-mode 'pan'", icon = "pan")
+               sensitive = _has_visible_map)
- _tool_command("map_identify_tool", "&Identify", "IdentifyTool", "IdentifyTool",
+ _tool_command("map_pan_tool", _("&Pan"), "PanTool", "PanTool",
-               helptext = "Switch to map-mode 'identify'", icon = "identify")
+               helptext = _("Switch to map-mode 'pan'"), icon = "pan",
- _tool_command("map_label_tool", "&Label", "LabelTool", "LabelTool",
+               sensitive = _has_visible_map)
-               helptext = "Add/Remove labels", icon = "label")
+ _tool_command("map_identify_tool", _("&Identify"), "IdentifyTool",
- _method_command("map_full_extent", "&Full extent", "FullExtent",
+               "IdentifyTool",
-                helptext = "Full Extent", icon = "fullextent")
+               helptext = _("Switch to map-mode 'identify'"), icon = "identify",
- _method_command("map_print", "Prin&t", "PrintMap", helptext = "Print the map")
+               sensitive = _has_visible_map)
+ _tool_command("map_label_tool", _("&Label"), "LabelTool", "LabelTool",
+               helptext = _("Add/Remove labels"), icon = "label",
+               sensitive = _has_visible_map)
+ _method_command("map_full_extent", _("&Full extent"), "FullExtent",
+                helptext = _("Full Extent"), icon = "fullextent",
+               sensitive = _has_visible_map)
+ _method_command("layer_full_extent", _("&Full layer extent"), "FullLayerExtent",
+                helptext = _("Full Layer Extent"), icon = "fulllayerextent",
+               sensitive = _has_selected_layer)
+ _method_command("selected_full_extent", _("&Full selection extent"), "FullSelectionExtent",
+                helptext = _("Full Selection Extent"), icon = "fullselextent",
+               sensitive = _has_selected_shapes)
+ _method_command("map_print", _("Prin&t"), "PrintMap",
+                 helptext = _("Print the map"))
+ _method_command("map_rename", _("&Rename..."), "RenameMap",
+                 helptext = _("Rename the map"))
+ _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 = _can_remove_layer)
  # Layer menu
- _method_command("layer_add", "&Add Layer", "AddLayer",
+ _method_command("layer_projection", _("Pro&jection..."), "LayerProjection",
-                 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",
+ _method_command("layer_raise", _("&Raise"), "RaiseLayer",
-                 "LayerTransparentFill",
+                 helptext = _("Raise selected layer(s)"),
-                 helptext = "Do not fill the selected layer(s)",
                  sensitive = _has_selected_layer)
- _method_command("layer_outline_color", "&Outline Color", "LayerOutlineColor",
+ _method_command("layer_lower", _("&Lower"), "LowerLayer",
-                 helptext = "Set the outline color of selected layer(s)",
+                 helptext = _("Lower selected layer(s)"),
                  sensitive = _has_selected_layer)
- _method_command("layer_no_outline", "&No Outline", "LayerNoOutline",
+ _method_command("layer_show", _("&Show"), "ShowLayer",
-                 helptext = "Do not draw the outline of the selected layer(s)",
+                 helptext = _("Make selected layer(s) visible"),
                  sensitive = _has_selected_layer)
- _method_command("layer_raise", "&Raise", "RaiseLayer",
+ _method_command("layer_hide", _("&Hide"), "HideLayer",
-                 helptext = "Raise selected layer(s)",
+                 helptext = _("Make selected layer(s) unvisible"),
                  sensitive = _has_selected_layer)
- _method_command("layer_lower", "&Lower", "LowerLayer",
+ _method_command("layer_show_table", _("Show Ta&ble"), "LayerShowTable",
-                 helptext = "Lower selected layer(s)",
+                 helptext = _("Show the selected layer's table"),
                  sensitive = _has_selected_layer)
- _method_command("layer_show", "&Show", "ShowLayer",
+ _method_command("layer_properties", _("&Properties..."), "LayerEditProperties",
-                 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",
+                  [Menu("file", _("&File"),
                         ["new_session", "open_session", None,
                          "save_session", "save_session_as", None,
-                         "show_session_tree", None,
+                         "toggle_session_tree", None,
                          "exit"]),
-                   Menu("map", "&Map",
+                   Menu("map", _("&Map"),
-                        ["layer_add", "layer_remove",
+                        ["layer_add", "layer_remove", "map_rename",
                          None,
                          "map_projection",
                          None,
                          "map_zoom_in_tool", "map_zoom_out_tool",
-                         "map_pan_tool", "map_identify_tool", "map_label_tool",
+                         "map_pan_tool",
+                         "map_full_extent",
+                         "layer_full_extent",
+                         "selected_full_extent",
                          None,
-                         "map_full_extent",
+                         "map_identify_tool", "map_label_tool",
                          None,
-                         "map_print"]),
+                         "toggle_legend",
-                   Menu("layer", "&Layer",
-                        ["layer_fill_color", "layer_transparent_fill",
-                         "layer_outline_color", "layer_no_outline",
                          None,
-                         "layer_raise", "layer_lower",
+                         "map_print"]),
+                   Menu("layer", _("&Layer"),
+                         ["layer_raise", "layer_lower",
                          None,
                          "layer_show", "layer_hide",
                          None,
-                         "layer_show_table"]),
+                         "layer_show_table",
-                   Menu("help", "&Help",
+                         None,
+                         "layer_projection",
+                         "layer_properties"]),
+                   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"])
+                      "map_full_extent",
+                      "layer_full_extent",
+                      "selected_full_extent",
+                      None,
+                      "map_identify_tool", "map_label_tool"])

 Legend:



Removed from v.264
 


changed lines


 
Added in v.829
 Legend:



Removed from v.264
 


changed lines


 
Added in v.829
-Removed from v.264
+Added in v.829

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26