Module: Ruber::KTextEditorWrapper

Included in:
Document, EditorView
Defined in:
lib/ruber/editor/ktexteditor_wrapper.rb

Overview

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 wrapped object.

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.

Defined Under Namespace

Classes: InterfaceProxy

Class Method Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &blk) ⇒ Object

Forwards the method call to the wrapped object



156
157
158
159
160
161
 
# File 'lib/ruber/editor/ktexteditor_wrapper.rb', line 156

def method_missing name, *args, &blk
  begin super
  rescue NoMethodError, NameError, NotImplementedError
    @_wrapped.send name, *args, &blk
  end
end

Class Method Details

.prepare_wrapper_connections(cls, data) ⇒ Object

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 initialize_wrapper.

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 initialize_wrapper.

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 QWidget* if cls derives from Qt::Widget and QObject* otherwise).



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/ruber/editor/ktexteditor_wrapper.rb', line 115

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

Instance Method Details

#interface(name) ⇒ Object

Returns an InterfaceProxy set to the interface name. See InterfaceProxy#interface= for the possible values for name. It is meant to be used this way (supposing doc is an object which wraps KTextEditor::Document)

doc.interface(:modification_interface).modified_on_disk_warning = true



148
149
150
151
 
# File 'lib/ruber/editor/ktexteditor_wrapper.rb', line 148

def interface name
  @_interface.interface = name
  @_interface
end