weft-qda 0.9.6 → 0.9.8

data/lib/weft/wxgui/constants.rb

@@ -0,0 +1,43 @@
+require 'uri'
+
+module QDA
+  module GUI
+    # save some typing
+    DEF_POS  = Wx::DEFAULT_POSITION
+    DEF_SIZE = Wx::DEFAULT_SIZE
+    
+    # Some versions of WxRuby on OS X seem not to have Wx::RUBY_PLATFORM
+    # correctly defined
+    if not defined?(Wx::RUBY_PLATFORM) and ::RUBY_PLATFORM =~ /powerpc/
+      Wx::RUBY_PLATFORM = 'WXMAC'
+    end
+    
+    # What window layout strategy should we use?
+    if defined? ::WEFT_MDI_MODE
+      WINDOW_MODE = :MDI
+    elsif defined? ::WEFT_MULTIFRAME_MODE
+      WINDOW_MODE = :MULTIFRAME
+    end
+
+    if defined? ::WEFT_CRASH_REPORTING
+      REPORT_CRASHES = true
+      CRASH_REPORT_URL = URI.parse('http://www.pressure.to/cgi-bin/weft-crash-report.rb')
+    else
+      REPORT_CRASHES = false
+    end
+    
+    # use windows type icons by preference on windows, otherwise settle for
+    # XPMs (which don't do multi-resolution).
+    # Also - use MDI style by default on windows, otherwise use
+    # multiframe style
+    IconType = Struct.new(:extension, :constant)
+    if Wx::RUBY_PLATFORM == 'WXMSW'
+      ICON_EXTS = [ IconType[ :ico, Wx::BITMAP_TYPE_ICO ] ,
+                    IconType[ :xpm, Wx::BITMAP_TYPE_XPM ] ]
+      WINDOW_MODE = :MDI if not defined?(WINDOW_MODE)
+    else
+      ICON_EXTS = [ IconType[ :xpm, Wx::BITMAP_TYPE_XPM ] ]
+      WINDOW_MODE = :MULTIFRAME if not defined?(WINDOW_MODE)
+    end
+  end
+end

data/lib/weft/wxgui/controls.rb

