weft-qda 0.9.6 → 0.9.8

data/lib/weft/query.rb

@@ -0,0 +1,169 @@
+# A stub class modelling a boolean query expression
+module QDA
+class Query
+  attr_accessor :dbid, :root
+
+  def initialize( func = nil )
+    @root = func
+  end
+  
+  def add_expression(expr, arg_2 = nil)
+    begin
+      expr_class = self.class.const_get( expr.upcase.gsub(/\s+/, '_') )
+    rescue NameError
+      raise ArgumentError.new("Unknown expression '#{expr}'")
+    end
+    @root = expr_class.new(@root, arg_2)
+  end
+  
+  def empty?()
+    @root.nil?
+  end
+  
+  def items(entry = @root)
+    entry.to_a.flatten
+  end
+
+  def traverse(entry = @root)
+    items(entry).each { | expr | yield(expr) }
+  end
+  
+  # Yields a series of pairs of functions and expressions, in the evaluating
+  # left-to-right order of the query. Note that in the last iteration, the 
+  # +expr+ will be nil.
+  # 
+  # query.unroll { | func, expr | ... }
+  # 
+  def unroll(entry = @root)
+    things = items(entry)
+    while func = things.shift
+      yield func, things.shift
+    end
+  end
+  
+  def num_functions()
+    items.grep(Function).length
+  end
+
+  def num_expressions()
+    items.grep(LogicalExpression).length
+  end
+  
+  def calculate()
+    @root.calculate()  
+  end
+  
+  def to_s()
+    @root.to_s()
+  end
+  class Function
+    def initialize(app = nil)
+      @app = app
+    end
+    
+    def to_a
+      [ self ]
+    end
+    
+    def calculated?()
+      true
+    end
+  end
+  
+  class CodedByFunction < Function
+    attr_reader :identifier
+    def initialize(app, identifier)
+      super(app)
+      case identifier
+      when Category # a category specified directly
+        @identifier = identifier.path
+      when String # a path to a category
+        @identifier = identifier
+      when Fixnum # a category id
+        @identifier = @app.get_category(identifier, false).path
+      when NilClass
+        raise ArgumentError.new("Unspecified category for CODED BY expression")
+      else
+        raise ArgumentError.new("Invalid value '#{identifier}' for CODED BY function")
+      end
+    end
+    
+    def to_s()
+      "( CODED BY(#{@identifier.inspect}) )"
+    end
+    
+    def calculate()
+      cat = @app.get_category(@identifier, false)
+      @app.get_text_at_category( cat )
+    end
+  end
+  
+  class WordSearchFunction < Function
+    attr_reader :word
+    def initialize(app, word, options = {})
+      super(app)
+      if word.empty?
+        raise ArgumentError.new('No word supplied for CONTAINS WORD function')
+      end
+      @word = word
+      @options = options
+    end
+    
+    def to_s()
+      "( SEARCH(#{@word.inspect}) )"
+    end
+    
+    def calculate()
+      @app.get_search_fragments(@word, @options)
+    end
+  end
+
+  class LogicalExpression
+    attr_reader :arg_1, :arg_2
+    private :arg_1, :arg_2
+    def initialize(arg_1, arg_2)
+      @arg_1, @arg_2 = arg_1, arg_2
+    end
+    
+    def to_a()
+      [ @arg_1.to_a, self, @arg_2.to_a ]
+    end
+    
+    def val_1()
+      @arg_1.respond_to?(:calculate) ? @arg_1.calculate : @arg_1
+    end
+    
+    def val_2()
+      @arg_2.respond_to?(:calculate) ? @arg_2.calculate : @arg_2      
+    end      
+  end
+    
+  class OR < LogicalExpression
+    def calculate()
+      val_1.dup.merge(val_2)
+    end
+    
+    def to_s
+      "( #{arg_1} OR #{@arg_2} )"
+    end
+  end
+    
+  class AND < LogicalExpression
+    def calculate()
+      val_1.dup.join(val_2)
+    end
+    def to_s
+      "( #{arg_1} AND #{arg_2} )"
+    end
+  end
+   
+  class AND_NOT < LogicalExpression
+    def calculate()
+      val_1.dup.remove(val_2)
+    end
+    def to_s
+      "( #{arg_1} AND NOT #{arg_2} )"
+    end
+  end
+end
+end

data/lib/weft/wxgui.rb

@@ -1,30 +1,11 @@
 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/constants'
 require 'weft/wxgui/utilities'
+require 'weft/wxgui/exceptions'
 require 'weft/wxgui/lang'
 
