weft-qda 0.9.6 → 0.9.8

data/lib/weft/wxgui/controls/document_list.rb

@@ -0,0 +1,97 @@
+module QDA::GUI
+  class DocumentList < Wx::ListBox
+    include ListLikeItemData
+    include QDA::Subscriber
+    attr_reader :client
+    
+    def initialize(weft_client, *args)
+      @client = weft_client
+      super(*args)
+      evt_left_dclick()  { | event | on_double_click(event) }
+      evt_key_down() { | e | on_key_down(e) }
+      evt_listbox( self.get_id ) { | e | on_item_selected(e) }
+      subscribe(@client, :document_added, :document_deleted, :document_changed)
+      
+      # evt_context_menu()  { | event | on_context_menu(event) }
+      # @menu = Wx::Menu.new()
+      # @menu.append(1234, 'Foo')
+      # @menu.append(1235, 'Bar')
+    end
+    
+    def app()
+      @client.app
+    end
+    # add the document to the end of the list.
+    def append_item(doc)
+      push_item_data(doc)
+      append(doc.title)
+    end
+
+    def remove_item(item)
+      if i = value_to_ident(item)
+        data.delete_at(i)
+        delete(i)
+      end
+    end
+
+    def update_item(doc)
+      if i = value_to_ident(doc)
+        set_item_data(i, doc)
+        set_string( value_to_ident(doc), doc.title )
+      end
+    end
+    
+    def get_selection_data()
+      get_item_data( get_selection )
+    end
+    
+    def delete_selection()
+      # Hand back to the client to process, including confirmation checks
+      client.on_delete_document()
+    end
+    
+    def on_item_selected(e)
+      @client.current_document = selected_document
+      e.skip()
+    end
+    
+    def on_context_menu(e)
+      popup_menu_xy(@menu, e.get_x, e.get_y)
+    end
+
+    def on_double_click(e)
+      if string_selection.empty?
+        @client.import_document()
+      else
+        @client.on_document_open( selected_document() )
+      end
+    end
+
+    def selected_document()
+      sel = get_selection()
+      return nil unless sel and sel != -1
+      get_item_data( sel )
+    end
+
+    def receive_document_deleted(doc)
+      remove_item(doc)
+    end
+
+    def receive_document_changed(doc)
+      update_item(doc)
+    end
+
+    def receive_document_added(doc)
+       append_item(doc)
+    end
+
+    def on_key_down(evt)
+      case evt.key_code()
+      when 127 # DEL
+        delete_selection()
+      else
+        evt.skip()
+      end
+    end
+  end
+end

data/lib/weft/wxgui/controls/multitype_control.rb

@@ -0,0 +1,37 @@
+module QDA::GUI
+  # A control which has multiple different forms which can be shown or hidden
+  class MultiTypedControl < Wx::BoxSizer
+    attr_reader :controls, :visible
+
+    # 
+    def initialize( first_item )
+      super(Wx::HORIZONTAL)
+      @controls = [ first_item ]
+      @visible  = 0
+      add(visible_item, 1, Wx::ALL)
+    end
+    
+    def add_control(control)
+      controls.push(control)
+      control.hide()
+    end
+    
+    def visible_item()
+      controls[visible]
+    end
+    
+    def show(i)
+      return if i == visible
+      if i < 0 or i >= controls.length
+        raise ArgumentError, "Bad Index"
+      end
+      visible_item.hide()
+      remove(visible_item)
+      @visible = i
+      add(visible_item, 1, Wx::ADJUST_MINSIZE|Wx::ALL)
+      visible_item.show()
+      layout()
+    end
+  end
+  
+end

data/lib/weft/wxgui/{inspectors → controls}/textcontrols.rb

@@ -3,41 +3,57 @@ module QDA::GUI
   # source text - addresses issues with the cross-platform
   # representation of newlines in multiline text controls.
   class TrueSelectionTextCtrl < Wx::TextCtrl
-    # because of the varying x-platform representation of newlines,
-    # we need a variable correction factor.
-    if Wx::RUBY_PLATFORM == 'WXMSW'
+  
+    if Wx::RUBY_PLATFORM == 'WXMSW' # Microsoft Windows
       NEWLINE_CORRECTION_FACTOR = 1
