weft-qda 0.9.6

data/lib/weft/wxgui/inspectors/imagedocument.rb

@@ -0,0 +1,56 @@
+module QDA
+module GUI
+
+	class ImageDocumentWindow < InspectorWindow
+	  Wx::init_all_image_handlers
+
+	  def initialize(image_file, *args)
+		@img = Wx::Image.new(image_file)
+        # magnifier
+		@bitmap = Wx::Bitmap.new( @img )
+        @zoom   = 0
+		# check height & widget to set size of child window
+		# @bitmap.get_height
+        # sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+        # sizer.add(img, 1, Wx::SHAPED|Wx::GROW, 5)
+		super(*args) do
+          # client_size = Wx::Size.new(@bitmap.width, @bitmap.height)
+          set_client_size(Wx::Size.new(@bitmap.width, @bitmap.height))
+        end
+        self.set_cursor( Wx::Cursor.new(Wx::CURSOR_MAGNIFIER) )
+		evt_paint { on_paint }
+        evt_left_up { | e | zoom_in(e) }
+        evt_right_up { | e | zoom_out(e) }
+	  end
+
+	  def on_paint
+		paint do | dc |
+		  dc.clear
+		  dc.draw_bitmap(@bitmap, 0, 0, false)
+		end
+	  end
+
+      def zoom_in(*args)
+        @zoom += 1
+        zoom(*args)
+      end
+
+      def zoom_out(*args)
+        @zoom -= 1
+        zoom(*args)
+      end
+
+      def zoom(event)
+        img_x2 = @img.scale(@img.get_width * ( 2 ** @zoom ), 
+                            @img.get_height * ( 2 ** @zoom) )
+        #rotate90                             
+        @bitmap = Wx::Bitmap.new( img_x2 )
+        dc = Wx::ClientDC.new(self)
+        dc.clear
+        dc.draw_bitmap(@bitmap, 0, 0, false)
+        set_client_size(Wx::Size.new( @img.get_width * ( 2 ** @zoom ), 
+                                      @img.get_height * ( 2 ** @zoom) ) )
+      end
+	end
+end
+end

data/lib/weft/wxgui/inspectors/script.rb

@@ -0,0 +1,35 @@
+module QDA::GUI
+  class ScriptWindow < WorkAreaWindow
+    def initialize(obj, app, workarea, layout)
+      super(workarea, "Script #{obj.dbid}", nil)
+      @app = app
+      code = ''
+      sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+      @code = Wx::TextCtrl.new(self, -1, code, Wx::DEFAULT_POSITION, 
+                                Wx::DEFAULT_SIZE, Wx::TE_MULTILINE)
+      sizer.add(@code, 2, Wx::GROW|Wx::ALL, 5)
+
+      button = Wx::Button.new(self, -1, 'Run')
+      button.evt_button(button.get_id) { | e | on_run(e) }
+      sizer.add(button, 0, Wx::ALL, 5)
+
+      @output  = Wx::TextCtrl.new(self, -1, '', Wx::DEFAULT_POSITION, 
+                                   Wx::DEFAULT_SIZE, 
+                                   Wx::TE_MULTILINE|Wx::TE_READONLY)
+      sizer.add(@output, 2, Wx::GROW|Wx::ALL, 5)
+      self.sizer = sizer
+    end
+
+    def on_run(e)
+      $stdout = result = StringIO.new()
+      @app.instance_eval( @code.get_value() )
+      # STDERR.puts result.inspect()
+      result.rewind()
+      @output.value = result.read()
+      $stdout = STDOUT
+    rescue Exception => err
+      @output.value = err
+      @output.value += err.backtrace.join("\n")
+    end
+  end
+end

data/lib/weft/wxgui/inspectors/search.rb

