class Tk::Text

Constants

SEARCH_MUTEX

Public Class Methods

new(parent = Tk.root, options = None) click to toggle source
Calls superclass method Tk::Widget::new
# File lib/ffi-tk/widget/text.rb, line 14
def initialize(parent = Tk.root, options = None)
  @tag_commands = {}
  super
end
tk_command() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 6
def self.tk_command
  'text'
end

Public Instance Methods

bbox(index) click to toggle source

Returns a list of four elements describing the screen area of the character given by index. The first two elements of the list give the x and y coordinates of the upper-left corner of the area occupied by the character, and the last two elements give the width and height of the area. If the character is only partially visible on the screen, then the return value reflects just the visible part. If the character is not visible on the screen then the return value is an empty list.

# File lib/ffi-tk/widget/text.rb, line 41
def bbox(index)
  execute('bbox', index)
end
clear() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 28
def clear
  delete '0.0', :end
end
compare(index1, op, index2) click to toggle source

Compares the indices given by index1 and index2 according to the relational operator given by op, and returns 1 if the relationship is satisfied and 0 if it is not. Op must be one of the operators <, <=, ==, >=, >, or !=. If op is == then true is returned if the two indices refer to the same character, if op is < then true is returned if index1 refers to an earlier character in the text than index2, and so on.

# File lib/ffi-tk/widget/text.rb, line 52
def compare(index1, op, index2)
  execute('compare', index1, op, index2).to_boolean
end
copy() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 890
def copy
  Tk.execute(:tk_textCopy, self)
end
count(index1, index2, *options) click to toggle source

Counts the number of relevant things between the two indices. If index1 is after index2, the result will be a negative number (and this holds for each of the possible options). The actual items which are counted depend on the options given. The result is a list of integers, one for the result of each counting option given.

