weft-qda 0.9.6 → 0.9.8

data/lib/weft/wxgui/utilities.rb

@@ -1,126 +1,105 @@
+# temporary hack to turn c++ style set_foo(), get_foo() and is_foo()
+# accessors into ruby style foo=() foo() and foo?() 
+wx_classes = Wx::constants.collect { | c | Wx::const_get(c) }.grep(Class)
+wx_classes.each do | klass |
+  klass.instance_methods.grep(/^([gs]et|evt|is)_/).each do | meth |
+    case meth
+    when /^get_(\w+)$/
+      klass.class_eval("alias :#{$1} :#{meth}")
+    when /^set_(\w+)$/
+      klass.class_eval("alias :#{$1}= :#{meth}")
+    when /^is_(\w+)$/
+      klass.class_eval("alias :#{$1}? :#{meth}")
+    end
+  end
+end
+
+Wx::NORMAL_CURSOR = Wx::Cursor.new(Wx::CURSOR_ARROW)
+Wx::BUSY_CURSOR   = Wx::Cursor.new(Wx::CURSOR_WAIT)
+
 module QDA::GUI
   # ItemData - allows widgets to store information about assocations
   # with underlying project objects such as categories and documents.
   module ItemData
     # for faked-up item data
     def get_item_data(id)
-      @data_table[id]
+      data[id]
     end
     alias :get_client_data :get_item_data
 
     # for faked-up item data
-    def set_item_data(id, data)
-      @data_table ||= Hash.new()
-      @data_table[id] = data
-      return nil
+    def set_item_data(id, data_obj)
+      data[id] = data_obj
     end
     alias :set_client_data :set_item_data
-
+    
     # returns the key associated with the value +value+
     def value_to_ident(value)
       return nil if value.nil?
-      unless value.respond_to?(:dbid)
+      if value.nil?
+        return nil
+      elsif value.respond_to?(:dbid)
+        the_id = value.dbid
+      elsif value.kind_of?(Fixnum)
+        the_id = value
+      else
         Kernel.raise "Cannot search for invalid value #{value.inspect}"
       end
-      doc = @data_table.each do | k, val |
-        return k if val.dbid == value.dbid
-      end
-      return nil
+      return index(the_id)
     end
   end
-
-
-  # Allows an object such as the global Wx App to broadcast messages
-  # about changes in the database and other application states that
-  # might require the child to update its appearance.
-  module Broadcaster
-    SUBSCRIBABLE_EVENTS = [ :document_added, :document_changed,
-      :document_deleted, :category_added, :category_changed,
-      :category_deleted, :focus_category, :savestate_changed ]
-
-    # intended to be module private variables to managed which widgets
-    # are subscribing to which events
-    attr_accessor :bc__subscribers, :bc__subscriptions
-	  
-    # broadcast an event to all subscribers to event of type
-    # +event_type+, optionally including +content+
-    def broadcast(event_type, content = nil)
-      for subscriber in bc__subscriptions[event_type]
-        subscriber.notify(event_type, content)
-      end
+  
+  module ListLikeItemData
+    include ItemData
+    def data()
+      @data_table ||= Array.new()
     end
-
-    # subscribe the widget +subscriber+ to receive notification of
-    # app event types +*events+ (which should be a set of symbols)
-    def add_subscriber(subscriber, *events)
-      events.each do | e |
-        bc__subscriptions[e].push(subscriber)
-      end
-      subscriber.evt_close do | e | 
-        delete_subscriber(subscriber)
-        e.skip()
+    
+    def delete_item_data(the_data)
+      if i = value_to_ident(the_data)
+        data.delete_at(i)
       end
     end
-
-    # accepts a ruby item
-    def delete_subscriber(subscriber)
-      if subscriber.respond_to?(:associated_subscribers)
-        subscriber.associated_subscribers.each do | child |
-          delete_subscriber(child)
-        end
-      end
-      bc__subscribers.delete(subscriber)
-      bc__subscriptions.each_value do | subscriber_set |
-        subscriber_set.delete(subscriber)
-      end
+    
+    def unshift_item_data(the_data)
+      delete_item_data(the_data)
+      data.unshift(the_data)
     end
 
-    def Broadcaster.extended(obj)
-      $wxapp = obj
-      # this is where module-private variables would be great ..
-      obj.reset_subscriptions()
+    def push_item_data(the_data)
+      delete_item_data(the_data)
+      data.push(the_data)
     end
-
-    def reset_subscriptions()
-      self.bc__subscribers = []
-      self.bc__subscriptions = Hash.new do | ev | 
-        raise "Cannot subscribe to unknown event #{ev}"
+    
+    def index(the_id)
+      data.each_with_index do | val, i |
+        return i if val.dbid == the_id
       end
