/[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 1644 by bh,
Mon Aug 25 12:44:55 2003 UTC
+revision 2551 by jonathan,
Thu Jan 27 14:19:41 2005 UTC
 Line 1
- # Copyright (C) 2001, 2002, 2003 by Intevation GmbH
+ # Copyright (C) 2001, 2002, 2003, 2004, 2005 by Intevation GmbH
  # Authors:
  # Jan-Oliver Wagner <[email protected]>
  # Bernhard Herzog <[email protected]>
 Line 19 
 import os
  import copy
  from wxPython.wx import *
- from wxPython.wx import __version__ as wxPython_version
  import Thuban
- import Thuban.version
  from Thuban import _
+ from Thuban.Model.messages import TITLE_CHANGED, LAYER_PROJECTION_CHANGED, \
+      MAP_PROJECTION_CHANGED, MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED
  from Thuban.Model.session import create_empty_session
  from Thuban.Model.layer import Layer, RasterLayer
  from Thuban.Model.postgisdb import PostGISShapeStore, has_postgis_support
-Line 36 
 from Thuban.UI.multiplechoicedialog impo
+Line 37 
 from Thuban.UI.multiplechoicedialog impo
  import view
  import tree
  import tableview, identifyview
- from Thuban.UI.classifier import Classifier
  import legend
  from menu import Menu
 Line 48 
 from about import About
  from Thuban.UI.dock import DockFrame
  from Thuban.UI.join import JoinDialog
- from Thuban.UI.dbdialog import DBFrame, ChooseDBTableDialog
+ from Thuban.UI.dbdialog import DBFrame, DBDialog, ChooseDBTableDialog
  import resource
  import Thuban.Model.resource
  import projdialog
+ from Thuban.UI.classifier import Classifier
+ from Thuban.UI.rasterlayerproperties import RasterLayerProperties
+ from Thuban.Model.layer import RasterLayer
+ from Thuban.Lib.classmapper import ClassMapper
+ layer_properties_dialogs = ClassMapper()
+ layer_properties_dialogs.add(RasterLayer, RasterLayerProperties)
+ layer_properties_dialogs.add(Layer, Classifier)
  class MainWindow(DockFrame):
-Line 74 
 class MainWindow(DockFrame):
+Line 83 
 class MainWindow(DockFrame):
                           "SelectedShapes": "canvas",
                           }
+     # Messages from the canvas that may require a status bar update.
+     # The update_status_bar method will be subscribed to these messages.
+     update_status_bar_messages = (VIEW_POSITION, LAYER_PROJECTION_CHANGED,
+                                   MAP_PROJECTION_CHANGED, MAP_LAYERS_ADDED,
+                                   MAP_LAYERS_REMOVED)
      def __init__(self, parent, ID, title, application, interactor,
                   initial_message = None, size = wxSize(-1, -1)):
          DockFrame.__init__(self, parent, ID, title, wxDefaultPosition, size)
-Line 100 
 class MainWindow(DockFrame):
+Line 115 
 class MainWindow(DockFrame):
          # Create the map canvas
          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.canvas.Subscribe(TITLE_CHANGED, self.title_changed)
+         for channel in self.update_status_bar_messages:
+             self.canvas.Subscribe(channel, self.update_status_bar)
          self.SetMainWindow(self.canvas)
-Line 134 
 class MainWindow(DockFrame):
+Line 152 
 class MainWindow(DockFrame):
          """
          if channel in self.delegated_messages:
              object = getattr(self, self.delegated_messages[channel])
-             object.Unsubscribe(channel, *args)
+             try:
+                 object.Unsubscribe(channel, *args)
+             except wxPyDeadObjectError:
+                 # The object was a wxObject and has already been
+                 # destroyed. Hopefully it has unsubscribed all its
+                 # subscribers already so that it's OK if we do nothing
+                 # here
+                 pass
      def __getattr__(self, attr):
          """If attr is one of the delegated methods return that method
-Line 325 
 class MainWindow(DockFrame):
+Line 350 
 class MainWindow(DockFrame):
      def get_open_dialog(self, name):
          return self.dialogs.get(name)
