ruber 0.0.5 → 0.0.7

data/plugins/ruby_development/ui/config_widget.ui

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RubyDevelopmentConfigWidget</class>
+ <widget class="QWidget" name="RubyDevelopmentConfigWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>38</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="toolTip">
+      <string>The command to use to run a ruby script in a terminal</string>
+     </property>
+     <property name="whatsThis">
+      <string>In the command line, use %d to indicate the initial working directory for the terminal and %r to indicate where to put the ruby command line. The %r sequence should be either sourrounded by spaces or have a space before it and the end of the command after it.
+
+Note that you can't use arguments containing spaces in the command line.</string>
+     </property>
+     <property name="text">
+      <string>&amp;Terminal</string>
+     </property>
+     <property name="buddy">
+      <cstring>_ruby__run_in_terminal_cmd</cstring>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="KLineEdit" name="_ruby__run_in_terminal_cmd">
+     <property name="toolTip">
+      <string>The command to use to run a ruby script in a terminal</string>
+     </property>
+     <property name="whatsThis">
+      <string>In the command line, use %d to indicate the initial working directory for the terminal and %r to indicate where to put the ruby command line.
+
+Note that you can't use arguments containing spaces in the command line</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>KLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>klineedit.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

data/plugins/ruby_development/ui/project_widget.rb

@@ -1,7 +1,7 @@
 =begin
 ** Form generated from reading ui file 'project_widget.ui'
 **
-** Created: ven ott 29 17:39:04 2010
+** Created: mar nov 16 11:52:49 2010
 **      by: Qt User Interface Compiler version 4.7.0
 **
 ** WARNING! All changes made in this file will be lost when recompiling ui file!

data/plugins/ruby_runner/plugin.yaml

@@ -7,7 +7,7 @@ about:
  bug_address: http://github.com/stcrocco/ruber/issues
  icon: ruby.png
 class: Ruber::RubyRunner::RubyInterpretersPlugin
-require: ruby_runner
+require: ruby_runner.rb
 ui_file: ruby_interpretersui.rc
 features: [ruby_interpreters]
 config_widgets:
@@ -19,7 +19,7 @@ config_options:
   ruby_options: {:default: [-w]}
 project_options:
  ruby:
-   ruby: {default: 'Ruber[:config][:ruby, :ruby]', scope: [global, document], mimetype: 'application/x-ruby', file_extension: [*.rb, Rakefile, rakefile]}
+   ruby: {default: 'Ruber[:config][:ruby, :ruby]', scope: [global, document], mimetype: 'application/x-ruby', file_extension: [*.rb, Rakefile, rakefile], place: all}
 project_widgets:
  - {caption: Ruby, pixmap: ruby.png, class: 'Ruber::RubyRunner::ProjectWidget', scope: [global, document], mimetype: 'application/x-ruby', file_extension: [*.rb, Rakefile, rakefile]}
 actions:

data/plugins/ruby_runner/ruby_runner.rb

@@ -156,7 +156,6 @@ the plugin
       def initialize psf
         silently do
           Object.const_set :RubyOptionsWidget, RubyOptionsWidget
-          Ruber::RubyRunner.const_set :RubyRunnerPlugin, RubyRunnerPluginInternal
         end
         super
         @default_interpreter_action = action_collection.action('ruby_runner-configured_interpreter')
@@ -245,6 +244,18 @@ default entry is selected.
         nil
       end
       
