ffi-tk 2009.11.29

data/lib/ffi-tk/widget/canvas/arc.rb

@@ -0,0 +1,18 @@
+module Tk
+  class Canvas
+    # Items of type arc appear on the display as arc-shaped regions.
+    # An arc is a section of an oval delimited by two angles (specified by the
+    # :start and :extent options) and displayed in one of several ways
+    # (specified by the :style option).
+    class Arc < Item
+      options(
+        :dash, :activedash, :disableddash, :dashoffset, :fill, :activefill,
+        :disabledfill, :offset, :outline, :activeoutline, :disabledoutline,
+        :outlineoffset, :outlinestipple, :activeoutlinestipple,
+        :disabledoutlinestipple, :stipple, :activestipple, :disabledstipple,
+        :state, :tags, :width, :activewidth, :disabledwidth, :extent, :start,
+        :style
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/bitmap.rb

@@ -0,0 +1,13 @@
+module Tk
+  class Canvas
+    # Items of type bitmap appear on the display as images with two colors,
+    # foreground and background.
+    class Bitmap < Item
+      options(
+        :state, :tags, :anchor, :background, :activebackground,
+        :disabledbackground, :bitmap, :activebitmap, :disabledbitmap,
+        :foreground, :activeforeground, :disabledforeground
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/image.rb

@@ -0,0 +1,10 @@
+module Tk
+  class Canvas
+    # Items of type image are used to display images on a canvas.
+    class Image < Item
+      options(
+        :state, :tags, :anchor, :image, :activeimage, :disabledimage
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/item.rb

@@ -0,0 +1,170 @@
+module Tk
+  class Canvas
+    class Item < Struct.new(:canvas, :id)
+      OPTION_MAP = {
+        activebackground:       :bitmap,
+        activebitmap:           :bitmap,
+        activedash:             :integer,
+        activefill:             :color,
+        activeforeground:       :bitmap,
+        activeimage:            :string,
+        activeoutline:          :color,
+        activeoutlinestipple:   :bitmap,
+        activestipple:          :bitmap,
+        activewidth:            :integer,
+        anchor:                 :string,
+        arrow:                  :symbol,
+        arrowshape:             :list,
+        background:             :color,
+        bitmap:                 :bitmap,
+        capstyle:               :symbol,
+        dash:                   :integer,
+        dashoffset:             :integer,
+        disabledbackground:     :bitmap,
+        disabledbitmap:         :bitmap,
+        disableddash:           :integer,
+        disabledfill:           :color,
+        disabledforeground:     :bitmap,
+        disabledimage:          :string,
+        disabledoutline:        :color,
+        disabledoutlinestipple: :bitmap,
+        disabledstipple:        :bitmap,
+        disabledwidth:          :integer,
+        extent:                 :float,
+        fill:                   :color,
+        font:                   :font,
+        foreground:             :color,
+        height:                 :integer,
+        image:                  :string,
+        joinstyle:              :symbol,
+        justify:                :symbol,
+        offset:                 :string,
+        outline:                :color,
+        outlineoffset:          :integer,
+        outlinestipple:         :bitmap,
+        smooth:                 :boolean,
+        splinesteps:            :integer,
+        start:                  :float,
+        state:                  :symbol,
+        stipple:                :bitmap,
+        style:                  :symbol,
+        tags:                   :list,
+        text:                   :string,
+        underline:              :integer,
+        width:                  :integer,
+        width:                  :integer,
+        window:                 :pathname
+      }
+
+      def self.create(canvas, type, id)
+        klass = Canvas.const_get(type.to_s.capitalize)
+        klass.new(canvas, id)
+      end
+
+      OPTIONS_CODE = <<-RUBY
+def %s
+  Cget.type_to_ruby(%p, canvas.itemcget(id, %p))
+end
+      RUBY
+
+      def self.options(*names)
+        names.each do |name|
+          type = OPTION_MAP.fetch(name)
+          class_eval(OPTIONS_CODE % [name, type, name], __FILE__, __LINE__)
+        end
+      end
+
+      def to_tcl
+        TclString.new(id.to_s)
+      end
+
+      def inspect
+        "#<%s %d>" % [self.class.name, id]
+      end
+
+      def cget(option)
+        canvas.itemcget(self, option)
+      end
+
+      def addtag(tag)
+        canvas.addtag_withtag(tag, self)
+      end
+
+      def bbox
+        canvas.bbox(self)
+      end
+
+      def bind(sequence = None, &command)
+        canvas.bind(self, sequence, &command)
+      end
+
+      def coords(*coord_list)
+        canvas.coords(self, *coord_list)
+      end
+
+      def dchars(first, last = None)
+        canvas.dchars(self, first, last)
+      end
+
+      def delete
+        canvas.delete(self)
+      end
+
+      def dtag(tag)
+        canvas.dtag(self, tag)
+      end
+
+      def focus
+        canvas.focus(self)
+      end
+
+      def gettags
+        canvas.gettags(self)
+      end
+
+      def icursor(index)
+        canvas.icursor(self, index)
+      end
+
+      def index(index)
+        canvas.index(self, index)
+      end
+
+      def configure(options = None)
+        canvas.itemconfigure(self, options)
+      end
+
+      def lower(below = None)
+        canvas.lower(self, below)
+      end
+
+      def move(x_amount, y_amount)
+        canvas.move(self, x_amount, y_amount)
+      end
+
+      def raise(above = None)
+        canvas.raise(self, above)
+      end
+
+      def scale(x_origin, y_origin, x_scale, y_scale)
+        canvas.scale(self, x_origin, y_origin, x_scale, y_scale)
+      end
+
+      def select_adjust(index)
+        canvas.select_adjust(self, index)
+      end
+
+      def select_from(index)
+        canvas.select_from(self, index)
+      end
+
+      def select_to(index)
+        canvas.select_to(self, index)
+      end
+
+      def type
+        canvas.type(self)
+      end
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/line.rb

@@ -0,0 +1,16 @@
+module Tk
+  class Canvas
+    # Items of type line appear on the display as one or more connected line
+    # segments or curves.
+    # Line items support coordinate indexing operations using the Canvas
+    # methods: [Canvas.dchars], [Canvas.index], and [Canvas.insert].
+    class Line < Item
+      options(
+        :dash, :activedash, :disableddash, :dashoffset, :fill, :activefill,
+        :disabledfill, :stipple, :activestipple, :disabledstipple, :state,
+        :tags, :width, :activewidth, :disabledwidth, :arrow, :arrowshape,
+        :capstyle, :joinstyle, :smooth, :splinesteps
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/oval.rb

@@ -0,0 +1,15 @@
+module Tk
+  class Canvas
+    # Items of type oval appear as circular or oval regions on the display.
+    # Each oval may have an outline, a fill, or both.
+    class Oval < Item
+      options(
+        :dash, :activedash, :disableddash, :dashoffset, :fill, :activefill,
+        :disabledfill, :offset, :outline, :activeoutline, :disabledoutline,
+        :outlineoffset, :outlinestipple, :activeoutlinestipple,
+        :disabledoutlinestipple, :stipple, :activestipple, :disabledstipple,
+        :state, :tags, :width, :activewidth, :disabledwidth
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/polygon.rb

@@ -0,0 +1,16 @@
+module Tk
+  class Canvas
+    # Items of type polygon appear as polygonal or curved filled regions on the
+    # display. [Polygon] supports coordinate indexing operations using the
+    # [Canvas] methods: [Canvas.dchars], [Canvas.index], and [Canvas.insert].
+    class Polygon < Item
+      options(
+        :dash, :activedash, :disableddash, :dashoffset, :fill, :activefill,
+        :disabledfill, :offset, :outline, :activeoutline, :disabledoutline,
+        :outlinestipple, :activeoutlinestipple, :disabledoutlinestipple,
+        :stipple, :activestipple, :disabledstipple, :state, :tags, :width,
+        :activewidth, :disabledwidth, :joinstyle, :smooth, :splinesteps
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/rectangle.rb

@@ -0,0 +1,15 @@
+module Tk
+  class Canvas
+    # Items of type rectangle appear as rectangular regions on the display.
+    # Each rectangle may have an outline, a fill, or both.
+    class Rectangle < Item
+      options(
+        :dash, :activedash, :disableddash, :dashoffset, :fill, :activefill,
+        :disabledfill, :offset, :outline, :activeoutline, :disabledoutline,
+        :outlineoffset, :outlinestipple, :activeoutlinestipple,
+        :disabledoutlinestipple, :stipple, :activestipple, :disabledstipple,
+        :state, :tags, :width, :activewidth, :disabledwidth
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/text.rb

@@ -0,0 +1,15 @@
+module Tk
+  class Canvas
+    # A text item displays a string of characters on the screen in one or more
+    # lines. [Canvas::Text] items support indexing and selection, along with the
+    # following text-related [Canvas] methods: [Canvas.dchars], [Canvas.focus],
+    # [Canvas.icursor], and [Canvas.index].
+    class Text < Item
+      options(
+        :activefill, :activestipple, :anchor, :disabledfill, :disabledstipple,
+        :fill, :font, :justify, :state, :stipple, :tags, :text, :underline,
+        :width
+      )
+    end
+  end
+end

data/lib/ffi-tk/widget/canvas/window.rb

@@ -0,0 +1,11 @@
+module Tk
+  class Canvas
+    # Items of type window cause a particular window to be displayed at a given
+    # position on the canvas.
+    class Window < Item
+      options(
+        :state, :tags, :anchor, :height, :width, :window
+      )
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Tk
+  # Create and manipulate checkbutton widgets
+  class CheckButton < Button
+    include Cget, Configure
+
+    def self.tk_command; 'checkbutton'; end
+
+    def initialize(parent = Tk.root, options = None)
+      if block_given?
+        super do |options|
+          options[:command] = register_command(:command, &Proc.new)
+        end
+      else
+        super
+      end
+    end
+
+    # Deselects the checkbutton and sets the associated variable to its “off”
+    # value.
+    def deselect
+      execute_only(:deselect)
+    end
+
+    # Flashes the checkbutton.
+    # This is accomplished by redisplaying the checkbutton several times,
+    # alternating between active and normal colors.
+    # At the end of the flash the checkbutton is left in the same normal/active
+    # state as when the command was invoked.
+    # This command is ignored if the checkbutton's state is disabled.
+    def flash
+      execute_only(:flash)
+    end
+
+    # Does just what would have happened if the user invoked the checkbutton
+    # with the mouse: toggle the selection state of the button and invoke the
+    # Tcl command associated with the checkbutton, 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 checkbutton.
+    # This command is ignored if the checkbut‐ ton's state is disabled.
+    def invoke
+      execute_only(:invoke)
+    end
+
+    # Selects the checkbutton and sets the associated variable to its “on”
+    # value.
+    def select
+      execute_only(:select)
+    end
+
+    # Toggles the selection state of the button, redisplaying it and modifying
+    # its associated variable to reflect the new state.
+    # pressed over a checkbutton, the button activates whenever the mouse
+    # pointer is inside the button, and deactivates whenever the mouse pointer
+    # leaves the button.
+    # minus (-) deselects the button.
+    # labelframe .lbl -text "Steps:" checkbutton .c1 -text Lights -variable
+    # lights checkbutton .c2 -text Cameras -variable cameras checkbutton .c3
+    # -text Action! -variable action pack .c1 .c2 .c3 -in .lbl pack .lbl
+    def toggle
+      execute_only(:toggle)
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+module Tk
+  # An entry is a widget that displays a one-line text string and allows that
+  # string to be edited using widget methods described below, which are
+  # typically bound to keystrokes and mouse actions.
+  # When first created, an entry's string is empty.
+  # A portion of the entry may be selected as described below.
+  # If an entry is exporting its selection (see the exportSelection option),
+  # then it will observe the standard X11 protocols for handling the selection;
+  # entry selections are available as type STRING.
+  # Entries also observe the standard Tk rules for dealing with the input focus.
+  # When an entry has the input focus it displays an insertion cursor to
+  # indicate where new characters will be inserted.
+  #
+  # Entries are capable of displaying strings that are too long to fit entirely
+  # within the widget's window.
+  # In this case, only a portion of the string will be displayed; methods
+  # described below may be used to change the view in the window.
+  # Entries use the standard xScrollCommand mechanism for interacting with
+  # scrollbars (see the description of the xScrollCommand option for details).
+  # They also support scanning, as described below.
+  class Entry < Widget
+    include Cget, Configure
+
+    def self.tk_command; 'entry'; end
+
+    def value
+      get
+    end
+
+    def value=(string)
+      delete 0, :end
+      insert 0, string
+    end
+
+    def clear
+      delete 0, :end
+    end
+
+    def cursor
+      index(:insert)
+    end
+
+    def cursor=(index)
+      icursor(index)
+    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 entry.
+    # 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.
+    def delete(first, last = None)
+      execute(:delete, first, last)
+    end
+
+    # Returns the entry's string.
+    def get
+      execute(:get).to_s
+    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 numerical index corresponding to index.
+    def index(index)
+      execute(:index, index)
+    end
+
+    # Insert the characters of string just before the character indicated by
+    # index.
+    def insert(index, string)
+      execute_only(:insert, index, string)
+    end
+
+    # Records x and the current view in the entry 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 entry 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 entry, 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
+
+    # 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 true if there is are characters selected in the entry, false if
+    # nothing is selected.
+    def selection_present
+      execute(:selection, :present) == 1
+    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
+    # entry's selection is cleared.
+    def selection_range(from, to)
+      execute_only(: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.
+    def selection_to(index)
+      execute_only(:selection, :to, index)
+    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 true or false.
+    def validate
+      execute(:validate) == 1
+    end
+
+    # Adjusts the view in the window so that the character given by index is
+    # displayed at the left edge of the window.
+    #
+    # If no index is given, it 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 0.2 and the second element is 0.6,
+    # 20% of the entry'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.
+    def xview(index = None)
+      if index == None
+        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_only(: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_only(:xview, :scroll, number, what)
+    end
+  end
+end