-     def view_position_changed(self):
+     def update_status_bar(self, *args):
+         """Handler for a bunch of messages that may require a status bar update
+         Currently this handles the canvas' VIEW_POSITION_CHANGED
+         messages as well as several messages about changes in the map
+         which may affect whether and how projections are used.
+         These messages affect the text in the status bar in the following way:
+         When VIEW_POSITION_CHANGED messages are sent and the mouse is
+         actually in the canvas window, display the current mouse
+         coordinates as defined by the canvas' CurrentPosition method.
+         If there is no current position to show, check whether there is
+         a potential problem with the map and layer projections and
+         display a message about it.  Otherwise the status bar will
+         become empty.
+         The text is displayed in the status bar using the
+         set_position_text method.
+         """
+         # Implementation note: We do not really have to know which
+         # message was sent.  We can simply call the canvas'
+         # CurrentPosition method and if that returns a tuple, it was a
+         # VIEW_POSITION_CHANGED message and we have to display it.
+         # Otherwise it was a VIEW_POSITION_CHANGED message where the
+         # mouse has left the canvas or it was a message about a change
+         # to the map, in which case we check the projections.
+         #
+         # When changing this method, keep in mind that the
+         # VIEW_POSITION_CHANGED message are sent for every mouse move in
+         # the canvas window, that is they happen very often, so the path
+         # taken in that case has to be fast.
+         text = ""
          pos = self.canvas.CurrentPosition()
          if pos is not None:
              text = "(%10.10g, %10.10g)" % pos
          else:
-             text = ""
+             for layer in self.canvas.Map().Layers():
+                 bbox = layer.LatLongBoundingBox()
+                 if bbox:
+                     left, bottom, right, top = bbox
+                     if not (-180 <= left <= 180 and
+                             -180 <= right <= 180 and
+                             -90 <= top <= 90 and
+                             -90 <= bottom <= 90):
+                         text = _("Select layer '%s' and pick a projection "
+                                  "using Layer/Projection...") % layer.title
+                         break
          self.set_position_text(text)
      def set_position_text(self, text):
-         """Set the statusbar text showing the current position.
+         """Set the statusbar text to that created by update_status_bar
          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.
