ffi-tk 2009.11.29

data/lib/ffi-tk/widget/menubutton.rb

@@ -0,0 +1,7 @@
+module Tk
+  class MenuButton < Button
+    include Cget, Configure
+
+    def self.tk_command; 'menubutton'; end
+  end
+end

data/lib/ffi-tk/widget/message.rb

@@ -0,0 +1,36 @@
+module Tk
+  # Create and manipulate message widgets
+  #
+  # A message is a widget that displays a textual string.
+  #
+  # A message widget has three special features.
+  #
+  # First, it breaks up its string into lines in order to produce a given aspect
+  # ratio for the window.
+  # The line breaks are chosen at word boundaries wherever possible (if not even
+  # a single word would fit on a line, then the word will be split across
+  # lines). Newline characters in the string will force line breaks; they can be
+  # used, for example, to leave blank lines in the display.
+  #
+  # The second feature of a message widget is justification.
+  # The text may be displayed left-justified (each line starts at the left side
+  # of the window), centered on a line-by-line basis, or right-justified (each
+  # line ends at the right side of the window).
+  #
+  # The third feature of a message widget is that it handles control characters
+  # and non-printing characters specially.
+  # Tab characters are replaced with enough blank space to line up on the next
+  # 8-character boundary.
+  # Newlines cause line breaks.
+  # Other control characters (ASCII code less than 0x20) and characters not
+  # defined in the font are displayed as a four-character sequence \xhh where hh
+  # is the two-digit hexadecimal number corresponding to the character.
+  # In the unusual case where the font does not contain all of the characters in
+  # "0123456789abcdef\x" then control characters and undefined characters
+  # are not displayed at all.
+  class Message < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'message'; end
+  end
+end

data/lib/ffi-tk/widget/panedwindow.rb