+require 'weft/wxgui/controls'
 require 'weft/wxgui/dialogs'
 require 'weft/wxgui/inspectors'
 require 'weft/wxgui/sidebar'
@@ -34,42 +15,62 @@ 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
-
+    DEFAULT_FONT = Wx::Font.new(10, Wx::DEFAULT, Wx::NORMAL, Wx::NORMAL)
+	class WeftClient < Wx::App
+	  attr_reader :display_font, :workarea, :sidebar, :app
+      attr_reader :current_category, :current_document
+      
 	  include Wx
-
-      SUBSCRIBABLE_EVENTS = [ :document_added, :document_changed,
-      :document_deleted, :category_added, :category_changed,
-      :category_deleted, :focus_category ]
+      include Broadcaster
+      include Subscriber
+      SUBSCRIBABLE_EVENTS = QDA::Application::SUBSCRIBABLE_EVENTS +
+        [ :focus_category, :focus_document, :text_font_changed ]
 
 	  def on_init()
-        @display_font = GLOBAL_FONT
+        self.app_name = 'WeftQDA'
+        # retrieve font
+        conf = Wx::ConfigBase.get()
+        conf.path = '/DisplayFont'
+        @display_font = Wx::Font.new( conf.read_int('size', 12), 
+                                      conf.read_int('family', Wx::DEFAULT),
+                                      conf.read_int('style', Wx::NORMAL),
+                                      conf.read_int('weight', Wx::NORMAL),
+                                      false,
+                                      conf.read('face', '') )
         # 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')
+        @icon_dirs = []
+        add_icon_dir( File.join( WEFT_SHAREDIR, 'icons') )
+        add_icon_dir( File.join( File.dirname( __FILE__ ), 'wxgui') )
         create_workarea()
         create_menus()
 		@workarea.show()
       end
-
+      
+      
+      def main_loop()
+        super()
+      rescue Exception => err
+        if REPORT_CRASHES and not err.kind_of? SystemExit
+          workarea.hide_all()
+          CrashReportDialog.display(self, err)
+        end
+        Kernel.raise(err)
+      end
+      
+      def app=(the_app)
+        if the_app
+          subscribe(the_app, :all)
+        else
+          @app.end()
+        end
+        @app = the_app
+      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
 
@@ -78,8 +79,8 @@ module QDA
       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) }
+        @workarea.set_icon( fetch_icon("weft") )
+        @workarea.evt_close() { | e | on_quit(e) }
       end
 
       # create menus - also only created once, then manipulated as
@@ -102,21 +103,44 @@ module QDA
 		@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)
+		@menu_file.add_item("&Revert", "Ctrl-Shift-R") do | e |
+          on_revert_project(e)
         end
 		@menu_file.append_separator()
 		@menu_file.add_item("&Exit", "Alt-F4") do | e | 
-          @workarea.close()
+          @workarea.close() # this will trigger on_quit
+        end
+
+        
+        @menu_view = EasyMenu.new(@workarea)
+        if WINDOW_MODE == :MDI
+          @menu_view.add_item("&Documents and Categories", "",
+                               Wx::ITEM_CHECK) { | e | on_toggle_dandc(e) }
         end
 
+		@menu_view.add_item("&Set Display Font") do | e | 
+          on_set_display_font(e)
+        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)
+        @menu_project.add_item("Delete Document") do | e |
+          on_delete_document(e)
         end
+        @menu_project.append_separator()
+		@menu_project.add_item("&Add Category") do | e | 
+          on_add_category() 
+        end
+        @menu_project.add_item("Delete Category") do | e |
+          on_delete_category(e)
+        end        
+        @menu_project.append_separator()
+		@menu_project.add_item("&Export") do | e | 
+          on_export(e)
+        end
+        
 # 		menu_project.append(MENU_IMPORT_DOCUMENT_CLIPBOARD , 
 # 							"&Import Document...\t", 'Import')
 # 		@workarea.evt_menu(MENU_IMPORT_DOCUMENT_CLIPBOARD) do | e | 
@@ -139,9 +163,6 @@ module QDA
           @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) }
@@ -150,21 +171,14 @@ module QDA
         
 		menu_bar = Wx::MenuBar.new()
         menu_bar.append(@menu_file, "&File")
+   		menu_bar.append(@menu_view, "&View")
 		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
@@ -175,95 +189,75 @@ module QDA
         win.jump_to(offset)
 	  end
 
+      
+      def display_font=(font)
+        broadcast(:text_font_changed, font)
+        @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.6.0
+        conf = Wx::ConfigBase.get()
+        conf.path = '/DisplayFont'
+        conf.write("size", font.point_size)
+        conf.write("family", font.family)
+        conf.write("style", font.style)
+        conf.write("weight", font.weight)
+        conf.write("face", font.face_name)
+      end
+      
       def on_set_display_font(e)
         font_data = Wx::FontData.new()