-      SUBSCRIBABLE_EVENTS.each { | ev | self.bc__subscriptions[ev] = [] }
+      return nil
     end
   end
 
-  # Any gui element that may need to modify its appearance in response
-  # to application updates may include the subscriber module. Instances
-  # of the class may then call the +subscribe+ method to receive
-  # notification of changes.
-  module Subscriber
-    # receive notification that an event of type +ev+ has been called,
-    # optionally passing +content+ for additional information about the
-    # object the event concerned.
-    def notify(ev, content = nil)
-      receiver = "receive_#{ev}".intern
-      if respond_to?(receiver)
-        send(receiver, content)
-      else
-        warn "#{self} received unhandled event #{ev}"
-      end
+  module HashLikeItemData
+    include ItemData
+    def data()
+      @data_table ||= Hash.new()    
     end
-
-    # Subscribe this object to the events +events+, which should be a
-    # list of symbols. For example, to receive notification of category
-    # changes and additions, the recipient shoudl call
-    #  subscribe(:category_changed, :category_added)
-    # 
-    # For every event type to which a subscriber subscribes, it should
-    # implement a corresponding receive_xxx method, where xxx is the
-    # name of the event type. To act upon category changes, the
-    # subscriber should implement +receive_category_changed+
-    def subscribe(*events)
-      $wxapp.add_subscriber(self, *events)
+    
+    def index(the_id)
+      data.each do | k, val |
+        return k if val.dbid == the_id
+      end
+      return nil
     end
   end
-
+  
+  class LabelledVSizer < Wx::StaticBoxSizer
+    def initialize(sized_object, label)
+      static_box = Wx::StaticBox.new(sized_object, -1, label)
+      super(static_box, Wx::VERTICAL)
+    end
+  end  
+  
   # extension to Wx::Colour
   class Wx::Colour
     # Create a new colour by mixing +self_parts+ of +self+ with

data/lib/weft/wxgui/workarea.rb

@@ -1,27 +1,28 @@
 module QDA::GUI
   # The main application window, where docuemnts, categories, searches
   # etc are displayed. Only one instance per application.
-  class WorkArea < Wx::MDIParentFrame
-    include Subscriber
-
-    attr_accessor :app
-    def initialize(wx_app)
-      @wx_app = wx_app
-      @window_map = {}
-      super(nil, -1, "Weft QDA")
-      restore_size()
-      subscribe(:savestate_changed)
-    end
-
+  module InspectorWindowManager
+    include QDA::Subscriber
+    
+    # This sets the last-focussed child. However, when later requesting info 
+    # on the currently active window, MDI reports the active_child() call,
+    # whereas the @active_child variable is read by MultiframeWindowManager
+    # - in MDI there is a foremost window which may not have received focus.
+    attr_writer :active_child
     # Resizes the workarea to the state when the application was last used
     def restore_size()
       conf = Wx::ConfigBase::get()
       conf.path = "/MainFrame"
-      x = conf.read_int("x", 200)
-      y = conf.read_int("y", 0)
-      w = conf.read_int("w", 300)
-      h = conf.read_int("h", 400)
+      x = conf.read_int( "x", -1 )
+      y = conf.read_int( "y", -1 )
+      w = conf.read_int( "w", -1 )
+      h = conf.read_int( "h", -1 )
       max = conf.read_bool("max", false)
+
+      x = DEF_POS.x if x < 0
+      y = DEF_POS.y if y < 0
+      w = DEF_SIZE.width  if w < 200
+      h = DEF_SIZE.height if h < 200
       
       if max
         maximize(true)
@@ -32,6 +33,9 @@ module QDA::GUI
     end
 
     # save layout to Config so window is same position next time
+    
+
+    
     def remember_size()
       conf = Wx::ConfigBase::get()
       # global window size settings
@@ -70,7 +74,7 @@ module QDA::GUI
         else
           w_i = window_ident(bound_obj)
           last_layout  = restore_layout( w_i )
-          win = klass.new( bound_obj, @wx_app, self, last_layout )
+          win = klass.new( bound_obj, @client, self, last_layout )
           @window_map[w_i] = win
 
           # set up a hook to clean up when this window is closed later
@@ -127,7 +131,7 @@ module QDA::GUI
     # remember how the windows were arranged
     def remember_layouts()
       # project specific settings
-      if @app
+      if self.app
         @window_map.each do | key, window | 
           remember_layout(key, window, true) unless key.nil?
         end
@@ -135,64 +139,167 @@ module QDA::GUI
     end
 
     def remember_layout(window_id, window, open = false)
-      if @app
-        layouts = @app.get_preference('Layouts') || {}
+      if self.app
+        layouts = app.get_preference('Layouts') || {}
         layouts[window_id] = window.layout
         layouts[window_id][:open] = open
