weft-qda 0.9.6 → 0.9.8

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

@@ -0,0 +1,284 @@
+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 QDA::Subscriber
+    attr_reader :query, :rows, :funcs, :args, :exprs
+    private :rows, :funcs, :args, :exprs
+    
+    # obj is a simple object with a +dbid+  representing a project
+    # unique identifier for this query
+    def initialize(obj, client, workarea, layout)
+      @client = client
+
+      
+      @rows, @funcs, @args, @exprs = [], [], [], []
+      
+      super(workarea, "Query #{obj.dbid}", layout) do | parent |
+        @text_box = CompositeText.new(parent, '', 0, @client)
+      end
+      set_icon( @client.fetch_icon("query") )
+      construct_query_panel
+      # go to the query constructor panel, if query not defined, else show 
+      # results pane
+      self.query = obj
+      if query.empty?
+        @notebook.selection = 1
+      else
+        if results = get_results(query)
+          populate(results)
+        end
+      end
+    end
+
+    def obj
+      @query
+    end
+    
+    
+    
+    def query=(the_query)
+      @query = the_query
+      i = 0
+      query.unroll do | func, expr |
+        show_row(i)
+        case func
+        when QDA::Query::CodedByFunction
+          funcs[i].string_selection = 'CODED BY'
+          args[i].show( 0 )
+          cat = @client.app.get_category( func.identifier )
+          args[i].visible_item.set_active_category( cat )
+        when QDA::Query::WordSearchFunction
+          funcs[i].string_selection = 'CONTAINS WORD'
+          args[i].show( 1 )
+          args[i].visible_item.value = func.word
+        end
+
+        
+        case expr
+        when QDA::Query::AND
+          exprs[i].string_selection = 'AND'
+        when QDA::Query::OR
+          exprs[i].string_selection = 'OR'
+        when QDA::Query::AND_NOT
+          exprs[i].string_selection = 'AND NOT'
+        end
+        i += 1
+      end
+    end
+    
+    def associated_subscribers()
+      super << @args.grep(CategoryDropDown)
+    end
+
+    # runs a query using the currently selected query options
+    def get_results(query)
+      # remember the last query we did
+      @last_query = query
+      set_cursor( Wx::BUSY_CURSOR )
+      @last_results = @last_query.calculate()
+      set_cursor( Wx::NORMAL_CURSOR )
+      return @last_results
+    end
+
+    def get_target_argument(offset, as_string = false)
+      return nil unless @objects[offset].is_shown
+
+    end
+    
+    def get_function(i)
+      arg_ctrl = args[i].visible_item
+      case funcs[i].string_selection
+      when 'IS CODED BY'
+        return QDA::Query::CodedByFunction.new(@client.app,
+                                               arg_ctrl.current_category)
+      when 'CONTAINS WORD'
+          return QDA::Query::WordSearchFunction.new(@client.app, 
+                                                    arg_ctrl.get_value(),
+                                                    :wrap_both => 200 )
+      end    
+    end
+    
+    def get_query()
+      q = QDA::Query.new( get_function(0) )
+      1.upto(rows.length - 1) do | i |
+        expr = exprs[i - 1].string_selection
+        break if expr.empty?
+        q.add_expression(expr, get_function(i))
+      end
+      return q
+    rescue ArgumentError => err
+      ErrorDialog.display("Error in query", err.to_s)
+      return
+    end
+
+    # 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 = " ")
+      get_query.to_s
+    end
+
+    # run the query, display the results, view them
+    def on_view(e)
+      return unless query   = get_query()
+      return unless results = get_results( query )
+
+      populate(results)
+      @notebook.selection = 0
+    end
+    
+    def populate(results)
+      @text_box.populate( results )
+      if curr_category = @drop_down.current_category()
+        @text_box.highlight_codingtable(curr_category.codes)
+      end    
+    end
+    
+    def on_save_results(e)
+      # check for saved results
+      Wx::BusyCursor.busy do
+        results = get_results( get_query )
+        return unless results
+        @text_box.populate(results)
+      end
+
+      q_string = get_query_string
+      title = "'Query #{obj.dbid} results'"
+      search_parent = @client.app.get_root_category('SEARCHES')
+      title = search_parent.unique_name(title)
+      query_cat = QDA::Category.new( title, search_parent )
+      query_cat.codetable = @last_results
+      query_cat.memo = get_query_string("\n")
+
+      @client.app.save_category(query_cat, true)
+    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 show_row(idx)
+      if rows[idx].nil?
+        add_row()
+      else
+        @crit_sizer.show( rows[idx], true )
+      end
+      
+      # show the next row below if this one ends with a valid expression
+      if not exprs[idx].get_string_selection.empty?
+        show_row(idx + 1)
+      end
+      @crit_sizer.layout()
+    end
+    
+    def hide_row(idx)
+      return if rows[idx].nil?
+      @crit_sizer.show( rows[idx], false )
+      @crit_sizer.layout()
+      hide_row(idx + 1)
+    end
+    
+    # handle changing the /AND/OR/AND NOT/ selector at the end of each row, 
+    # hiding or showing rows below as appropriate
+    def on_alter_expression(expr_sel, row_index)
+      # Previously used to receive parameters as (event, row_index)
+      # .. but ..
+      # This seems to cause regular segfaults - wxruby 0.6.0
+      # expr_sel = event.event_object()
+      expr = expr_sel.string_selection()
+      if expr.empty?
+        hide_row(row_index + 1)
+      else
+        show_row(row_index + 1)
+      end
+    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 )
+
+      @crit_panel = Wx::Panel.new(panel2, -1)
+      @crit_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+      add_row()
+      @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)
+    end
+
+    def add_row()
+      row_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      row_index = @rows.length
+      
+      func_sel = Wx::Choice.new( @crit_panel, -1)
+      func_sel.append('IS CODED BY')
+      func_sel.append('CONTAINS WORD')
+      func_sel.selection = 0
+      row_sizer.add( func_sel, 2, Wx::GROW|Wx::ALL, 2)
+      @funcs.push( func_sel )
+
+      cat_dd  = CategoryDropDown.new(@client, @crit_panel, nil, true)
+      arg_sel = MultiTypedControl.new(cat_dd)
+      arg_sel.add_control( Wx::TextCtrl.new(@crit_panel, -1, '') )
+      # 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) }
+      row_sizer.add( arg_sel, 2, Wx::GROW|Wx::ADJUST_MINSIZE|Wx::ALL, 2)
+      @args.push( arg_sel )
+
+
+      # switch inputs
+      evt_choice(func_sel.get_id) { arg_sel.show( func_sel.selection() ) }
+
+      expr_sel = Wx::Choice.new(@crit_panel, -1)
+      expr_sel.append('')
+      expr_sel.append('OR')
+      expr_sel.append('AND')
+      expr_sel.append('AND NOT')
+      expr_sel.selection = 0
+      # Previously passed the event, but see on_alter_expression
+      # evt_choice(expr_sel.get_id) { | e | on_alter_expression(e, row_index) }
+      evt_choice(expr_sel.get_id) { on_alter_expression(expr_sel, row_index) }
+      
+      row_sizer.add( expr_sel, 1, Wx::GROW|Wx::ALL, 2)
+      @exprs.push( expr_sel )
+      @crit_sizer.add( row_sizer, 0,  
+                       Wx::GROW|Wx::ALL|Wx::ALIGN_TOP, 1 )
+      
+      @rows.push(row_sizer)
+    end
+  end
+end

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