@@ -0,0 +1,164 @@
+module Tk
+  class PanedWindow < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'panedwindow'; end
+
+    # Add one or more windows to the panedwindow, each in a separate pane.
+    # The arguments consist of the names of one or more windows followed by
+    # pairs of arguments that specify how to manage the windows.
+    # Option may have any of the values accepted by the configure subcommand.
+    def add(window, *arguments)
+      options, windows = arguments.partition{|arg| arg.respond_to?(:to_tcl_options) }
+
+      if option = options.first
+        execute(:add, window, *windows, option.to_tcl_options)
+      else
+        execute(:add, window, *windows)
+      end
+    end
+
+    # Remove the pane containing window from the panedwindow.
+    # All geometry management options for window will be forgotten.
+    def forget(window, *windows)
+      execute_only(:forget, window, *windows)
+    end
+
+    # Identify the panedwindow component underneath the point given by x and y,
+    # in window coordinates.
+    # If the point is over a sash or a sash handle, the result is a two element
+    # list containing the index of the sash or handle, and a word indicating
+    # whether it is over a sash or a handle, such as {0 sash} or {2 handle}.
+    # If the point is over any other part of the panedwindow, the result is an
+    # empty list.
+    def identify(x, y)
+      execute(:identify, x, y)
+    end
+
+    # Return a list containing the x and y coordinates of the most recent proxy
+    # location.
+    def proxy_coord
+      execute(:proxy, :coord).to_a
+    end
+
+    # Remove the proxy from the display.
+    def proxy_forget
+      execute(:proxy, :forget)
+    end
+
+    # Place the proxy at the given x and y coordinates.
+    def proxy_place(x, y)
+      execute(:proxy, :place, x, y)
+    end
+
+    # Return the current x and y coordinate pair for the sash given by index.
+    # Index must be an integer between 0 and 1 less than the number of panes in
+    # the panedwindow.
+    # The coordinates given are those of the top left corner of the region
+    # containing the sash.
+    def sash_coord(index)
+      execute(:sash, :coord, index)
+    end
+
+    # This command computes the difference between the given coordinates and
+    # the coordinates given to the last sash mark command for the given sash.
+    # It then moves that sash the computed dif‐ ference.
+    def sash_dragto(index, x, y)
+      execute_only(:sash, :dragto, index, x, y)
+    end
+
+    # Records x and y for the sash given by index; used in conjunction with
+    # later sash dragto commands to move the sash.
+    def sash_mark(index, x, y)
+      execute(:sash, :mark, index, x, y)
+    end
+
+    # Place the sash given by index at the given coordinates.
+    def sash_place(index, x, y)
+      execute(:sash, :place, index, x, y)
+    end
+
+    # Query a management option for window.
+    # Option may be any value allowed by the paneconfigure subcommand.
+    def panecget(window, option)
+      execute(:panecget, window, option.to_tcl_option)
+    end
+
+    # Query or modify the management options for window.
+    # If no option is specified, returns a list describing all of the available
+    # options for pathName (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 widget option(s) to have the given value(s); in this
+    # case the command returns an empty string.
+    # The following options are supported: -after window Insert the window
+    # after the window specified.
+    # window should be the name of a window already managed by pathName.
+    # -before window Insert the window before the window specified.
+    # window should be the name of a window already managed by pathName.
+    # -height size Specify a height for the window.
+    # The height will be the outer dimension of the window including its
+    # border, if any.
+    # If size is an empty string, or if -height is not specified, then the
+    # height requested internally by the window will be used initially; the
+    # height may later be adjusted by the movement of sashes in the
+    # panedwindow. Size may be any value accepted by Tk_GetPixels.
+    # -hide boolean Controls the visibility of a pane.
+    # When the boolean is true (according to Tcl_GetBoolean) the pane will not
+    # be visible, but it will still be maintained in the list of panes.
+    # │ -minsize n Specifies that the size of the window cannot be made less
+    # than n.
+    # This constraint only affects the size of the widget in the paned
+    # dimension — the x dimension for horizontal panedwin‐ dows, the y
+    # dimension for vertical panedwindows.
+    # May be any value accepted by Tk_GetPixels.
+    # -padx n Specifies a non-negative value indicating how much extra space to
+    # leave on each side of the window in the X-direction.
+    # The value may have any of the forms accepted by Tk_GetPixels.
+    # -pady n Specifies a non-negative value indicating how much extra space to
+    # leave on each side of the window in the Y-direction.
+    # The value may have any of the forms accepted by Tk_GetPixels.
+    # -sticky style If a window's pane is larger than the requested dimensions
+    # of the window, this option may be used to position (or stretch) the
+    # window within its pane.
+    # Style is a string that contains zero or more of the characters n, s, e or
+    # w. The string can optionally contains spaces or commas, but they are
+    # ignored. Each letter refers to a side (north, south, east, or west) that
+    # the window will “stick” to.
+    # If both n and s (or e and w) are specified, the window will be stretched
+    # to fill the entire height (or width) of its cavity.
+    # -stretch when Controls how extra space is allocated to each of the panes.
+    # When is one of always, first, last, middle, and never.
+    # The panedwindow will calculate the required size of all its panes.
+    # │ Any remaining (or deficit) space will be distributed to those panes
+    # marked for stretching.
+    # The space will be distributed based on each panes current ratio of the
+    # whole. The when values │ have the following definition: │ always │ This
+    # pane will always stretch.
+    # │ first │ Only if this pane is the first pane (left-most or top-most)
+    # will it stretch.
+    # │ last │ Only if this pane is the last pane (right-most or bottom-most)
+    # will it stretch.
+    # This is the default value.
+    # │ middle │ Only if this pane is not the first or last pane will it
+    # stretch. │ never │ This pane will never stretch.
+    # │ -width size Specify a width for the window.
+    # The width will be the outer dimension of the window including its border,
+    # if any.
+    # If size is an empty string, or if -width is not specified, then the width
+    # requested internally by the window will be used initially; the width may
+    # later be adjusted by the movement of sashes in the panedwindow.
+    # Size may be any value accepted by Tk_Get‐ Pixels.
+    def paneconfigure(window, options = None)
+      common_configure([:paneconfigure, window], options)
+    end
+
+    # Returns an ordered list of the widgets managed by pathName.
+    def panes
+      execute(:panes).to_a
+    end
+  end
+end

data/lib/ffi-tk/widget/radiobutton.rb

@@ -0,0 +1,43 @@
+module Tk
+  class RadioButton < Button
+    include Cget, Configure
+
+    def self.tk_command; 'radiobutton'; end
+
+    # Deselects the radiobutton and sets the associated variable to an empty
+    # string. If this radiobutton was not currently selected, the command has
+    # no effect.
+    def deselect
+      execute_only(:deselect)
+    end
+
+    # Flashes the radiobutton.
+    # This is accomplished by redisplaying the radiobutton several times,
+    # alternating between active and normal colors.
+    # At the end of the flash the radiobutton is left in the same normal/active
+    # state as when the command was invoked.
+    # This command is ignored if the radiobutton's state is disabled.
+    def flash
+      execute_only(:flash)
+    end
+
+    # Does just what would have happened if the user invoked the radiobutton
+    # with the mouse: selects the button and invokes its associated Tcl
+    # command, if there is one.
+    # The return value is the return value from the Tcl command, or an empty
+    # string if there is no command associated with the radiobutton.
+    # This command is ignored if the radiobutton's state is disabled.
+    def invoke
+      execute_only(:invoke)
+    end
+
+    # Selects the radiobutton and sets the associated variable to the value
+    # corresponding to this widget.
+    # pressed over a radiobutton, the button activates whenever the mouse
+    # pointer is inside the button, and deactivates whenever the mouse pointer
+    # leaves the button.
+    def select
+      execute_only(:select)
+    end
+  end
+end

