ruber 0.0.1.1

data/lib/ruber/main_window/choose_plugins_dlg.rb

@@ -0,0 +1,353 @@
+=begin 
+    Copyright (C) 2010 by Stefano Crocco   
+    stefano.crocco@alice.it   
+  
+    This program is free software; you can redistribute it andor modify  
+    it under the terms of the GNU General Public License as published by  
+    the Free Software Foundation; either version 2 of the License, or     
+    (at your option) any later version.                                   
+  
+    This program is distributed in the hope that it will be useful,       
+    but WITHOUT ANY WARRANTY; without even the implied warranty of        
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         
+    GNU General Public License for more details.                          
+  
+    You should have received a copy of the GNU General Public License     
+    along with this program; if not, write to the                         
+    Free Software Foundation, Inc.,                                       
+    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             
+=end
+
+require 'facets/kernel/require_relative'
+require_relative 'ui/choose_plugins_widget'
+
+module Ruber
+
+=begin rdoc
+Dialog where the user can choose the plugins to load and the directories where
+to look for plugins.
+
+The main functionality is provided by the main widget, of class ChoosePluginsWidget.
+=end
+  class ChoosePluginsDlg < KDE::Dialog
+    
+    slots :write_settings
+
+=begin rdoc
+Creates a new +ChoosePluginsDlg+ and initializes it using both the settings
+in the configuration file and the loaded plugins.
+=end
+    def initialize parent = nil
+      super
+      self.caption = "Choose plugins"
+      self.buttons = Ok | Cancel | Apply | Default | Reset
+      self.main_widget = ChoosePluginsWidget.new
+      enable_button_apply false
+      main_widget.connect(SIGNAL('plugins_changed()')){enable_button_apply true}
+      main_widget.connect(SIGNAL('directories_changed()')){enable_button_apply true}
+      connect self, SIGNAL(:applyClicked), self, SLOT(:write_settings)
+      connect self, SIGNAL(:okClicked), self, SLOT(:write_settings)
+      connect self, SIGNAL(:defaultClicked), main_widget, SLOT(:apply_defaults)
+    end
+    
+# See ChoosePluginsWidget#plugins
+    def plugins
+      main_widget.plugins
+    end
+
+    private
+    
+=begin rdoc
+  Writes the settings to the configuration file and disables the Apply button
+=end
+    def write_settings
+      main_widget.write_settings
+      enable_button_apply false
+    end
+
+=begin rdoc
+Override the default behaviour when the user presses the Ok or Apply buttons and
+there are problems with dependencies (unresolved dependencies or circular dependencies).
+In this case, it displays a message box where the user can choose whether he
+truly wants to save the settings or not. If he chooses to write the settings,
+the usual behaviour is followed. Otherwise, the method does nothing.
+=end
+    def slotButtonClicked btn
+      if btn == Ok || btn == Apply and !main_widget.deps_satisfied?
+        msg = "There are dependencies problems among plugins. Are you sure you want to accept these settings?"
+        if KDE::MessageBox.question_yes_no(nil, msg) == KDE::MessageBox::Yes
+          super
+        else return
+        end
+      else super
+      end
+    end
+
+  end
+  
+=begin rdoc
+Widget which implements most of the functionality of the ChoosePluginsDlg class.
+
+It contains a list of plugins in the current search path, where the user can choose
+the plugins to load (using checkboxes), and a list of directories where the user
+can choose where to look for plugins.
+
+In the plugin list, chosen plugins are shown with a selected mark, while plugins
+which will be loaded to satisfy the dependencies of chosen plugins will be shown
+with a partial mark.
+
+Whenever the user changes the chosen plugins, the dependencies are re-computed.
+If there's a problem, the user is warned with a message box.
+=end
+  class ChoosePluginsWidget < Qt::Widget
+    
+    signals :directories_changed, :plugins_changed
+    
+    slots :add_directory, :remove_directory, :write_settings, :apply_defaults, 
+        'plugin_toggled(QStandardItem*)'
+
+=begin rdoc
+Creates a new ChoosePluginsWidget.
+
+The list of directories where to look for plugins is read from the configuration
+file. The chosen plugins are read from the configuration file, but excluding all
+those which aren't currently loaded (the reason to do so is that a chosen plugin
+might have failed to load and thus it should not appear in the chosen list). Also,
+any plugin which is included in the chosen list but whose PDF can't be found is
+excluded.
+
+Dependencies are then computed, and dependencies of the chosen plugins are marked
+as such. If a dependency problem occurs, the user is warned and all plugins are
+deselected.
+=end
+    def initialize parent = nil
+      super
+      @ui = Ui::ChoosePluginsWidget.new
+      @ui.setupUi self
+      
+      dirs = Ruber[:config][:general].plugin_dirs
+      
+      @chosen_plugins = Ruber[:config][:general, :plugins].map(&:to_sym)
+      loaded = Ruber[:components].plugins.map(&:plugin_name)
+      @chosen_plugins.delete_if{|i| !loaded.include? i}
+      
+      read_plugins dirs
+      res = find_deps(:warning) do |e| 
+        "There were problems making dependencies. #{create_failure_message e}\nAll plugins will be deselected"
+      end
+      if res
+        @chosen_plugins.clear
+        @needed_plugins = []
+      end
+      m = Qt::StandardItemModel.new @ui.plugins
+      @ui.plugins.model = m
+      
+      connect m, SIGNAL('itemChanged(QStandardItem*)'), self, SLOT('plugin_toggled(QStandardItem*)')
+      
+      def m.flags idx
+        Qt::ItemIsSelectable|Qt::ItemIsEnabled| Qt::ItemIsUserCheckable
+      end
+      
+      @url = KDE::UrlRequester.new self
+      @ui.directories.custom_editor = @url.custom_editor
+      @url.mode = KDE::File::Directory | KDE::File::LocalOnly
+      connect @ui.directories, SIGNAL(:changed), self, SLOT(:slot_directories_changed)      
+      @ui.directories.items = dirs
+      
+      fill_plugin_list
+    end
+
+
+    def sizeHint #:nodoc:
+      Qt::Size.new 600, 550
+    end
+    
+=begin rdoc
+  Writes the settings to the configuration file. The directories listed in the
+  directory widget are stored in the <i>general/plugin_dirs</i> entry, while
+  the chosen plugins are stored in the <i>general/plugins</i> entry. Plugins
+  which haven't been chosen but are dependencies of the chosen ones aren't stored.
+=end
+    def write_settings
+      dirs = @ui.directories.items
+      Ruber[:config][:general,:plugin_dirs] = dirs
+      plugins = []
+      @ui.plugins.model.each_row do |r|
+        plugins << r[0].data.to_string if  r[0].fully_checked?
+      end
+      Ruber[:config][:general, :plugins] = plugins
+      Ruber[:config].write
+    end
+    
+=begin rdoc
+Sets both the chosen plugins and the plugin directories to their default values
+(see Appplication::DEFAULT_PLUGIN_PATHS and Application::DEFAULT_PLUGINS). If a
+dependency problem occurs, the user is warned and all plugins are deselected
+=end
+    def apply_defaults
+      dirs = Ruber[:config].default :general, :plugin_dirs
+      @chosen_plugins = Ruber[:config].default( :general, :plugins).split(',').map{|i| i.to_sym}
+      read_plugins dirs
+      res = find_deps(:warning) do |e| 
+        "There were problems making dependencies. #{create_failure_message e}\nAll plugins will be deselected"
+      end
+      if res
+        @chosen_plugins.clear
+        @needed_plugins = []
+      end
+      @ui.directories.clear
+      @ui.directories.items = dirs
+      
+      fill_plugin_list
+    end
+
+=begin rdoc
+Returns *false* if there's a dependency problem among the chosen plugins and
+*true* otherwise.
+=end
+    def deps_satisfied?
+      begin 
+        find_deps
+        true
+      rescue ComponentManager::UnresolvedDep, ComponentManager::CircularDep
+        false
+      end
+    end
+
+=begin rdoc
+Returns a hash containing both the chosen plugins and their dependencies. The
+keys are the plugin names, while the values are the directories of the plugins.
+=end
+    def plugins
+      @ui.plugins.model.enum_for(:each_row).map do |name, _, dir|
+        [name.data.to_string.to_sym, dir.text] if name.checked?
+      end.compact.to_h
+    end
+    
+    private
+    
+=begin rdoc
+Finds all the plugins in subdirectories of directories in the _dir_ array,
+reads their PDFs and stores the data in the <tt>@plugins_files</tt> and 
+<tt>@plugin_data</tt> instance variables. Also removes from the <tt>@chosen</tt>
+instance variable the plugins whose PDF wasn't found.
+=end
+    def read_plugins dirs
+      @plugins_files = ComponentManager.find_plugins dirs, true
+      @plugin_data = @plugins_files.map{|_, v| [v.name, v]}.to_h
+      @chosen_plugins.delete_if{|i| !@plugin_data[i]}
+    end
+
+=begin rdoc
+Finds the dependencies of the chosen plugins and stores them in the
+<tt>@needed_plugins</tt> instance variable. If a dependency error occurs, if a
+block was passed, a message box of type _type_ is displayed. The text of the
+message box is obtained by calling the block with the exception as argument. If
+an error occurs and no block is passed, the exception is passed on.
+
+This method returns *nil* if no error occurs and the value returned by the
+message box otherwise.
+=end
+    def find_deps msg_type = :warning
+      chosen_data = @chosen_plugins.map{|i| @plugin_data[i]}
+      begin @needed_plugins = ComponentManager.fill_dependencies chosen_data, @plugin_data.values
+      rescue ComponentManager::UnresolvedDep, ComponentManager::CircularDep => e
+        if block_given? then KDE::MessageBox.send(msg_type, yield(e))
+        else raise
+        end
+      end
+      nil
+    end
+
+=begin rdoc
+Fills the list of plugins with the names, descriptions and paths of all plugins
+found and marks each one according to whether it is among the chosen plugins,
+the needed plugins or neither.
+
+It also resizes the columns of the plugin list widget so that they match the
+size of the contents.
+=end
+    def fill_plugin_list
+      m = @ui.plugins.model
+      m.clear
+      m.horizontal_header_labels = %w[Name Description Directory]
+      @plugins_files.each do |k, v|
+        name = Qt::StandardItem.new v.about.human_name
+        name.data = Qt::Variant.new(k.to_s)
+        desc = Qt::StandardItem.new v.about.description
+        dir = Qt::StandardItem.new v.directory
+        m.append_row [name, desc, dir]
+      end
+      update_plugin_status
+      3.times{|i| @ui.plugins.resize_column_to_contents i}
+    end
+
+=begin rdoc
+Changes the contents of the <tt>@chosen_plugins</tt> and <tt>@needed_plugins</tt>
+instance variable to reflect the checked status of the plugins in the plugin list
+widget. Emits the <tt>plugins_changed</tt> signal.
+=end
+    def update_plugin_status
+      @ui.plugins.model.each_row do |name, desc, dir|
+        plug_name = name.data.to_string.to_sym
+        state = if @chosen_plugins.include? plug_name then Qt::Checked
+        elsif @needed_plugins.include? plug_name then Qt::PartiallyChecked
+        else Qt::Unchecked
+        end
+        name.check_state = state
+      end
+      emit plugins_changed
+    end
+
+=begin rdoc
+Updates the plugin status to reflect the changes made to the plugin corresponding
+to the item _it_.
+=end
+    def plugin_toggled it
+      name = it.data.to_string
+      if it.check_state == Qt::Checked then @chosen_plugins << name.to_sym
+      else @chosen_plugins.delete name.to_sym
+      end
+      find_deps{|e| create_failure_message( e) + "\nPlease, be sure to correct the problem before accepting changes" }
+      update_plugin_status
+    end
+    
+=begin rdoc
+Updates the plugin widgets and emits the {#directories_changed signal}
+
+If the dependencies aren't respected, the user is warned with a message box.
+@return [nil]
+=end
+    def slot_directories_changed
+      new_dirs = @ui.directories.items
+      find_deps{|e| create_failure_message( e) + "\nPlease, be sure to correct the problem before accepting changes" }
+      fill_plugin_list
+      emit directories_changed
+      nil
+    end
+    slots :slot_directories_changed
+
+=begin rdoc
+Creates an appropriate failure message for the exception _e_, which should be
+an instance of ComponentManager::DependencyError. It is meant to generate consistent
+error messages for all the places in the widget where a dependency error can
+happen.
+=end
+    def create_failure_message e
+      case e
+      when ComponentManager::UnresolvedDep
+        deps = e.missing.map do |p1, p2|
+          "#{d}, needed by #{pl.join ', '}"
+        end
+        "Some dependencies couldn't be satisifed:\n#{deps.join "\n"}"
+      when ComponentManager::CircularDep
+        deps = e.missing.map do |p1, p2|
+          "#{p1} and #{p2}"
+        end
+        "There were circular dependencies between the following plugins:\n#{deps.join "\n"}"
+      end
+    end
+
+  end
+
+end

data/lib/ruber/main_window/main_window.rb

@@ -0,0 +1,524 @@
+=begin 
+    Copyright (C) 2010 by Stefano Crocco   
+    stefano.crocco@alice.it   
+  
+    This program is free software; you can redistribute it andor modify  
+    it under the terms of the GNU General Public License as published by  
+    the Free Software Foundation; either version 2 of the License, or     
+    (at your option) any later version.                                   
+  
+    This program is distributed in the hope that it will be useful,       
+    but WITHOUT ANY WARRANTY; without even the implied warranty of        
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         
+    GNU General Public License for more details.                          
+  
+    You should have received a copy of the GNU General Public License     
+    along with this program; if not, write to the                         
+    Free Software Foundation, Inc.,                                       
+    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             
+=end
+
+# Special comments used here to mark things to do:
+# OBSOLETE: method to remove (or likely so)
+# MOVE: method which should be moved somewhere else (to another class)
+
+require 'forwardable'
+
+require 'ruber/plugin_like'
+require 'ruber/gui_states_handler'
+
+require 'ruber/main_window/main_window_internal'
+require 'ruber/main_window/main_window_actions'
+
+require 'ruber/main_window/status_bar'
+require 'ruber/main_window/workspace'
+
+module Ruber
+
+=begin rdoc
+The application's main window. It is made of a menu bar, a tool bar, a workspace
+and a status bar. The workspace (see Workspace) is the main window's central widget
+and where most of the user interaction happens. It contains the editors and the
+tool widgets.
+=end
+  class MainWindow < KParts::MainWindow
+    
+    include PluginLike
+    
+    include GuiStatesHandler
+    
+    extend Forwardable
+##
+# :method: current_document_changed(QObject* obj) [SIGNAL]
+# Signal emitted whenever the current document changes. _obj_ is the new current
+# document and will be <tt>Qt::NilObject</tt> if there's no current document.
+    
+##
+# :method: active_editor_changed(QObject* obj) [SIGNAL]
+# Signal emitted whenever the active editor changes _obj_ is the new active editor
+# and will be <tt>Qt::NilObject</tt> if there's no active editor
+    
+    
+    signals 'current_document_changed(QObject*)', 'active_editor_changed(QObject*)'
+        
+    slots :load_settings
+    
+=begin rdoc
+The widget which contains the tool widgets.
+
+The primary use of this method is to connect to the signals emitted from the workspace
+when a tool widget is raised, shown or hidden. All of its other methods are also
+provided by the MainWindow, so you shouldn't need to access the workspace to use
+them.
+=end
+    attr_reader :workspace
+    
+=begin rdoc
+A hash with the data stored in the session manager by plugins. The hash is only
+availlable after the <tt>restore</tt> method has been called (which means that it
+will always be unavaillable if ruber wasn't started by the session manager). If
+the hash isn't availlable, *nil* is returned
+
+<b>NOTE:</b> only for use by Application when restoring the session
+=end
+    attr_reader :last_session_data
+        
+=begin rdoc
+Creates a new MainWindow. <i>_manager</i> is the component manager, while _pdf_
+is the plugin description for this object.
+=end
+    def initialize _manager, pdf
+      super nil, 0
+      initialize_plugin pdf
+      initialize_states_handler
+      self.central_widget = Workspace.new self
+      # We need the instance variable to use it with Forwardable
+      @workspace = central_widget 
+      @views = central_widget.instance_variable_get :@views
+      @current_view = nil
+      @active_editor = nil
+      @auto_activate_editors = true
+      @editors_mapper = Qt::SignalMapper.new self
+      @ui_states = {}
+      @actions_state_handlers = Hash.new{|h, k| h[k] = []}
+      @about_plugin_actions = []
+      @last_session_data = nil
+      self.status_bar = StatusBar.new self
+      self.connect(SIGNAL('current_document_changed(QObject*)')) do |doc|
+        change_state 'current_document', !doc.nil_object?
+      end
+      connect Ruber[:components], SIGNAL('component_loaded(QObject*)'), self, SLOT('add_about_plugin_action(QObject*)')
+      connect Ruber[:components], SIGNAL('unloading_component(QObject*)'), self, SLOT('remove_about_plugin_action(QObject*)')
+      connect Ruber[:components], SIGNAL('unloading_component(QObject*)'), self, SLOT('remove_plugin_ui_actions(QObject*)')
+      connect @editors_mapper, SIGNAL('mapped(QWidget*)'), self, SLOT('remove_view(QWidget*)')
+      setup_actions action_collection
+      @views.connect(SIGNAL('currentChanged(int)')) do |idx|
+        if @auto_activate_editors then activate_editor idx 
+        else activate_editor nil
+        end
+      end
+      Ruber[:projects].connect( SIGNAL('current_project_changed(QObject*)') ) do |prj|
+        change_state "active_project_exists", !prj.nil?
+        make_title
+      end
+      connect Ruber[:projects], SIGNAL('closing_project(QObject*)'), self, SLOT('close_project_files(QObject*)')
+      
+      setup_GUI
+      create_shell_GUI true
+      
+      config_obj = Ruber[:config].kconfig
+      apply_main_window_settings KDE::ConfigGroup.new( config_obj, 'MainWindow')
+      recent_files = KDE::ConfigGroup.new config_obj, 'Recent files'
+      action_collection.action("file_open_recent").load_entries recent_files
+      recent_projects = KDE::ConfigGroup.new config_obj, 'Recent projects'
+      action_collection.action("project-open_recent").load_entries recent_projects
+      status_bar.show
+      setup_initial_states
+    end
+    
+    ##
+    # :method: add_tool
+    # Adds a tool widget to the main window. See Workspace#add_tool_widget for more information.
+    def_delegator :@workspace, :add_tool_widget, :add_tool
+    
+    ##
+    # :method: remove_tool
+    # Removes a tool widget from the main window. See Workspace#remove_tool_widget for more information.
+    def_delegator :@workspace, :remove_tool_widget, :remove_tool
+    
+    ##
+    # :method: toggle_tool
+    # Activates a tool widget if it was hidden and hides it if it was active.
+    # See Workspace#toggle_tool for more information.
+    def_delegators :@workspace, :toggle_tool
+    
+    ##
+    # :method: raise_tool
+    # Activates a tool widget. See Workspace#raise_tool for more information.
+    def_delegators :@workspace, :raise_tool
+    
+    ##
+    # :method: show_tool
+    # Displays a tool widget. See Workspace#show_tool for more information.
+    def_delegators :@workspace, :show_tool
+    
+    ##
+    # :method: activate_tool
+    # Shows and gives focus to a tool. See Workspace#activate_tool for more information.
+    def_delegators :@workspace, :activate_tool
+    
+    ##
+    # :method: hide_tool
+    # Hides a tool widget. See Workspace#hide_tool for more information.
+    def_delegators :@workspace, :hide_tool
+    
+    ##
+    # :method: tool_widgets
+    # Returns a hash having the tool widgets as keys and their positions as values.
+    # See Workspace#tool_widgets for more information.
+    def_delegators :@workspace, :tool_widgets
+    
+=begin rdoc
+Returns the editor view for the given document, creating it if needed
+
+@param [Document, String, KDE::Url] doc the document. If it is a string representing
+  an absolute path, the document will be obtained using {DocumentList#document},
+  while for other strings it will be obtained using {DocumentList#document_with_name}
+@return [EditorView,nil] an editor associated with the document or *nil* if _doc_
+  is interpreted as document name but no documents with that name exists
+@raise [ArgumentError] if _doc_ is an absolute path or a @KDE::Url@ but the file
+  doesn't exist
+=end
+    def editor_for! doc
+      doc = unless doc.is_a? Document
+        if doc.is_a? KDE::Url or doc.start_with? '/' then Ruber[:documents].document doc
+        else Ruber[:documents].document_with_name doc
+        end
+      end
+      return unless doc
+      create_editor_if_needed doc
+    end
+    
+=begin rdoc
+Similar to <tt>editor_for!</tt> but it doesn't create the document or the editor
+if they don't exist. If a Document for the string _doc_ doesn't exist, or if it
+doesn't have an editor, returns *nil*.
+=end
+    def editor_for doc
+      doc = Ruber[:documents][doc] if doc.is_a? String
+      return unless doc
+      doc.view
+    end
+    
+=begin rdoc
+Returns the active editor, or *nil* if there's no active editor.
+
+<b>Note:</b> strictly speaking, this is not the same as <tt>tab_widget.current_widget</tt>.
+For an editor to be active, it's not enough to be in the current tab, but it also
+need to having been its gui merged with the main window gui.
+
+TODO: in all places this is called, change the name from <tt>current_view</tt> to
+<tt>active_editor</tt>.
+=end
+    def active_editor
+      @active_editor
+    end
+    
+=begin rdoc
+Returns the editor in the current tab, or *nil* if there's no tab. Note that this
+may not be the active editor.
+=end
+    def current_editor
+      @views.current_widget
+    end
+    
+=begin rdoc
+Activates an editor. _arg_ can be either the index of a widget in the tab widget
+(for internal uses only) or the editor to activate, or *nil*. If the editor to
+activate is not in the current tab, the tab which contains it will become the current
+one. Activating an editor deactivates the previously active one.
+
+Activating an editor means merging its GUI with the main window's GUI, changing
+the title of the main window accordingly and telling the status bar to refer to
+that view. Also, the <tt>current_document_changed</tt> and <tt>active_editor_changed</tt>
+signals are emitted.
+=end
+    def activate_editor arg
+      view = arg.is_a?(Integer) ? @views.widget( arg ) : arg
+      @views.current_widget = view if view and @views.current_widget != view
+      deactivate_editor @active_editor if @active_editor != view
+      @active_editor = view
+      if @active_editor
+        gui_factory.add_client @active_editor.doc.view.send(:internal)
+        @active_editor.document.activate
+      end
+      make_title
+      status_bar.view = @active_editor
+      emit current_document_changed @active_editor ?  @active_editor.document : Qt::NilObject
+      emit active_editor_changed @active_editor || Qt::NilObject
+    end
+    
+=begin rdoc
+  Returns the document associated with the active editor or *nil* if there's no
+  current editor.
+  
+  It's almost the same as <tt>active_editor.doc</tt>, but already takes care of
+  the case when <tt>active_editor</tt> is *nil*.
+=end
+    def current_document
+      view = @views.current_widget
+      view ? view.doc : nil
+    end
+    
+=begin rdoc
+Similar to <tt>editor_for!</tt> but, after having retrieved/created the editor
+view, it activates and gives focus to it and moves the cursor to the line _line_
+and column _col_ (both of them are 0-based indexes).
+=end
+    def display_doc doc, line = nil, col = 0
+      ed = editor_for! doc
+      return unless ed
+      activate_editor ed
+      ed.go_to line, col if line and col
+      ed.set_focus
+    end
+    alias display_document display_doc
+    
+=begin rdoc
+Executes the contents of the block with automatical editor activation disabled.
+This should be used, for example, when more than one editor should be opened at
+once. Without this, every new editor would become (for a little time) the active
+one, with its gui merged with the main window and so on. This slows things down
+and should be avoided. To do so, you use this method:
+  Ruber[:main_window].without_activating do
+    ed = nil
+    files.each do |f|
+      ed = Ruber[:main_window].editor_for! f
+    end
+    Ruber[:main_window].activate_editor ed
+  end
+After the block has been called, if there is no editor, or if the current widget
+in the tab widget is different from the active editor, the current widget will
+be activated.
+<b>Note:</b> automatical editor activation will be restored at the end of this
+method (even if exceptions occur).
+=end
+    def without_activating
+      begin
+        @auto_activate_editors = false
+        yield
+      ensure 
+        @auto_activate_editors = true
+        if @views.current_index < 0 then activate_editor nil
+        elsif @views.current_widget != @active_editor
+          activate_editor @views.current_widget
+        end
+      end
+    end
+    
+=begin rdoc
+Closes the editor _ed_, deleting its tab and closing the corresponding document
+and activating the next tab if auto activating is on. If _ask_ is *true*, the document
+will ask whether to save modifications, otherwise it won't
+=end
+    def close_editor ed, ask = true
+      ed.document.close_view ed, ask
+    end
+    
+=begin rdoc
+  This method is meant to be called in situation where the user may want to save
+  a number of documents, for example when the application is quitting, as it avoids
+  displaying a dialog box for each modified document.
+    
+  _docs_ can be either an array containing the documents which can be saved (documents
+  in it which aren't modified will be ignored) or *nil*. In this case, all the
+  open documents (with or without an open editor) will be taken into account.
+  
+  It displays a dialog where the user can choose, among the documents passed as
+  first argument, which ones he wants to save. The user has three choiches:
+  * save some (or all) the files, then proceed with the operation which has caused
+    the dialog to be shown (for example, quitting the application)
+  * don't save any file and go on with the operation
+  * abort the operation.
+    
+  In the first case, this method attempts to perform save the selected files. If
+  any of them can't be saved, the dialog to choose the files to save will be
+  displayed again, with only those files which couldn't be saved (after informing
+  the user of the failure). The user can again chose which of those files this method
+  should attempt to save again, or whether to abort the operation or skip saving.
+  This will be repeated until all files have been saved or the user gives up
+    
+  In the second and third cases, the method simply returns respectively +true+ or
+  *false*.
+    
+  The value returned by this method is *false* if the user choose to abort the
+  operation and *true* otherwise. Calling methods should act appropriately (for
+  example, if this is called from a method which closes all documents and returns
+  *false*, the documents should't be closed. If it returns true, instead, they
+  should be closed, without asking again to save them).
+    
+  <b>Note:</b> if _docs_ only contains non-modified documents, this method will
+  do nothing and immediately return *true*.
+=end
+    def save_documents docs = nil
+      docs ||= Ruber[:docs]
+      to_save = docs.select{|d| d.modified?}
+      until to_save.empty?
+        dlg = SaveModifiedFilesDlg.new to_save, self
+        case dlg.exec
+        when KDE::Dialog::Yes
+          to_save = Ruber[:docs].save_documents dlg.to_save
+          unless to_save.empty?
+            msg = "The following documents couldn't be saved: #{to_save.join "\n"}\nPlease, choose how to proceed"
+            KDE::MessageBox.sorry nil, KDE.i18n(msg)
+          end
+        when KDE::Dialog::No then to_save.clear
+        when Qt::Dialog::Rejected then return false
+        end
+      end
+      true
+    end
+    
+=begin rdoc
+Asks the user whether to save the modified documents and saves the chosen ones.
+Returns *true* all the selected documents where saved and *false* if some of the
+document couldn't be saved.
+MOVE: this should be moved to DocumentList, as there might be documents without
+a window
+=end
+    def query_close
+      if Ruber[:app].session_saving
+        @session_data = Ruber[:components].session_data
+      end
+      true
+    end
+    
+=begin rdoc
+Provides a standard interface to creating a project from a project file named _file_, automatically
+handling the possible exceptions. In particular, a message box will be displayed
+if the project file doesn't exist or if it exists but it's not a valid project file.
+A message box is also displayed if <i>allow_reuse</i> is *false* and the project
+list already contains a project corresponding to _file_. In all cases in which a
+message box is displayed *nil* is returned. Otherwise, the +Project+ object
+corresponding to +file+ is returned.
+
+If a project was created from the project file, it will be made active and the
+old active project (if any) will be closed.
+
+<b>Note:</b> _file_ must be an absolute path.
+=end
+    def safe_open_project file, allow_reuse = false
+      prj = Ruber[:projects][file]
+      if !allow_reuse and prj
+        text = "A project corresponding to the file #{file} is already open. Please, close it before attempting to open it again"
+        KDE::MessageBox.sorry self, KDE.i18n(text)
+        return nil
+      elsif prj then return prj
+      end
+      begin prj = Ruber[:projects].project file
+      rescue Project::InvalidProjectFile => ex
+        text = <<-EOS
+#{file} isn't a valid project file. The error reported was:
+#{ex.message}
+        EOS
+        KDE::MessageBox.sorry self, KDE.i18n(text)
+        return nil
+      rescue LoadError
+        KDE::MessageBox.sorry self, KDE.i18n(ex.message)
+        return nil
+      end
+# The following two lines should be removed when we'll allow more than one project
+# open at the same time
+      Ruber[:projects].current_project.close if Ruber[:projects].current_project
+      Ruber[:projects].current_project = prj
+      prj
+    end
+
+=begin rdoc
+Saves recent files and projects, the position of the splitters and the size of
+the window.
+
+TODO: since restoring window position seems to work correctly in Kate (even if
+there's still an open bug, it seems to work, at least for me) see whether it's
+still necessary to store the window size.
+=end
+    def save_settings
+      @workspace.store_sizes
+# TODO use Ruber[:config] as soon as it works
+#       config = Ruber[:config].kconfig
+      config = KDE::Global.config
+      recent_files = KDE::ConfigGroup.new config, 'Recent files'
+      action_collection.action("file_open_recent").save_entries recent_files
+      recent_projects = KDE::ConfigGroup.new config, 'Recent projects'
+      action_collection.action("project-open_recent").save_entries recent_projects
+      config.sync
+      c = Ruber[:config][:main_window]
+      c.window_size = rect.size
+    end
+    
+=begin rdoc
+Loads the settings (in particular, the default script directory and the
+default project directory)
+=end
+    def load_settings
+      c = Ruber[:config][:general]
+      @default_script_dir = KDE::Url.from_path c.default_script_directory
+      @default_project_dir = KDE::Url.from_path c.default_project_directory
+    end
+    
+=begin rdoc
+Gives the focus to the current editor view. _ed_ can be:
+* an EditorView
+* any argument acceptable by <tt>editor_for!</tt>
+* *nil*
+In the first two cases, the editor corresponding to _ed_ is activated and given
+focus; in the last case the active editor is given focus.
+=end  
+    def focus_on_editor ed = nil
+      if ed
+        ed = editor_for! ed unless ed.is_a? EditorView
+        activate_editor ed if ed
+      end
+      @active_editor.set_focus if @active_editor
+    end
+    
+=begin rdoc
+The directory where to save files which don't belong to a project
+=end
+#     def scripts_directory
+#       @default_script_dir
+#     end
+    
+=begin rdoc
+The directory where to create new projects by default
+=end
+    def projects_directory
+      @default_project_dir
+    end
+    
+=begin rdoc
+Executes the action with name _action_ contained in the main window's action collection.
+
+See <tt>GuiPlugin#execute_action</tt> for more details
+=end
+    def execute_action name, *args
+      data = plugin_description.actions[name.to_s]
+      if data
+        slot = data.slot.sub(/\(.*/, '')
+        instance_eval(data.receiver).send slot, *args
+        true
+      elsif (action = action_collection.action(name))
+        if action.class == KDE::ToggleAction then KDE::ToggleAction
+          action.instance_eval{emit toggled(*args)}
+        elsif action.class == KDE::Action 
+          action.instance_eval{emit triggered()}
+        else action.instance_eval{emit triggered(*args)}
+        end
+        true
+      else false
+      end
+    end
+    
+  end
+  
+end