@@ -1,35 +1,159 @@
+require 'stringio'
+
 module QDA::GUI
+    # stub class - to be moved to core weft lib?
+    class Script
+      attr_accessor :dbid
+    end
+
+  class CodeTextCtrl < Wx::TextCtrl
+    def initialize(parent, code = '')
+      super( parent, -1, code, DEF_POS, DEF_SIZE,
+             Wx::TE_MULTILINE|Wx::TE_RICH|Wx::TE_PROCESS_TAB )
+      set_default_style( normal_style )
+      evt_set_focus() { reset() }
+    end
+    
+    def reset
+      set_style(0, get_last_position, normal_style)
+    end
+    
+    def normal_font
+      @normal_font ||= Wx::Font.new( 10, Wx::MODERN, Wx::NORMAL, Wx::NORMAL )
+    end
+    def normal_style
+      @normal_style ||= Wx::TextAttr.new(Wx::BLACK, Wx::WHITE, normal_font)
+    end
+    def bold_font
+      @bold_font ||= Wx::Font.new( 10, Wx::MODERN, Wx::NORMAL, Wx::BOLD )
+    end
+    
+    def bold_style
+      @bold_style ||= Wx::TextAttr.new(Wx::RED, Wx::WHITE, bold_font)
+    end
+    
+    def highlight_line(lineno)
+      line_start = xy_to_position(0, lineno)
+      line_end   = line_start + get_line_length(lineno)
+      set_style(line_start, line_end, bold_style)
+    end
+  end
+
   class ScriptWindow < WorkAreaWindow