data/lib/ffi-tk/widget/root.rb

@@ -0,0 +1,8 @@
+module Tk
+  class Root < Toplevel
+    def initialize
+      @tk_parent = nil
+      @tk_pathname = '.'
+    end
+  end
+end

data/lib/ffi-tk/widget/scale.rb

@@ -0,0 +1,44 @@
+module Tk
+  class Scale < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'scale'; end
+
+    # Returns a list whose elements are the x and y coordinates of the point
+    # along the centerline of the trough that corresponds to value.
+    # If value is omitted then the scale's current value is used.
+    def coords(value = None)
+      execute(:coords, value)
+    end
+
+    # If x and y are omitted, returns the current value of the scale.
+    # If x and y are specified, they give pixel coordinates within the widget;
+    # the command returns the scale value corresponding to the given pixel.
+    # Only one of x or y is used: for horizontal scales y is ignored, and for
+    # vertical scales x is ignored.
+    def get(x = None, y = None)
+      execute(:get, x, y)
+    end
+
+    # Returns a string indicating what part of the scale lies under the
+    # coordinates given by x and y.
+    # A return value of slider means that the point is over the slider; trough1
+    # means that the point is over the portion of the slider above or to the
+    # left of the slider; and trough2 means that the point is over the portion
+    # of the slider below or to the right of the slider.
+    # If the point is not over one of these elements, an empty string is
+    # returned.
+    def identify(x, y)
+      execute(:identify, x, y)
+    end
+
+    # This command is invoked to change the current value of the scale, and
+    # hence the position at which the slider is displayed.
+    # Value gives the new value for the scale.
+    # The command has no effect if the scale is disabled.
+    # the button is held down, the action auto-repeats.
+    def set(value)
+      execute(:set, value)
+    end
+  end
+end

data/lib/ffi-tk/widget/scrollbar.rb