-    else
+        
+      def true_point(point)
+        point - get_range(0, point).count("\n")
+      end
+      
+      # returns the start and end of the selection as indexes within
+      # the underlying string. This is handled differently on each platform,
+      # but the end result is the same.
+      def true_selection()
+        # On windows, we have to correct for the way WxWidgets returns
+        # newlines in TextCtrls as two characters.
+        lines = get_range(0, get_insertion_point()).count("\n")
+        [ get_insertion_point() - lines,
+          get_insertion_point() + get_string_selection().length - lines ]
+      end
+    else 
+      # GTK and Mac OS X
       NEWLINE_CORRECTION_FACTOR = 0
+      # a no-op
+      def true_point(point)
+        point
+      end
+      
+      def true_selection()
+        # on Linux and Mac OS X, the representation of newlines is not a
+        # problem (a single \n character in both the textctrl string and the
+        # underlying string), but the fact that get_selection() is missing 
+        # from the wxruby is a problem. Additionally, WxGTK (not WxMac) returns
+        # different values for get_insertion_point when a selection has been
+        # depending on whether the selection was made left-to-right or
+        # right-to-left. So we do a bit of guessing.
+        str = get_string_selection()
+        val = get_value()
+        ins = get_insertion_point()
+        if str == val[ ins, str.length ] # should be always true on WxMac
+          return [ ins, ins + str.length ]
+        elsif str == val[ ins - str.length, str.length ]
+          return [ ins - str.length, ins ]
+        else
+          Kernel.raise "Insertion Point: #{ins}, Selection #{str}"
+        end
+      end
     end
 
-    # background colour doesn't seem to work in MSW
-    HEADER_STYLE = Wx::TextAttr.new(Wx::RED)
-    # SUBHEADER_STYLE = Wx::TextAttr.new(Wx::BLUE)
-    NORMAL_STYLE = Wx::TextAttr.new(Wx::BLACK)
-    HIGHLIGHTED_STYLE = Wx::TextAttr.new(Wx::BLUE)
-
-    def initialize(*args)
-      super
-      @highlights = []
-    end
-
-    # returns the start and end of the selection as indexes within
-    # the underlying string
-    def true_selection()
-      lines = get_range(0, get_insertion_point()).count("\n")
-      lines *= NEWLINE_CORRECTION_FACTOR
-      [ get_insertion_point() - lines,
-        get_insertion_point() + get_string_selection().length - lines ]
-    end
-    alias :get_true_selection :true_selection
-
     # returns the current insertion point as an index within the
     # underlying string
     def true_insertion_point()
-      lines = get_range(0, get_insertion_point()).count("\n")
-      lines *= NEWLINE_CORRECTION_FACTOR
-      get_insertion_point() - lines
+      true_point( insertion_point )
     end
     alias :get_true_insertion_point :true_insertion_point
 
@@ -49,30 +65,6 @@ module QDA::GUI
       index + adjustment
     end
 
-    # remove all highlights
-    def unhighlight()
-      while extent = @highlights.shift()
-        from, to = *extent
-        true_from, true_to = true_index_to_pos(from), true_index_to_pos(to)
-        set_style( true_from, true_to, NORMAL_STYLE )
-      end      
-    end
-
-    # highlight the characters from +from+ to +to+. These are
-    # characters within the underlying text - this method will
-    # automatically translate those to real characters displayed within
-    # the text control.
-    def highlight(from, to)
-      true_from, true_to = true_index_to_pos(from), true_index_to_pos(to)
-      set_style( true_from, true_to, HIGHLIGHTED_STYLE )
-      @highlights.push( [from, to] )
-    end
-
-    def clear()
-      super()
-      @highlights = []
-    end
-
     # call this with a block that alters the appearance or content of
     # the text control - this includes call to set_style(), highlight()
     # as well as changing text content. It reduces flicker and keeps the
@@ -100,8 +92,178 @@ module QDA::GUI
     end
   end
 
