weft-qda 0.9.6

data/lib/weft/wxgui/utilities.rb

@@ -0,0 +1,148 @@
+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]
+    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
+    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)
+        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
+    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
+    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()
+      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
+    end
+
+    def Broadcaster.extended(obj)
+      $wxapp = obj
+      # this is where module-private variables would be great ..
+      obj.reset_subscriptions()
+    end
+
+    def reset_subscriptions()
+      self.bc__subscribers = []
+      self.bc__subscriptions = Hash.new do | ev | 
+        raise "Cannot subscribe to unknown event #{ev}"
+      end
+      SUBSCRIBABLE_EVENTS.each { | ev | self.bc__subscriptions[ev] = [] }
+    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
+    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)
+    end
+  end
+
+  # extension to Wx::Colour
+  class Wx::Colour
+    # Create a new colour by mixing +self_parts+ of +self+ with
+    # +other_parts+ of other. The new colour is produced by applying the
+    # following averaging formula to the red, green and blue components
+    # of each colour
+    # 
+    #   ( colour_1 * conc_1 ) + ( colour_2 * conc_2 )
+    #         --------------------------
+    #              conc_1 + conc_2
+    #
+
+    def mix(other, self_parts = 1, other_parts = 1)
+      return self if self_parts.zero? && other_parts.zero?
+      rgb = [ :red, :green, :blue ].map do | component |
+        mix = self.send(component) * self_parts
+        mix += other.send(component) * other_parts 
+        mix = mix.to_f
+        mix /= self_parts + other_parts
+        mix.to_i
+      end
+      Wx::Colour.new(*rgb)
+    end
+  end
+end

data/lib/weft/wxgui/weft16.xpm

@@ -0,0 +1,31 @@
+/* XPM */
+static char *weft16[] = {
+/* columns rows colors chars-per-pixel */
+"16 16 9 1",
+"  c #400000",
+". c #CCCC00",
+"X c #E9E991",
+"o c #999900",
+"O c gray100",
+"+ c black",
+"@ c black",
+"# c black",
+"$ c None",
+/* pixels */
+"$$$$$  $$$  $$$$",
+"$$$$ XX $ XX $$$",
+"$$$$ .XX XX. $$$",
+"$$  $ .XX o $ $$",
+"$ XX $ .XX $ X $",
+"$ XX. o .X. XX. ",
+"$$ . XXo . XX. $",
+"$$$ XX. $ XX. $$",
+"$$ XX. o XX. o $",
+"$ XX. o.X . o.X ",
+" XX. $ XXX $ X $",
+" X. $ o XXX $ $$",
+"$  $ XXo XXX $$$",
+"$$$ XX. $ XX $$$",
+"$$$ X. $$$  $$$$",
+"$$$$  $$$$$$$$$$"
+};

data/lib/weft/wxgui/workarea.rb