-        font_data.initial_font = @display_font
+        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
+        return unless dialog.show_modal() == Wx::ID_OK
+
+        # actually find the newly selected font and communicate new choice
+        self.display_font = dialog.font_data.chosen_font()
       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()
+        confirm = WarningDialog.display( Lang::REINDEX_DOCS_WARNING_TITLE, 
+                                         Lang::REINDEX_DOCS_WARNING )
+        return true unless confirm == Wx::ID_YES
+        
+        Wx::BusyCursor.busy do
+          begin
+            docs = @app.get_all_docs()
+            prog =  StageProgressDialog.new(@workarea, 
+                                            "Reindexing documents", '')
+            
+            prog.retarget(docs.length + 2)
+            docs.each do | doc |
+              prog.step("Indexing document #{doc.title}")
+              doc = @app.get_doc(doc.dbid)
+              @app.drop_reverse_indexes(doc.dbid)
+              indexer = QDA::WordIndexer.new()
+              indexer.feed(doc)
+              @app.save_reverse_index(doc.dbid, indexer.words)
             end
-          end          
+            prog.finish()
+          rescue UserAbortedException => err
+            prog.finish() if prog
+            ErrorDialog.display("Reindex halted", err.to_s())
+            @workarea.cursor = Wx::NORMAL_CURSOR
+          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()
-        
+        InformationDialog.display('Help', Lang::HELP_HELP_MESSAGE)
       end
 
       def on_help_about(e)
-        MessageDialog.new(nil, Lang::HELP_ABOUT_MESSAGE, 'About',
-                          OK|ICON_INFORMATION).show_modal()
+        InformationDialog.display('About', Lang::HELP_ABOUT_MESSAGE)
       end
 
 	  def on_category_open(cat)
+	    if not cat.codes
+	      cat = @app.get_category(cat.dbid)
+	    end
         @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
@@ -279,99 +273,133 @@ module QDA
       
       # 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
+		file_dialog = ImportFileDialog.new(@workarea, QDA::Document)
+	    return unless file_dialog.show_modal() == Wx::ID_OK
+	    file_dialog.each_with_path do | fpath, fname |
+          Wx::BusyCursor.busy do
+            prog = StageProgressDialog.new(@workarea, "Importing document",
+                                           "Reading file #{fname}")
+            begin
+              doc = Filters.import_file(Document, fpath) do | doc, filter |
+                doc.title = fname.gsub(/\.\w+$/, '')
               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
-
+              prog.step('Saving document')
+              @app.save_document(doc, true)
+              prog.step('Indexing document')
+              indexer = QDA::WordIndexer.new()
+              indexer.feed(doc)
+              prog.step('Saving indexes')
+              wordcount = indexer.words.keys.length
+              if wordcount > 0
+                prog.retarget(wordcount)
+                @app.save_reverse_index(doc.dbid, indexer.words, prog)
               end
-              broadcast(:document_added, doc)
+              prog.finish()
+            rescue UserAbortedException, IOError => err
+              prog.finish() if prog
+              app.delete_document(doc) if doc && doc.dbid
+              MessageDialog.new(nil, err.to_s(),
+                                "Document not imported", 
+                                OK|ICON_ERROR).show_modal()
+              @workarea.cursor = Wx::Cursor.new(Wx::CURSOR_ARROW)
             end
           end
 		end
 	  end
 
-
-      # could potentially be saved in database 
-      class Query
-        attr_accessor :dbid
+      def on_delete_document(e = nil)
+        return unless current_document
+        msg = Lang::DELETE_DOCUMENT_WARNING % current_document.title
+        confirm = SuppressibleConfirmDialog.display('DeleteDocument',
+                                                Lang::DELETE_DOCUMENT_TITLE,
+                                                msg )
+        return unless confirm == Wx::ID_YES
+        Wx::BusyCursor.busy do
+          @app.delete_document( current_document )
+        end
       end