+         For historical reasons this method is called set_position_text
+         because at first the text was always either the current position
+         or the empty string.  Now it can contain other messages as well.
+         The method will be renamed at one point.
          """
+         # Note: If this method is renamed we should perhaps think about
+         # some backwards compatibility measures for projects like
+         # GREAT-ER which override this method.
          self.SetStatusText(text)
+     def OpenOrRaiseDialog(self, name, dialog_class, *args, **kw):
+         """
+         Open or raise a dialog.
+         If a dialog with the denoted name does already exist it is
+         raised.  Otherwise a new dialog, an instance of dialog_class,
+         is created, inserted into the main list and displayed.
+         """
+         dialog = self.get_open_dialog(name)
+         if dialog is None:
+             dialog = dialog_class(self, name, *args, **kw)
+             self.add_dialog(name, dialog)
+             dialog.Show(True)
+         else:
+             dialog.Raise()
      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
-Line 371 
 class MainWindow(DockFrame):
+Line 465 
 class MainWindow(DockFrame):
      def OpenSession(self):
          if self.save_modified_session() != wxID_CANCEL:
-             dlg = wxFileDialog(self, _("Open Session"), ".", "",
+             dlg = wxFileDialog(self, _("Open Session"),
+                                self.application.Path("data"), "",
                                 "Thuban Session File (*.thuban)|*.thuban",
                                 wxOPEN)
              if dlg.ShowModal() == wxID_OK:
-                 self.application.OpenSession(dlg.GetPath())
+                 self.application.OpenSession(dlg.GetPath(),
+                                              self.run_db_param_dialog)
+                 self.application.SetPath("data", dlg.GetPath())
              dlg.Destroy()
+     def run_db_param_dialog(self, parameters, message):
+         dlg = DBDialog(self, _("DB Connection Parameters"), parameters,
+                        message)
+         return dlg.RunDialog()
      def SaveSession(self):
          if self.application.session.filename == None:
              self.SaveSessionAs()
-Line 385 
 class MainWindow(DockFrame):
+Line 487 
 class MainWindow(DockFrame):
              self.application.SaveSession()
      def SaveSessionAs(self):
-         dlg = wxFileDialog(self, _("Save Session As"), ".", "",
+         dlg = wxFileDialog(self, _("Save Session As"),
+                            self.application.Path("data"), "",
                             "Thuban Session File (*.thuban)|*.thuban",
                             wxSAVE|wxOVERWRITE_PROMPT)
          if dlg.ShowModal() == wxID_OK:
              self.application.session.SetFilename(dlg.GetPath())
              self.application.SaveSession()
+             self.application.SetPath("data",dlg.GetPath())
          dlg.Destroy()
      def Exit(self):
-Line 404 
 class MainWindow(DockFrame):
+Line 508 
 class MainWindow(DockFrame):
              # 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)
+             for channel in self.update_status_bar_messages:
+                 self.canvas.Unsubscribe(channel, self.update_status_bar)
              DockFrame.OnClose(self, event)
              for dlg in self.dialogs.values():
                  dlg.Destroy()
-Line 413 
 class MainWindow(DockFrame):
+Line 519 
 class MainWindow(DockFrame):
      def SetMap(self, map):
          self.canvas.SetMap(map)
-         self.__SetTitle(map.Title())
+         self.update_title()
          dialog = self.FindRegisteredDock("legend")
          if dialog is not None:
-Line 455 
 class MainWindow(DockFrame):
+Line 561 
 class MainWindow(DockFrame):
          dialog.Raise()
      def AddLayer(self):
-         dlg = wxFileDialog(self, _("Select one or more data files"), ".", "",
+         dlg = wxFileDialog(self, _("Select one or more data files"),
-                            _("Shapefiles (*.shp)") + "|*.shp|" +
+                            self.application.Path("data"), "",
-                            _("All Files (*.*)") + "|*.*",
+                            _("Shapefiles (*.shp)") + "|*.shp;*.SHP|" +
+                            _("All Files (*.*)") + "|*.*",
                             wxOPEN | wxMULTIPLE)
          if dlg.ShowModal() == wxID_OK:
              filenames = dlg.GetPaths()
-Line 478 
 class MainWindow(DockFrame):
+Line 585 
 class MainWindow(DockFrame):
                          # if we're adding a layer to an empty map, fit the
                          # new map to the window
                          self.canvas.FitMapToWindow()
+                     self.application.SetPath("data",filename)
          dlg.Destroy()
      def AddRasterLayer(self):
-         dlg = wxFileDialog(self, _("Select an image file"), ".", "", "*.*",
+         dlg = wxFileDialog(self, _("Select an image file"),
+                            self.application.Path("data"), "", "*.*",
                             wxOPEN)
          if dlg.ShowModal() == wxID_OK:
              filename = dlg.GetPath()
-Line 500 
 class MainWindow(DockFrame):
+Line 609 
 class MainWindow(DockFrame):
                      # if we're adding a layer to an empty map, fit the
                      # new map to the window
                      self.canvas.FitMapToWindow()
+                 self.application.SetPath("data", filename)
          dlg.Destroy()
      def AddDBLayer(self):
          """Add a layer read from a database"""
          session = self.application.Session()
-         dlg = ChooseDBTableDialog(self.application.Session(), self,-1, "")
+         dlg = ChooseDBTableDialog(self, self.application.Session())
          if dlg.ShowModal() == wxID_OK:
-             dbconn, dbtable = dlg.GetTable()
+             dbconn, dbtable, id_column, geo_column = dlg.GetTable()
              try:
                  title = str(dbtable)
                  # Chose the correct Interface for the database type
-                 store = PostGISShapeStore(dbconn, dbtable)
+                 store = session.OpenDBShapeStore(dbconn, dbtable,
-                 session.AddShapeStore(store)
+                                                  id_column = id_column,
+                                                  geometry_column = geo_column)
                  layer = Layer(title, store)
              except:
                  # Some error occured while initializing the layer
                  self.RunMessageBox(_("Add Layer from database"),
                                     _("Can't open the database table '%s'")
                                     % dbtable)
+                 return
              map = self.canvas.Map()
-Line 549 
 class MainWindow(DockFrame):
+Line 661 
 class MainWindow(DockFrame):
              return self.canvas.Map().CanRemoveLayer(layer)
          return False
+     def LayerToTop(self):
+         layer = self.current_layer()
+         if layer is not None:
+             self.canvas.Map().MoveLayerToTop(layer)
      def RaiseLayer(self):
          layer = self.current_layer()
          if layer is not None:
-Line 559 
 class MainWindow(DockFrame):
+Line 676 
 class MainWindow(DockFrame):
          if layer is not None:
              self.canvas.Map().LowerLayer(layer)
+     def LayerToBottom(self):
+         layer = self.current_layer()
+         if layer is not None:
+             self.canvas.Map().MoveLayerToBottom(layer)
      def current_layer(self):
          """Return the currently selected layer.
-Line 570 
 class MainWindow(DockFrame):
+Line 692 
 class MainWindow(DockFrame):
          """Return true if a layer is currently selected"""
          return self.canvas.HasSelectedLayer()
+     def has_selected_shape_layer(self):
+         """Return true if a shape layer is currently selected"""
+         return isinstance(self.current_layer(), Layer)
      def has_selected_shapes(self):
          """Return true if a shape is currently selected"""
          return self.canvas.HasSelectedShapes()