-    def initialize(obj, app, workarea, layout)
+    attr_reader :code, :output, :obj
+    private :code, :output
+    
+    def initialize(obj, client, 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
+      @client = client
+      @obj = obj
+      self.construct()
     end
+    
+    
+    def construct()
+      @splitter = Wx::SplitterWindow.new(self, -1,
+                                         Wx::DEFAULT_POSITION,
+                                         Wx::DEFAULT_SIZE,Wx::SP_3DSASH)
+      @splitter.minimum_pane_size = 75
+      
+      # the input pane and buttons
+      panel_code = Wx::Panel.new(@splitter)
+      code_panel_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+      
+      code_sizer = LabelledVSizer.new(panel_code, 'Script')
+
+      @code = CodeTextCtrl.new(panel_code)
+      code_sizer.add(@code, 1, Wx::GROW|Wx::ALL, 4)
+      
+      b_panel = Wx::Panel.new(panel_code)
+      b_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      @button_run = Wx::Button.new(b_panel, -1, 'Run')
+      @button_run.evt_button(@button_run.get_id) { | e | on_run(e) }
+      b_sizer.add(@button_run, 0, Wx::ALL, 4)
+
+      @button_load = Wx::Button.new(b_panel, -1, 'Load from file...')
+      @button_load.evt_button(@button_load.get_id) { | e | on_load_script(e) }
+      b_sizer.add(@button_load, 0, Wx::ALL|Wx::ALIGN_RIGHT, 4)
 
+      @button_save = Wx::Button.new(b_panel, -1, 'Save to file...')
+      @button_save.evt_button(@button_save.get_id) { | e | on_save_script(e) }
+      b_sizer.add(@button_save, 0, Wx::ALL|Wx::ALIGN_RIGHT, 4)
+      b_panel.set_sizer(b_sizer)
+
+      code_sizer.add(b_panel, 0, Wx::ADJUST_MINSIZE|Wx::ALL)
+      code_panel_sizer.add(code_sizer, 1, Wx::ALL|Wx::GROW, 4)
+      panel_code.set_sizer(code_panel_sizer)
+        
+
+      # the output pane
+      panel_outp = Wx::Panel.new(@splitter)
+      outp_panel_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      outp_sizer = LabelledVSizer.new(panel_outp, 'Output')
+      
+      @output  = Wx::TextCtrl.new(panel_outp, -1, '', DEF_POS, DEF_SIZE,
+                                   Wx::TE_MULTILINE|Wx::TE_READONLY)
+      outp_sizer.add(@output, 1, Wx::GROW|Wx::ALL, 4)
+      outp_panel_sizer.add(outp_sizer, 1, Wx::GROW|Wx::ALL, 4)
+      panel_outp.set_sizer(outp_panel_sizer)
+      
+      @splitter.split_horizontally( panel_code, panel_outp, 
+                                    get_client_size.height / 2)
+    end
+    
     def on_run(e)
       $stdout = result = StringIO.new()
-      @app.instance_eval( @code.get_value() )
-      # STDERR.puts result.inspect()
+      $stderr = errors = StringIO.new()
+      output.value = ''
+      code.reset() 
+
+      file_id = "Script #{obj.dbid}"
+      @button_run.disable()
+      @button_load.disable()
+      @button_save.disable()
+      
+      set_cursor( Wx::BUSY_CURSOR )
+      client.app.instance_eval( @code.get_value(), file_id)
+
       result.rewind()
-      @output.value = result.read()
-      $stdout = STDOUT
+      output.value = result.read()
     rescue Exception => err
-      @output.value = err
-      @output.value += err.backtrace.join("\n")
+      script_line = /\A#{file_id}:(\d)/
+      trace = err.backtrace
+      # remove backtrace info unrelated to the specific script
+      trace.pop while trace[-1] !~ script_line
+      # find the first backtrace item from within the script
+      first_script_err = trace.detect { | x | x =~ script_line }
+      # find the script line that caused the problem
+      line = first_script_err.match(script_line)[1].to_i - 1
+      code.highlight_line(line)
+      # spit the error out in the output box
+      output.value += "#{err}\n"
+      output.value += trace.join("\n")
+    ensure
+      $stdout, $stderr = STDOUT, STDERR
+      set_cursor( Wx::NORMAL_CURSOR )
+      @button_run.enable()
+      @button_load.enable()
+      @button_save.enable()
+    end
+    
+    def on_load_script(e)
+      file_dialog = ScriptFileDialog.new(self, false)
+      return unless file_dialog.show_modal == Wx::ID_OK
+      @code.load_file( file_dialog.get_path() )
+    end
+    
+    def on_save_script(e)
+      file_dialog = ScriptFileDialog.new(self, true)
+      return unless file_dialog.show_modal == Wx::ID_OK
+      @code.save_file( file_dialog.get_path() )
+    end
+    
+    def on_save_output(e)
+      file_dialog = ScriptOutputFileDialog.new(self)
+      return unless file_dialog.show_modal == Wx::ID_OK
+      @output.save_file( file_dialog.get_path() )
     end
   end
 end