-  class DocTextViewer < TrueSelectionTextCtrl
+    
+  class HighlightingTextCtrl < TrueSelectionTextCtrl
+    # TODO - using set_style on GTK (1.2) seems to trigger a serious bug
+    # where the text is moved out of correct position, and multiple
+    # successive calls trigger a segfault. This module provides stub
+    # functionality to hide this problem on Linux
+    module NullHighlighter
+      # pale_yellow = Wx::Colour.new(255, 255, 192)
+      # HIGHLIGHTED_STYLE = Wx::TextAttr.new( Wx::BLACK, pale_yellow )
+      def highlight(from, to) 
+      end
+      def unhighlight()
+      end
+    end
+
+    # Provide support for highlighting regions within the text control by
+    # changing the text foreground colour - background colour doesn't work
+    # on MS Windows WxWidgets.
+    module TextColourHighlighter
+      # background colour doesn't seem to work in MSW
+      HIGHLIGHTED_STYLE = Wx::TextAttr.new(Wx::BLUE)
+      NORMAL_STYLE      = Wx::TextAttr.new(Wx::BLACK)
+
+      def initialize(*args)
+        super
+        @highlights = []
+      end
+      
+      # highlight the characters from +from+ to +to+. These are
+      # characters within the underlying text - this method will
+      # automatically translate those to real characters displayed within
+      # the text control.
+      def highlight(from, to)
+        true_from, true_to = true_index_to_pos(from), true_index_to_pos(to)
+        set_style( true_from, true_to, HIGHLIGHTED_STYLE )
+        @highlights.push( [from, to] )
+      end
+
+      # remove all highlights
+      def unhighlight()
+        while extent = @highlights.shift()
+          from, to = *extent
+          true_from, true_to = true_index_to_pos(from), true_index_to_pos(to)
+          set_style( true_from, true_to, NORMAL_STYLE )
+        end      
+      end
+
+      def clear()
+        super()
+        @highlights = []
+      end
+    end
+
+    if Wx::RUBY_PLATFORM == 'WXGTK' # Linux
+      include NullHighlighter
+    else
+      include TextColourHighlighter
+    end
+  end
+  
+  module FindableText
+    class UsefulFindReplaceData < Wx::FindReplaceData
+      attr_accessor :flags
+      def down?
+        ! up?
+      end
+      
+      def up?
+        ( flags & Wx::FR_DOWN ).zero?
+      end
+      
+      def no_matchcase?
+        ( flags & Wx::FR_MATCHCASE).zero?
+      end
+      
+      def matchcase?
+        ! no_matchcase?
+      end
+    end
+    
+    def initialize(*args)
+      super(*args)
+      @f_dialog = nil
+      @f_data   = UsefulFindReplaceData.new(1)
+      @hooked = nil
+    end
+
+    def start_find(parent_win)
+      if not @f_dialog
+        @f_dialog = Wx::FindReplaceDialog.new( parent_win, @f_data,
+                                               "Find text", Wx::FR_NOWHOLEWORD )
+      end
+      if not @hooked
+        # TextCtrl doesn't receive evt_find, so route through parent
+        parent_win.evt_find(-1) { | e | on_find(e) }
+        parent_win.evt_find_next(-1) { | e | on_find(e) }
+        parent_win.evt_find_close(-1) { | e | on_find_close(e) }
+        # ensure dialog is destroyed when parent is closed
+        parent_win.evt_close() { | e | on_find_close(e) }
+        @hooked = parent_win
+      end
+      @f_dialog.show()
+    end
+    
+    def get_subject()
+      if @f_data.up?
+        subject = get_range( 0, insertion_point )
+      else
+        subject = get_range( insertion_point, last_position )
+      end
+      if @f_data.no_matchcase?
+        subject.downcase!
+      end
+      return subject
+    end
+    
+    def searching_down?
+      @f_data.down?
+    end
+    
+    def searching_up?
+      @f_data.up?
+    end
+    
+    def on_find(evt)
+      # query? bug in WxRuby 0.6.0 FindReplaceData#get_flags - 
+      # doesn't get automatically updated as documented
+      @f_data.flags = evt.flags
+
+      # get the string we're searching for, bail out if nothing there
+      sought  = @f_data.find_string()
+      return if sought.empty?
+      
+      sought.downcase! if @f_data.no_matchcase?
+
+      # get part of our contents in the right case ready to 
+      return unless subject = get_subject()
+      adjustment = 0
+      # hack to avoid recapturing when searching down
+      if searching_down? and string_selection == sought
+        adjustment = sought.length
+        subject = subject[adjustment .. -1]
+      end
+      
+      point = searching_down? ? subject.index( sought ) :
+                                subject.rindex( sought ) 
+      if point
+        if searching_up?
+          self.insertion_point = true_point( point )
+        else
+          self.insertion_point = true_insertion_point + point + adjustment
+        end
+        
+        sel_start = true_index_to_pos( insertion_point )
+        sel_end   = true_index_to_pos( insertion_point + sought.length )
+        self.set_selection( sel_end, sel_start )
+      end
+    end
+
+    def on_find_close(evt)
+      if @f_dialog
+        @f_dialog.destroy()
+        @f_dialog = nil
+      end
+      self.set_focus()
+      evt.skip()
+    end
+  end
+  
+  class DocTextViewer < HighlightingTextCtrl
     attr_reader :docid