-Line 577 
 class MainWindow(DockFrame):
+Line 703 
 class MainWindow(DockFrame):
      def HideLayer(self):
          layer = self.current_layer()
          if layer is not None:
-             layer.SetVisible(0)
+             layer.SetVisible(False)
      def ShowLayer(self):
          layer = self.current_layer()
          if layer is not None:
-             layer.SetVisible(1)
+             layer.SetVisible(True)
+     def ToggleLayerVisibility(self):
+         layer = self.current_layer()
+         layer.SetVisible(not layer.Visible())
      def DuplicateLayer(self):
          """Ceate a new layer above the selected layer with the same shapestore
-Line 593 
 class MainWindow(DockFrame):
+Line 723 
 class MainWindow(DockFrame):
                                layer.ShapeStore(),
                                projection = layer.GetProjection())
              new_classification = copy.deepcopy(layer.GetClassification())
+             new_layer.SetClassificationColumn(
+                     layer.GetClassificationColumn())
              new_layer.SetClassification(new_classification)
              self.Map().AddLayer(new_layer)
-Line 602 
 class MainWindow(DockFrame):
+Line 734 
 class MainWindow(DockFrame):
          return layer is not None and hasattr(layer, "ShapeStore")
      def LayerShowTable(self):
+         """
+         Present a TableView Window for the current layer.
+         In case the window is already open, bring it to the front.
+         In case, there is no active layer, do nothing.
+         In case, the layer has no ShapeStore, do nothing.
+         """
          layer = self.current_layer()
          if layer is not None:
+             if not hasattr(layer, "ShapeStore"):
+                 return
              table = layer.ShapeStore().Table()
              name = "table_view" + str(id(table))
              dialog = self.get_open_dialog(name)
-Line 614 
 class MainWindow(DockFrame):
+Line 754 
 class MainWindow(DockFrame):
                  self.add_dialog(name, dialog)
                  dialog.Show(True)
              else:
-                 # FIXME: bring dialog to front here
+                 dialog.Raise()
-                 pass
      def MapProjection(self):
-Line 657 
 class MainWindow(DockFrame):
+Line 796 
 class MainWindow(DockFrame):
          self.OpenLayerProperties(layer)
      def OpenLayerProperties(self, layer, group = None):
-         name = "layer_properties" + str(id(layer))
+         """
-         dialog = self.get_open_dialog(name)
+         Open or raise the properties dialog.
-         if dialog is None:
+         This method opens or raises the properties dialog for the
-             dialog = Classifier(self, name, self.Map(), layer, group)
+         currently selected layer if one is defined for this layer
-             self.add_dialog(name, dialog)
+         type.
-             dialog.Show()
+         """
-         dialog.Raise()
+         dialog_class = layer_properties_dialogs.get(layer)
+         if dialog_class is not None:
+             name = "layer_properties" + str(id(layer))
+             self.OpenOrRaiseDialog(name, dialog_class, layer, group = group)
      def LayerJoinTable(self):
          layer = self.canvas.SelectedLayer()
-Line 705 
 class MainWindow(DockFrame):
+Line 848 
 class MainWindow(DockFrame):
          return dialog is not None and dialog.IsShown()
      def TableOpen(self):
-         dlg = wxFileDialog(self, _("Open Table"), ".", "",
+         dlg = wxFileDialog(self, _("Open Table"),
+                            self.application.Path("data"), "",
                             _("DBF Files (*.dbf)") + "|*.dbf|" +
                             #_("CSV Files (*.csv)") + "|*.csv|" +
                             _("All Files (*.*)") + "|*.*",
-Line 721 
 class MainWindow(DockFrame):
+Line 865 
 class MainWindow(DockFrame):
                                     _("Can't open the file '%s'.") % filename)
              else:
                  self.ShowTableView(table)
+                 self.application.SetPath("data",filename)
      def TableClose(self):
          tables = self.application.session.UnreferencedTables()
-Line 797 
 class MainWindow(DockFrame):
+Line 942 
 class MainWindow(DockFrame):
          # Second, let the user rename the layers
          for table in to_rename:
-             dlg = wxTextEntryDialog(self, "Table Title: ", "Rename Table",
+             dlg = wxTextEntryDialog(self, _("Table Title:"), _("Rename Table"),
                                      table.Title())
              try:
                  if dlg.ShowModal() == wxID_OK:
-Line 846 
 class MainWindow(DockFrame):
+Line 991 
 class MainWindow(DockFrame):
          self.canvas.Print()
      def RenameMap(self):
-         dlg = wxTextEntryDialog(self, "Map Title: ", "Rename Map",
+         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()
-Line 860 
 class MainWindow(DockFrame):
+Line 1004 
 class MainWindow(DockFrame):
          """Let the user rename the currently selected layer"""
          layer = self.current_layer()
          if layer is not None:
-             dlg = wxTextEntryDialog(self, "Layer Title: ", "Rename Layer",
+             dlg = wxTextEntryDialog(self, _("Layer Title:"), _("Rename Layer"),
                                      layer.Title())
              try:
                  if dlg.ShowModal() == wxID_OK:
-Line 894 
 class MainWindow(DockFrame):
+Line 1038 
 class MainWindow(DockFrame):
                  # FIXME: bring dialog to front?
                  pass
-     def __SetTitle(self, title):
+     def title_changed(self, map):
-         self.SetTitle("Thuban - " + title)
+         """Subscribed to the canvas' TITLE_CHANGED messages"""
+         self.update_title()
+     def update_title(self):
+         """Update the window's title according to it's current state.
+         In this default implementation the title is 'Thuban - ' followed
+         by the map's title or simply 'Thuban' if there is not map.
+         Derived classes should override this method to get different
+         titles.
+         This method is called automatically by other methods when the
+         title may have to change. For the methods implemented in this
+         class this usually only means that a different map has been set
+         or the current map's title has changed.
+         """
+         map = self.Map()
+         if map is not None:
+             title = _("Thuban - %s") % (map.Title(),)
+         else:
+             title = _("Thuban")
+         self.SetTitle(title)
  #
  # Define all the commands available in the main window
