Class: Ruber::OutputWidget::Model

Inherits:
Qt::StandardItemModel show all
Defined in:
lib/ruber/output_widget.rb,
lib/ruber/output_widget.rb,
lib/ruber/output_widget.rb,
lib/ruber/output_widget.rb

Overview

Convenience class to use instead of Qt::StandardItem as model for OutputWidget.

It provides three methods which make easier to insert items in the widget: insert, insert_lines and set. Besides, it allows to set the item flags globally, using the global_flags attribute.

Direct Known Subclasses

FindInFiles::ReplaceWidget::Model

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Methods inherited from Qt::StandardItemModel

#each, #each_row

Constructor Details

- (Model) initialize(widget, parent = nil)

Creates a new instance. widget is the output widget which will use the model. parent is the parent object



916
917
918
919
920
 
# File 'lib/ruber/output_widget.rb', line 916

def initialize widget, parent = nil
  super parent
  @output_widget = widget
  @global_flags = (Qt::ItemIsEnabled | Qt::ItemIsSelectable).to_i
end

Instance Attribute Details

- (Object) global_flags

The flags to use for all valid indexes (always converted to an integer). If this is nil, then flags will revert to Qt::StandardModel behaviour. The default value is Qt::ItemIsEnabled|Qt::ItemIsSelectable



910
911
912
 
# File 'lib/ruber/output_widget.rb', line 910

def global_flags
  @global_flags
end

Instance Method Details

- (Object) insert(text, type, row, opts = {})

Inserts a new row in the model and sets the output type of its elements.

opts can contain two keys: :parent:: the Qt::StandardItem the new row should be child of. If not given, the new row will be a top-level row :col:: the column where to put the text (default: 0). It has effect only if text is a string (see below)

text represents the contents of the new row and can be either a string or an array containing strings and nils.

If text is an array, each entry of the array will become a column in the new row. with a text, while nil entries will produce empty items (that is items without text. Calling item.text on these items will give nil. The associated indexes, however, are valid).

If text is a string, the resulting row will have all the elements from column 0 to the one before the :col entry set to empty element (as described above). The column :col has text text. Of course, if :col is 0 (or is missing) no empty items are created.

type is the output type to give to the items in the new row. It can be either a symbol or an array of symbols. If it is a symbol, it will be the output type of all elements in the new row. If it is an array, each entry will be the type of the corresponding non-empty item (that is of the item in text which has the same index after removing all nil elements from text). If type is longer than the text array, the entries in excess are ignored (if text is a string, it behaves as an array of size 1 in this regard). If type is shorter than the text array, the entries in excess won’t have their output type set.

row is the index where the new row should be put. If nil, the new row will be appended to the model.

If row or :col are negative, they’re counted from the end. That is, the actual row index if row is negative is row_count+row. The same happens with :col.

If row is greater than row_count (or negative and its absolute value is greater than row_count), IndexError is raised. This is because Qt::StandardItemModel doesn’t allow for a row to be inserted after the last one. This doesn’t happen for the columns, which are added automatically.

This method returns an array containing all the non-empty items of the new row.



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
 
# File 'lib/ruber/output_widget.rb', line 1023

def insert text, type, row, opts = {}
  parent = opts[:parent] || self
  rc = parent.row_count
  row ||= rc
  row =  rc + row if row < 0
  col = opts[:col] || 0
  cc = parent.column_count
  col = cc + col if col < 0
  if row < 0 or row > rc 
    raise IndexError, "Row index #{row} is out of range. The allowed values are from 0 to #{rc}"
  end
  text = Array.new(col) << text unless text.is_a? Array
  items = text.map do |i| 
    it = i ? Qt::StandardItem.new(i) : Qt::StandardItem.new
    it.flags = @global_flags if @global_flags
    it
  end
  parent.insert_row row, items
  items.delete_if{|i| i.text.nil?}
  type = Array.new(items.size, type) unless type.is_a? Array
  items.each_with_index do |it, i|
    @output_widget.set_output_type it.index, type[i]
  end
  items
end

- (Object) insert_lines(text, type, row, opts = {})

Similar to insert, but inserts each line of text in a different item, one below the other, starting at the position given by the row and opts argument.

row and opts have the same meaning as in insert.

text can be either a string or an array of strings. If it is a string, it will be split into lines, while if it is an array, each entry of the array will be considered a single line (even if it contains newlines). In both cases, a single string is passed to insert for each line.

type is the output type to assign to each item and should be a symbol. The same type is used for all lines.



1063
1064
1065
1066
1067
1068
1069
 
# File 'lib/ruber/output_widget.rb', line 1063

def insert_lines text, type, row, opts = {}
  lines = text.is_a?(Array) ? text : text.split("\n")
  lines.each do |l|
    insert l, type, row, opts
    row += 1 if row
  end
end

- (Object) set(text, type, row, opts = {})

Changes content of the given element.

It creates a new Qt::StandardItem containing the text text, inserts it in the model, sets the output type of the corresponding index to type and changes its flags to make it enabled and selectabled.

row is an integer corresponding to the row where the item should be put. If opts contains the :col entry, it represents the colun of the new item (if this option is missing, the column is 0). If opts contains the :parent entry, it is the parent item (not index) of the new one. If row and/or the :col entry are negative, they’re counted from backwards.

Note that, if an item with the given row, column and parent already exist, it is replaced by the new item.

Returns the new item.



965
966
967
968
969
970
971
972
973
974
975
976
977
 
# File 'lib/ruber/output_widget.rb', line 965

def set text, type, row, opts = {}
  col = opts[:col] || 0
  parent = opts[:parent]
  it = Qt::StandardItem.new(text)
  it.flags = @global_flags if @global_flags
  row = (parent || self).row_count + row if row < 0
  col = (parent || self).column_count + col if col < 0
  if parent then parent.set_child row, col, it
  else set_item row, col, it
  end
  @output_widget.set_output_type it.index, type
  it
end