-        @app.save_preference('Layouts', layouts)
+        app.save_preference('Layouts', layouts)
       end
     end
 
     def restore_layout(window_id)
-      if @app
-        layouts = @app.get_preference('Layouts') || {}
+      if self.app
+        layouts = app.get_preference('Layouts') || {}
         return layouts[window_id]
       end
     end
 
     def restore_layouts()
-      if @app
-        layouts = @app.get_preference('Layouts')
+      if self.app
+        layouts = app.get_preference('Layouts')
         return unless layouts
         # get all previously open windows
         open =  layouts.find_all { | x | x[1][:open] }
         open.each do | ident, layout |
           if ident =~ /^Document(\w+)$/
-            $wxapp.on_document_open($1)
+            @client.on_document_open($1)
           elsif ident =~ /^Category(\w+)/ and 
-              cat = @app.get_category($1, true)
-            $wxapp.on_category_open(cat)
+              cat = app.get_category($1, true)
+            @client.on_category_open(cat)
           end
         end
       end
     end
 
-    def set_display_font(font)
-      # super(font)
-      @window_map.values.each do | child |
-        child.set_display_font(font) if child.respond_to?(:set_display_font)
-      end
-    end
-
     def close_all()
       @window_map.values.each { | child | child.close() }
+      close_d_and_c()
     end
 
-    def receive_savestate_changed(app)
-      title = 'Weft QDA'
-      if app
-        if app.dbfile
+    def notify(ev, content = nil)
+      case ev
+      when :focus_category
+        return # ignore
+      when :ended
+        title = 'Weft QDA'
+      when :saved, :started
+        title = 'Weft QDA'
+        if self.app.dbfile
           title << " - #{app.dbfile}"
         else
           title << " - [New Project]"
         end
-        if app.dirty?
-          title << "*"
-        end
+      else
+        title = get_title()
+        title << '*' if title[-1,1] != '*'
+      end
+      set_title(title)  
+    end
+    
+    def app()
+      @client.app
+    end
+    
+  end
+  
+  class MDIWorkArea < Wx::MDIParentFrame
+    include InspectorWindowManager
+    def initialize(weft_client)
+      @client = weft_client
+      @window_map = {}
+      super(nil, -1, "Weft QDA")
+      restore_size()
+      subscribe(@client, :all)
+    end
+    
+    def d_and_c()
+      @sidebar
+    end
+    
+    # display the listings of documents and categories
+    def show_d_and_c()
+      if not @sidebar
+        # see sidebar.rb
+		@sidebar = SideBar.new( self, @client )
       end
-      set_title(title)
+      @sidebar.show()
+    end
+    
+    def hide_d_and_c()
+      @sidebar.hide() if @sidebar
+    end
+    
+    def close_d_and_c()
+      return if not @sidebar
+      @sidebar.remember_size()
+      @sidebar.close()
+      @sidebar = nil
+    end
+    
+    def d_and_c_visible?()
+      @sidebar.shown?
+    end
+    
+    def hide_all()
+      hide_d_and_c()
+      self.hide()
     end
   end
+  
+  # presentation of main window as a standalone window, launching inspector
+  # windows as separate frames
+  class MultiFrameWorkArea < Wx::Frame
+    include InspectorWindowManager
+    
+    attr_reader :d_and_c, :active_child
+    
+    def initialize(weft_client)
+      @client = weft_client
+      @window_map = {}
+      super(nil, -1, "Weft QDA")
+      restore_size()
+      set_sizer( @sizer = Wx::BoxSizer.new(Wx::VERTICAL) )
+      subscribe(@client, :all)
+    end
+    
+    def show_d_and_c()
+      if not @d_and_c
+        @d_and_c ||= DocumentsAndCategories.new(self, @client)
+        conf = Wx::ConfigBase::get()
+        conf.path = "/SideFrame"
+        split = conf.read_int("split", 200)
+        # sometimes weirdly ends up with negative value
+        split = client_size.height / 2 if split <= 0
+        @d_and_c.set_sash_position(split)
+        @sizer.add(@d_and_c, 1, Wx::GROW|Wx::ALL, 0)
+        @sizer.layout()
+      end
+    end
+    
+    def hide_d_and_c()
+      # do nothing
+    end
+    
+    def close_d_and_c()
+      @sizer.remove(@d_and_c)
+      @d_and_c.destroy()
+      @d_and_c = nil
+    end
+    
+    def hide_all()
+      @window_map.each { | w | w.hide() }
+      self.hide()
+    end
+  end
+  
+  
+  
+  if WINDOW_MODE == :MDI
+    WorkArea = MDIWorkArea
+  else
+    WorkArea = MultiFrameWorkArea
+  end
+
 
   class EasyMenu < Wx::Menu
     def EasyMenu.next_base()