+      
+      def on_add_category()
+        dialog = Wx::TextEntryDialog.new(@workarea.d_and_c, "Add Category\n",
+                                         "Enter the new category name",
+                                         "", Wx::OK | Wx::CANCEL)
+        return unless dialog.show_modal() == Wx::ID_OK
+
+        # go ahead and make the new category
+        parent = self.current_category || @app.get_root_category('CATEGORIES')  
+        name   = dialog.get_value()
+        begin
+          cat = QDA::Category.new(name, parent )
+          @app.save_category(cat)
+        rescue QDA::BadNameError
+          ErrorDialog.display( Lang::BAD_CATEGORY_NAME_TITLE, 
+                               Lang::BAD_CATEGORY_NAME_WARNING )
+          return false
+        rescue QDA::NotUniqueNameError
+          ErrorDialog.display( Lang::DUPLICATE_CATEGORY_NAME_TITLE, 
+                               Lang::DUPLICATE_CATEGORY_NAME_WARNING )
+          return false
+          
+        end
+      end
+      
+      # deletes the currently active category
+      def on_delete_category(e = nil)
+        return false unless current_category
+        msg = Lang::DELETE_CATEGORY_WARNING % current_category.name
+        confirm = SuppressibleConfirmDialog.display( 'DeleteCategory',
+                                                Lang::DELETE_CATEGORY_TITLE,
+                                                msg )
+        
+        return false unless confirm == Wx::ID_YES
+        Wx::BusyCursor.busy() do
+          @app.delete_category(current_category)
+        end
+      end
+      
 
+      def on_export(e)
+        a_win = @workarea.active_child
+        return unless a_win.respond_to?(:object)
+        obj = a_win.object
+        file_dialog = ExportFileDialog.new(@workarea, obj)
+        return unless file_dialog.show_modal() == Wx::ID_OK
+        Wx::BusyCursor.busy do
+          filter = file_dialog.filter.new(app)
+          File.open(file_dialog.get_path, 'w') do | outfile |
+            filter.write(obj, outfile)
+          end
+        end
+      end
+      
+      def on_print(e)
+        a_win = @workarea.active_child
+        return unless a_win.respond_to?(:object)
+        obj = a_win.object
+        htmlprint = Wx::HtmlEasyPrinting.new('Weft print', @workarea)
+        htmlprint.page_setup()
+        file_dialog = ExportFileDialog.new(@workarea, obj)
+        return unless file_dialog.show_modal() == Wx::ID_OK
+        Wx::BusyCursor.busy do
+          filter = file_dialog.filter.new(app)
+          File.open(file_dialog.get_path, 'w') do | outfile |
+            filter.write(obj, outfile)
+          end
+        end      
+      end
       # run a new query
       def on_query(e)
-        q_id = @app.get_preference('NextQuery') || 1
-        @app.save_preference('NextQuery', q_id + 1)
+        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)
+        app.save_preference('NextReview', q_id + 1)
         q = CodeReview.new()
         q.dbid = q_id
         @workarea.launch_window(CodeReviewWindow, q)
@@ -385,79 +413,94 @@ module QDA
                         :case_sensitive => search.case_sensitive,
                         :whole_word => search.whole_word }
             
-            text_results = @app.get_search_fragments(search.term, options)
+            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 )
+            search_cat.codetable_init() # urgh
             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)
+            app.save_category(search_cat, true)
             @workarea.launch_window(CategoryWindow, search_cat)
           end
 		end		
 	  end
 
-      def on_close(event)
+      def on_quit(event)
         if on_close_project(event)
           # remember window position and size
           @workarea.remember_size()
           event.skip()
+          exit() # required to exit reliably on Linux
         else
           event.veto()
         end
       end
-
+      
+      def on_revert_project(e)
+        result = WarningDialog.display( Lang::REVERT_WARNING_TITLE,
+                                        Lang::REVERT_WARNING_MESSAGE )
+        return unless result == Wx::ID_OK
+        
+        the_file = @app.dbfile
+        unpopulate()
+        open_project(the_file)
+      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
+        return false unless file_dialog.show_modal() == Wx::ID_OK
+        
+        open_project( file_dialog.get_path() )
 	  end
+	  
+      def open_project(pfile)
+        @workarea.set_cursor( Wx::BUSY_CURSOR )
+        self.app = QDA::Application.new()
+        app.extend( QDA::Backend::SQLite )
+        app.start(:dbfile => pfile)
+        populate()
+      rescue ArgumentError, NotImplementedError => err
+        ErrorDialog.display(Lang::OPEN_PROJECT_ERROR_TITLE, err.to_s)
+        self.app = nil
+        return false
+      ensure
+          @workarea.set_cursor( Wx::NORMAL_CURSOR )
+      end
 
-      # receives notifications when the application is dirtied or cleaned
-      def update(state)
-        if state
-          @menu_file.enable_item(:save_project)
+      def add_subscriber(subscriber, *events)
+        super
+        subscriber.evt_close do | e | 
+          delete_subscriber(subscriber)
+          e.skip()
+        end
+      end
+      
+      def notify(ev, content = nil)
+        if ev == :saved or ev == :started
+          @menu_file.disable_items(:save_project, :revert)
         else