+    include FindableText
     DOCTEXT_STYLE = Wx::TE_MULTILINE|Wx::TE_READONLY|
       Wx::TE_RICH|Wx::TE_NOHIDESEL
 
@@ -137,9 +299,13 @@ module QDA::GUI
   end
 
   # a text display that is made up of text fragments from multiple
-  # documents
-  # It keeps track of which fragment is found at which point
-  class CompositeText < TrueSelectionTextCtrl
+  # documents. It keeps track of which fragment is found at which point,
+  # so that when passages are marked they are routed back to the source
+  # document.
+  class CompositeText < HighlightingTextCtrl
+    include FindableText
+    HEADER_STYLE = Wx::TextAttr.new(Wx::RED)
+    NORMAL_STYLE = Wx::TextAttr.new(Wx::BLACK)
     class TextTable < Hash
       def initialize(*args)
         @reverse_table = {}
@@ -205,6 +371,7 @@ module QDA::GUI
         target = @reverse_table.keys.find do | frag |
           frag.docid == docid && frag.contains?(point)
         end
+        return nil if target.nil?
         return @reverse_table[target] - target.length +
           ( point - target.offset )
       end
@@ -231,16 +398,19 @@ module QDA::GUI
       # sort by document title
       save_position() do
         fragments.each_title do | doc_title, frags |
-          frags.each do | frag |
-            header = "#{doc_title} [#{frag.offset}-#{frag.end}]\n"
-            write_range(header, nil, HEADER_STYLE)
-            write_range(frag, frag)
-            write_range("\n\n", nil)
-          end
+          frags.each { | frag | write_frag(frag) }
           write_range("\n", nil)
         end
       end
       evt_left_dclick()  { | e | jump_to_fragment(e) }
+      self.insertion_point = 0
+    end
+    
+    def write_frag(frag)
+      header = "#{frag.doctitle} [#{frag.offset}-#{frag.end}]\n"
+      write_range(header, nil, HEADER_STYLE)
+      write_range(frag, frag)
+      write_range("\n\n", nil)
     end
 
     # writes the text +text+ to the control using the sytle +style+,
@@ -249,7 +419,7 @@ module QDA::GUI
       set_default_style(style)
       ins_start = get_last_position()
       append_text(text)
-      ins_end = get_last_position
+      ins_end = get_last_position()
 
       if style != NORMAL_STYLE
         @saved_styles[style] ||= []
@@ -259,7 +429,7 @@ module QDA::GUI
       @cursor += text.length
       @table[ @cursor ] = bound_value
     end
-    private :write_range
+    private :write_frag, :write_range
 
     def jump_to_fragment(evt)
       frag, offset = *@table.fetch(true_insertion_point)
@@ -285,6 +455,7 @@ module QDA::GUI
         areas.each do | docid, codes  |
           codes.each do | code |
             translated = @table.translate(docid, code.offset)
+            next if translated.nil?
             highlight(translated, translated + code.length)
           end
         end