Valid counting options are :chars, :displaychars, :displayindices, :displaylines, :indices, :lines, :xpixels and :ypixels. The default value, if no option is specified, is :indices. There is an additional possible option :update which is a modifier. If given, then all subsequent options ensure that any possible out of date information is recalculated. This currently only has any effect for the :ypixels count (which, if :update is not given, will use the text widget's current cached value for each line). The count options are interpreted as follows:

:chars

count all characters, whether elided or not. Do not count embedded
windows or images.

:displaychars

count all non-elided characters.

:displayindices

count all non-elided characters, windows and images.

:displaylines

count all display lines (i.e. counting one for each time a line wraps)
from the line of the first index up to, but not including the display
line of the second index. Therefore if they are both on the same display
line, zero will be returned. By definition displaylines are visible and
therefore this only counts portions of actual visible lines.

:indices

count all characters and embedded windows or images (i.e. everything
which counts in text-widget index space), whether they are elided or
not.

:lines

count all logical lines (irrespective of wrapping) from the line of the
first index up to, but not including the line of the second index.
Therefore if they are both on the same line, zero will be returned.
Logical lines are counted whether they are currently visible
(non-elided) or not.

:xpixels

count the number of horizontal pixels from the first pixel of the first
index to (but not including) the first pixel of the second index. To
count the total desired width of the text widget (assuming wrapping is
not enabled), first find the longest line and then use
`text.count("#{line}.0", "#{line}.0", :xpixels)`.

:ypixels

count the number of vertical pixels from the first pixel of the first
index to (but not including) the first pixel of the second index. If
both indices are on the same display line, zero will be returned. To
count the total number of vertical pixels in the text widget, use
`text.count('1.0', 'end', :ypixels)`, and to ensure this is up to date,
use `text.count('1.0', 'end', :update, :ypixels)`.

The command returns a positive or negative integer corresponding to the number of items counted between the two indices. One such integer is returned for each counting option given, so a list is returned if more than one option was supplied. For example `text.count('1.3', '4.5', :xpixels, :ypixels` is perfectly valid and will return a list of two elements.

# File lib/ffi-tk/widget/text.rb, line 116
def count(index1, index2, *options)
  args = options.map(&:to_tcl_option)
  execute('count', *args, index1, index2)
end
cut() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 894
def cut
  Tk.execute(:tk_textCut, self)
end
debug(boolean = None) click to toggle source

If boolean is specified, then it must have one of the true or false values accepted by Tcl_GetBoolean. If the value is a true one then internal consistency checks will be turned on in the B-tree code associated with text widgets. If boolean has a false value then the debugging checks will be turned off. In either case the command returns an empty string. If boolean is not specified then the command returns on or off to indicate whether or not debugging is turned on. There is a single debugging switch shared by all text widgets: turning debugging on or off in any widget turns it on or off for all widgets. For widgets with large amounts of text, the consistency checks may cause a noticeable slow-down. When debugging is turned on, the drawing routines of the text widget set the global variables tk_textRedraw and tk_textRelayout to the lists of indices that are redrawn. The values of these variables are tested by Tk's test suite.

# File lib/ffi-tk/widget/text.rb, line 137
def debug(boolean = None)
  if boolean == None
    execute('debug') == 1
  else
    execute_only('debug', boolean ? true : false)
  end
end
debug?() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 145
def debug?
  execute('debug') == 1
end
delete(index1, *rest) click to toggle source

Delete a range of characters from the text. If both index1 and index2 are specified, then delete all the characters starting with the one given by index1 and stopping just before index2 (i.e. the character at index2 is not deleted). If index2 does not specify a position later in the text than index1 then no characters are deleted. If index2 is not specified then the single character at index1 is deleted. It is not allowable to delete characters in a way that would leave the text without a newline as the last character. The command returns an empty string. If more indices are given, multiple ranges of text will be deleted. All indices are first checked for validity before any deletions are made. They are sorted and the text is removed from the last range to the first range to deleted text does not cause an undesired index shifting side-effects. If multiple ranges with the same start index are given, then the longest range is used. If overlapping ranges are given, then they will be merged into spans that do not cause deletion of text outside the given ranges due to text shifted during deletion.

# File lib/ffi-tk/widget/text.rb, line 169
def delete(index1, *rest)
  execute('delete', index1, *rest)
end
dlineinfo(index) click to toggle source

Returns a list with five elements describing the area occupied by the display line containing index. The first two elements of the list give the x and y coordinates of the upper-left corner of the area occupied by the line, the third and fourth elements give the width and height of the area, and the fifth element gives the position of the baseline for the line, measured down from the top of the area. All of this information is measured in pixels. If the current wrap mode is none and the line extends beyond the boundaries of the window, the area returned reflects the entire area of the line, including the portions that are out of the window. If the line is shorter than the full width of the window then the area returned reflects just the portion of the line that is occupied by characters and embedded windows. If the display line containing index is not visible on the screen then the return value is an empty list.

# File lib/ffi-tk/widget/text.rb, line 189
def dlineinfo(index)
  info = execute('dlineinfo', index).to_a
  info.empty? ? nil : info.map(&:to_i)
end
dump(*arguments, given_index) click to toggle source

Return the contents of the text widget from index1 up to, but not including index2, including the text and information about marks, tags, and embedded windows. If index2 is not specified, then it defaults to one character past index1. The information is returned in the following format:

pathName dump ?switches? index1 ?index2?

# File lib/ffi-tk/widget/text.rb, line 201
def dump(*arguments, given_index)
  arguments = arguments.dup
  invocation = []
  indices = [given_index]

  loop do
    arg = arguments.shift
    break unless arg

    if arg.respond_to?(:to_tcl_option)
      case tcl_option = arg.to_tcl_option
      when '-command'
        command = arguments.shift
        invocation << ['-command', command]
      when /^-(?:all|image|mark|tag|text|window)$/
        invocation << tcl_option
      else
        indices.unshift(arg)
      end
    else
      indices.unshift(arg)
    end
  end

  execute('dump', *invocation, *indices).to_a.each_slice(3).to_a
end
edit_modified(boolean = None) click to toggle source

If boolean is not specified, returns the modified flag of the widget. The insert, delete, edit undo and edit redo commands or the user can set or clear the modified flag. If boolean is specified, sets the modified flag of the widget to boolean.

# File lib/ffi-tk/widget/text.rb, line 232
def edit_modified(boolean = None)
  if boolean == None
    execute('edit', 'modified')
  else
    execute_only('edit', 'modified', boolean ? true : false)
  end
end
edit_modified?() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 240
def edit_modified?
  execute('edit', 'modified').to_boolean
end
edit_redo() click to toggle source

When the -undo option is true, reapplies the last undone edits provided no other edits were done since then. Generates an error when the redo stack is empty. Does nothing when the -undo option is false.

# File lib/ffi-tk/widget/text.rb, line 248
def edit_redo
  execute_only('edit', 'redo')
end
edit_reset() click to toggle source

Clears the undo and redo stacks.

# File lib/ffi-tk/widget/text.rb, line 253
def edit_reset
  execute_only('edit', 'reset')
end
edit_separator() click to toggle source

Inserts a separator (boundary) on the undo stack. Does nothing when the -undo option is false.

# File lib/ffi-tk/widget/text.rb, line 259
def edit_separator
  execute_only('edit', 'separator')
end
edit_undo() click to toggle source

Undoes the last edit action when the -undo option is true. An edit action is defined as all the insert and delete commands that are recorded on the undo stack in between two separators. Generates an error when the undo stack is empty. Does nothing when the -undo option is false.

# File lib/ffi-tk/widget/text.rb, line 268
def edit_undo
  execute_only('edit', 'undo')
end
get(index, *indices) click to toggle source

Return a range of characters from the text.

The return value will be all the characters in the text starting with the one whose index is index1 and ending just before the one whose index is index2 (the character at index2 will not be returned).

If index2 is omitted then the single character at index1 is returned. If there are no characters in the specified range (e.g. index1 is past the end of the file or index2 is less than or equal to index1) then an empty string is returned.

If the specified range contains embedded windows, no information about them is included in the returned string. If multiple index pairs are given, multiple ranges of text will be returned in a list. Invalid ranges will not be represented with empty strings in the list. The ranges are returned in the order passed to [get].

@see get_displaychars

# File lib/ffi-tk/widget/text.rb, line 291
def get(index, *indices)
  execute('get', index, *indices).to_s
end
get_displaychars(index, *indices) click to toggle source

Same as [get], but within each range, only those characters which are not elided will be returned. This may have the effect that some of the returned ranges are empty strings.

# File lib/ffi-tk/widget/text.rb, line 299
def get_displaychars(index, *indices)
  execute('get', '-displaychars', index, *indices).to_s
end
image_cget(index, option) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 303
def image_cget(index, option)
  option = tcl_option(option)
  Cget.option_to_ruby(option, execute('image', 'cget', index))
end
image_configure(index, options = None) click to toggle source

Query or modify the configuration options for an embedded image. If no option is specified, returns a list describing all of the available options for the embedded image at index (see Tk_ConfigureInfo for information on the format of this list). If option is specified with no value, then the command returns a list describing the one named option (this list will be identical to the corresponding sublist of the value returned if no option is specified). If one or more option-value pairs are specified, then the command modifies the given option(s) to have the given value(s); in this case the command returns an empty string. See EMBEDDED IMAGES for information on the options that are supported.

# File lib/ffi-tk/widget/text.rb, line 319
def image_configure(index, options = None)
  common_configure([:image, :configure, index], options)
end
image_create(index, options = {}) click to toggle source

This command creates a new image annotation, which will appear in the text at the position given by index. Any number of option-value pairs may be specified to configure the annotation. Returns a unique identifier that may be used as an index to refer to this image. See EMBEDDED IMAGES for information on the options that are supported, and a description of the identifier returned.

# File lib/ffi-tk/widget/text.rb, line 331
def image_create(index, options = {})
  execute('image', 'create', index, options.to_tcl_options)
end
image_names() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 335
def image_names
  execute('image', 'names')
end
index(index) click to toggle source

Returns the position corresponding to index in the form line.char where line is the line number and char is the character number. Index may have any of the forms described under INDICES above.

# File lib/ffi-tk/widget/text.rb, line 342
def index(index)
  execute('index', index).to_s
end
insert(index, string, taglist = nil, *rest) click to toggle source

Inserts all of the chars arguments just before the character at index.

If index refers to the end of the text (the character after the last newline) then the new text is inserted just before the last newline instead. If there is a single chars argument and no tagList, then the new text will receive any tags that are present on both the character before and the character after the insertion point; if a tag is present on only one of these characters then it will not be applied to the new text. If tagList is specified then it consists of a list of tag names; the new characters will receive all of the tags in this list and no others, regardless of the tags present around the insertion point. If multiple chars-tagList argument pairs are present, they produce the same effect as if a separate pathName insert widget command had been issued for each pair, in order. The last tagList argument may be omitted.

# File lib/ffi-tk/widget/text.rb, line 362
def insert(index, string, taglist = nil, *rest)
  execute_only('insert', index, *[string, taglist, *rest].compact)
end
mark_gravity(name, direction = None) click to toggle source

If direction is not specified, returns left or right to indicate which of its adjacent characters markName is attached to. If direction is specified, it must be left or right; the gravity of markName is set to the given value.

# File lib/ffi-tk/widget/text.rb, line 370
def mark_gravity(name, direction = None)
  if direction == None
    execute('mark', 'gravity', name)&.to_sym
  else
    execute_only('mark', 'gravity', name, direction)
  end
end
mark_names() click to toggle source

Returns a list whose elements are the names of all the marks that are currently set.

# File lib/ffi-tk/widget/text.rb, line 380
def mark_names
  execute('mark', 'names').to_a.map(&:to_sym)
end
mark_next(index) click to toggle source

Returns the name of the next mark at or after index. If index is specified in numerical form, then the search for the next mark begins at that index. If index is the name of a mark, then the search for the next mark begins immediately after that mark. This can still return a mark at the same position if there are multiple marks at the same index. These semantics mean that the mark next operation can be used to step through all the marks in a text widget in the same order as the mark information returned by the pathName dump operation. If a mark has been set to the special end index, then it appears to be after end with respect to the pathName mark next operation. nil is returned if there are no marks after index.

# File lib/ffi-tk/widget/text.rb, line 397
def mark_next(index)
  execute('mark', 'next', index)&.to_sym
end
mark_previous(index) click to toggle source

Returns the name of the mark at or before index. If index is specified in numerical form, then the search for the previous mark begins with the character just before that index. If index is the name of a mark, then the search for the next mark begins immediately before that mark. This can still return a mark at the same position if there are multiple marks at the same index. These semantics mean that the pathName mark previous operation can be used to step through all the marks in a text widget in the reverse order as the mark information returned by the pathName dump operation. nil is returned if there are no marks before index.

# File lib/ffi-tk/widget/text.rb, line 412
def mark_previous(index)
  execute('mark', 'previous', index)&.to_sym
end
mark_set(name, index) click to toggle source

Sets the mark named markName to a position just before the character at index. If markName already exists, it is moved from its old position; if it does not exist, a new mark is created.

# File lib/ffi-tk/widget/text.rb, line 420
def mark_set(name, index)
  execute_only('mark', 'set', name, index)
end
mark_unset(*names) click to toggle source

Remove the mark corresponding to each of the markName arguments. The removed marks will not be usable in indices and will not be returned by future calls to [mark_names].

# File lib/ffi-tk/widget/text.rb, line 427
def mark_unset(*names)
  execute_only('mark', 'unset', *names)
end
paste() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 898
def paste
  Tk.execute(:tk_textPaste, self)
end
peer_create(options = {}) click to toggle source

Creates a peer text widget, and any optional standard configuration options (as for the text command). By default the peer will have the same start and end line as the parent widget, but these can be overridden with the standard configuration options.

# File lib/ffi-tk/widget/text.rb, line 436
def peer_create(options = {})
  Peer.new(self, options)
end
peer_names() click to toggle source

Returns a list of peers of this widget (this does not include the widget itself). The order within this list is undefined.

# File lib/ffi-tk/widget/text.rb, line 442
def peer_names
  execute('peer', 'names').to_a.map(&:to_s)
end
replace(index1, index2, chars, *taglists_and_chars) click to toggle source

Replaces the range of characters between index1 and index2 with the given characters and tags. See the section on [insert] for an explanation of the handling of taglist arguments, and the docs of [delete] for an explanation of the handling of the indices. If index2 corresponds to an index earlier in the text than index1, an error will be generated. The deletion and insertion are arranged so that no unnecessary scrolling of the window or movement of insertion cursor occurs. In addition the undo/redo stack are correctly modified, if undo operations are active in the text widget. The command returns nil.

# File lib/ffi-tk/widget/text.rb, line 458
def replace(index1, index2, chars, *taglists_and_chars)
  execute_only(:replace, index1, index2, chars, *taglists_and_chars)
end
rsearch(pattern, from, to, *switches) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 633
def rsearch(pattern, from, to, *switches)
  search(pattern, from, to, *switches, :backwards)
end
scan_dargto(x, y) click to toggle source

This command computes the difference between its x and y arguments and the x and y arguments to the last pathName scan mark command for the widget. It then adjusts the view by 10 times the difference in coordinates. This command is typically associated with mouse motion events in the widget, to produce the effect of dragging the text at high speed through the window. The return value is nil.

# File lib/ffi-tk/widget/text.rb, line 478
def scan_dargto(x, y)
  execute_only(:scan, :dragto, x, y)
end
scan_mark(x, y) click to toggle source

Records x and y and the current view in the text window, for use in conjunction with later pathName scan dragto commands. Typically this command is associated with a mouse button press in the widget. It returns nil.

# File lib/ffi-tk/widget/text.rb, line 467
def scan_mark(x, y)
  execute_only(:scan, :mark, x, y)
end
see(index) click to toggle source

Adjusts the view in the window so that the character given by index is completely visible. If index is already visible then the command does nothing. If index is a short distance out of view, the command adjusts the view just enough to make index visible at the edge of the window. If index is far out of view, then the command centers index in the window.

# File lib/ffi-tk/widget/text.rb, line 644
def see(index)
  execute_only(:see, index)
end
tag_add(tag_name, index1, index2 = None, *indices) click to toggle source

Associate the tag tagName with all of the characters starting with index1 and ending just before index2 (the character at index2 is not tagged). A single command may contain any number of index1-index2 pairs. If the last index2 is omitted then the single character at index1 is tagged. If there are no characters in the specified range (e.g. index1 is past the end of the file or index2 is less than or equal to index1) then the command has no effect.

# File lib/ffi-tk/widget/text.rb, line 655
def tag_add(tag_name, index1, index2 = None, *indices)
  execute_only(:tag, :add, tag_name, index1, index2, *indices)
end
tag_bind(tag_name, sequence = None, &script) click to toggle source

This command associates script with the tag given by tagName. Whenever the event sequence given by sequence occurs for a character that has been tagged with tagName, the script will be invoked. This widget command is similar to the bind command except that it operates on characters in a text rather than entire widgets. See the bind manual entry for complete details on the syntax of sequence and the substitutions performed on script before invoking it. If all arguments are specified then a new binding is created, replacing any existing binding for the same sequence and tagName (if the first character of script is “+” then script augments an existing binding rather than replacing it). In this case the return value is an empty string. If script is omitted then the command returns the script associated with tagName and sequence (an error occurs if there is no such binding). If both script and sequence are omitted then the command returns a list of all the sequences for which bindings have been defined for tagName. The only events for which bindings may be specified are those related to the mouse and keyboard (such as Enter, Leave, ButtonPress, Motion, and KeyPress) or virtual events. Event bindings for a text widget use the current mark described under MARKS above. An Enter event triggers for a tag when the tag first becomes present on the current character, and a Leave event triggers for a tag when it ceases to be present on the current character. Enter and Leave events can happen either because the current mark moved or because the character at that position changed. Note that these events are different than Enter and Leave events for windows. Mouse and keyboard events are directed to the current character. If a virtual event is used in a binding, that binding can trigger only if the virtual event is defined by an underlying mouse-related or keyboard-related event. It is possible for the current character to have multiple tags, and for each of them to have a binding for a particular event sequence. When this occurs, one binding is invoked for each tag, in order from lowest-priority to highest priority. If there are multiple matching bindings for a single tag, then the most specific binding is chosen (see the manual entry for the bind command for details). continue and break commands within binding scripts are processed in the same way as for bindings created with the bind command. If bindings are created for the widget as a whole using the bind command, then those bindings will supplement the tag bindings. The tag bindings will be invoked first, followed by bindings for the window as a whole.

# File lib/ffi-tk/widget/text.rb, line 703
def tag_bind(tag_name, sequence = None, &script)
  if !script && None == sequence
    return Tk.execute(:tag, :bind, tag_name)
  elsif !script
    return Tk.execute(:tag, :bind, tag_name, sequence)
  end

  # create name for command
  name = "#{tk_pathname}_#{tag_name}".scan(/\w+/).join('_')
  @events ||= {}
  unregister_event(name)

  Event::Handler.register_custom(script) do |id|
    code = "%s tag bind %s %s { ::RubyFFI::event %d '' %s }"
    props = Event::Data::PROPERTIES.transpose[0].join(' ')
    tcl = code % [tk_pathname, tag_name, sequence, id, props]
    Tk.interp.eval(tcl)
    @events[name] = id
  end
end
tag_cget(tag_name, option) click to toggle source

This command returns the current value of the option named option associated with the tag given by tagName. Option may have any of the values accepted by the pathName tag configure widget command.

# File lib/ffi-tk/widget/text.rb, line 734
def tag_cget(tag_name, option)
  value = execute(:tag, :cget, tag_name, option.to_tcl_option)
  Cget.option_to_ruby(option, value)
end
tag_configure(tag_name, options = None) click to toggle source

This command is similar to the pathName configure widget command except that it modifies options associated with the tag given by tagName instead of modifying options for the overall text widget. If no option is specified, the command returns a list describing all of the available options for tagName (see Tk_ConfigureInfo for information on the format of this list). If option is specified with no value, then the command returns a list describing the one named option (this list will be identical to the corresponding sublist of the value returned if no option is specified). If one or more option-value pairs are specified, then the command modifies the given option(s) to have the given value(s) in tagName; in this case the command returns an empty string. See TAGS above for details on the options available for tags.

# File lib/ffi-tk/widget/text.rb, line 752
def tag_configure(tag_name, options = None)
  common_configure([:tag, :configure, tag_name], options)
end
tag_delete(tag_name, *tag_names) click to toggle source

Deletes all tag information for each of the tagName arguments. The command removes the tags from all characters in the file and also deletes any other information associated with the tags, such as bindings and display information. The command returns an empty string.

# File lib/ffi-tk/widget/text.rb, line 761
def tag_delete(tag_name, *tag_names)
  execute_only(:tag, :delete, tag_name, *tag_names)
end
tag_lower(tag_name, below = None) click to toggle source

Changes the priority of tag tagName so that it is just lower in priority than the tag whose name is belowThis. If belowThis is omitted, then tagName's priority is changed to make it lowest priority of all tags.

# File lib/ffi-tk/widget/text.rb, line 769
def tag_lower(tag_name, below = None)
  execute_only(:tag, :lower, tag_name, below)
end
tag_names(index = None) click to toggle source

Returns a list whose elements are the names of all the tags that are active at the character position given by index. If index is omitted, then the return value will describe all of the tags that exist for the text (this includes all tags that have been named in a “pathName tag” widget command but have not been deleted by a “pathName tag delete” widget command, even if no characters are currently marked with the tag). The list will be sorted in order from lowest priority to highest priority.

# File lib/ffi-tk/widget/text.rb, line 782
def tag_names(index = None)
  execute(:tag, :names, index).to_a
end
tag_nextrange(tag_name, index1, index2 = None) click to toggle source

This command searches the text for a range of characters tagged with tagName where the first character of the range is no earlier than the character at index1 and no later than the character just before index2 (a range starting at index2 will not be considered). If several matching ranges exist, the first one is chosen. The command's return value is a list containing two elements, which are the index of the first character of the range and the index of the character just after the last one in the range. If no matching range is found then the return value is an empty string. If index2 is not given then it defaults to the end of the text.

# File lib/ffi-tk/widget/text.rb, line 796
def tag_nextrange(tag_name, index1, index2 = None)
  execute(:tag, :nextrange, tag_name, index1, index2).to_a
end
tag_prevrange(tag_name, index1, index2 = None) click to toggle source

This command searches the text for a range of characters tagged with tagName where the first character of the range is before the character at index1 and no earlier than the character at index2 (a range starting at index2 will be considered). If several matching ranges exist, the one closest to index1 is chosen. The command's return value is a list containing two elements, which are the index of the first character of the range and the index of the character just after the last one in the range. If no matching range is found then the return value is an empty string. If index2 is not given then it defaults to the beginning of the text.

# File lib/ffi-tk/widget/text.rb, line 810
def tag_prevrange(tag_name, index1, index2 = None)
  execute(:tag, :prevrange, tag_name, index1, index2).to_a
end
tag_raise(tag_name, above = None) click to toggle source

Changes the priority of tag tagName so that it is just higher in priority than the tag whose name is aboveThis. If aboveThis is omitted, then tagName's priority is changed to make it highest priority of all tags.

# File lib/ffi-tk/widget/text.rb, line 818
def tag_raise(tag_name, above = None)
  execute_only(:tag, :raise, tag_name, above)
end
tag_ranges(tag_name) click to toggle source

Returns a list describing all of the ranges of text that have been tagged with tagName. The first two elements of the list describe the first tagged range in the text, the next two elements describe the second range, and so on. The first element of each pair contains the index of the first character of the range, and the second element of the pair contains the index of the character just after the last one in the range. If there are no characters tagged with tag then an empty string is returned.

# File lib/ffi-tk/widget/text.rb, line 831
def tag_ranges(tag_name)
  [*execute(:tag, :ranges, tag_name)].each_slice(2).to_a
end
tag_remove(tag_name, index1, index2 = None, *indices) click to toggle source

Remove the tag tagName from all of the characters starting at index1 and ending just before index2 (the character at index2 is not affected). A single command may contain any number of index1-index2 pairs. If the last index2 is omitted then the tag is removed from the single character at index1. If there are no characters in the specified range (e.g. index1 is past the end of the file or index2 is less than or equal to index1) then the command has no effect. This command returns an empty string.

# File lib/ffi-tk/widget/text.rb, line 844
def tag_remove(tag_name, index1, index2 = None, *indices)
  execute_only(:tag, :remove, tag_name, index1, index2, *indices)
end
tk_next_line_pos(count) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 918
def tk_next_line_pos(count)
  Tk.execute('tk::TextUpDownLine', self, count).to_s
end
tk_next_page_pos(count) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 926
def tk_next_page_pos(count)
  Tk.execute('tk::TextScrollPages', self, count).to_s
end
tk_next_word_pos(start) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 906
def tk_next_word_pos(start)
  Tk.execute('tk::TextNextPos', self, start, 'tcl_startOfNextWord').to_s
end
tk_next_word_pos_end(start) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 910
def tk_next_word_pos_end(start)
  Tk.execute('tk::TextNextWord', self, start).to_s
end
tk_prev_line_pos(count) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 914
def tk_prev_line_pos(count)
  Tk.execute('tk::TextUpDownLine', self, -count.abs).to_s
end
tk_prev_page_pos(count) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 922
def tk_prev_page_pos(count)
  Tk.execute('tk::TextScrollPages', self, -count.abs).to_s
end
tk_prev_word_pos(start) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 902
def tk_prev_word_pos(start)
  Tk.execute('tk::TextPrevPos', self, start, 'tcl_startOfPreviousWord').to_s
end
unregister_event(name, id = @events[name]) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 724
def unregister_event(name, id = @events[name])
  return unless id
  @events.delete(id)
  Event::Handler.unregister(id)
end
value() click to toggle source
# File lib/ffi-tk/widget/text.rb, line 19
def value
  get '1.0', :end
end
value=(string) click to toggle source
# File lib/ffi-tk/widget/text.rb, line 23
def value=(string)
  clear
  insert :end, string
end
window_cget(index, option) click to toggle source

Returns the value of a configuration option for an embedded window. Index identifies the embedded window, and option specifies a particular configuration option, which must be one of the ones listed in the section EMBEDDED WINDOWS.

# File lib/ffi-tk/widget/text.rb, line 852
def window_cget(index, option)
  execute(:window, :cget, index, option.to_tcl_option)
end
window_configure(index, options = None) click to toggle source

Query or modify the configuration options for an embedded window. If no option is specified, returns a list describing all of the available options for the embedded window at index (see Tk_ConfigureInfo for information on the format of this list). If option is specified with no value, then the command returns a list describing the one named option (this list will be identical to the corresponding sublist of the value returned if no option is specified). If one or more option-value pairs are specified, then the command modifies the given option(s) to have the given value(s); in this case the command returns an empty string. See EMBEDDED WINDOWS for information on the options that are supported.

# File lib/ffi-tk/widget/text.rb, line 867
def window_configure(index, options = None)
  common_configure([:window, :configure, index], options)
end
window_create(index, options = None) click to toggle source

This command creates a new window annotation, which will appear in the text at the position given by index. Any number of option-value pairs may be specified to configure the annotation. See EMBEDDED WINDOWS for information on the options that are supported. Returns an empty string.

# File lib/ffi-tk/widget/text.rb, line 876
def window_create(index, options = None)
  if None == argument
    execute(:window, :create, index)
  else
    execute(:window, :create, index, options.to_tcl_options)
  end
end
window_names() click to toggle source

Returns a list whose elements are the names of all windows currently embedded in window.

# File lib/ffi-tk/widget/text.rb, line 886
def window_names
  execute(:window, :names).to_a
end