@@ -0,0 +1,6 @@
+# controls are little customised WxGUI widgets that aren't frames or dialogs
+lib_patts = $LOAD_PATH.map { | path | /^#{Regexp.escape(path)}\// }
+Dir.glob( __FILE__.sub(/\.rb$/, File::SEPARATOR + '*.rb' ) ).each do | f |
+  lib_patts.find { | x | f.sub!(x, '') }
+  require f
+end

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

@@ -0,0 +1,192 @@
+module QDA::GUI
+  class CategoryDropDown < Wx::ComboBox
+    include QDA::Subscriber
+    include ListLikeItemData
+    
+    MAXIMUM_DROPDOWN_LENGTH = 7
+    attr_accessor :sticky
+
+    # +locked+ if true will prevent the dropdown from responding to
+    # global category focus events.
+    def initialize(app, parent, text_box = nil, locked = false)
+      super(parent, -1, '', Wx::DEFAULT_POSITION,
+             Wx::DEFAULT_SIZE, [])
+      @locked = locked
+      @client_data = {}
+      @text_box = text_box
+      @sticky = false
+
+      @app = app
+
+      evt_kill_focus() do | e | 
+        find_and_add_categories()
+        e.skip()
+      end
+
+      evt_text_enter(self.get_id) do | e |
+        find_and_add_categories()
+      end
+
+      evt_combobox(self.get_id) do | e |
+        e.skip()
+        on_item_selected(e)
+      end
+        
+      subscribe(@app, :focus_category, :category_deleted, :category_changed)
+      if @app.current_category
+        set_active_category(@app.current_category)
+      end
+    end
+
+    def redraw()
+      delete(0) while count.nonzero?
+      data.each_with_index do | item, i |
+        append(item.name, nil)
+      end
+      set_selection(0)
+    end
+    
+    def append_item(cat)
+      push_item_data(cat)
+      append(cat.name, nil)
+    end
+    
+    def prepend_item(the_cat)
+      unshift_item_data(the_cat)
+      redraw()
+    end
+    
+    def update_item(the_cat)
+      if i = value_to_ident(the_cat)
+        set_item_data(i, the_cat)
+        redraw()
+      end
+    end
+    
+    def remove_item(the_cat)
+      if i = value_to_ident(the_cat)
+        delete(i)
+        data.delete_at(i)
+        if count.zero?
+          set_selection(0)
+        end
+      end
+    end
+    
+    # is this dropdown responding to global :focus_category events?
+    def locked?
+      @locked ? true : false
+    end
+
+    # make this dropdown receive global :focus_category events
+    def lock
+      @locked = true
+    end
+
+    # prevent this dropdown responding to global :focus_category events
+    def unlock
+      @locked = false
+    end
+
+
+    # highlight text coded by the category on the way.
+    def set_selection(idx)
+      super(idx)
+      on_item_selected(nil)
+    end
+    
+    # highlight text coded by the newly-selected category
+    def on_item_selected(e)
+      if @text_box
+        if category = current_category 
+          @text_box.highlight_codingtable(category.codes)
+        else
+          @text_box.unhighlight()
+        end
+      end
+    end
+
+    def delete_first()
+      delete(0)
+      data.shift
+    end
+    
+    def set_active_category(category)
+      # clear the first node unless it is sticky because it has been used,
+      # or if the category is already in the list
+      delete_first unless @sticky or value_to_ident(category)
+
+      trim()
+      prepend_item(category)
+      @sticky = false
+      set_selection(0)
+    end
+    
+    def trim(to_length = MAXIMUM_DROPDOWN_LENGTH)
+      # clear any remaining excess items
+      while count > to_length
+        data.delete_at(count - 1)
+        delete(count - 1)
+      end
+    end
+
+    def find_and_add_categories()
+      typed_text = get_value()
+      return if find_string( typed_text )
+      return if typed_text.empty?
+      matches = @app.app.get_categories_by_path(typed_text)
+      matches.each do | cat | 
+        prepend_item(cat) unless cat.parent.nil?
+      end
+      trim(matches.length) if count > MAXIMUM_DROPDOWN_LENGTH
+      set_selection( 0 )
+    end
+    
+    # add the newly-focused category to this dropdown and highlight
+    # its text.
+    def receive_focus_category(cat)
+      set_active_category(cat) unless locked?
+    end
+
+    # if a category is deleted it should be removed from the list
+    def receive_category_deleted(cat)
+      remove_item(cat)
+    end
+
+    def receive_category_changed(cat)
+      update_item(cat)
+    end
+
+
+    def on_blur(e)
+      find_and_add_categories()
+      e.skip()
+    end
+
+    # missing in wxruby, but part of WxWidgets
+    # this version differs by returning nil rather than -1 on failure
+    def find_string(str)
+      ( 0 ... count ).each do | i |
+        return i if str == get_string(i)
+      end
+      return nil
+    end
+
+
+    # TODO - some visual cue to indicate that no category matched find-first
+    def set_broken(bool)
+      
+    end
+
+    def set_warning(bool)
+
+    end
+    # returns the Category object associated with the currently
+    # selected item in the drop down.
+    def current_category
+      if curr_sel = get_selection() and curr_sel >= 0
+        return get_client_data( curr_sel )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,314 @@
+module QDA::GUI
+  # the category tree list for the side panel
+  class CategoryTree < Wx::TreeCtrl
+    CATEGORY_TREE_STYLE = Wx::TR_HIDE_ROOT|Wx::TR_HAS_BUTTONS|
+                          Wx::TR_LINES_AT_ROOT|Wx::TR_EDIT_LABELS
+
+    include HashLikeItemData
+    include QDA::Subscriber
+
+    attr_reader :root_id
+
+    # a +locked+ control is one that is not editable, and does not
+    # affect the selection of categories in other widgetes.
+    def initialize(weft_client, parent, locked = false)
+      @client = weft_client
+      @locked = locked
+      # a hash whose keys are the dbids which are expanded
+      @expanded = {}
+      super(parent, -1, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE,
+            CATEGORY_TREE_STYLE)
+      my_id = self.get_id()
+      evt_tree_item_activated(my_id) { | e | on_item_activated(e) }
+
+      if ! @locked
+        evt_tree_sel_changed(my_id) { | e | on_item_selected(e) }
+        evt_tree_end_drag(my_id) { | e | on_drag_end(e) }
+        evt_tree_begin_drag(my_id) { | e | on_drag_begin(e) }
+        evt_tree_begin_label_edit(my_id) { | e | on_edit_label_begin(e) }
+        evt_tree_end_label_edit(my_id) { | e | on_edit_label_end(e) }
+        evt_tree_key_down(my_id) { | e | on_key_down(e) }
+        evt_tree_item_expanded(my_id) { | e | on_item_expanded(e) }
+        evt_tree_item_collapsed(my_id) { | e | on_item_collapsed(e) }
+      end
+
+      subscribe(@client, :category_deleted, :category_changed, :category_added)
+    end
+
+    # for faked-up item data
+    def append_item(parent, text, data = nil)
+      id = super(parent, text, -1, -1)
+      set_item_data(id, data)
+      set_item_bold(id) if parent == @root_id
+      id
+    end
+
+    # for faked-up item data
+    def prepend_item(parent, text, img = -1, sel_img = -1, data = nil)
+      id = super(parent, text, img, sel_img)
+      set_item_data(id, data)
+      return id
+    end
+
+    # for faked-up item data
+    def delete(id)
+      super(id)
+      del_cat = data.delete(id)
+      if del_cat.parent and old_parent_id = value_to_ident(del_cat.parent)
+        set_item_data( old_parent_id, 
+                       @client.app.get_category(del_cat.parent.dbid) )
+      end        
+      return nil
+    end
+    
+    def populate(children)
+      # the root isn't shown, so the top level of +children+ is what
+      # appears at the base of the tree.
+      @root_id = add_root('ROOT')
+      append_recursively(@root_id, children)
+      refresh()
+    end
+    
+    # returns an array of category ids
+    # NOT USED?
+    def expanded_items()
+      @expanded.keys
+    end
+    
+    # Opens the category nodes corresponding to the category ids in +catids+
+    def expand_items(catids)
+      catids.keys.each do | catid |
+        if itemid = value_to_ident(catid) 
+          # this is done here to prevent it being seen as a change by evt handler
+          @expanded[catid] = true
+          expand( itemid )
+        end 
+      end
+    end
+    
+    def append_recursively(parent, children)
+      children.each do | child_cat |
+        name = child_cat.name.empty? ? 'DEFAULT' : child_cat.name
+
+        id = append_item(parent, name, child_cat )
+        # remember this for later use
+        @search_id = id if name == 'SEARCHES' 
+        @codes_id  = id if name == 'CATEGORIES' or name == 'CODES'
+
+        append_recursively(id, child_cat.children)
+      end
+    end
+
+    # get the currently active category
+    def get_current_category()
+      if curr_sel = get_selection()
+        return nil if curr_sel == 0
+        category = get_item_data( curr_sel )
+        return nil if category.nil? # important for GTK
+        return nil if category.parent.nil? # don't return root nodes
+        category
+      end
+    end
+    alias :selected_category :get_current_category
+    
+    def on_item_expanded(evt)
+      cat = get_item_data(evt.item)
+      return unless cat
+      return if @expanded[cat.dbid] # prevents futile re-saving if already open
+      @expanded[cat.dbid] = true
+      @client.app.save_preference('TreeLayout', @expanded)
+    end
+    
+    def on_item_collapsed(evt)
+      cat = get_item_data(evt.item)
+      return unless cat
+      @expanded.delete(cat.dbid)
+      @client.app.save_preference('TreeLayout', @expanded)
+    end
+    
+    def on_edit_label_begin(evt)
+      # TODO - this should really talk to the underlying category,
+      # rather than just assuming bold = locked
+      evt.veto() if bold?(evt.item)
+    end
+
+    def on_edit_label_end(evt)
+      new_text = evt.label
+      if new_text == ""
+        evt.veto()
+        return
+      end
+
+      old_text = get_item_text( evt.item )
+      # don't bother saving if the text isn't changed
+      return if old_text == new_text
+      c_cdata  = get_item_data( evt.item )
+      category = @client.app.get_category( c_cdata.dbid )
+      Wx::BusyCursor.busy do
+        begin
+          category.name = new_text
+          @client.app.save_category( category)
+        rescue QDA::BadNameError
+          category.name = old_text
+          ErrorDialog.display( Lang::BAD_CATEGORY_NAME_TITLE, 
+                               Lang::BAD_CATEGORY_NAME_WARNING )
+          evt.veto()
+        rescue QDA::NotUniqueNameError
+          category.name = old_text
+          ErrorDialog.display( Lang::DUPLICATE_CATEGORY_NAME_TITLE, 
+                               Lang::DUPLICATE_CATEGORY_NAME_WARNING )
+          evt.veto()
+        end
+      end
+      
+      set_item_data(evt.item, category )
+    end
+    
+    def on_drag_begin(evt)
+      @drag_subject = evt.item
+      evt.allow()
+    end
+
+    # relocates or merges the coding of the draggee to the drag target
+    def on_drag_end(evt)
+      @drag_target = evt.item
+      # control_down is a property of a mouse event, so this doesn't work
+      # p "CONTROL IS DOWN" if evt.control_down
+      move(@drag_subject, @drag_target)
+
+      @drag_subject = nil
+      @drag_target  = nil
+    end
+
+    def dont_move(from)
+      select_item(from) if from != 0
+    end
+    
+
+    # moves the item identifed by the tree id +from+ to be the last child of
+    # the category with the tree id +to+ 
+    def move(from, to)
+      return dont_move(from) unless from and to
+      return dont_move(from) if from == 0 or to == 0
+      return dont_move(from) if from == to 
+
+      movee = get_item_data( from )
+      destination = get_item_data( to )
+      # don't move root nodes
+      return dont_move(from) if not movee.parent
+      # ignore if no move
+      return dont_move(from) if movee.parent == destination
+      # don't attach to descendants
+      return dont_move(from) if destination.is_descendant_of?(movee)
+      # complain if a child with this name already attached to parent
+      if destination[movee.name]
+        ErrorDialog.display( Lang::DUPLICATE_CATEGORY_NAME_TITLE, 
+                             Lang::DUPLICATE_CATEGORY_NAME_WARNING )
+        return dont_move(from)
+      end
+      
+      Wx::BusyCursor.busy do
+        movee.parent = destination
+        @client.app.save_category( movee )
+      end
+    end
+    
+    # Moves the tree item identified by +from+ so that it is attached the parent
+    # identified by +new_parent+. Does nothing if that is already the location
+    # of the node.
+    def move_item(from, to)
+      # don't alter if unchanged
+      return from if get_item_parent(from) == to
+      new_child = append_item(to, get_item_text(from), get_item_data(from))
+      child = get_first_child(from)[0]
+      while child != 0
+        move_item(child, new_child)
+        child = get_first_child(from)[0]
+      end
+      delete( from )
+      new_child
+    end
+
+    # when we're asked to add an item. This will be attached to the
+    # currently selected category in the tree, or the default 'CATEGORIES'
+    # category if no item is selected
+    def on_create_item()
+      @client.on_add_category()
+    end
+
+    def on_item_selected(event)
+      if valid_selection?(event)
+        @client.current_category = get_item_data( event.get_item )
+      else
+        @client.current_category = nil
+      end
+    end
+
+    def on_item_activated(event)
+      item_id  = event.get_item()
+      category =  get_item_data(item_id)
+      return nil if category.parent.nil?
+      Wx::BusyCursor.busy() do 
+        category = @client.app.get_category(category.dbid, true)
+        if category != nil
+          @client.on_category_open(category)
+        end
+      end
+    end
+    
+    def valid_selection?( event )
+      # wxruby varies across platforms in how it indicates "no item
+      # selected" - on windows, get_selection returns 0, on Linux, a
+      # weird large integer id. Returning nil is the "correct" future behaviour
+      item_id = event.get_item()
+      if item_id.nil? or item_id == 0 or is_bold(item_id)
+        return false
+      elsif not get_item_data( item_id )
+        return false
+      else
+        return true
+      end
+    end
+    
+    def delete_selection()
+      @client.on_delete_category()
+    end
+    
+    def on_key_down(evt)
+      case evt.key_code()
+      when 127 # DEL
+        delete_selection()
+      end
+    end
+    
+    def receive_category_deleted(cat)
+      # may not include this item if it's a partial subtree
+      if tree_id = value_to_ident(cat)
+        delete( tree_id )
+      end
+    end
+
+    def receive_category_changed(cat)
+      # may not include this item if it's a partial subtree
+      if tree_id = value_to_ident(cat)
+        # it's maybe moved
+        tree_id = move_item(tree_id, value_to_ident(cat.parent) )
+        set_item_text( tree_id, cat.name)
+        set_item_data( tree_id, cat)
+      end
+    end
+
+    def receive_category_added(cat)
+      if cat.parent.nil? 
+        p_id = @root_id
+      else
+        p_id = value_to_ident(cat.parent)
+      end
+      return if not p_id
+      append_item( p_id, cat.name, cat)
+      expand(p_id)
+      id = value_to_ident(cat)
+      select_item(id)
+    end
+  end
+end