@@ -0,0 +1,249 @@
+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
+
+    # 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)
+      max = conf.read_bool("max", false)
+      
+      if max
+        maximize(true)
+      else
+        move( Wx::Point.new(x, y) )
+        set_size( Wx::Size.new(w, h) )
+      end
+    end
+
+    # save layout to Config so window is same position next time
+    def remember_size()
+      conf = Wx::ConfigBase::get()
+      # global window size settings
+      if conf
+        size = get_size()
+        pos = get_position
+        conf.path = '/MainFrame'
+        conf.write("x", pos.x)
+        conf.write("y", pos.y)
+        conf.write("w", size.width)
+        conf.write("h", size.height)
+        conf.write("max", is_maximized)
+      end
+    end
+
+    # returns a Wx::Size object that has a width equal to that of the
+    # current window times +w+, and a height equal to that of the
+    # current window times +h+. This is used to help size MDI children
+    # when they are first created.
+    def proportional_size(w, h)		
+      size = client_size()
+      Wx::Size.new( ( size.get_width * w ).to_i, 
+                    ( size.get_height * h ).to_i )
+    end
+
+    # launch a child window of the type +klass+ (which should be a
+    # constant of the name of a subclass of QDA::GUI::InspectorWindow),
+    # optionally bound to the database object +bound_obj+ (typically a
+    # document or category).
+    # Returns a reference to the newly opened inspector window.
+    def launch_window(klass, bound_obj)
+      win = nil
+      Wx::BusyCursor.busy(self) do
+        if win = get_open_window(bound_obj)
+          win.activate()
+        else
+          w_i = window_ident(bound_obj)
+          last_layout  = restore_layout( w_i )
+          win = klass.new( bound_obj, @wx_app, self, last_layout )
+          @window_map[w_i] = win
+
+          # set up a hook to clean up when this window is closed later
+          win.evt_close() do | e |
+            remember_layout(w_i, win)
+            @window_map.delete(w_i)
+            win.hide()
+            e.skip()
+          end
+          win.activate()
+        end
+      end
+      # should go over D & C window now
+      self.raise()
+      return win
+    end
+
+    def set_active_category(category)
+      @window_map.each do | name, win |
+        if win.respond_to?(:set_active_category)
+          win.set_active_category(category)
+        end
+      end
+    end
+
+    # turns a QDA object into a string window identifier a bit messy b/c
+    # has to deal with Queries (which aren't currently saved in
+    # database) and categories and documents (which are).
+    def window_ident(bound_obj)
+      bound_obj_id = bound_obj.dbid ? bound_obj.dbid : ''
+      # deal with either full or partial class names
+      bound_obj.class.name.sub(/^.*\:/, '') << bound_obj_id.to_s
+    end
+    private :window_ident
+
+    # gets the open MDI window representing +bound_obj+, if there is one
+    def get_open_window(bound_obj)
+      @window_map[ window_ident(bound_obj) ]
+    end
+
+
+    def get_open_windows(type_of)
+      if type_of == QDA::Document
+        doc_wins = @window_map.keys.grep(/^doc-/)
+        return @window_map.values_at( *doc_wins )
+      elsif type_of == QDA::Category
+        cat_wins = @window_map.keys.grep(/^cat-/)
+        return  @window_map.values_at( *cat_wins ) 
+      else          
+        return []
+      end
+    end
+
+    # remember how the windows were arranged
+    def remember_layouts()
+      # project specific settings
+      if @app
+        @window_map.each do | key, window | 
+          remember_layout(key, window, true) unless key.nil?
+        end
+      end
+    end
+
+    def remember_layout(window_id, window, open = false)
+      if @app
+        layouts = @app.get_preference('Layouts') || {}
+        layouts[window_id] = window.layout
+        layouts[window_id][:open] = open
+        @app.save_preference('Layouts', layouts)
+      end
+    end
+
+    def restore_layout(window_id)
+      if @app
+        layouts = @app.get_preference('Layouts') || {}
+        return layouts[window_id]
+      end
+    end
+
+    def restore_layouts()
+      if @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)
+          elsif ident =~ /^Category(\w+)/ and 
+              cat = @app.get_category($1, true)
+            $wxapp.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() }
+    end
+
+    def receive_savestate_changed(app)
+      title = 'Weft QDA'
+      if app
+        if app.dbfile
+          title << " - #{app.dbfile}"
+        else
+          title << " - [New Project]"
+        end
+        if app.dirty?
+          title << "*"
+        end
+      end
+      set_title(title)
+    end
+  end
+
+  class EasyMenu < Wx::Menu
+    def EasyMenu.next_base()
+      @base_id ||= 0
+      @base_id += 100
+    end
+
+    def initialize(target)
+      super()
+      @target   = target
+      @base_id  = EasyMenu.next_base()
+      @commands = Hash.new do | hash, key | 
+        Kernel.raise ArgumentError.new("No such menu item #{key}")
+      end
+    end
+
+    # adds the item +command_str+ to the menu, with the optional
+    # shortcut key +command_key+, and sets it to run the associated
+    # block when the menu item is chosen. The menu item can later be
+    # referred to by the symbol with the commands name with special
+    # characters removed andspaces turned to underscores. For
+    # example, "Save Project" becomes :save_project
+    def add_item(command_str, command_key = '', itemtype = Wx::ITEM_NORMAL)
+      const = ( @base_id += 1 )
+      ident = command_str.gsub(/\s+/, "_").gsub(/\W/, "").downcase.to_sym
+      @commands[ident] = const
+      append(const, "#{command_str}\t#{command_key}", "", itemtype)
+      @target.evt_menu(const) { | e | yield(e) }
+      return ident
+    end
+
+    # pass a series of symbol idents eg :save_project, :close
+    def enable_items(*idents)
+      idents.each { | ident | enable( @commands[ident], true ) }
+    end
+    alias :enable_item :enable_items
+
+    def disable_items(*idents)
+      idents.each { | ident | enable( @commands[ident], false ) }
+    end
+    alias :disable_item :disable_items
+
+    def check_items(*idents)
+      idents.each { | ident | check( @commands[ident], true ) }
+    end
+    alias :check_item :check_items
+
+    def uncheck_items(*idents)
+      idents.each { | ident | check( @commands[ident], false ) }
+    end
+    alias :uncheck_item :uncheck_items
+
+  end
+end