@@ -0,0 +1,265 @@
+module QDA::GUI
+  # a window that allows the entry of criteria (category
+  # intersections and unions, text search, document attributes), and
+  # interactively presents the text meeting the criteria, and to save
+  # the results as a permanent category (memo describing the rules
+  # used to produce the codes.
+  class QueryWindow < InspectorWindow
+    include Subscriber
+
+    # obj is a simple object with a +dbid+  representing a project
+    # unique identifier for this query
+    def initialize(obj, app, workarea, layout)
+      @app = app
+      @query = obj # currently a pretty much empty object
+
+      super(workarea, "Query #{@query.dbid}", layout) do | parent |
+        @text_box = CompositeText.new(parent, '', 0, @app)
+      end
+      set_icon( app.fetch_icon("search.xpm") )
+      construct_query_panel
+      @notebook.selection = 1
+      subscribe()
+      # evt_set_focus() { | e | p "focussed #{e.event_object}"; e.skip() }
+    end
+    
+    def associated_subscribers()
+      super << @objects.grep(CategoryDropDown)
+    end
+
+    # runs a query using the currently selected query options
+    def get_results()
+      begin
+        # remember the last query we did
+        @last_query = get_query_string
+        @last_results = @app.app.do_query( *get_query_arguments )
+      rescue Exception => err
+        Wx::MessageDialog.new(nil, err.to_s,
+                               "Error running query", 
+                               Wx::OK|Wx::ICON_EXCLAMATION).show_modal()
+        return
+      end
+      return @last_results
+    end
+
+    def get_target_argument(offset, as_string = false)
+      return nil unless @objects[offset].is_shown
+      if @rules[offset].value == 'IS CODED BY'
+        if @objects[offset].current_category
+          category = @objects[offset].current_category
+          return as_string ? category.name : category.dbid
+        else
+          # use fail rather than raise as it gets interp as a method...
+          fail RuntimeError.new("No category value set for CODED BY")
+        end
+      elsif @rules[offset].value == 'CONTAINS WORD'
+        str = @objects[offset].get_value
+        if str.empty?
+          fail RuntimeError.new("No text search set for CONTAINS WORD")
+        else
+          return str
+        end
+      end
+    end
+
+    def get_query_arguments()
+      return @rules[0].value, get_target_argument(0), 
+      @ops[0].value, 
+      @rules[1].value, get_target_argument(1)
+    end
+
+    # TODO
+    # returns a stringified representation of the query. The only
+    # reason this is here at the moment is because the underlying
+    # query code parser doesn't accept string literal paths or names
+    # for categories- only database ids. This should be remedied, so
+    # the string passed to query and this are the same.
+    def get_query_string(join_char = " ")
+      begin
+        query_parts = [ @rules[0].value, get_target_argument(0, true) ]
+        # add on the second bit if used
+        # TODO - this is barbaric - this whole thing needs tidying
+        # and being made more extensible n = many
+        if @ops[0].value != ''
+          query_parts += [ @ops[0].value, 
+            @rules[1].value, get_target_argument(1, true) ]
+        end
+        return query_parts.join(join_char)
+      rescue Exception => err
+        return ''
+      end
+    end
+
+    # run the query, display the results, view them
+    def on_view(e)
+      Wx::BusyCursor.busy do
+        results = get_results()
+        return unless results
+        @text_box.populate( results )
+        if curr_category = @drop_down.current_category()
+          @text_box.highlight_codingtable(curr_category.codes)
+        end
+      end
+      @notebook.selection = 0
+    end
+
+    def on_save_results(e)
+      # check for saved results
+      unless @last_results and ! @last_query.empty? and
+          @last_query == get_query_string()
+        Wx::BusyCursor.busy do
+          results = get_results()
+          return unless results
+          @text_box.populate(results)
+        end
+      end
+
+      q_string = get_query_string
+      title = "'#{q_string[0, 30]}...' (query results)"
+      search_parent = @app.app.get_root_category('SEARCHES')
+      query_cat = Category.new( title, search_parent )
+      query_cat.codetable = @last_results
+      query_cat.memo = get_query_string("\n")
+      $wxapp.app.save_category(query_cat)
+      $wxapp.broadcast(:category_added, query_cat)
+    end
+
+    def on_focus_dropdown(e)
+      # p "focussed #{e.event_object}"
+      # e.skip()
+    end
+
+    def on_blur_dropdown(e)
+      # p "blurred #{e.event_object}"
+      # p active?
+      # e.skip()
+    end
+
+    def construct_query_panel()
+      panel2 = Wx::Panel.new(@notebook, -1)
+      sizer2 = Wx::BoxSizer.new(Wx::VERTICAL)
+      sizer2.add( Wx::StaticText.new(panel2, -1, 'Find text that:'),
+                  0, Wx::ALL|Wx::ADJUST_MINSIZE, 4 )
+
+      # criteria consist of rules ('is coded by', 'text matches'),
+      # targets ('category "Foo"', 'text "Bar"') and may be joined by
+      # ops ('AND', 'OR')
+      
+      @rules   = []
+      @objects = []
+      @ops     = []
+      
+      @crit_panel = Wx::Panel.new(panel2, -1)
+      @crit_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+      add_criterion(true)
+      add_criterion(false)
+
+
+      @ops[0].evt_combobox(@ops[0].get_id) do | e |
+        operator = @ops[0].get_string_selection
+        if operator != ""
+          @rules[1].show(true)
+          @objects[1].show(true)
+        else
+          @rules[1].hide()
+          @objects[1].hide()
+        end
+      end 
+      @rules[1].hide()
+      @objects[1].hide()
+
+      @crit_panel.set_sizer(@crit_sizer)
+      sizer2.add(@crit_panel, 1, Wx::GROW|Wx::ALL|Wx::ADJUST_MINSIZE, 4 )
+
+      butt_panel = Wx::Panel.new(panel2, -1)
+      bott_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+
+      button = Wx::Button.new(butt_panel, -1, 'View')
+      button.evt_button(button.get_id) { | e | on_view(e) }
+      bott_sizer.add(button, 1, Wx::ALL, 4)
+
+      button = Wx::Button.new(butt_panel, -1, 'Save Results')
+      button.evt_button(button.get_id) { | e | on_save_results(e) }
+      bott_sizer.add(button, 1, Wx::ALL, 4)
+
+      butt_panel.set_sizer(bott_sizer)
+      sizer2.add(butt_panel, 0,
+                  Wx::GROW|Wx::ADJUST_MINSIZE|Wx::ALIGN_BOTTOM) 
+      @notebook.add_page(panel2, 'query')
+      panel2.set_sizer_and_fit(sizer2)
+      # sizer2.set_size_hints(panel2)
+    end
+
+    def add_criterion(with_bool = false)
+      row_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      row_n = @rules.length
+
+      type_op1 = Wx::ComboBox.new(@crit_panel, -1, '', Wx::DEFAULT_POSITION,
+                                   Wx::DEFAULT_SIZE, [],
+                                   Wx::CB_READONLY|Wx::CB_DROPDOWN)
+      type_op1.append('IS CODED BY')
+      type_op1.append('CONTAINS WORD')
+
+      type_op1.selection = 0
+      row_sizer.add( type_op1, 1, Wx::GROW|Wx::ALL)
+      @rules.push( type_op1 )
+
+      op2_placeholder = Wx::BoxSizer.new(Wx::VERTICAL)
+      type_op2 = CategoryDropDown.new(@app, @crit_panel, nil, true)
+      # TODO - allow currently highlighted category dropdown to
+      # receive global focus_category events
+      # type_op2.evt_set_focus() { | e | on_focus_dropdown(e) }
+      # type_op2.evt_kill_focus() { | e | on_blur_dropdown(e) }
+
+      op2_placeholder.add(type_op2, 1, 
+                           Wx:: GROW|Wx::ALL)
+
+      type_op2_a = Wx::TextCtrl.new(@crit_panel, -1, '')
+      type_op2_a.hide()
+      row_sizer.add( op2_placeholder, 1, Wx::ADJUST_MINSIZE)
+
+      @objects.push( type_op2 )
+
+
+      # switch inputs
+      evt_combobox(type_op1.get_id) do | e |
+        function = type_op1.get_string_selection()
+        if function == "IS CODED BY" and not type_op2.shown?
+          type_op2_a.hide()
+          op2_placeholder.remove(type_op2_a)
+
+          op2_placeholder.add(type_op2, 1, 
+                               Wx::GROW|Wx::ADJUST_MINSIZE|Wx::ALL)
+          type_op2.show()
+          op2_placeholder.layout()
+          @objects[row_n] = type_op2
+        elsif function == "CONTAINS WORD" and not type_op2_a.shown?
+          type_op2.hide()
+          op2_placeholder.remove(type_op2)
+          op2_placeholder.add(type_op2_a, 1, 
+                               Wx:: GROW|Wx::ADJUST_MINSIZE|Wx::ALL)
+          type_op2_a.show()
+          op2_placeholder.layout()
+          @objects[row_n] = type_op2_a
+        end
+      end
+
+      type_op3 = Wx::ComboBox.new(@crit_panel, -1, '', Wx::DEFAULT_POSITION,
+                                   Wx::DEFAULT_SIZE, [],
+                                   Wx::CB_READONLY|Wx::CB_DROPDOWN)
+      type_op3.append('')
+      type_op3.append('AND')
+      type_op3.append('AND NOT')
+      type_op3.append('OR')
+      type_op3.selection = 0
+
+      row_sizer.add( type_op3, 1, Wx::GROW|Wx::ALL, 2)
+      @ops.push( type_op3 )
+      unless with_bool 
+        type_op3.hide()
+      end
+      @crit_sizer.add( row_sizer, 0,  Wx::GROW|Wx::ALL|Wx::ALIGN_TOP )
+    end
+  end
+end