@@ -0,0 +1,114 @@
+module Tk
+  class Scrollbar < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'scrollbar'; end
+
+    # Marks the element indicated by element as active, which causes it to be
+    # displayed as specified by the activeBackground and activeRelief options.
+    # The only element values understood by this command are arrow1, slider, or
+    # arrow2. If any other value is specified then no element of the scrollbar
+    # will be active.
+    # If element is not specified, the command returns the name of the element
+    # that is currently active, or an empty string if no element is
+    # active.
+    def activate(element = None)
+      execute(:activate, element).to_s?
+    end
+
+    # Returns a real number indicating the fractional change in the scrollbar
+    # setting that corresponds to a given change in slider position.
+    # For example, if the scrollbar is horizontal, the result indicates how
+    # much the scrollbar setting must change to move the slider deltaX pixels
+    # to the right (deltaY is ignored in this case).
+    # If the scrollbar is vertical, the result indicates how much the scrollbar
+    # setting must change to move the slider deltaY pixels down.
+    # The arguments and the result may be zero or negative.
+    def delta(delta_x, delta_y)
+      execute(:delta, delta_x, delta_y)
+    end
+
+    # Returns a real number between 0 and 1 indicating where the point given by
+    # x and y lies in the trough area of the scrollbar.
+    # The value 0 corresponds to the top or left of the trough, the value 1
+    # corresponds to the bottom or right, 0.5 corresponds to the middle, and so
+    # on. X and y must be pixel coordinates relative to the scrollbar widget.
+    # If x and y refer to a point outside the trough, the closest point in the
+    # trough is used.
+    def fraction(x, y)
+      execute(:fraction, x, y)
+    end
+
+    # Returns the scrollbar settings in the form of a list whose elements are
+    # the arguments to the most recent set widget command.
+    def get
+      execute(:get)
+    end
+
+    # Returns the name of the element under the point given by x and y (such as
+    # arrow1), or an empty string if the point does not lie in any element of
+    # the scrollbar.
+    # X and y must be pixel coordinates relative to the scrollbar widget.
+    def identify(x, y)
+      execute(:identify, x, y)
+    end
+
+    # This command is invoked by the scrollbar's associated widget to tell the
+    # scrollbar about the current view in the widget.
+    # The command takes two arguments, each of which is a real fraction between
+    # 0 and 1.
+    # The fractions describe the range of the document that is visible in the
+    # associated widget.
+    # For example, if first is 0.2 and last is 0.4, it means that the first
+    # part of the document visible in the window is 20% of the way through the
+    # document, and the last visible part is 40% of the way through.
+    # Fraction is a real number between 0 and 1.
+    # The widget should adjust its view so that the point given by fraction
+    # appears at the beginning of the widget.
+    # If fraction is 0 it refers to the beginning of the document.
+    # 1.0 refers to the end of the document, 0.333 refers to a point one-third
+    # of the way through the document, and so on.
+    # The widget should adjust its view by number units.
+    # The units are defined in whatever way makes sense for the widget, such as
+    # characters or lines in a text widget.
+    # Number is either 1, which means one unit should scroll off the top or
+    # left of the window, or -1, which means that one unit should scroll off
+    # the bottom or right of the window.
+    # The widget should adjust its view by number pages.
+    # It is up to the widget to define the meaning of a page; typically it is
+    # slightly less than what fits in the window, so that there is a slight
+    # overlap between the old and new views.
+    # Number is either 1, which means the next page should become visible, or
+    # -1, which means that the previous page should become visible.
+    #
+    # In this form the arguments are all integers.
+    # TotalUnits gives the total size of the object being displayed in the
+    # associated widget.
+    # The meaning of one unit depends on the associated widget; for example, in
+    # a text editor widget units might correspond to lines of text.
+    # WindowUnits indicates the total number of units that can fit in the
+    # associated window at one time.
+    # FirstUnit and lastUnit give the indices of the first and last units
+    # currently visible in the associated window (zero corresponds to the first
+    # unit of the object).
+    # Unit is an integer that indicates what should appear at the top or left
+    # of the associated widget's window.
+    # It has the same meaning as the firstUnit and lastUnit arguments to the
+    # set widget command.
+    # the action auto-repeats.
+    # held down, the action auto-repeats.
+    # the mouse button is released.
+    # held down, the action auto-repeats.
+    # the action auto-repeats.
+    # button 2 is pressed over one of the arrows, it causes the same behavior
+    # as pressing button 1.
+    # the view changes to the very bottom (right) of the document; if the mouse
+    # is anywhere else then the button press has no effect.
+    # toplevel .tl text .tl.t -yscrollcommand {.tl.s set} scrollbar .tl.s
+    # -command {.tl.t yview} grid .tl.t .tl.s -sticky nsew grid columnconfigure
+    # .tl 0 -weight 1 grid rowconfigure .tl 0 -weight 1
+    def set(first, second, third = None, fourth = None)
+      execute(:set, first, second, third, fourth)
+    end
+  end
+end

data/lib/ffi-tk/widget/spinbox.rb