data/test/001-document.rb

@@ -0,0 +1,196 @@
+$:.push('../lib/')
+
+require 'weft/document'
+require 'test/unit'
+require 'weft/category'
+
+class TestDocument < Test::Unit::TestCase
+  def setup
+
+  end
+  
+  def test_basic
+	d = QDA::Document.new('The Title')
+	assert_equal('The Title', d.title,
+				 'Set title at initialisation')
+	assert_equal(0, d.length,
+				 'Document length is 0')
+
+	d.append('ego')
+	assert_equal(4, d.length,
+				 'Document length is 4')
+	assert_equal('eg', d[0,2],
+				 'Retrieved doc substring')
+	assert_equal('go', d[1,2],
+				 'Retrieved doc substring')
+	assert_equal('', d[4,5],
+				 'Retrieved doc substring')
+	assert_equal('', d[2,0],
+				 'Retrieved doc substring')
+
+	d.append('bar')
+	assert_equal(8, d.length,
+				 'Document length is 8')
+	assert_equal("o\nba", d[2,4],
+				 'Retrieved doc substring')
+	assert_equal("ba", d[4,2],
+				 'Retrieved doc substring')
+	assert_equal("bar\n", d[4,9],
+				 'Retrieved doc substring')
+  end
+
+  def test_fragment
+	d = QDA::Document.new('The Title')
+    d.append('abc def ghi jkl')
+    d.append('ABC DEF GHI JKL')
+    fr_1 = d[0,4]
+    assert_equal(0, fr_1.offset, 'Give offset correctly')
+    assert_equal(4, fr_1.end, 'Give end correctly')
+    assert_equal('abc ', fr_1, 'String equality')
+    
+    fr_2 = d[2,5]
+    assert_equal(2, fr_2.offset, 'Give offset correctly')
+    assert_equal(7, fr_2.end, 'Give end correctly')
+
+    fr_3 = d[12,6]
+    assert_equal(12, fr_3.offset, 'Give offset correctly')
+    assert_equal(18, fr_3.end, 'Give end correctly')
+
+    fr_3.docid = 1
+    code = fr_3.to_code()
+    assert_equal(1, code.docid)
+    assert_equal(12, code.offset)
+    assert_equal(6, code.length)
+  end
+
+  def test_fragment_equivalence
+    c_1 = QDA::Fragment.new('ABC', 'title', 5)
+    c_2 = QDA::Fragment.new('XYZ', 'title', 0)
+    c_3 = QDA::Fragment.new('ABC', 'other', 5)
+    c_4 = QDA::Fragment.new('ABC', 'title', 50)
+    c_5 = QDA::Fragment.new('ABC', 'title', 5)
+
+	assert(c_1 == c_1, 'Identity Equality')
+	assert(c_1 == c_5, 'Equivalence Equality')
+	assert(c_1 != c_2, 'Text inequality')
+	assert(c_1 != c_3, 'Document inequality')
+	assert(c_1 != c_4, 'Offset inequality')
+
+    c_1 = QDA::Fragment.new('ABCDEF', 'title', 5)
+    c_2 = QDA::Fragment.new('DEFGH', 'title', 8)
+
+    assert(c_1.overlap?(c_2), 'Overlap 1/2')
+    assert(c_2.overlap?(c_1), 'Overlap 1/1')
+    assert(c_1.touch?(c_2), 'Touch 1/1')
+    assert(c_2.touch?(c_1), 'Touch 1/2')
+
+    c_1 = QDA::Fragment.new('ABCDEF', 'title', 5)
+    c_2 = QDA::Fragment.new('GHIJKL', 'title', 11)
+
+    assert(! c_1.overlap?(c_2), 'Overlap 2/2')
+    assert(! c_2.overlap?(c_1), 'Overlap 2/1')
+    assert(c_1.touch?(c_2), 'Touch 2/1')
+    assert(c_2.touch?(c_1), 'Touch 2/2')
+
+    c_1 = QDA::Fragment.new('ABCDEF', 'title', 5)
+    c_2 = QDA::Fragment.new('JKL', 'title', 14)
+    assert(! c_1.overlap?(c_2), 'Overlap 3/2')
+    assert(! c_2.overlap?(c_1), 'Overlap 3/1')
+    assert(! c_1.touch?(c_2), 'Touch 3/1')
+    assert(! c_2.touch?(c_1), 'Touch 3/2')
+  end
+
+  def test_fragment_comparison
+    c_1 = QDA::Fragment.new('ABC', 'title', 5)
+    c_2 = QDA::Fragment.new('XYZ', 'title', 0)
+	assert(c_2 < c_1, 'Offset comparison')
+
+    cs = QDA::CodeSet[ c_1, c_2 ]
+    cs = cs.sort { | x, y | x <=> y }
+    assert_equal('XYZ', cs[0], 
+                 'Sort test')
+
+    c_1 = QDA::Fragment.new('abc', 'title', 0)
+    c_2 = QDA::Fragment.new('xyz', 'title', 5)
+	assert(c_2 > c_1, 'Offset comparison')
+    
+    cs = QDA::CodeSet[ c_1, c_2 ]
+    cs = cs.sort
+    assert_equal('abc', cs[0], 
+                 'Sort test')
+  end
+
+  def test_fragment_addition
+	d = QDA::Document.new('The Title')
+    d.append('abc def ghi jkl')
+    d.append('ABC DEF GHI JKL')
+    fr_1 = d[0,4]
+    fr_2 = d[2,5]
+    fr_3 = d[12,6]
+
+    assert_equal('abc def', fr_1 + fr_2,
+                 'Fragment addition')
+    assert_equal( d[0, 14], fr_1 + d[3, 11],
+                 'Overlapping fragment addition')
+    assert_equal(['abc ', "jkl\nAB"], fr_1 + fr_3,
+                 'Disjoint fragment addition')
+    assert_equal('abc ', fr_1 + d[1,2],
+                 'Surrounded fragment addition')
+
+    cs_1 = QDA::CodeSet[ fr_1, fr_3 ]
+    cs_2 = QDA::CodeSet[ d[3, 11] ]
+
+    results = cs_1.union(cs_2)
+    assert_equal( [ d[0, 18 ] ], results,
+                 'CodeSet union')
+
+    results = cs_1.union(cs_2)
+    assert_equal( [ d[0, 18] ], results,
+                 'CodeSet union')
+  end
+
+  def test_fragment_intersect
+	d = QDA::Document.new('The Title')
+    d.append('abc def ghi jkl')
+    d.append('ABC DEF GHI JKL')
+    fr_1 = d[0,4]
+    fr_2 = d[2,5]
+    fr_3 = d[12,6]
+    assert_equal('c ', fr_1 % fr_2,
+                 'Fragment intersection')
+
+    assert_nil(fr_1 % fr_3,
+               'Disjoint fragment intersection')
+
+    assert_equal('bc', fr_1 % d[1,2],
+                 'overlapping fragment intersection')
+  end
+
+  def test_fragment_exclude
+	d = QDA::Document.new('The Title')
+    d.append('abc def ghi jkl')
+    d.append('ABC DEF GHI JKL')
+    fr_1 = d[0,4]
+    fr_2 = d[2,5]
+    fr_3 = d[12,6]
+    assert_equal([ 'ab' ], fr_1 - fr_2,
+                 'Fragment exclusion')
+
+    assert_equal([ 'abc ' ], fr_1 - fr_3,
+               'Disjoint fragment exclusion')
+
+    assert_equal([ 'a', ' ' ], fr_1 - d[1,2],
+                 'overlapping fragment exclusion')
+
+    cs_1 = QDA::CodeSet[ fr_1, fr_3 ]
+    cs_2 = QDA::CodeSet[ d[3, 11] ]
+
+    results = cs_1.exclude(cs_2)
+    assert_equal( [ d[0,3], d[14, 4] ], results,
+                 'CodeSet subtraction')
+
+    results = cs_1.exclude(cs_2)
+    assert_equal( [ d[0,3], d[14, 4] ], results,
+                 'CodeSet subtraction')
+  end
+end