data/lib/weft/wxgui/inspectors/textcontrols.rb

@@ -0,0 +1,304 @@
+module QDA::GUI
+  # a text control that is able to relate the selection back to the
+  # 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'
+      NEWLINE_CORRECTION_FACTOR = 1
+    else
+      NEWLINE_CORRECTION_FACTOR = 0
+    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
+    end
+    alias :get_true_insertion_point :true_insertion_point
+
+    # given an index within the underlying string, returns the
+    # corresponding position within the TextCtrl
+    def true_index_to_pos(index)
+      str = get_value()[0, index]
+      adjustment = str.count("\n") * NEWLINE_CORRECTION_FACTOR
+      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
+    # viewable area positioned correctly.
+    def save_position()
+      freeze()
+      saved_pos = get_scroll_pos(Wx::VERTICAL)
+      # calculate how many pixels it moves when we nudge the scrollbar
+      # down a 'line'
+      scroll_lines(1)
+      pos_down = saved_pos - get_scroll_pos(Wx::VERTICAL)
+      # calculate how many pixels it moves when we nudge the scrollbar
+      # up a 'line'
+      scroll_lines(-1)
+      pos_up = saved_pos - get_scroll_pos(Wx::VERTICAL)
+
+      # how long is a 'line'
+      movement = 0 - pos_down + pos_up
+      yield
+      show_position(0)
+      if movement > 0
+        scroll_lines(saved_pos / movement)
+      end
+      thaw()
+    end
+  end
+
+  class DocTextViewer < TrueSelectionTextCtrl
+    attr_reader :docid
+    DOCTEXT_STYLE = Wx::TE_MULTILINE|Wx::TE_READONLY|
+      Wx::TE_RICH|Wx::TE_NOHIDESEL
+
+    def initialize(parent, docid)
+      super( parent, -1, '', Wx::DEFAULT_POSITION, 
+             Wx::DEFAULT_SIZE, 
+             DOCTEXT_STYLE)
+      @docid = docid
+    end
+
+    # in this case simply returns a single code, representing the
+    # extent of the document currently highlighted.
+    def selection_to_fragments()
+      start, finish = true_selection()
+      length = finish - start
+      return [] if length == 0
+      QDA::CodeSet[ QDA::Code.new(@docid, start, length) ]
+    end
+
+    def highlight_codingtable(codes)
+      highlight_codeset( codes[@docid] )
+    end
+
+    # highlight all the passages found
+    def highlight_codeset(codeset)
+      save_position do
+        unhighlight()
+        codeset.each do | area |
+          highlight( area.offset, area.end )
+        end
+      end
+    end
+  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
+    class TextTable < Hash
+      def initialize(*args)
+        @reverse_table = {}
+        super(*args)
+      end
+
+      # returns the object associated with the character point #{key}
+      # within the text table. Note that 
+      def [] (key)
+        keys.sort.each { | k | return super(k) if key < k }
+        return nil
+      end
+
+      # returns the object associated with the character point #{key}
+      # within the text table. Note that 
+      def []=(key, value)
+        super(key, value)
+        @reverse_table[ value.to_code() ] = key unless value.nil?
+      end
+
+      def fetch(key)
+        offset = 0
+        keys.sort.each do | k |
+          if key < k
+            return super(k), key - offset
+          end
+          offset = k
+        end
+        return nil
+      end
+
+      # given a range across the text +length+ characters long from
+      # +start+, returns an Array of Vectors describing it
+      def range_to_vectors(start, length)
+        offset = 0
+        results = QDA::CodeSet[]
+
+        # at each iteration, offset is the position that we're starting from
+        # k is the offset we're going to. 
+        keys.sort.each do | k |
+          word = self[k]
+          next unless word
+          this_start  = [ k, start ].max
+          this_end    = [ k + word.length, start + length ].min
+          # they're not overlapping
+          next if this_start >= this_end
+          results.add( QDA::Code.new( word.docid,
+                                      word.offset - k + this_start,
+                                      this_end - this_start ) )
+          # break if k >= start + length
+          offset = k
+        end
+        return results
+      end
+      
+      # Returns the notional offset of the point +point+  within the
+      # document +docid+, or nil if that point is not displayed. Note
+      # that this represents position within the notional underlying
+      # contents, not the actual display in text control. If you wish to
+      # use these to refer to text displayed within the text control,
+      # call true_index_to_pos() on the return value.
+      def translate(docid, point)
+        target = @reverse_table.keys.find do | frag |
+          frag.docid == docid && frag.contains?(point)
+        end
+        return @reverse_table[target] - target.length +
+          ( point - target.offset )
+      end
+    end
+
+    def initialize(parent, text, offset, app)
+      @saved_styles = Hash.new()
+      super(parent, -1, text, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 
+             Wx::TE_MULTILINE|Wx::TE_READONLY|Wx::TE_RICH|Wx::TE_NOHIDESEL)
+      @app = app
+      evt_enter_window do | e |
+        set_cursor Wx::Cursor.new(Wx::CURSOR_IBEAM)
+      end
+      set_font( @app.display_font )
+    end
+
+    # displays the hash table of fragments, keyed on document title as a set
+    # of results, ordered by case-insensitive document title order.
+    def populate(fragments)
+      self.clear()
+      @table = TextTable.new()
+      @cursor = 0
+      @fragments = fragments
+      # 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
+          write_range("\n", nil)
+        end
+      end
+      evt_left_dclick()  { | e | jump_to_fragment(e) }
+    end
+
+    # writes the text +text+ to the control using the sytle +style+,
+    # and associates the object +bound_value+ to that text range.
+    def write_range(text, bound_value = nil, style = NORMAL_STYLE)
+      set_default_style(style)
+      ins_start = get_last_position()
+      append_text(text)
+      ins_end = get_last_position
+
+      if style != NORMAL_STYLE
+        @saved_styles[style] ||= []
+        @saved_styles[style].push([ ins_start, ins_end ])
+      end
+      # @table[ get_last_position() ] = bound_value
+      @cursor += text.length
+      @table[ @cursor ] = bound_value
+    end
+    private :write_range
+
+    def jump_to_fragment(evt)
+      frag, offset = *@table.fetch(true_insertion_point)
+      # if we've clicked on a text bit
+      return unless frag
+      @app.on_document_open( frag.docid,
+                             frag.offset + offset )
+
+    end
+
+    def selection_to_fragments()
+      cursor, finish = *true_selection()
+      length = finish - cursor
+      results = @table.range_to_vectors(cursor, length)
+    end
+
+    # highlights the coded vectors or fragments
+    def highlight_codingtable(codingtable)
+      return unless @fragments
+      areas = @fragments.to_codingtable.join(codingtable)
+      save_position do
+        unhighlight()
+        areas.each do | docid, codes  |
+          codes.each do | code |
+            translated = @table.translate(docid, code.offset)
+            highlight(translated, translated + code.length)
+          end
+        end
+      end
+    end
+
+    # need to repaint headers and so on
+    def set_font(font)
+      super(font)
+      @saved_styles.each do | style, segments |
+        segments.each do | seg | 
+          set_style(seg[0], seg[1], style)
+        end
+      end
+    end
+  end
+end