+=begin rdoc
+Override of {PluginLike#unload}
+
+Besides doing the same as the base class method, it also removes the @Ruber::RubyRunner::RubyRunnerPlugin@
+constant, so that other plugins may reimplement it using another base class.
+@return [nil]
+=end
+      def unload
+        Ruber::RubyRunner.send :remove_const, :RubyRunnerPlugin
+        super
+      end
+      
     end
       
 =begin
@@ -266,7 +277,7 @@ plugin.
 @api_method #interpreter_for
 @api_method #ruby_command_for
 =end
-    class RubyRunnerPluginInternal < ExternalProgramPlugin
+    class RubyRunnerPlugin < ExternalProgramPlugin
 
 =begin rdoc
 Creates a new instance.
@@ -293,7 +304,7 @@ must be an array, even if it only contains one entry
       def initialize pso, group, rules = {}, order = nil, line_buffered = true
         group = group.to_sym
         @group = group
-        default_rules = {:scope => [:global], :file_extension => [], :mimetype => []}
+        default_rules = {:scope => [:global], :file_extension => [], :mimetype => [], :place => [:local]}
         rules = default_rules.merge rules
         ruby_options_data = {
           :name => :ruby_options,
@@ -303,6 +314,7 @@ must be an array, even if it only contains one entry
           :mimetype => rules[:mimetype],
           :file_extension => rules[:file_extension],
           :order => order,
+          :place => rules[:place]
         }
         pso.project_options[[group, :ruby_options]] ||= PluginSpecificationReader::Option.new ruby_options_data
         super pso, line_buffered

data/plugins/ruby_runner/ui/config_widget.rb

@@ -1,7 +1,7 @@
 =begin
 ** Form generated from reading ui file 'config_widget.ui'
 **
-** Created: ven ott 29 17:39:04 2010
+** Created: mar nov 16 11:52:49 2010
 **      by: Qt User Interface Compiler version 4.7.0
 **
 ** WARNING! All changes made in this file will be lost when recompiling ui file!

data/plugins/ruby_runner/ui/project_widget.rb

@@ -1,7 +1,7 @@
 =begin
 ** Form generated from reading ui file 'project_widget.ui'
 **
-** Created: ven ott 29 17:39:04 2010
+** Created: mar nov 16 11:52:49 2010
 **      by: Qt User Interface Compiler version 4.7.0
 **
 ** WARNING! All changes made in this file will be lost when recompiling ui file!

data/plugins/ruby_runner/ui/ruby_runnner_plugin_option_widget.rb

@@ -1,7 +1,7 @@
 =begin
 ** Form generated from reading ui file 'ruby_runnner_plugin_option_widget.ui'
 **
-** Created: ven ott 29 17:39:04 2010
+** Created: mar nov 16 11:52:49 2010
 **      by: Qt User Interface Compiler version 4.7.0
 **
 ** WARNING! All changes made in this file will be lost when recompiling ui file!

data/plugins/state/plugin.yaml

@@ -11,14 +11,18 @@ config_options:
  state:
   open_documents: {default: []}
   open_projects: {default: []}
-  active_document: {default: nil}
   restore_cursor_position: {default: true}
   restore_project_files: {default: true}
   startup_behaviour: {default: :restore_all}
+  tabs: {default: []}
+  active_view: {default: nil}
+  cursor_positions: {default: []}
 project_options:
  state:
   open_documents: {default: [], type: session, scope: global}
-  active_document: {default: ~, type: session, scope: global}
+  tabs: {default: [], scope: global, type: session}
+  cursor_positions: {default: [], type: session, scope: global }
+  active_view: {default: ~, type: session, scope: global}
   cursor_position: {default: [0, 0], type: session, scope: document}
 config_widgets:
  - {class: Ruber::State::ConfigWidget, caption: General}

data/plugins/state/state.rb

@@ -1,5 +1,5 @@
 =begin
-    Copyright (C) 2010 by Stefano Crocco   
+    Copyright (C) 2010,2011 by Stefano Crocco   
     stefano.crocco@alice.it   
   
     This program is free software; you can redistribute it andor modify  
@@ -30,12 +30,18 @@ module Ruber
 =begin rdoc
 Plugin which allows Ruber to store and restore back its state.
 
-In this context, the term _state_ means the open project and documents, the position
-of the cursor in each document and the active document. All this data is stored
+In this context, the term _state_ means the open project and documents, the tabs
+in the main window, the editors in each tab, the position of the cursor in the
+editors and the active editor. All this data is stored
 in the configuration file and in the project or document project files. Using
 the API provided by this plugin, it is possible to restore a single document,
 project or the whole application to the state it was when it was last closed.
 
+Documents which haven't been saved to a file are only partially restored: an empty
+document is created for them (different views associated with the same document
+will correctly be associated with the same empty document after restoration). Unsaved
+changes in documents not associated with files won't be restored.
+
 In addition to providing an API for saving and restoring state, this plugin also
 restores the full Ruber state when restoring a session and (according to the
 user preferences) when the application starts up.
@@ -57,7 +63,7 @@ Plugin object for the State plugin
       
 =begin rdoc
 @param [Ruber::PluginSpecification] psf the plugin specification object associated
-with the plugin
+  with the plugin
 =end
       def initialize psf
         super
@@ -155,7 +161,7 @@ files in projects should be restored, regardless of what the user chose
 =begin rdoc
 Restores the given document
 
-See {DocumentExtension#restore} for more information
+@see DocumentExtension#restore DocumentExtension#restore for more information
 
 @param [Ruber::Document] doc the document to restore
 @return [nil]
@@ -167,7 +173,7 @@ See {DocumentExtension#restore} for more information
 =begin rdoc
 Restores the given global project
 
-See {ProjectExtension#restore} for more information
+@see ProjectExtension#restore ProjectExtension#restore for more information
 
 @param [Ruber::Project] prj the document to restore
 @return [nil]
@@ -179,6 +185,9 @@ See {ProjectExtension#restore} for more information
 =begin rdoc
 Restores the open projects according to a given configuration object
 
+Restoring the project means closing all the open projects and opening the projects
+and setting the active project according to the information in _conf_
+
 This method is called both when the session is restored and when ruber starts
 up (if the user chose so).
 
@@ -200,6 +209,13 @@ for more information
 =begin rdoc
 Restores the open documents according to a given configuration object
 
+Restoring the open documents means:
+* closing all the open documents. If any of thess is modified, the user is asked
+  how to proceed. If the choses to abort, nothing else is done
+* opening the documents according to the @state/open_documents@ entry of _conf_
+* recreating the tabs and the editors according to the @state/tabs@ entry of _conf_
+* activating the editor contained in the @state/active_editor@ entry of _conf_
+
 This method is called both when the session is restored and when ruber starts
 up (if the user chose so).
 
@@ -208,17 +224,91 @@ for more information
 @return [nil]
 =end
       def restore_documents config = Ruber[:config]
-        Ruber[:docs].close_all
-        files = config[:state, :open_documents]
-        return if files.empty?
-        active_file = config[:state, :active_document]
-        active_file = files[-1] unless files.include? active_file
+        return unless Ruber[:documents].close_all
+        docs = config[:state, :open_documents]
+        unnamed_docs = []
+        docs = docs.map do |i| 
+          if i.is_a?(String) then Ruber[:documents].document(i)
+          else 
+            doc = Ruber[:documents].new_document
+            unnamed_docs << doc
+            doc
+          end
+        end
+        return if docs.empty?
+        tabs = config[:state, :tabs]
         mw = Ruber[:main_window]
-        mw.without_activating do
-          files.each{|f| ed = mw.editor_for! f}
-          mw.display_document active_file
+        positions = config[:state, :cursor_positions]
+        tabs.each_with_index do |t, i| 
+          pn = restore_pane t, unnamed_docs
+          views = pn.to_a
+          views.each_with_index do |v, j|
+            cursor = KTextEditor::Cursor.new(*(positions[i][j] rescue [0,0]))
+            v.cursor_position = cursor
+          end
+        end
+        active_editor = config[:state, :active_view]
+        if active_editor
+          mw.focus_on_editor mw.tabs[active_editor[0]].to_a[active_editor[1]]
         end
-        nil
+      end
+      
+=begin rdoc
+Restores a pane
+
+Restoring a pane means creating the editors which were contained in the pane,
+in the correct disposition.
+
+The contents of the pane are described by the array _data_, which has the following
+format:
+
+* if it has a single element, the corresponding pane contains only a view. If the
+  element is a string, it must represent the URL of the document the view is associated
+  with. If it is a number, it means the view is associated with a document which
+  hasn't been saved
+* if it has more than one element, it means that the pane contains more than one
+  view. The first element represents the orientation of the pane and can be either
+  @Qt::Horizontal@ or @Qt::Vertical@. The other elements can be either strings,
+  numbers or arrays. A string or number means, as above, the URL of the document
+  associated with the view or a document which isn't associated with a file. An
+  array (which should have the same format as this) means a sub pane
+@param [Array] data the array containing the description of the contents of the
+  pane
+@param [Array<Document>] docs the document not associated with files to use for
+  the numeric entries of _data_. A number _n_ in _data_ means to use the entry
+  _n_ in _docs_
+@return [Pane] the new pane
+=end
+      def restore_pane data, docs
+        mw = Ruber[:main_window]
+        find_first_view = lambda do |array|
+          if array.size == 1 then array[0]
+          elsif array[1].is_a? Array then find_first_view.call array[1]
+          else array[1]
+          end
+        end
+        recreate_pane = lambda do |pn, array|
+          orientation = array[0]
+          last_view = pn.view
+          array.each_with_index do |e, i|
+            #the first element of the array is the orientation; the second is
+            #the first view, which is already contained in the pane
+            next if i < 2 
+            view = e.is_a?(Array) ? find_first_view.call(e) : e
+            view = mw.editor_for! view.is_a?(String) ? view: docs[view], 
+                        :existing => :never, :show => false
+            pn.split last_view, view, orientation
+            last_view = view
+            recreate_pane.call view.parent, e if e.is_a? Array
+          end
+          recreate_pane.call pn.splitter.widget(0), array[1] if array[1].is_a?(Array)
+        end
+        view = find_first_view.call data
+        view = mw.editor_for! view.is_a?(String) ? view : docs[view], 
+                      :existing => :never, :new => :new_tab
+        pane = view.parent
+        recreate_pane.call pane, data
+        pane
       end
       
 =begin rdoc
@@ -262,7 +352,7 @@ Since this method deals with session management, it ignores the user settings
 @return [nil]
 =end
       def restore_session data
-        hash = data['State'] || {:open_projects => [], :open_documents => [], :active_document => nil}
+        hash = data['State'] || {:open_projects => [], :open_documents => [], :active_view => nil, :tabs => []}
         hash = hash.map_hash{|k, v| [[:state, k], v]}
         def hash.[] k, v
           super [k, v]
@@ -281,8 +371,8 @@ Saves Ruber's state to the global config object
       def save_settings
         h = gather_settings
         cfg = Ruber[:config]
-        [:open_projects, :open_documents, :active_document].each do |i| 
-          cfg[:state, i] = h[i]
+        h.each_pair do |k, v| 
+          cfg[:state, k] = v
         end
         nil
       end
@@ -296,6 +386,84 @@ Override of {PluginLike#session_data}
         {'State' => gather_settings}
       end
       
+=begin rdoc
+The open projects in a form suitable to be written to a configuration object
+
+@return [Array<String>] an array containing the names of the project files for
+  the currently open projects. The active project is the first one. This value
+  is the one to write under the @state/open_projects@ entry in a project or configuration
+  object
+=end
+      def projects_state
+        projects = Ruber[:projects].projects.map{|pr| pr.project_file}
+        unless projects.empty?
+          active_prj = Ruber[:projects].current
+          projects.unshift projects.delete(active_prj.project_file) if active_prj
+        end
+        projects
+      end
+
+=begin rdoc
+The open documents in a form suitable to be written to a configuration object
+
+@return [Array<String,nil>] an array containing the names of the URLs associated with
+  the currently open documents. Documents not associated with files are represented
+  by *nil*s in the array. This value is the one to write under the @state/open_documents@
+  entry in a project or configuration object
+=end
+      def documents_state
+        docs = Ruber[:documents].documents
+        docs.map{ |doc| doc.has_file? ? doc.url.to_encoded.to_s : nil}
+      end
+
+=begin rdoc
+The open tabs configuration in a form suitable to be written to a configuration object
+
+@return [Hash] A hash containing the following keys:
+ * @:tabs@: an array of arrays, with each inner array representing one tab, with
+  the format described in {#restore_pane}. This value is the one to write under
+  the @state/tabs@ entry in a project or configuration object
+ * @:cursor_positions@:an array of arrays. Each inner array corresponds to a tab
+  and contains the cursor position of each view. Each cursor position is represented
+  as an array with two elements: the first is the line, the second is the column.
+  The order the views are is the same used by {Pane#each_view}. This value is the one to write under
+  the @state/cursor_positions@ entry in a project or configuration object
+ * @:active_view@: the active view. It is represented by a size 2 array, with the
+  first element being the index of the tab of the active view and the second being
+  the index of the view in the corresponding pane (according to the order used by
+  {Pane#each_view}). If there's no active view, this entry is *nil*. This is the value to write under
+  the @state/active_view@ entry in a project or configuration object
+=end
+      def tabs_state
+        res = {}
+        doc_map = {}
+        doc_idx = 0
+        Ruber[:documents].each do |doc|
+          if !doc.has_file?
+            doc_map[doc] = doc_idx
+            doc_idx += 1
+          end
+        end
+        tabs = Ruber[:main_window].tabs
+        tabs_tree = []
+        cursor_positions = []
+        tabs.each do |t|
+          tabs_tree << tab_to_tree(t, doc_map)
+          cursor_positions << t.map do |v|
+            pos = v.cursor_position
+            [pos.line, pos.column]
+          end
+        end
+        res[:tabs] = tabs_tree
+        res[:cursor_positions] = cursor_positions
+        active = Ruber[:main_window].active_editor
+        if active
+          active_tab = Ruber[:main_window].tab(active)
+          res[:active_view] = [tabs.index(active_tab), active_tab.to_a.index(active)]
+        end
+        res
+      end
+      
       private
       
 =begin rdoc
@@ -307,60 +475,95 @@ Creates a hash with all the data needed to restore Ruber's state
  * @:open_documents@: an array with the name of the file corresponding to each
   open document (documents without an associated file can't be restored and aren't
   included). The order is that of opening
+ * @:visible_documents@: an array with the name of the files corresponding to the
+  documents associated with a file and having a view
  * @:active_document@: the name of the file associated with the active document or
   *nil* if there's no open document
 =end
       def gather_settings
-        res = {}
-        projects = Ruber[:projects].projects.map{|pr| pr.project_file}
-        unless projects.empty?
-          active_prj = Ruber[:projects].current
-          projects.unshift projects.delete(active_prj.project_file) if active_prj
-        end
-        res[:open_projects] = projects
-        docs = Ruber[:docs].documents.map{|doc| doc.path}.select{|path| !path.empty?}
-        res[:open_documents] = docs
-        current_doc = Ruber[:main_window].current_document.path rescue ''
-        res[:active_document] = current_doc.empty? ? nil : current_doc
+        res = {
+          :open_projects => projects_state,
+          :open_documents => documents_state
+        }
+        res.merge! tabs_state
         res
       end
       
+=begin rdoc
+A representation of a pane's configuration suitable to be written to a configuration
+object
+
+@param [Pane] pane the pane to return the representation for
+@param [Hash{Document=>Integer}] docs a map between documents not associated
+  with files and the number to represent them
+@return [Array<Array,Integer,String>] an array as described in {#restore_pane}
+=end
+      def tab_to_tree pane, docs
+        if pane.single_view?
+          doc = pane.view.document
+          return [doc.has_file? ? doc.url.url : docs[doc]]
+        end
+        panes = {}
+        tab_to_tree_prc = lambda do |pn|
+          if pn.single_view?
+            doc = pn.view.document
+            panes[pn.parent_pane] << (doc.has_file? ? doc.url.url : docs[doc])
+          else 
+            data = [pn.orientation]
+            panes[pn] = data
+            panes[pn.parent_pane] << data if pn.parent_pane
+          end
+        end
+        tab_to_tree_prc.call pane
+        pane.each_pane :recursive, &tab_to_tree_prc
+        panes[pane]
+      end
+      
     end
     
 =begin rdoc
 Extension for documents needed by the State plugin
 
-The scope of this extension is to save and restore the position of the cursor
-in the document
+The scope of this extension is to move the cursor of all newly created views
+associated with the document to the position it was in the last used view. The
+cursor position for the first view is read from the document's own project, where
+it is saved whenever the document is closed.
+
+The cursor position for a view is moved in response to the {Document#view_created}
+signal.
 =end
     class DocumentExtension < Qt::Object
       
       include Extension
       
-      slots :auto_restore
+      slots 'auto_restore(QObject*)'
       
 =begin rdoc
 @param [Ruber::DocumentProject] prj the project associated with the document
 =end
       def initialize prj
         super
+        @last_view = nil
         @project = prj
         @document = prj.document
-        connect @document, SIGNAL('view_created(QObject*, QObject*)'), self, SLOT(:auto_restore)
+        connect @document, SIGNAL('view_created(QObject*, QObject*)'), self, SLOT('auto_restore(QObject*)')
+        connect @document, SIGNAL('closing_view(QWidget*, QObject*)'), self, SLOT('view_closing(QWidget*)')
       end
       
 =begin rdoc
-Restores the position of the cursor according to the value saved in the document's
-own project
+Moves the cursor of a view to the position it was in the last used view
 
-It does nothing if the document isn't associated with a view
+If there are no other views associated with the document, the position of the
+cursor is read from the document's own project
+@param [EditorView] the view to move the cursor for
 @return [nil]
 =end
-      def restore
-        view = @document.view
-        return unless view
-        pos = @document.own_project[:state, :cursor_position]
-        view.go_to *pos
+      def restore view
+        if @last_view then view.cursor_position = @last_view.cursor_position
+        else
+          pos = @document.own_project[:state, :cursor_position]
+          view.go_to *pos
+        end
         nil
       end
       
@@ -371,43 +574,74 @@ It does nothing if the document isn't associated with a view
 @return [nil]
 =end
       def save_settings
-        view = @document.view 
-        pos = if view
-          cur = view.cursor_position
-          [cur.line, cur.column]
-        else [0,0]
-        end
-        @project[:state, :cursor_position] = pos
+        if @last_view
+          cur = @last_view.cursor_position
+          pos = [cur.line, cur.column]
+          @project[:state, :cursor_position] = pos
+        end        
         nil
       end
       
       private
       
 =begin rdoc
-Moves the cursor in a new view to the position stored in the document's own project
+Restores the cursor position for a view if the user choosed to do so
+
+It does nothing if the user choosed not to restore the cursor position when a view
+is created
+
+@param [EditorView] the view to restore the cursor position for
+@return [nil]
+=end
+      def auto_restore view
+        restore view if Ruber[:state].restore_cursor_position?
+        connect view, SIGNAL('focus_in(QWidget*)'), self, SLOT('view_received_focus(QWidget*)')
+        nil
+      end
+      
+=begin rdoc
+Memorizes which view has last received focus
 
-It does nothing if the user chose not to have the position restored when opening
-a document.
+This information is used to decide which view to ask for the cursor position when
+a new view is created or the cursor position needs to be saved to the project
+@param [EditorView] view the view which has received focus
 @return [nil]
 =end
-      def auto_restore
-        restore if Ruber[:state].restore_cursor_position?
+      def view_received_focus view
+        @last_view = view
         nil
       end
+      slots 'view_received_focus(QWidget*)'
+      
+=begin rdoc
+Method called whenever a view associated with the document is closed
+
+If the closed view is the one which last got focus, its cursor position is saved
+in the document's own project. Otherwise nothing is done. 
+@param [EditorView] view the view being closed
+@return [nil]
+=end
+      def view_closing view
+        if view == @last_view
+          save_settings
+          @last_view = nil
+        end
+      end
+      slots 'view_closing(QWidget*)'
       
     end
     
 =begin rdoc
 Extension for projects needed by the State plugin
 
-The scope of this extension is to save and restore the open documents associated
-with projects
+The scope of this extension is to save and restore the state of the tabs open
+when the project was last closed
 =end
     class ProjectExtension < Qt::Object
       
       include Extension
       
-      slots :auto_restore
+      slots :auto_restore, :save_settings
       
 =begin rdoc
 @param [Ruber::Project] prj the project associated with the extension
@@ -416,55 +650,45 @@ with projects
         super
         @project = prj
         connect @project, SIGNAL(:activated), self, SLOT(:auto_restore)
+        connect @project, SIGNAL(:deactivated), self, SLOT(:save_settings)
       end
       
 =begin rdoc
-Opens all the files associated with the proejct which were opened last time the
-project's state was changed
+Restore Ruber's state as it was when the project was last closed
 
-Any already open document is closed (after saving)
+See {Plugin#restore_documents} for more information
 
 @return [nil]
 =end
 
       def restore
-        files = @project[:state, :open_documents]
-        Ruber[:docs].close_all
-        return if files.empty?
-        active_file = @project[:state, :active_document]
-        active_file = files[-1] unless files.include? active_file
-        mw = Ruber[:main_window]
-        mw.without_activating do
-          files.each{|f| mw.editor_for! f}
-        end
-        mw.display_document active_file
+        Ruber[:state].restore_documents @project
         nil
       end
       
 =begin rdoc
-Saves the list of open project files to the project
+Saves Ruber's state to the project
+
+The saved information is: the configuration of open tabs, the position of the cursor
+in the views and the active view
 
 @return [nil]
 =end
       def save_settings
-        files = Ruber[:docs].documents_with_file.map{|d| d.path}
-        active = Ruber[:main_window].current_document
-        active_path = (active.nil? or active.path.empty?) ? nil : active.path
-        @project[:state, :open_documents] = files
-        @project[:state, :active_document] = active_path
+        @project[:state, :open_documents] = Ruber[:state].documents_state
+        tabs_state = Ruber[:state].tabs_state
+        [:tabs, :cursor_positions, :active_view].each do |e|
+          @project[:state, e] = tabs_state[e]
+        end
         nil
       end
       
       private
 
 =begin rdoc
-Opens all the files associated with the proejct which were opened last time the
-project's state was changed when the project is opened.
-
-Any already open document is closed (after saving).
+Restores the project's state when a new project is activated
 
-It does nothing if the user chose not restore open project files when opening a
-project.
+It does nothing if the user choosed not to restore the projects's state.
 @return [nil]
 =end
       def auto_restore