-Line 937 
 def _has_selected_layer(context):
+Line 1103 
 def _has_selected_layer(context):
      """Return true if a layer is selected in the context"""
      return context.mainwindow.has_selected_layer()
+ def _has_selected_layer_visible(context):
+     """Return true if a layer is selected in the context which is
+     visible."""
+     if context.mainwindow.has_selected_layer():
+         layer = context.mainwindow.current_layer()
+         if layer.Visible(): return True
+     return False
+ def _has_selected_shape_layer(context):
+     """Return true if a shape layer is selected in the context"""
+     return context.mainwindow.has_selected_shape_layer()
  def _has_selected_shapes(context):
      """Return true if a layer is selected in the context"""
      return context.mainwindow.has_selected_shapes()
-Line 956 
 def _has_visible_map(context):
+Line 1134 
 def _has_visible_map(context):
      if map is not None:
          for layer in map.Layers():
              if layer.Visible():
-                 return 1
+                 return True
-     return 0
+     return False
  def _has_legend_shown(context):
      """Return true if the legend window is shown"""
-Line 1073 
 _method_command("layer_hide", _("&Hide")
+Line 1251 
 _method_command("layer_hide", _("&Hide")
                  sensitive = _has_selected_layer)
  _method_command("layer_show_table", _("Show Ta&ble"), "LayerShowTable",
                  helptext = _("Show the selected layer's table"),
-                 sensitive = _has_selected_layer)
+                 sensitive = _has_selected_shape_layer)
  _method_command("layer_properties", _("&Properties..."), "LayerEditProperties",
                  sensitive = _has_selected_layer,
                  helptext = _("Edit the properties of the selected layer"))
  _method_command("layer_jointable", _("&Join Table..."), "LayerJoinTable",
-                 sensitive = _has_selected_layer,
+                 sensitive = _has_selected_shape_layer,
                  helptext = _("Join and attach a table to the selected layer"))
+ # further layer methods:
+ _method_command("layer_to_top", _("&Top"), "LayerToTop",
+                 helptext = _("Put selected layer to the top"),
+                 sensitive = _has_selected_layer)
+ _method_command("layer_to_bottom", _("&Bottom"), "LayerToBottom",
+                 helptext = _("Put selected layer to the bottom"),
+                 sensitive = _has_selected_layer)
+ _method_command("layer_visibility", _("&Visible"), "ToggleLayerVisibility",
+                 checked = _has_selected_layer_visible,
+                 helptext = _("Toggle visibility of selected layer"),
+                 sensitive = _has_selected_layer)
  def _can_unjoin(context):
      """Return whether the Layer/Unjoin command can be executed.

 Legend:



Removed from v.1644
 


changed lines


 
Added in v.2551
 Legend:



Removed from v.1644
 


changed lines


 
Added in v.2551
-Removed from v.1644
+Added in v.2551

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26