ruber 0.0.1.1

data/lib/ruber/editor/editor_view.rb

@@ -0,0 +1,167 @@
+=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 'ktexteditor'
+require 'facets/boolean'
+
+require 'ruber/editor/ktexteditor_wrapper'
+
+module Ruber
+
+  class EditorView < Qt::Widget
+    
+    include KTextEditorWrapper
+    
+    signal_data = {
+      'information_message' => ['KTextEditor::View*, QString', [1, nil]],
+      'context_menu_about_to_show' => ['KTextEditor::View*, QMenu*', [1, nil]],
+      'focus_in' => ['KTextEditor::View*', [nil]],
+      'focus_out' => ['KTextEditor::View*', [nil]],
+#       'selection_changed' => ['KTextEditor::View*', [nil]],
+      'vertical_scroll_position_changed' => ['KTextEditor::View*, KTextEditor::Cursor', [1, nil]],
+      'horizontal_scroll_position_changed' => ['KTextEditor::View*', [nil]],
+      'text_inserted' => ['KTextEditor::View*, KTextEditor::Cursor, QString', [1, 2, nil]],
+    }
+    
+    @signal_table = KTextEditorWrapper.prepare_wrapper_connections self, signal_data
+    
+    signals 'closing()', 'cursor_position_changed(KTextEditor::Cursor, QWidget*)', 
+    'view_mode_changed(QString, QWidget*)', 'edit_mode_changed(KTextEditor::View::EditMode, QWidget*)',
+    'selection_mode_changed(bool, QWidget*)', 'mouse_position_changed(KTextEditor::Cursor, QWidget*)',
+    'selection_changed(QWidget*)'
+    
+    slots 'slot_selection_changed(KTextEditor::View*)'
+    
+#     @view.connect(SIGNAL('selectionChanged(KTextEditor::View*)')) do |v|
+#       changed = @view.block_selection ^ @block_selection
+#       if changed
+#         @block_selection = @view.block_selection
+#         emit selection_mode_changed @block_selection, self
+#       end
+#     end
+    
+
+
+#     signals 'closing()', 'information_message(QString, QObject*)', 
+# 'cursor_position_changed(KTextEditor::Cursor, QObject*)', 
+# 'view_mode_changed(QString, QObject*)', 'edit_mode_changed(KTextEditor::View::EditMode, QObject*)',
+# 'selection_mode_changed(bool, QObject*)', 'context_menu_about_to_show(QMenu*, QObject*)',
+# 'focus_in(QObject*)', 'focus_out(QObject*)', 'horizontal_scroll_position_changed(QObject*)',
+# 'mouse_position_changed(KTextEditor::Cursor, QObject*)', 'selection_changed(QObject*)',
+# 'text_inserted(KTextEditor::Cursor, QString, QObject*)', 'vertical_scroll_position_changed(KTextEditor::Cursor, QObject*)'
+
+    attr_reader :doc
+    alias_method :document, :doc
+    def initialize doc, internal, parent = nil
+      super parent
+      @block_selection = false
+      @doc = doc
+      @view = internal
+      @view.parent = self
+      initialize_wrapper @view, self.class.instance_variable_get(:@signal_table)
+      self.focus_proxy = @view
+      self.layout = Qt::VBoxLayout.new self
+      layout.set_contents_margins 0,0,0,0
+      layout.spacing = 0
+      layout.add_widget @view
+
+      connect @view, SIGNAL('selectionChanged(KTextEditor::View*)'), self, SLOT('slot_selection_changed(KTextEditor::View*)')
+      
+      @view.connect(SIGNAL('cursorPositionChanged(KTextEditor::View*, KTextEditor::Cursor)'))do |v, c| 
+        emit cursor_position_changed( @view.cursor_position_virtual, self)
+      end
+      @view.connect(SIGNAL('mousePositionChanged(KTextEditor::View*, KTextEditor::Cursor)')) do |v, c|
+        emit mouse_position_changed( @view.cursor_position_virtual, self)
+      end
+      @view.connect(SIGNAL('viewModeChanged(KTextEditor::View*)')) do |v|
+        emit view_mode_changed( view_mode, self)
+      end
+      @view.connect(SIGNAL('viewEditModeChanged(KTextEditor::View*, KTextEditor::View::EditMode)')) do |v, m|
+        emit edit_mode_changed( m, self)
+      end
+
+      am = @doc.interface('annotation_interface').annotation_model
+      am.connect(SIGNAL('annotations_changed()')) do
+        show = Ruber[:config][:general, :auto_annotations] && am.has_annotations?
+        set_annotation_border_visible(show) rescue NoMethodError
+      end
+      
+      @view.context_menu = @view.default_context_menu(Qt::Menu.new(@view))
+      
+    end
+    
+    def go_to row, col
+      @view.cursor_position = KTextEditor::Cursor.new(row, col)
+    end
+
+    def show_annotation_border
+      set_annotation_border_visible true
+    end
+
+    def hide_annotation_border
+      set_annotation_border_visible false
+    end
+
+    def block_selection?
+      @view.block_selection.to_bool
+    end
+
+    def close
+      emit closing
+      super
+    end
+
+    def set_annotation_border_visible vis
+      @view.qobject_cast(KTextEditor::AnnotationViewInterface).set_annotation_border_visible vis
+    end
+
+=begin rdoc
+Executes the action with name the view's action
+collection. This is made by having the action emit the <tt>triggered()</tt> or
+<tt>toggled(bool)</tt> signal (depending on whether it's a standard action or a
+<tt>KDE::ToggleAction</tt>). In the second case, _arg_ is the argument passed to
+the signal.
+
+Returns *true* if an action with name _name_ was found and *false* otherwise.
+=end
+    def execute_action name, arg = nil
+      a = action_collection.action(name)
+      case a
+      when KDE::ToggleAction then a.instance_eval{emit toggled(arg)}
+      when nil then return false
+      else a.instance_eval{emit triggered}
+      end
+      true
+    end
+    
+    private
+    
+    def slot_selection_changed v
+      emit selection_changed(self)
+      changed = @view.block_selection ^ @block_selection
+      if changed
+        @block_selection = @view.block_selection
+        emit selection_mode_changed(@block_selection, self)
+      end
+    end
+
+  end
+
+end

