weft-qda 0.9.6

data/lib/weft/wxgui/lang.rb

@@ -0,0 +1,17 @@
+module QDA::GUI
+  module Lang
+    # +lang_code+ = 'En'
+    def Lang.set_language(lang_code)
+      begin
+        require "weft/wxgui/lang/#{lang_code.downcase}"
+      rescue LoadError
+        raise LoadError, "No language file for language '#{lang_code}'"
+      end
+      language = QDA::GUI::Lang.const_get(lang_code)
+      language.constants.each do | interface_element |
+        translation = language::const_get(interface_element)
+        const_set( interface_element, translation )
+      end
+    end
+  end
+end

data/lib/weft/wxgui/lang/en.rb

@@ -0,0 +1,45 @@
+module QDA::GUI::Lang
+  module En
+    UNSAVED_CHANGES_CONFIRM = "You have unsaved changes in your project; do you wish to save these?"
+    UNSAVED_CHANGES_CONFIRM_TITLE = "Save changes?"
+    FILE_ALREADY_EXISTS = "A project file with this name already exists. If you continue, all data in it will be lost. Are you sure?"
+    SIDEBAR_TITLE = "Documents & Categories"
+    SEARCH_RESULTS = "search results"
+    REINDEX_DOCS_WARNING = 
+"This will reindex all previously imported documents, which will take
+  some time. You only need to do this once if:
+  1) you first created this project in version 0.9.3 or earlier OR
+  2) you have recently imported documents from N6. 
+Otherwise there is no need to run this command.
+
+Are you sure you wish to proceed and reindex all documents? "
+
+    REINDEX_DOCS_WARNING_TITLE = "Reindex all documents?"
+
+    NO_SEARCH_TERM_SPECIFIED = "No search term specified"
+    DOC_PANEL_TITLE = 'Documents'
+    IMPORT_DOC_BUTTON = 'Import...'
+    VIEW_DOC_BUTTON = 'View'
+    CAT_PANEL_TITLE = 'Categories'
+    NEW_CAT_BUTTON = 'New...'
+    VIEW_CAT_BUTTON = 'View'
+    DISPLAY_OPTIONS_LABEL = 'Display options'
+
+    HELP_ABOUT_MESSAGE = "Thank you for trying Weft QDA 
+Version '#{::WEFT_VERSION}'\n\n-- qda@pressure.to"
+
+    if RUBY_PLATFORM =~ /mswin/
+      HELP_HELP_MESSAGE = <<HELP
+Help files are installed with Weft QDA. 
+Please check in your 'Start' menu for a shortcut the Weft Manual help file.
+
+Alternatively, read the manual online  
+http://www.pressure.to/qda/doc/
+HELP
+
+    else
+      HELP_HELP_MESSAGE = "Please see the online documentation at  
+http://www.pressure.to/qda/doc/"
+    end
+  end
+end

data/lib/weft/wxgui/mondrian.xpm

@@ -0,0 +1,44 @@
+/* XPM */
+static char *mondrian_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"32 32 6 1",
+"  c Black",
+". c Blue",
+"X c #00bf00",
+"o c Red",
+"O c Yellow",
+"+ c Gray100",
+/* pixels */
+"                                ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+"                                ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++      ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++                    ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+"                                "
+};

data/lib/weft/wxgui/search.xpm

@@ -0,0 +1,25 @@
+/* XPM */
+static char *search[] = {
+/* columns rows colors chars-per-pixel */
+"16 16 3 1",
+"  c black",
+". c gray100",
+"X c None",
+/* pixels */
+"XXXXXXXXXXXXXXXX",
+"XXXXXXXXX    XXX",
+"XXXXXXXX .... XX",
+"XXXXXXX ...... X",
+"XXXXXXX ...... X",
+"XXXXXXX ...... X",
+"XXXXXXX ...... X",
+"XXXXXXXX .... XX",
+"XXXXXXX X    XXX",
+"XXXXXX XXXXXXXXX",
+"XXXXX XXXXXXXXXX",
+"XXXX XXXXXXXXXXX",
+"XXX XXXXXXXXXXXX",
+"XX XXXXXXXXXXXXX",
+"XXXXXXXXXXXXXXXX",
+"XXXXXXXXXXXXXXXX"
+};