-          @menu_file.disable_item(:save_project)
+          @menu_file.enable_items(:save_project)
+          @menu_file.enable_items(:revert) if app.dbfile
         end
-        broadcast(:savestate_changed, @app)
+        broadcast(ev, content)
       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()
+        if @workarea.d_and_c_visible?
+          @workarea.hide_d_and_c()
+          @menu_view.uncheck_items(:documents_and_categories)
         else
-          @menu_view.check_item(:documents_and_categories)
-          @sidebar.show()
+          @workarea.show_d_and_c()
+          @menu_view.check_items(:documents_and_categories)
         end
       end
 
@@ -474,15 +517,14 @@ module QDA
       # 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
+        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)
+        Wx::BusyCursor.busy() { app.save }
       end
 
       def on_saveas_project(e)
@@ -506,17 +548,19 @@ module QDA
 			  raise "Bad Status"
 			end
 		  end
-          Wx::BusyCursor.busy() { @app.save(new_file) }
-          broadcast(:savestate_changed, @app)
+          Wx::BusyCursor.busy() { app.save(new_file) }
         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
+        # TODO - this process is too protracted
+        self.app = QDA::Application.new(QDA::Backend::SQLite)
+        app.start(:dbfile => nil)
+        app.install_clean()
+        app.set_up()
         populate()
 	  end
 
@@ -554,53 +598,74 @@ module QDA
 		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)
+        if category
+          category = @app.get_category( category.dbid )
+          broadcast(:focus_category, category)
+        end
+        @current_category = category
+      end
+      
+      def current_document=(document)
+        if document
+          document = @app.get_document( document.dbid )
+          broadcast(:focus_document, document)
+        end
+        @current_document = document
       end
 
       # unloads the currently loaded Weft instance and tidies up the GUI
       def unpopulate()
-        return unless @app
-        # does this clean up searches as well?
+        return unless app
+
         @workarea.close_all()
-        @sidebar.remember_size()
-        @sidebar.close()
-        @sidebar = nil
+        
         menu_state_no_project()
-        @app.end()
-        @app = nil
-        broadcast(:savestate_changed, nil)
+        self.app = nil
         reset_subscriptions()
-        add_subscriber(@workarea, :savestate_changed)
+        @workarea.subscribe(self, :all)
       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)
+                                 :save_project_as, :revert)
+        @menu_project.disable_items(:import_document, :delete_document,
+                                    :add_category, :delete_category,
+                                    :export)
 		@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)
+		if WINDOW_MODE == :MDI
+		  @menu_view.disable_item(:documents_and_categories, :set_display_font)
+        else
+          @menu_view.disable_item(:set_display_font)
+        end
       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)
+        # :revert and :save_project are enabled when a change has been made
+        @menu_file.enable_items(:close_project, :save_project_as)
+        @menu_project.enable_items( :import_document, :delete_document,
+                                    :add_category, :delete_category,
+                                    :export)
 		@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)
+		if WINDOW_MODE == :MDI
+          @menu_view.enable_item(:documents_and_categories, :set_display_font)
+          @menu_view.check_item(:documents_and_categories)
+        else
+          @menu_view.enable_item(:set_display_font)        
+        end
       end
 
       # Tries to close the current project, checking for unsaved
@@ -639,15 +704,22 @@ module QDA
         end
       end
 
+
       # hunt through icon directories to find an icon +icon+ - returns
       # a Wx::Icon constructed from that file, or raise an exception.
+      # +icon+ should be the name of an icon file *without* the extension.
+      # This method will search only for icons appropriate to the current
+      # platform. Raises a RuntimeError if no icon is found.
       def fetch_icon(icon)
-        @icon_dirs.each do | dir | 
-          f = File.join(dir, icon)
-          if File.exist?( f )
-            return Wx::Icon.new( f )
+        ICON_EXTS.each do | type |
+          maybe_icon_file = "%s.%s" % [ icon, type.extension ]
+          @icon_dirs.each do | dir | 
+            if File.exist?( f = File.join(dir, maybe_icon_file) )
+              return Wx::Icon.new( f, type.constant )
+            end
           end
         end
+        
         raise RuntimeError, "Could not find icon #{icon}"
       end
 
@@ -656,31 +728,14 @@ module QDA
       end
 
 	  def populate()
-        if ! @app
+        unless 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()
-
+        @workarea.show_d_and_c()
         # restore windows
         @workarea.restore_layouts
 
         menu_state_open_project()
-        broadcast(:savestate_changed, @app)
 	  end
 	end
   end