data/lib/ruber/editor/ktexteditor_wrapper.rb

@@ -0,0 +1,202 @@
+=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/string/camelcase'
+
+module Ruber
+
+=begin rdoc
+Module which abstracts some common functionality of Document and EditorView due
+to the fact that both are mostly simply wrappers around two +KTextEditor+ classes.
+
+Throught this documentation, the KTextEditor::Document or KTextEditor::View corresponding
+to the object will be referred to as the <i>wrapped object</i>.
+
+In particular, this class:
+* provide a way to access methods provided by the different interfaces implemented
+  by the wrapped object without directly accessing it (using InterfaceProxy)
+* redirect to the wrapped object any method call the object itself doesn't respond
+  to
+* provide a (private) method to access the wrapped object
+* provide some automatization in the process having the object emit an appropriate
+  signal when the wrapped object emits a signal.
+=end
+  module KTextEditorWrapper
+    
+=begin rdoc
+Helper class which, given a Qt::Object implementing different interfaces, allows
+to access method provided by one interface without exposing the object itself.
+=end
+    class InterfaceProxy
+      
+=begin rdoc
+Creates a new InterfaceProxy. _obj_ is the <tt>Qt::Object</tt> to cast to the
+appropriate interface
+=end
+      def initialize obj
+        @obj = obj
+        @interface = nil
+      end
+      
+=begin rdoc
+Sets the interface to which the object is going to be cast. _iface_ can be either
+the name of an interface, as symbol or string, both in camelcase or snakecase
+(withouth the +KTextEditor+ namespace) or the class itself. After a call to this
+method (and until the next one) <tt>method_missing</tt> will redirect all unknown
+method calls to this interface.
+=end
+      def interface= iface
+        cls = if iface.is_a? Class then iface
+        else
+          name = iface.to_s.split('_').map(&:capitalize).join ''
+          KTextEditor.const_get(name)
+        end
+        @interface = @obj.qobject_cast cls
+      end
+      
+=begin rdoc
+Passes the method call to the object cast to the current interface. If the argument
+list contains instances of classes which mix-in KTextEditorWrapper, they're replaced
+with the object they wrap before being passed to the interface.
+=end
+      def method_missing name, *args, &blk
+        args.map!{|a| a.is_a?(KTextEditorWrapper) ? a.send(:internal) : a}
+        @interface.send name, *args, &blk
+      end
+      
+    end
+    
+=begin rdoc
+Makes easier having the object emit a signal in corrispondence with
+signals emitted by the wrapped object. In particular, this method does the following
+(for each signal given in the arguments):
+* creates a signal for the object based on the name of the signal in the wrapped
+  object
+* creates a slot for the object with a name obtained from the name of the signal, which takes
+  the same arguments as the signal in the wrapped object and emits the associated
+  signal of the object. The arguments of the emitted signal are taken from those
+  passed to the slot, but they can be reordered. Also, *self* can be specified
+* returns a hash suitable to be passed as second argument to <tt>initialize_wrapper</tt>.
+Usually, this method is called when the class is created and the returned hash
+is stored in a class instance variable. The class's +initialize+ method then passes
+it as second argument to <tt>initialize_wrapper</tt>.
+
+_cls_ is the class for which signals and slots will be defined. _data_ is a hash
+containing the information for the signal and slot to create.
+* its keys are the names of the signals converted to snakecase. This name will be
+  converted to camelcase to obtain the name of the signal of the wrapped object,
+  while will be used as is for the signal of the object.
+* its values are arrays. The first element is the signature of the signal of the
+  wrapped object. The second element is an array of integers and *nil*s. An integer
+  _i_ in the position _n_ of the array means that the _n_th argument of the new
+  signal will be the _i_th argument of the signal of the wrapped object (both 
+  indexes start from 0). If the array contains *nil* in position _n_, the _n_th
+  argument of the new signal will be *self* (in the signature of the new signal,
+  this will mean <tt>QWidget*</tt> if _cls_ derives from <tt>Qt::Widget</tt> and
+  <tt>QObject*</tt> otherwise).
+=end
+    def self.prepare_wrapper_connections cls, data
+      res = {}
+      data.each_pair do |name, d|
+        old_args = d[0].split(/,\s*/)
+        new_args = d[1].map do |i| 
+          if i then old_args[i]
+          elsif cls.ancestors.include?(Qt::Widget) then 'QWidget*'
+          else 'QObject*'
+          end
+        end
+        new_args = new_args.join ', '
+        new_signal = "#{name}(#{new_args})"
+        old_signal = "#{name.camelcase :lower}(#{d[0]})"
+        slot_name = "__emit_#{name}_signal(#{d[0]})"
+        cls.send :signals, new_signal
+        cls.send :slots, slot_name
+        res[old_signal] = slot_name
+        method_def = <<-EOS
+def __emit_#{name}_signal(#{old_args.size.times.map{|i| "a#{i}"}.join ', '})
+  emit #{name}(#{d[1].map{|i| i ? "a#{i}" : 'self'}.join ', '})
+end
+        EOS
+        cls.class_eval method_def
+      end
+      res
+    end
+    
+=begin rdoc
+Returns an InterfaceProxy set to the interface _name_. See <tt>InterfaceProxy#interface=</tt>
+for the possible values for _name_. It is meant to be used this way (supposing
+_doc_ is an object which wraps <tt>KTextEditor::Document</tt>)
+  doc.interface(:modification_interface).modified_on_disk_warning = true
+=end
+    def interface name
+      @_interface.interface = name
+      @_interface
+    end
+    
+=begin rdoc
+Forwards the method call to the wrapped object
+=end
+    def method_missing name, *args, &blk
+      begin super
+      rescue NoMethodError, NameError, NotImplementedError
+        @_wrapped.send name, *args, &blk
+      end
+    end
+  
+    private
+    
+=begin rdoc
+Method which needs to be called before using any of the functionality provided by
+the module (usually, it's called from +initialize+). _obj_ is the wrapped object,
+while _signals_ is a hash as described in <tt>connect_wrapped_signals</tt>.
+
+It creates an InterfaceProxy for the wrapped object and calls <tt>connect_wrapped_signals</tt>
+passing _signals_ as argument.
+=end
+    def initialize_wrapper obj, signals
+      @_interface = InterfaceProxy.new obj
+      @_wrapped = obj
+      connect_wrapped_signals signals
+    end
+    
+=begin rdoc
+Returns the wrapped object (this method is mainly for internal use)
+=end
+    def internal
+      @_wrapped
+    end
+   
+=begin rdoc
+Makes a connections between a series of signals and of slots. _signals_ is a hash
+whose keys are the names of the signals and whose entries are the slots each signal
+should be connected to (only one slot can be connected to each signal). You can't
+connect a signal to another signal with this method.
+
+This method is mainly meant to be used in conjunction with <tt>prepare_wrapper_connections</tt>.
+=end
+    def connect_wrapped_signals signals
+      signals.each_pair do |k, v|
+        connect @_wrapped, SIGNAL(k), self, SLOT(v)
+      end
+    end
+    
+  end
+  
+end

data/lib/ruber/exception_widgets.rb

@@ -0,0 +1,245 @@
+=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
+
+module Ruber
+
+=begin rdoc
+Dialog which displays the content of an exception (that is, the message and the
+backtrace) to the user.
+
+The backtrace is shown as an extension widget, only if the user clicks the 'Backtrace'
+button.
+=end
+  class ExceptionDialog < KDE::Dialog
+ 
+=begin rdoc
+Subclass of @KDE::TextEdit@ specialized in displaying the backtrace of an
+exception.
+    
+The differences with a standard @KDE::TextEdit@ are:
+* automatically uses a fixed width font
+* doesn't use word wrapping
+* is always read-only
+* its {#size_hint} method computes (or at least tries to compute) width
+  and height so that each line of the backtrace fits on a single line.
+* automatically extracts the message and the backtrace from the exception
+=end
+    class ExceptionBacktraceWidget < KDE::TextEdit
+            
+=begin rdoc
+@param [Exception] ex the exception whose backtrace should be displayed
+@param [Qt::Widget, nil] parent the parent widget
+=end
+      def initialize ex, parent = nil
+        super parent
+        self.line_wrap_mode = NoWrap
+        self.read_only = true
+        #Replace < and > with the corresponding HTML entities in the message
+        msg = ex.message.gsub(/[<>]/){|s| s == '<' ? '&lt;' : '&gt;'}
+        #Replace < and > with the corresponding HTML entities in the backtrace
+        backtrace = ex.backtrace.map{|l| l.gsub(/[<>]/){|s| s == '<' ? '&lt;' : '&gt;'}}
+        text = "<tt>#{msg}<br/>#{backtrace.join '<br/>'}</tt>"
+        self.html = text
+      end
+      
+=begin rdoc
+Override of @KDE::TextEdit#sizeHint@
+
+The width is computed as the size (using the fixed width font) of the longest line,
+while the height is computed as the height of a single line multiplied by the
+number of lines.
+
+Both width and height are computed using @Qt::FontMetrics@
+
+@return [Qt::Size] the suggested size of the widget
+=end
+      def sizeHint
+        font = Qt::TextCursor.new(document).char_format.font
+        fm = Qt::FontMetrics.new font
+        lines = to_plain_text.split_lines
+        longest = lines.sort_by{|l| l.size}[-1]
+        Qt::Size.new fm.width(longest), fm.height * lines.size
+      end
+      
+    end
+    
+=begin rdoc
+@param [Exception] ex the exception the dialog is for
+@param [Qt::Widget,nil] the parent widget
+@param [Boolean] out whether to display the exception to standard error when the
+        dialog is executed
+@param [String] msg the text to display in the dialog before the exception message.
+        Note that this will always be treated as rich text. Unless empty,
+        a line break will always be inserted after it
+=end
+    def initialize ex, parent = nil, out = true, msg = 'Ruber raised the following exception:'
+      super parent
+      self.caption = KDE::Dialog.make_standard_caption "Exception"
+      self.buttons = Ok | Details
+      set_button_text Ok, 'Quit Ruber'
+      set_button_text Details, 'Backtrace'
+      error = ex.message.gsub(/\n/, '<br/>')
+      error.gsub!(/[<>]/){|s| s == '<' ? '&lt;' : '&gt;'}
+      text = (!msg.empty? ? msg + '<br/>' : '') + '<tt>' + error + '</tt>'
+      self.main_widget = Qt::Label.new text, self
+      @backtrace_widget = ExceptionBacktraceWidget.new ex, self
+      self.details_widget = @backtrace_widget
+      @out = out
+    end
+    
+=begin rdoc
+Override of @KDE::Dialog#sizeHint@
+
+It takes into account the size of the details widget, if shown.
+
+@return [Qt::Size] the suggested size for the dialog
+=end
+    def sizeHint
+      orig = super
+      if defined?(@backtrace_widget) and @backtrace_widget.visible?
+        main_width = main_widget.sizeHint.width
+        diff = orig.width - main_width
+        det_width = @backtrace_widget.sizeHint.width
+        w = [det_width, main_width].max + diff
+        Qt::Size.new(w, orig.height)
+      else orig
+      end
+    end
+    
+=begin rdoc
+Override of @KDE::Dialog#exec@ 
+
+If the _out_ parameter passed to the constructor was *true*, displays the exception
+message and backtrace on standard error before displaying the dialog
+@return [Integer] the exit code of the dialog
+=end
+    def exec
+      if @out
+        $stderr.puts @backtrace_widget.to_plain_text
+      end
+      super
+    end
+    
+=begin rdoc
+Override of @KDE::Dialog#show@
+
+If the _out_ parameter passed to the constructor was *true*, displays the exception
+message and backtrace on standard error before displaying the dialog
+@return [nil]
+=end
+    def show
+      if @out
+        $stderr.puts @backtrace_widget.to_plain_text
+      end
+      super
+    end
+    
+  end
+  
+=begin rdoc
+ExceptionDialog specialized to display failures when loading plugins and components.
+
+It differs from {ExceptionDialog} in the following aspects:
+* it provides different buttons
+* it provides a check box to decide whether or not to warn of subsequent errors while
+  loading plugins
+* its #{exec} method provides values suitable to be returned from a block passed to
+  {ComponentManager#load_plugins}
+* it provides an appropriate text
+
+The buttons on the dialog are: 
+
+- Go on::= ignore the failure and attempt to load the remaining plugins, hoping
+  everything goes well
+- Quit::= immediately quit Ruber
+- Skip remaining::= ignore the failure, but don't attempt to load any other plugin
+
+If the exception was raised while loading a core component, the dialog will behave
+exactly as an {ExceptionDialog} (since you can't start Ruber without one of the core
+components, the other buttons and the checkbox would be useless).
+=end
+  class ComponentLoadingErrorDialog < ExceptionDialog
+        
+=begin rdoc
+
+@param [Symbol,String] plugin the name of the component which caused the exception
+@param [Exception] ex the exception which was raised
+@param [Qt::Widget,nil] the parent widget
+@param [Boolean] core whether the component which caused the failure is a core
+        component or a plugin
+=end
+    def initialize plugin, ex, parent = nil, core = false
+      msg = "An error occurred while loading the #{core ? 'component' : 'plugin' } #{plugin}. The error was:"
+      super ex, parent, true, msg
+      unless core
+        label = main_widget
+        w = Qt::Widget.new self
+        self.main_widget = w
+        w.layout = Qt::VBoxLayout.new w
+        label.parent = w
+        w.layout.add_widget label
+        @silent = Qt::CheckBox.new "&Don't report other errors", w
+        w.layout.add_widget @silent
+        self.buttons = Yes|No|Cancel|Details
+        self.set_button_text KDE::Dialog::Yes, "&Go on"
+        self.set_button_text KDE::Dialog::No, "&Quit Ruber"
+        self.set_button_text KDE::Dialog::Cancel, "&Skip remaining plugins"
+        self.escape_button = KDE::Dialog::No
+      end
+    end
+
+=begin rdoc
+Whether or not the user checked to ignore subsequent errors
+
+@return [Boolean,nil] *true* if the user checked the "Don't report other errors" check
+                  box and *false* otherwise. If the dialog is shown for a core
+                  component, this method always returns *nil*
+=end
+    def silently?
+      @silent.checked? rescue nil
+    end
+    
+=begin rdoc
+Override of {ExceptionDialog#exec}
+    
+It returns a different value according to the button pressed by the user and to
+whether he checked the "Don't report other errors" checkbox. The returned values
+are suitable for use by a block passed to {ComponentManager#load_plugins}.
+
+@return [Boolean,Symbol] 
+
+- *true*:= if the user pressed the "Go on" button without checking the checkbox
+- @:silent@:= if the user pressed the "Go on" button and checked the checkbox
+- *false*:= if the user pressed the "Quit" button
+- @:skip@:= if the user pressed the "Skip" button
+=end
+    def exec
+      res = super
+      case res
+      when KDE::Dialog::Yes then dlg.silently? ? :silent : true
+      when KDE::Dialog::No then false
+      when KDE::Dialog::Cancel then :skip
+      else res
+      end
+    end
+    
+  end
+  
+end