weft-qda 0.9.6

data/lib/weft/filters.rb

@@ -0,0 +1,243 @@
+require 'weft/category'
+require 'weft/coding'
+require 'English'
+
+module QDA
+  class InputFilter
+    attr_reader :cursor
+
+	def initialize()
+      @cursor = 0
+      @indexers = []
+	end
+	
+    def add_indexer(indexer)
+      unless indexer.respond_to?(:feed)
+        raise "Document indexers should have a feed method"
+      end
+      @indexers.push(indexer)
+    end
+	
+    # reads +file+ and creates a new document titled +doctitle+. +file+
+    # may be a String filename or an open stream.
+    # Under the hood, calls +read_content+ to extract the content. This
+    # method must be implemented in subclasses. Then +process_content+
+    # is called to create the documents text. This class does something
+    # reasonable with plain text, but structured text formats will want
+    # to subclass this method to process non-text information (for
+    # example, HTML or XML tags)
+	def read(file, doctitle)
+      @content = ''
+	  case file
+	  when IO
+		@content = file.read()
+      when QDA::Document
+        @content = file.text()
+	  when String
+        @content = File.read(file)
+	  end
+      process_content(doctitle)
+    end
+
+    def process_content(doctitle)
+      # signal to indexers we're about to start
+      @indexers.each { | indexer | indexer.prepare(@content) }
+	  doc = QDA::Document.new(doctitle)
+	  @content.each_line do | line |
+        doc.append(line.to_s.chomp)
+        # inform AutoCoders, reverse indexers and so on.
+        @indexers.each { | indexer | indexer.feed(line) }
+	  end
+      @indexers.each { | indexer | indexer.terminate() }
+	  doc.create
+      return doc
+    end
+  end
+
+  class TextFilter < InputFilter
+    EXTENSIONS = [ 'txt' ]
+	def read_content(file)
+      text = file.read()
+      file.close()
+      text
+	end
+  end
+
+  class PDFFilter < InputFilter
+    EXTENSIONS = [ 'pdf' ]
+    PDF_TO_TEXT_EXEC = 'pdftotext'
+    begin
+      out = `#{PDF_TO_TEXT_EXEC} -v 2>&1`
+      unless out =~ /pdftotext version 3/
+        warn 'PDFtotext Version 3 not found in path' +
+             'PDF Filters will not be avaialabl'
+      end
+    end
+
+    NO_COPYING_ERROR_TEXT = 
+      "The author or publisher of this PDF document has locked it to
+prevent copying and extraction of its text. It is not possible to
+import this document."
+    def read(file, doctitle)
+	  case file
+	  when IO
+        raise NotImplementedError
+		@content = `#{PDF_TO_TEXT_EXEC} -nopgbrk #{file.path} - 2>&1`
+        file.close()
+	  when String
+        @content = `#{PDF_TO_TEXT_EXEC} -nopgbrk #{file} - 2>&1`
+	  end
+
+      case $CHILD_STATUS
+      when 0
+        process_content(doctitle)
+      when 3
+        raise RuntimeError.new(NO_COPYING_ERROR_TEXT)
+      else
+        raise RuntimeError.new("Could not extract PDF text: #{text}")
+      end
+    end
+    
+  end
+
+  class OutputFilter
+
+  end
+
+  # ...
+  class HTMLFilter < OutputFilter
+
+  end
+
+  class Indexer
+    attr_reader :cursor
+    def initialize()
+      @cursor = 0
+    end
+
+    def index(str)
+      prepare(str)
+      str.each_line { | line | feed(line) }
+    end
+
+    def terminate()
+    end
+
+    def prepare(content)
+    end
+
+    def feed(line)
+      @cursor += line.length
+    end
+  end
+  
+  # An indexer which records the position of words for later reverse
+  # retrieval
+  class WordIndexer <  Indexer
+    attr_reader :words
+    # includes accented latin-1 characters
+    WORD_TOKENIZER = /[\w\xC0-\xD6\xD8-\xF6\xF8-\xFF][\w\xC0-\xD6\xD8-\xF6\xF8-\xFF\']+/
+    def initialize()
+      super
+      @words = Hash.new { | h, k | h[k] = [] }
+    end
+
+    def feed(line)
+      line.scan( WORD_TOKENIZER ) do | word |
+        next if word.length == 1
+        @words[word].push(cursor + Regexp.last_match.begin(0))
+      end
+      super
+    end
+  end
+
+  # An indexer that uses text patterns to identify, for example,
+  # passages by a particular speaker, or text headings. 
+  # The indexer can recognise a number of different types of codes,
+  # each denoted by a pattern of punctuation in a line of text. A
+  # default coder recognises the following
+  # A 'Heading', marked by a line **NAME OF HEADING**
+  # A 'Speaker', marked by a line SpeakerName:
+  # 
+  # After the filter has run, the results of the coding can be
+  # retrieved by calling Autocoder#codes
+  # This is a hash of codetype names to inner hashes of codevalue names
+  # (strings) to QDA::Codesets corresponding to them.
+  class AutoCoder < Indexer
+    STANDARD_TRIGGER_RULES = {
+      /^(\w+)\:\s*$/   => 'Speaker',
+      /^\*\*(.*)\*\*$/ => 'Heading'
+    }
+
+    attr_reader :codes
+    # +rules+ should be a hash of string keys, naming types of autocode
+    # (e.g. "Speaker", "Heading", "Topic") mapped to values, which
+    # should be regular expressions specifying how the start of such a
+    # code should be recognised.
+    # For example, to find topics marked by the characters '##' at the
+    # start of the line:
+    # 'Heading' => /^##(.*)$/
+    def initialize(rules = STANDARD_TRIGGER_RULES)
+      super()
+      @trigger_rules = rules
+      @codes      = Hash.new { | h, k | h[k] = {} }
+      @curr_codes = {}
+    end
+
+    # check a line of document content for triggers
+    def feed(line)
+      @trigger_rules.each do | rule, type |
+        if match = rule.match(line)
+          trigger(cursor, type, match[1]) 
+        end
+      end
+      super
+    end
+
+    # take action on finding a autocode marker
+    def trigger(cursor, group, codename)
+      # save any previous code that was being done for this group
+      store(group) if @curr_codes[group]
+      new_codeset = get_code(group, codename)
+      @curr_codes[group] = [ new_codeset, cursor ]
+    end
+    private :trigger
+
+    # returns the code name +codename+ within the group +group+,
+    # creating a new empty category
+    def get_code(group, codename)
+      return @codes[group][codename] if @codes[group][codename]
+      @codes[group][codename] = QDA::CodeSet.new()
+    end
+
+    # Returns the names and codesets for autocodes in group +group+
+    # in a series of pairs
+    def each_autocode(group)
+      @codes[group].each { | name, codeset | yield name, codeset }
+    end
+
+    # alters all the stored coding in this autocoder so that it refers
+    # to the document identified by +docid+
+    def apply(docid)
+      @codes.values.each do | group  |
+        group.values.each do | codeset | 
+          codeset.map! { | x | x.docid = docid; x }
+        end
+      end
+    end
+
+    # finish up all currently active coding in this autocoder
+    def terminate()
+      @curr_codes.each_key { | group | store(group) }
+    end
+
+    # finish the coding for the current code being used among +group+
+    def store(group)
+      codeset, start = @curr_codes[group]
+      # -1 here is a placeholder 
+      terminus = cursor - start
+      codeset.add( Code.new(-1, start, terminus) )
+    end
+    private :store
+  end
+end

data/lib/weft/wxgui.rb

@@ -0,0 +1,687 @@
+require 'wxruby'
+require 'stringio'
+
+# temporary hack to turn c++ style set_foo(), get_foo() and is_foo()
+# accessors into ruby style foo=() foo() and foo?() 
+wx_classes = Wx::constants.collect { | c | Wx::const_get(c) }.grep(Class)
+wx_classes.each do | klass |
+  klass.instance_methods.grep(/^([gs]et|evt|is)_/).each do | meth |
+    case meth
+    when /^get_(\w+)$/
+      klass.class_eval("alias :#{$1} :#{meth}")
+    when /^set_(\w+)$/
+      klass.class_eval("alias :#{$1}= :#{meth}")
+    when /^is_(\w+)$/
+      klass.class_eval("alias :#{$1}? :#{meth}")
+    end
+  end
+end
+
+# one global variable holds a reference to the single instance of the
+# Wx::App class. This allows widgets deep within the GUI to receive
+# notifications from the top level of the GUI.
+$wxapp = nil
+
+require 'weft/wxgui/utilities'
+require 'weft/wxgui/lang'
+
+require 'weft/wxgui/dialogs'
+require 'weft/wxgui/inspectors'
+require 'weft/wxgui/sidebar'
+require 'weft/wxgui/workarea'
+require 'weft/wxgui/error_handler.rb'
+
+
+module QDA
+  module GUI
+    # save some typing
+    DEF_POS  = Wx::DEFAULT_POSITION
+    DEF_SIZE = Wx::DEFAULT_SIZE
+
+    # the default display font for text
+    GLOBAL_FONT = Wx::Font.new(10, Wx::DEFAULT, Wx::NORMAL, Wx::NORMAL, 
+                               false, 'Tahoma')
+	class Instance < Wx::App
+	  attr_reader :display_font, :workarea, :sidebar
+      attr_accessor :app
+
+	  include Wx
+
+      SUBSCRIBABLE_EVENTS = [ :document_added, :document_changed,
+      :document_deleted, :category_added, :category_changed,
+      :category_deleted, :focus_category ]
+
+	  def on_init()
+        @display_font = GLOBAL_FONT
+        # see wxgui/lang.rb
+        Lang::set_language('En')
+
+        # see wxgui/utilities.rb
+        self.extend(Broadcaster)
+        
+        # check if running under rubyscript2exe?
+        @icon_dirs = $:.dup << File.join( File.dirname( __FILE__ ), 'wxgui')
+        create_workarea()
+        create_menus()
+		@workarea.show()
+      end
+
+      # forcibly closes all the windows - does not check for project
+      # saved state - just ends everything
+      def finish()
+        @sidebar.close() if @sidebar
+        @workarea.close()
+      end
+
+      # create the workarea - would normally only be called once in a
+      # whole execution
+      def create_workarea()
+		@workarea = WorkArea.new(self)
+        # TODO - nice windows icon
+        @workarea.set_icon( fetch_icon("weft16.xpm") )
+        @workarea.evt_close() { | e | on_close(e) }
+      end
+
+      # create menus - also only created once, then manipulated as
+      # projects open and close.
+      def create_menus()
+        @menu_file = EasyMenu.new(@workarea)
+		@menu_file.add_item("&New Project", "Ctrl-N") do | e |
+          on_new_project(e)
+        end
+		@menu_file.add_item("&Open Project", "Ctrl-O") do | e |
+          on_open_project(e)
+        end
+		@menu_file.add_item("&Close Project") do | e | 
+          on_close_project(e)
+        end
+		@menu_file.append_separator()
+		@menu_file.add_item("&Save Project", "Ctrl-S") do | e |
+          on_save_project(e)
+        end
+		@menu_file.add_item("Save Project &As", "Ctrl-Shift-S") do | e |
+          on_saveas_project(e)
+        end
+		@menu_file.add_item("&Import N6 Project") do | e |
+          on_import_n6(e)
+        end
+		@menu_file.append_separator()
+		@menu_file.add_item("&Exit", "Alt-F4") do | e | 
+          @workarea.close()
+        end
+
+		@menu_project = EasyMenu.new(@workarea)
+		@menu_project.add_item("&Import Document") do | e | 
+          on_import_document(e) 
+        end
+		@menu_project.add_item("&Set Display Font") do | e | 
+          on_set_display_font(e)
+        end
+# 		menu_project.append(MENU_IMPORT_DOCUMENT_CLIPBOARD , 
+# 							"&Import Document...\t", 'Import')
+# 		@workarea.evt_menu(MENU_IMPORT_DOCUMENT_CLIPBOARD) do | e | 
+#           on_paste_import_document(e) 
+#         end
+
+		@menu_search = EasyMenu.new(@workarea)
+		@menu_search.add_item("&Search") { | e | on_search(e) }
+
+		@menu_search.add_item("&Query") { | e | on_query(e) }
+		@menu_search.add_item("&Review Coding") { | e | on_review_coding(e) }
+		@menu_search.append_separator()
+		@menu_search.add_item("Reindex &Documents") do | e |  
+          on_search_reindex(e)
+        end
+
+        # hide script in release builds
+        if ::WEFT_TESTING
+          @menu_script = EasyMenu.new(@workarea)
+          @menu_script.add_item("&New") { | e | on_start_script(e) }
+        end
+
+        @menu_view = EasyMenu.new(@workarea)
+        @menu_view.add_item("&Documents and Categories", "",
+                            Wx::ITEM_CHECK) { | e | on_toggle_dandc(e) }
+
+ 		@menu_help = EasyMenu.new(@workarea)
+ 		@menu_help.add_item("&Help") { | e | on_help(e) }
+ 		@menu_help.add_item("&About") { | e | on_help_about(e) }
+        menu_state_no_project()
+        
+		menu_bar = Wx::MenuBar.new()
+        menu_bar.append(@menu_file, "&File")
+		menu_bar.append(@menu_project, "&Project")
+		menu_bar.append(@menu_search, "&Search")
+		menu_bar.append(@menu_script, "&Script") if ::WEFT_TESTING
+		menu_bar.append(@menu_view, "&View") 
+        menu_bar.append(@menu_help, "&Help") 
+
+        @workarea.menu_bar = menu_bar
+	  end
+
+	  def current_category
+        if @sidebar.tree_list.get_current_category()
+          return @app.get_category( @sidebar.tree_list.get_current_category().dbid )
+        end
+        return nil
+	  end
+      
+      # opens the document identified by +doc_id+, and, if +offset+ is
+      # supplied, jumps to that point in the document
+      def on_document_open(doc, offset = 0)
+        dbid = doc.is_a?(Document) ? doc.dbid : doc
+		doc = @app.get_document(dbid)
+        win = @workarea.launch_window(DocumentWindow, doc)
+        win.jump_to(offset)
+	  end
+
+      def on_set_display_font(e)
+        font_data = Wx::FontData.new()
+        font_data.initial_font = @display_font
+        dialog = Wx::FontDialog.new(@workarea, font_data)
+        case dialog.show_modal()
+        when Wx::ID_OK
+          font = dialog.get_font_data.get_chosen_font()
+          change_display_font(font)
+          # font.get_native_font_info_desc would be nicer, but
+          # set_native_font_info doesn't appear to work in WxRuby 0.5.0
+          @app.save_preference('DisplayFont', 
+                               :size   => font.point_size,
+                               :family => font.family,
+                               :style  => font.style,
+                               :weight => font.weight,
+                               :face   => font.face_name )
+        when Wx::ID_CANCEL
+          return
+        end
+      end
+
+      def on_search_reindex(e)
+        confirm = MessageDialog.new( nil, 
+                                     Lang::REINDEX_DOCS_WARNING,
+                                     Lang::REINDEX_DOCS_WARNING_TITLE, 
+                                     NO_DEFAULT|YES|NO|ICON_EXCLAMATION)
+        case confirm.show_modal()
+        when ID_NO
+          return true # skip
+        when ID_YES
+        end
+        @app.get_all_docs.each do | doc |
+          doc = @app.get_doc(doc.dbid)
+          @app.drop_reverse_indexes(doc.dbid)
+
+          Wx::BusyCursor.busy do
+            filter = QDA::TextFilter.new()
+            indexer = QDA::WordIndexer.new()
+            filter.add_indexer(indexer)
+            # filter.add_indexer(DocumentImportProgressTracker.new(@workarea))
+
+            begin
+              new_doc = filter.read(doc, doc.doctitle)
+            rescue Exception => err
+              MessageDialog.new(nil, err.to_s + caller.to_s,
+                                "Cannot reindex document", 
+                                OK|ICON_ERROR).show_modal()
+              return()
+            end
+
+            begin
+              wordcount = indexer.words.keys.length
+              prog = WordIndexSaveProgressTracker.new( wordcount, @workarea,
+                                                       doc.doctitle )
+              @app.save_reverse_index(doc.dbid, indexer.words, prog)
+            rescue Exception => err
+              MessageDialog.new(nil, err.to_s,
+                                "Cannot reindex document", 
+                                OK|ICON_ERROR).show_modal()
+            ensure
+              prog.progbar.close()
+            end
+          end          
+        end
+      end
+
+      def change_display_font(font)
+        @workarea.set_display_font(@display_font = font)
+      end
+
+      def on_help(e)
+        MessageDialog.new(nil, Lang::HELP_HELP_MESSAGE, 'Help',
+                          OK|ICON_INFORMATION).show_modal()
+        
+      end
+
+      def on_help_about(e)
+        MessageDialog.new(nil, Lang::HELP_ABOUT_MESSAGE, 'About',
+                          OK|ICON_INFORMATION).show_modal()
+      end
+
+	  def on_category_open(cat)
+        @workarea.launch_window(CategoryWindow, cat)
+	  end
+
+      class Script
+        attr_accessor :dbid
+      end
+
+      # run a new query
+      def on_start_script(e)
+        s_id = @app.get_preference('NextScript') || 1
+        @app.save_preference('NextScript', s_id + 1)
+        s = Script.new()
+        s.dbid = s_id
+        @workarea.launch_window(ScriptWindow, s)
+      end
+
+      def on_import_document(e)
+        import_document()
+      end
+      
+      # import a document
+	  def import_document()
+        wildcard = "Text files (*.txt)|*.txt|PDF files (*.pdf)|*.pdf"
+		file_dialog = Wx::FileDialog.new(@workarea, "Import a Document From File",
+										 "",  "", wildcard, Wx::MULTIPLE )
+		if file_dialog.show_modal() == Wx::ID_OK
+          file_dialog.get_paths.each_with_index do | fpath, i |
+            # Should this be determined from the file dialogue's
+            # current type selection, rather than file extension, which
+            # is unreliable (eg lots of plain text files don't end with
+            # .txt, esp on non-Windows platforms.
+            ext = fpath[-3, 3].downcase
+            if ext == 'txt'
+              filter = QDA::TextFilter.new()
+            elsif ext == 'pdf'
+              filter = QDA::PDFFilter.new()
+            else
+              # as a last shot, try importing the file as plaing text
+              filter = QDA::TextFilter.new()
+            end
+
+            Wx::BusyCursor.busy do
+              doc_title = file_dialog.get_filenames[i].gsub(/\.\w+$/, '')
+              indexer = QDA::WordIndexer.new()
+              filter.add_indexer(indexer)
+              tracker = DocumentImportProgressTracker.new( @workarea, 
+                                                           doc_title )
+              filter.add_indexer(tracker)
+
+              # try and import it
+              begin
+                doc = filter.read(fpath, doc_title)
+              rescue Exception => err
+                p err
+                tracker.terminate()
+                MessageDialog.new(nil, err.to_s,
+                                  "Cannot import document", 
+                                  OK|ICON_ERROR).show_modal()
+                @workarea.cursor = Wx::Cursor.new(Wx::CURSOR_ARROW)
+              ensure
+              end
+
+              # try and save it
+              begin
+                @app.save_document(doc)
+
+                wordcount = indexer.words.keys.length
+                if wordcount > 0
+                  prog = WordIndexSaveProgressTracker.new( wordcount, 
+                                                           @workarea, 
+                                                           doc.title )
+                  @app.save_reverse_index(doc.dbid, indexer.words, prog)
+                end
+              rescue Exception => err
+                prog.terminate() if prog
+                @app.delete_document(doc.dbid) if doc.dbid
+                MessageDialog.new(nil, err.to_s,
+                                  "Cannot import document", 
+                                  OK|ICON_ERROR).show_modal()
+                @workarea.cursor = Wx::Cursor.new(Wx::CURSOR_ARROW)
+                return
+              ensure
+
+              end
+              broadcast(:document_added, doc)
+            end
+          end
+		end
+	  end
+
+
+      # could potentially be saved in database 
+      class Query
+        attr_accessor :dbid
+      end
+
+      # run a new query
+      def on_query(e)
+        q_id = @app.get_preference('NextQuery') || 1
+        @app.save_preference('NextQuery', q_id + 1)
+        q = Query.new()
+        q.dbid = q_id
+        @workarea.launch_window(QueryWindow, q)
+      end
+
+
+      # could potentially be saved in database 
+      class CodeReview
+        attr_accessor :dbid
+      end
+
+      # run a new query
+      def on_review_coding(e)
+        q_id = @app.get_preference('NextReview') || 1
+        @app.save_preference('NextReview', q_id + 1)
+        q = CodeReview.new()
+        q.dbid = q_id
+        @workarea.launch_window(CodeReviewWindow, q)
+      end
+
+	  def on_search(e)
+		search = SearchDialog.new(@workarea)
+		if search.show_modal() == Wx::ID_OK
+          Wx::BusyCursor.busy do
+            options = { :wrap_both => search.expand,
+                        :case_sensitive => search.case_sensitive,
+                        :whole_word => search.whole_word }
+            
+            text_results = @app.get_search_fragments(search.term, options)
+            title = "'#{search.term}' (#{Lang::SEARCH_RESULTS}) "
+
+            # create a category from the returned fragments
+            search_parent = @app.get_root_category('SEARCHES')
+            search_cat = Category.new( title, search_parent )
+            text_results.each do | docid, fragments |
+              fragments.each do | f | 
+                search_cat.code( f.docid, f.offset, f.length )
+              end
+            end
+            @app.save_category(search_cat)
+            broadcast(:category_added, search_cat)
+            @workarea.launch_window(CategoryWindow, search_cat)
+          end
+		end		
+	  end
+
+      def on_close(event)
+        if on_close_project(event)
+          # remember window position and size
+          @workarea.remember_size()
+          event.skip()
+        else
+          event.veto()
+        end
+      end
+
+      # returns true if a new project was started, false if not
+	  def on_open_project(e)
+        return false unless on_close_project(e)
+		file_dialog = FileDialog.new(@workarea, "Open Project",
+										 "",  "", "Project Files (*.qdp)|*.qdp" )
+		if file_dialog.show_modal() == Wx::ID_OK
+          begin
+            Wx::BusyCursor.busy() do
+              @app = QDA::Application.new(self)
+              @app.extend( QDA::Backend::SQLite )
+              @app.start(:dbfile => file_dialog.get_path())
+            end
+          rescue Exception => err
+              MessageDialog.new(nil, err.to_s,
+                                 "Cannot open project", 
+                                 OK|ICON_ERROR).show_modal()
+            @app = nil
+            return()
+          end
+          populate()
+		end
+	  end
+
+      # receives notifications when the application is dirtied or cleaned
+      def update(state)
+        if state
+          @menu_file.enable_item(:save_project)
+        else
+          @menu_file.disable_item(:save_project)
+        end
+        broadcast(:savestate_changed, @app)
+      end
+
+	  # Loads up metadata - eg from CSV file
+	  def on_load_metadata(e)
+
+	  end
+      
+      def on_toggle_dandc(e)
+        if @sidebar.shown?
+          @menu_view.uncheck_item(:documents_and_categories)
+          @sidebar.hide()
+        else
+          @menu_view.check_item(:documents_and_categories)
+          @sidebar.show()
+        end
+      end
+
+      # should resize the toolbar window in proportion to the main
+      # window - seems to cause it to go  corrupted looking though  
+      def on_resize(e)
+        # if @tools
+        #   @tools.set_client_size( proportional_size(0.3, 0.995) )
+        # end
+
+      end
+
+      # Handles requests to save the project. Do nothing if no project
+      # is open, prompt the user to supply a filename if this is a new
+      # project, otherwise just save the project.
+      def on_save_project(e)
+        return unless @app
+        return on_saveas_project(e) unless @app.dbfile
+        save_project()
+      end
+
+      def save_project()
+        @workarea.remember_layouts()
+        Wx::BusyCursor.busy() { @app.save }
+        broadcast(:savestate_changed, @app)
+      end
+
+      def on_saveas_project(e)
+        wildcard = "QDA Project Files (*.qdp)|*.qdp"
+		file_dialog = Wx::FileDialog.new(@workarea, "Save Project As",
+										 "",  "", wildcard, Wx::SAVE)
+
+		if file_dialog.show_modal() == Wx::ID_OK
+		  new_file = file_dialog.get_path()
+
+		  if FileTest.exists?(new_file)
+			confirm = MessageDialog.new(nil, Lang::FILE_ALREADY_EXISTS,
+										"File already exists", 
+										NO_DEFAULT|OK|CANCEL|ICON_EXCLAMATION)
+			case confirm.show_modal()
+			when ID_OK
+			  # ok
+			when ID_CANCEL
+			  return()
+			else
+			  raise "Bad Status"
+			end
+		  end
+          Wx::BusyCursor.busy() { @app.save(new_file) }
+          broadcast(:savestate_changed, @app)
+        end
+      end
+
+	  # Starts a new project
+	  def on_new_project(e)
+        return unless on_close_project(e)
+        @app = QDA::Application.new_virgin(QDA::Backend::SQLite, 
+                                           { :dbfile => nil }, self)
+        @app.set_up
+        populate()
+	  end
+
+	  def on_import_n6(e)
+        wildcard = "Project Files (*.stp)|*.stp"
+		file_dialog = Wx::FileDialog.new(@workarea, "Import N6 Project", "",  
+                                         "", wildcard )
+		if file_dialog.show_modal() == Wx::ID_OK
+          Wx::BusyCursor.busy do 
+            src = QDA::Application.new()
+            src.extend(QDA::Backend::N6)
+            src.start( :basedir => file_dialog.get_directory() )
+            on_new_project(nil)
+
+            @app.batch() do
+              src.get_all_docs.each do | d |
+                d.dbid = nil
+                @app._save_document(d)
+                broadcast(:document_added, d)
+              end
+            
+              save_down = Proc.new do | cat |
+                if cat.parent.nil?
+                  cat.name = "IMPORTED"
+                end
+                @app._save_category(cat)
+                broadcast(:category_added, cat)
+
+                cat.children.each { | c | save_down.call(c) }
+              end
+
+              save_down.call(src.get_all_categories)
+            end
+          end
+		end
+	  end
+
+      # refetch here - this is when it is transmitted to the child
+      # windows, and may then be used for coding, so it should contain
+      # a list of all the codes that apply to the vector
+      def current_category=(category)
+        category = @app.get_category( category.dbid )
+        broadcast(:focus_category, category)
+      end
+
+      # unloads the currently loaded Weft instance and tidies up the GUI
+      def unpopulate()
+        return unless @app
+        # does this clean up searches as well?
+        @workarea.close_all()
+        @sidebar.remember_size()
+        @sidebar.close()
+        @sidebar = nil
+        menu_state_no_project()
+        @app.end()
+        @app = nil
+        broadcast(:savestate_changed, nil)
+        reset_subscriptions()
+        add_subscriber(@workarea, :savestate_changed)
+      end
+
+      # updates the state of the menu above the main workarea to its
+      # initial state with no active project
+      def menu_state_no_project()
+        @menu_file.disable_items(:close_project, :save_project,
+                                 :save_project_as)
+        @menu_project.disable_items(:import_document, :set_display_font)
+		@menu_search.disable_items( :search, :query, :review_coding,
+                                    :reindex_documents)
+		@menu_script.disable_items(:new) if ::WEFT_TESTING
+        @menu_view.disable_item(:documents_and_categories)
+      end
+
+      # updates the state of the menu above the main workarea to
+      # reflect the fact that a project has been opened.
+      def menu_state_open_project()
+        @menu_file.enable_items(:close_project, :save_project,
+                                 :save_project_as)
+        @menu_project.enable_items(:import_document, :set_display_font)
+		@menu_search.enable_items( :search, :query, :review_coding, 
+                                   :reindex_documents)
+		@menu_script.enable_items(:new) if ::WEFT_TESTING
+        @menu_view.enable_item(:documents_and_categories)
+        @menu_view.check_item(:documents_and_categories)
+      end
+
+      # Tries to close the current project, checking for unsaved
+      # changes. Returns true if the currently open project was closed,
+      # or false if it was not. If there was no currently open project,
+      # always returns true.
+      def on_close_project(e)
+        return true unless @app
+        if confirm_unsaved_changes()
+          unpopulate()
+          return true
+        else
+          return false
+        end
+      end
+
+      def confirm_unsaved_changes()
+        unless @app and  @app.dirty?
+          # there's no open project or there's no unsaved changes
+          return true 
+        end
+
+        style = NO_DEFAULT|YES|NO|CANCEL|ICON_EXCLAMATION
+        confirm = MessageDialog.new( nil, 
+                                     Lang::UNSAVED_CHANGES_CONFIRM,
+                                     Lang::UNSAVED_CHANGES_CONFIRM_TITLE, 
+                                     style )
+        case confirm.show_modal()
+        when ID_YES
+          @app.dbfile ? save_project() : on_saveas_project(nil)
+          return true
+        when ID_CANCEL
+          return false
+        when ID_NO
+          return true
+        end
+      end
+
+      # hunt through icon directories to find an icon +icon+ - returns
+      # a Wx::Icon constructed from that file, or raise an exception.
+      def fetch_icon(icon)
+        @icon_dirs.each do | dir | 
+          f = File.join(dir, icon)
+          if File.exist?( f )
+            return Wx::Icon.new( f )
+          end
+        end
+        raise RuntimeError, "Could not find icon #{icon}"
+      end
+
+      def add_icon_dir(dir)
+        @icon_dirs.push(dir)
+      end
+
+	  def populate()
+        if ! @app
+          raise "Populate called without an @app set"
+        end
+        if font_pref = @app.get_preference('DisplayFont')
+          # @display_font.set_native_font_info(font_pref) - not impl
+          change_display_font(Wx::Font.new( font_pref[:size],
+                                           font_pref[:family],
+                                           font_pref[:style],
+                                           font_pref[:weight],
+                                           false,
+                                           font_pref[:face] ) )
+        end
+
+		frame = @workarea
+        @workarea.app = @app
+        # see sidebar.rb
+		@sidebar = SideBar.new( @workarea, self )
+        @sidebar.set_icon( fetch_icon("weft16.xpm") )
+        @sidebar.show()
+
+        # restore windows
+        @workarea.restore_layouts
+
+        menu_state_open_project()
+        broadcast(:savestate_changed, @app)
+	  end
+	end
+  end
+end