data/lib/weft/wxgui/sidebar.rb

@@ -0,0 +1,498 @@
+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 ItemData
+    include 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(app, parent, locked = false)
+      @app = app
+      @locked = locked
+      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) }
+      end
+
+      subscribe(: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)
+      @data_table.delete(id)
+      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
+
+    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_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
+
+      Wx::BusyCursor.busy do
+        c_cdata  = get_item_data( evt.item )
+        category = @app.app.get_category( c_cdata.dbid )
+        category.name = new_text
+        @app.app.save_category( category)
+        set_item_data(evt.item, category )
+        $wxapp.broadcast(:category_changed, category)
+      end
+    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_item(@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 +from+ to be the last child of
+    # +to+ 
+    def move_item(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 @app.app.is_descendant?(movee, destination)
+
+      shift_nodes = Proc.new do | node, parent |
+        c_text     = get_item_text( node )
+        category   = get_item_data( node )
+        new_parent = get_item_data( parent )
+
+        # TODO - make expanded persist
+        # c_expand = is_expanded( node )
+        category.parent = new_parent
+        new_child = append_item(parent, c_text, category)
+        child = get_first_child(node)[0]
+        while child != 0
+          shift_nodes.call(child, new_child)
+          child = get_first_child(node)[0]
+        end
+        delete( node )
+        new_child
+      end
+      Wx::BusyCursor.busy do
+        new_cat = shift_nodes.call(from, to)
+        @app.app.save_category( get_item_data(new_cat) )
+      end
+    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()
+      # attach to currently selected
+      parent_item = get_selection()
+      # or default to 'CATEGORIES'
+      if parent_item.nil? || parent_item == 0
+        parent_item = @codes_id
+      end
+
+      dialog = Wx::TextEntryDialog.new(@app.sidebar, "Add Category\n",
+                                       "Enter the new category name",
+                                       "", Wx::OK | Wx::CANCEL)
+
+      if dialog.show_modal() == Wx::ID_OK
+        parent = get_item_data(parent_item)
+        cat = QDA::Category.new( dialog.get_value(), parent )
+        @app.app.save_category(cat)
+        $wxapp.broadcast(:category_added, cat)
+
+        expand(parent_item)
+        id = value_to_ident(cat)
+        select_item(id)
+      end
+    end
+
+    def valid_selection(event)
+      item_id  = event.get_item()
+      return false if item_id.nil? or item_id == 0
+      return false if is_bold(item_id)
+      get_item_data(item_id)
+    end
+
+    def on_item_selected(event)
+      category = valid_selection(event) or return()
+      @app.current_category = category
+    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 = @app.app.get_category(category.dbid, 1)
+        if category != nil
+          @app.on_category_open(category)
+        end
+      end
+    end
+
+    def delete_item(itemid)
+      Wx::BusyCursor.busy() do
+        return false if is_bold(itemid)
+        cat = get_item_data(itemid)
+        if cat
+          # delete_category is recursive and so several categories may be
+          # removed, and each is broadcast separately
+          dels = @app.app.delete_category(cat)
+          dels.each do | deletion |
+            $wxapp.broadcast(:category_deleted, deletion)
+          end
+        end
+      end
+    end
+
+    def on_key_down(evt)
+      sel = get_selection()
+      case evt.key_code()
+      when 127 # DEL
+        delete_item(sel)
+      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( value_to_ident(cat) )
+        @data_table.delete(cat)
+      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)
+        set_item_data( value_to_ident(cat), cat)
+        set_item_text( value_to_ident(cat), cat.name)
+      end
+    end
+
+    def receive_category_added(cat)
+      if cat.parent.nil? 
+        p_id = @root_id
+      else
+        p_id = value_to_ident(cat.parent)
+      end
+      append_item( p_id, cat.name, cat) if p_id
+    end
+  end
+
+  class DocumentList < Wx::ListBox
+    include ItemData
+    include Subscriber
+
+    def initialize(app, *args)
+      @app = app
+      super(*args)
+      evt_left_dclick()  { | event | on_double_click(event) }
+      evt_key_down() { | e | on_key_down(e) }
+      
+      subscribe(: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
+
+    # add the document to the end of the list.
+    def append(doc)
+      set_item_data(count, doc)
+      super(doc.title)
+    end
+
+    # needs to rejig the datatable to reflect the fact that all items
+    # below the deleted item have been deleted, and the datatable maps
+    # positions in the list to document values. Urgh. TODO - would be
+    # easier if data_table was an Array under the hood - but it is
+    # currently shared with TreeList data which is more Hash-ish.
+    def delete(item)
+      super(item)
+      @data_table.delete(item)
+      @data_table.keys.find_all { | k | k > item }.sort.each do | k |
+        set_item_data(k - 1, get_item_data(k) )
+        @data_table.delete(k)
+      end
+      # p @data_table
+    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 != ''
+        @app.on_document_open( selected_document() )
+      else
+        @app.import_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)
+      0.upto(count - 1) do | i |
+        if get_item_data(i).dbid == doc.dbid
+          delete(i) 
+          return true
+        end
+      end
+    end
+
+    def receive_document_changed(doc)
+      set_string( value_to_ident(doc), doc.title )
+    end
+
+    def receive_document_added(doc)
+       append(doc)
+    end
+
+    def on_key_down(evt)
+      sel = get_selection()
+      return if sel == -1
+      case evt.key_code()
+      when 127 # DEL
+        doc = get_item_data(sel)
+        @app.app.delete_document( doc.dbid )
+        $wxapp.broadcast(:document_deleted, doc)
+      else
+        evt.skip()
+      end
+    end
+  end
+
+  class SideBar < Wx::Frame
+    attr_reader :tree_list
+
+    def initialize(parent, app)
+      super(parent, -1, Lang::SIDEBAR_TITLE,
+            Wx::Point.new(0, 0), 
+            parent.proportional_size(0.3, 0.995) )
+      @app = app
+      self.construct()
+
+      conf = Wx::ConfigBase::get()
+      conf.path = "/SideFrame"
+      x = conf.read_int("x", 0)
+      y = conf.read_int("y", 0)
+      w = conf.read_int("w", 200)
+      h = conf.read_int("h", 400)
+      split = conf.read_int("split", 200)
+      split = 200 if split.zero? # otherwise "Documents" are invisible
+      move( Wx::Point.new(x, y) )
+      set_size( Wx::Size.new(w, h) )
+      @splitter.set_sash_position(split)
+
+
+      evt_close() { | e | on_close(e) }
+    end
+
+    def on_close(e)
+      if shown?
+        @app.on_toggle_dandc(e)
+      end
+      e.veto() # don't actually destroy the window
+    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 = '/SideFrame'
+        conf.write("x", pos.x)
+        conf.write("y", pos.y)
+        conf.write("w", size.width)
+        conf.write("h", size.height)
+        conf.write("split", @splitter.sash_position)
+      end
+    end
+
+    def construct()
+      # build the sidebar - should go in sidebar.rb
+      @splitter = Wx::SplitterWindow.new(self, -1,
+                                        Wx::DEFAULT_POSITION,
+                                        Wx::DEFAULT_SIZE,Wx::SP_3DSASH)
+
+      panel_docs = Wx::Panel.new(@splitter)
+      panel_docs_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+      doc_label = Wx::StaticBox.new(panel_docs, -1, Lang::DOC_PANEL_TITLE)
+      doc_box_sizer = Wx::StaticBoxSizer.new(doc_label, Wx::VERTICAL)
+
+      # Document List
+      @doc_list = DocumentList.new(@app, panel_docs)
+      doc_box_sizer.add(@doc_list, 1, Wx::GROW|Wx::ALL|Wx::ADJUST_MINSIZE, 4)
+
+      # Buttons Below Document List
+      butt_panel = Wx::Panel.new(panel_docs)
+      butt_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+
+      button = Wx::Button.new(butt_panel, -1, Lang::VIEW_DOC_BUTTON)
+      @view_doc_button = button
+      button.evt_button(button.get_id) do | e |
+        if @doc_list.selected_document
+          @app.on_document_open( @doc_list.selected_document )
+        end
+      end
+      button.disable()
+      evt_listbox( @doc_list.get_id ) { | e | @view_doc_button.enable(true) }
+
+      butt_sizer.add(button, 0, Wx::ALL|Wx::ALIGN_LEFT, 4)
+
+      button = Wx::Button.new(butt_panel, -1, Lang::IMPORT_DOC_BUTTON)
+      button.evt_button(button.get_id) { | e | @app.on_import_document(e) }
+      butt_sizer.add(button, 0, Wx::ALL|Wx::ALIGN_RIGHT, 4)
+
+      butt_panel.set_sizer(butt_sizer)
+      doc_box_sizer.add(butt_panel, 0, Wx::ALL|Wx::GROW|Wx::ADJUST_MINSIZE)
+      panel_docs_sizer.add(doc_box_sizer, 1, Wx::ALL|Wx::GROW, 4)
+      panel_docs.set_sizer(panel_docs_sizer)
+
+      # Category Tree
+      panel_cats = Wx::Panel.new(@splitter)
+      panel_cats_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+      cats_label = Wx::StaticBox.new(panel_cats, -1, Lang::CAT_PANEL_TITLE)
+      cats_box_sizer = Wx::StaticBoxSizer.new(cats_label, Wx::VERTICAL)
+
+      @tree_list = CategoryTree.new(@app, panel_cats, false)
+      cats_box_sizer.add(@tree_list, 3, Wx::GROW|Wx::ALL, 4)
+
+      # Buttons below Category Tree
+      butt_panel = Wx::Panel.new(panel_cats)
+      butt_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+
+      button = Wx::Button.new(butt_panel, -1, Lang::VIEW_CAT_BUTTON)
+      button.evt_button(button.get_id) do | e |
+        if @tree_list.selected_category
+          @app.on_category_open( @tree_list.selected_category )
+        end
+      end      
+      button.disable()
+      @view_cat_button = button
+      evt_tree_sel_changing( @tree_list.get_id ) do | e |
+        @tree_list.valid_selection(e) ?
+          @view_cat_button.enable(true) : @view_cat_button.disable()
+      end
+      butt_sizer.add(button, 0, Wx::ALL|Wx::ALIGN_RIGHT, 4)
+
+      button = Wx::Button.new(butt_panel, -1, Lang::NEW_CAT_BUTTON)
+      button.evt_button(button.get_id) { | e | @tree_list.on_create_item() }
+      butt_sizer.add(button, 0, Wx::ALL|Wx::ALIGN_LEFT, 4)
+
+      butt_panel.set_sizer(butt_sizer)
+      cats_box_sizer.add(butt_panel, 0, Wx::ALL|Wx::GROW|Wx::ADJUST_MINSIZE)
+      panel_cats_sizer.add(cats_box_sizer, 1, Wx::ALL|Wx::GROW, 4)
+      panel_cats.set_sizer(panel_cats_sizer)
+
+
+      @app.app.each_doc { | d | @doc_list.append(d) }
+      @tree_list.populate( @app.app.get_all_categories() )
+
+      @splitter.split_horizontally(panel_docs, panel_cats, 200)
+    end
+  end
+end