@@ -0,0 +1,198 @@
+module Tk
+  class Spinbox < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'spinbox'; end
+
+    # Returns a list of four numbers describing the bounding box 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 screen area covered by the character (in pixels
+    # relative to the widget) and the last two elements give the width and
+    # height of the character, in pixels.
+    # The bounding box may refer to a region outside the visible area of the
+    # window.
+    def bbox(index)
+      execute(:bbox, index).to_a(&:to_i)
+    end
+
+    # Delete one or more elements of the spinbox.
+    # First is the index of the first character to delete, and last is the
+    # index of the character just after the last one to delete.
+    # If last is not specified it defaults to first+1, i.e.
+    # a single character is deleted.
+    # This command returns an empty string.
+    def delete(first, last = None)
+      execute_only(:delete, first, last)
+    end
+
+    # Returns the spinbox's string.
+    def get
+      execute(:get)
+    end
+
+    # Arrange for the insertion cursor to be displayed just before the
+    # character given by index.
+    def icursor(index)
+      execute_only(:icursor, index)
+    end
+
+    # Returns the name of the window element corresponding to coordinates x and
+    # y in the spinbox.
+    # Return value is one of: none, buttondown, buttonup, entry.
+    def identify(x, y)
+      execute(:identify, x, y).to_sym
+    end
+
+    # Returns the numerical index corresponding to index.
+    def index(index)
+      execute(:index, index)
+    end
+
+    # Insert the characters of string just before the character indicated by
+    # index. Returns an empty string.
+    def insert(index, string)
+      execute_only(:insert, index, string)
+    end
+
+    # Causes the specified element, either buttondown or buttonup, to be
+    # invoked, triggering the action associated with it.
+    def invoke(element)
+      execute(:invoke, element)
+    end
+
+    # Records x and the current view in the spinbox window; used in conjunction
+    # with later scan dragto commands.
+    # Typically this command is associated with a mouse button press in the
+    # widget.
+    def scan_mark(x)
+      execute_only(:scan, :mark, x)
+    end
+
+    # This command computes the difference between its x argument and the x
+    # argument to the last scan mark command for the widget.
+    # It then adjusts the view left or right by 10 times the difference in
+    # x-coordinates. This command is typically associated with mouse motion
+    # events in the widget, to produce the effect of dragging the spinbox at
+    # high speed through the window.
+    def scan_dragto(x)
+      execute_only(:scan, :dragto, x)
+    end
+
+    # Locate the end of the selection nearest to the character given by index,
+    # and adjust that end of the selection to be at index (i.e.
+    # including but not going beyond index).
+    # The other end of the selection is made the anchor point for future select
+    # to commands.
+    # If the selection is not currently in the spinbox, then a new selection is
+    # created to include the characters between index and the most recent
+    # selection anchor point, inclusive.
+    def selection_adjust(index)
+      execute_only(:selection, :adjust, index)
+    end
+
+    # Clear the selection if it is currently in this widget.
+    # If the selection is not in this widget then the command has no effect.
+    def selection_clear
+      execute_only(:selection, :clear)
+    end
+
+    # Sets or gets the currently selected element.
+    # If a spinbutton element is specified, it will be displayed depressed.
+    def selection_element(element = None)
+      execute(:selection, :element, element)
+    end
+
+    # Set the selection anchor point to just before the character given by
+    # index. Does not change the selection.
+    def selection_from(index)
+      execute_only(:selection, :from, index)
+    end
+
+    # Returns 1 if there is are characters selected in the spinbox, 0 if
+    # nothing is selected.
+    def selection_present
+      execute(:selection, :present).to_boolean
+    end
+
+    # Sets the selection to include the characters starting with the one
+    # indexed by start and ending with the one just before end.
+    # If end refers to the same character as start or an earlier one, then the
+    # spinbox's selection is cleared.
+    def selection_range(from, to)
+      execute(:selection, :range, from, to)
+    end
+
+    # If index is before the anchor point, set the selection to the characters
+    # from index up to but not including the anchor point.
+    # If index is the same as the anchor point, do nothing.
+    # If index is after the anchor point, set the selection to the characters
+    # from the anchor point up to but not including index.
+    # The anchor point is determined by the most recent select from or select
+    # adjust command in this widget.
+    # If the selection is not in this widget then a new selection is created
+    # using the most recent anchor point specified for the widget.
+    # Returns an empty string.
+    def selection_to(index)
+      execute(:selection, :to, index)
+    end
+
+    # If string is specified, the spinbox will try and set it to this value,
+    # otherwise it just returns the spinbox's string.
+    # If validation is on, it will occur when setting the string.
+    def set(string = None)
+      if None == string
+        execute(:set)
+      else
+        execute_only(:set, string)
+      end
+    end
+
+    # This command is used to force an evaluation of the validateCommand
+    # independent of the conditions specified by the validate option.
+    # This is done by temporarily setting the validate option to all.
+    # It returns 0 or 1.
+    def validate
+      execute(:validate).to_boolean
+    end
+
+    # Returns a list containing two elements.
+    # Each element is a real fraction between 0 and 1; together they describe
+    # the horizontal span that is visible in the window.
+    # For example, if the first element is .2 and the second element is .6, 20%
+    # of the spinbox's text is off-screen to the left, the middle 40% is
+    # visible in the window, and 40% of the text is off-screen to the right.
+    # These are the same values passed to scrollbars via the -xscrollcommand
+    # option.
+    #
+    # Adjusts the view in the window so that the character given by index is
+    # displayed at the left edge of the window.
+    def xview(index = None)
+      if None == index
+        execute(:xview)
+      else
+        execute_only(:xview, index)
+      end
+    end
+
+    # Adjusts the view in the window so that the character fraction of the way
+    # through the text appears at the left edge of the window.
+    # Fraction must be a fraction between 0 and 1.
+    def xview_moveto(fraction)
+      execute(:xview, :moveto, fraction)
+    end
+
+    # This command shifts the view in the window left or right according to
+    # number and what.
+    # Number must be an integer.
+    # What must be either units or pages or an abbreviation of one of these.
+    # If what is units, the view adjusts left or right by number average-width
+    # characters on the display; if it is pages then the view adjusts by number
+    # screenfuls. If number is negative then characters farther to the left
+    # become visible; if it is positive then characters farther to the right
+    # become visible.
+    def xview_scroll(number, what)
+      execute(:xview, :scroll, number, what)
+    end
+  end
+end