ffi-tk 2009.11.29

data/lib/ffi-tk/command/grid.rb

@@ -0,0 +1,246 @@
+module Tk
+  # Geometry manager that arranges widgets in a grid
+  #
+  # The grid command is used to communicate with the grid geometry manager that
+  # arranges widgets in rows and columns inside of another window, called the
+  # geometry master (or master window).
+  module Grid
+    # If the first argument to grid is suitable as the first slave argument to
+    # grid configure, either a window name (any value starting with .) or one of
+    # the characters x or ^ (see the RELATIVE PLACEMENT section below), then the
+    # command is processed in the same way as grid configure.
+    def self.slave(*arguments)
+      Tk.execute('grid', 'slave', *arguments)
+    end
+
+    # The anchor value controls how to place the grid within the master when no
+    # row/column has any weight.
+    # The default anchor is nw.
+    def self.anchor(master, anchor = None)
+      Tk.execute('grid', 'anchor', master, anchor)
+    end
+
+    # With no arguments, the bounding box (in pixels) of the grid is returned.
+    # The return value consists of 4 integers.
+    #
+    # The first two are the pixel offset from the master window (x then y) of
+    # the top-left corner of the grid, and the second two integers are the width
+    # and height of the grid, also in pixels.
+    #
+    # If only +col1+ and +row1+ are given, then the bounding box for that cell
+    # is returned, where the top left cell is numbered from zero.
+    # If +col2+ and +col2+ are given as well, then the bounding box
+    # spanning the rows and columns indicated is returned.
+    #
+    # @usage Example
+    #
+    #   Bbox.bbox('.', 0, 0) # top left cell
+    #   Bbox.bbox('.', 1, 1) # cell in second column and row
+    #   Bbox.bbox('.', 0, 0, 1, 1) # cells from top left to second col/row
+    def self.bbox(master, col1 = None, row1 = None, col2 = None, row2 = None)
+      bbox = Tk.execute('grid', 'bbox', master, column1, row1, column2, row2)
+      bbox.map(&:to_i)
+    end
+
+    # Query or set the column properties of the index column of the geometry
+    # master, master.
+    # The valid options are -minsize, -weight, -uniform and -pad.
+    # If one or more options are provided, then index may be given as a list of
+    # column indices to which the configuration options will operate on.
+    # Indices may be integers, window names or the keyword all.
+    # For all the options apply to all columns currently occupied be slave
+    # windows. For a window name, that window must be a slave of this master and
+    # the options apply to all columns currently occupied be the slave.
+    # The -minsize option sets the minimum size, in screen units, that will be
+    # permitted for this column.
+    # The -weight option (an integer value) sets the relative weight for
+    # apportioning any extra spaces among columns.
+    # A weight of zero (0) indicates the column will not deviate from its
+    # requested size.
+    # A column whose weight is two will grow at twice the rate as a column of
+    # weight one when extra space is allocated to the layout.
+    # The -uniform option, when a non-empty value is supplied, places the column
+    # in a uniform group with other columns that have the same value for
+    # -uniform. The space for columns belonging to a uniform group is allocated
+    # so that their sizes are always in strict proportion to their -weight
+    # values. See THE GRID ALGORITHM below for further details.
+    # The -pad option specifies the number of screen units that will be added to
+    # the largest window contained completely in that column when the grid
+    # geometry manager requests a size from the containing window.
+    # If only an option is specified, with no value, the current value of that
+    # option is returned.
+    # If only the master window and index is specified, all the current settings
+    # are returned in a list of “-option value” pairs.
+    def self.columnconfigure(master, index, options = {})
+      Tk.execute('grid', 'columnconfigure', master, index, options)
+    end
+
+    # The arguments consist of the names of one or more slave windows followed
+    # by pairs of arguments that specify how to manage the slaves.
+    # The characters -, x and ^, can be specified instead of a window name to
+    # alter the default location of a slave.
+    def self.configure(*arguments)
+      options, slaves = arguments.partition{|arg| arg.respond_to?(:to_tcl_options?) }
+      options = options.first
+      Tk.execute('grid', 'configure', *slaves, options.to_tcl_options?)
+    end
+
+    # Removes each of the slaves from grid for its master and unmaps their
+    # windows. The slaves will no longer be managed by the grid geometry
+    # manager. The configuration options for that window are forgotten, so that
+    # if the slave is managed once more by the grid geometry manager, the
+    # initial default settings are used.
+    def self.forget(*slaves)
+      Tk.execute('grid', 'forget', *slaves)
+    end
+
+    # Returns a list whose elements are the current configuration state of the
+    # slave given by slave in the same option-value form that might be specified
+    # to grid configure.
+    # The first two elements of the list are “-in master” where master is
+    # the slave's master.
+    def self.info(slave)
+      Tk.execute('grid', 'info', slave)
+    end
+
+    # Given x and y values in screen units relative to the master window, the
+    # column and row number at that x and y location is returned.
+    # For locations that are above or to the left of the grid, -1 is returned.
+    def self.location(master, x, y)
+      Tk.execute('grid', 'location', master, x, y)
+    end
+
+    # If boolean has a true boolean value such as 1 or on then propagation is
+    # enabled for master, which must be a window name (see GEOMETRY PROPAGATION
+    # below). If boolean has a false boolean value then propagation is disabled
+    # for master.
+    # In either of these cases an empty string is returned.
+    # If boolean is omitted then the command returns 0 or 1 to indicate whether
+    # propagation is currently enabled for master.
+    # Propagation is enabled by default.
+    def self.propagate(master, boolean = None)
+      Tk.execute('grid', 'propagate', master, boolean)
+    end
+
+    # Query or set the row properties of the index row of the geometry master,
+    # master. The valid options are -minsize, -weight, -uniform and -pad.
+    # If one or more options are provided, then index may be given as a list of
+    # row indices to which the configuration options will operate on.
+    # Indices may be integers, window names or the keyword all.
+    # For all the options apply to all rows currently occupied be slave windows.
+    # For a window name, that window must be a slave of this master and the
+    # options apply to all rows currently occupied be the slave.
+    # The -minsize option sets the minimum size, in screen units, that will be
+    # permitted for this row.
+    # The -weight option (an integer value) sets the relative weight for
+    # apportioning any extra spaces among rows.
+    # A weight of zero (0) indicates the row will not deviate from its requested
+    # size. A row whose weight is two will grow at twice the rate as a row of
+    # weight one when extra space is allocated to the layout.
+    # The -uniform option, when a non-empty value is supplied, places the row in
+    # a uniform group with other rows that have the same value for -uniform.
+    # The space for rows belonging to a uniform group is allocated so that their
+    # sizes are always in strict proportion to their -weight values.
+    # See THE GRID ALGORITHM below for further details.
+    # The -pad option specifies the number of screen units that will be added to
+    # the largest window contained completely in that row when the grid geometry
+    # manager requests a size from the containing window.
+    # If only an option is specified, with no value, the current value of that
+    # option is returned.
+    # If only the master window and index is specified, all the current settings
+    # are returned in a list of “-option value” pairs.
+    def self.rowconfigure(master, index, options = None)
+      Tk.execute('grid', 'rowconfigure', master, index, options.to_tcl_options?)
+    end
+
+    # Removes each of the slaves from grid for its master and unmaps their
+    # windows. The slaves will no longer be managed by the grid geometry
+    # manager. However, the configuration options for that window are
+    # remembered, so that if the slave is managed once more by the grid geometry
+    # manager, the previous values are retained.
+    def self.remove(*slaves)
+      Tk.execute('grid', 'remove', *slaves)
+    end
+
+    # Returns the size of the grid (in columns then rows) for master.
+    # The size is determined either by the slave occupying the largest row or
+    # column, or the largest column or row with a minsize, weight, or pad that
+    # is non-zero.
+    def self.size(master)
+      Tk.execute('grid', 'size', master)
+    end
+
+    # If no options are supplied, a list of all of the slaves in master are
+    # returned, most recently manages first.
+    # Option can be either -row or -column which causes only the slaves in the
+    # row (or column) specified by value to be returned.
+    def self.slaves(master, options = {})
+      Tk.execute('grid', 'slaves')
+    end
+
+    # @see Grid::slave
+    def grid_slave(options = {})
+      Grid.slave(self, options)
+    end
+
+    # @see Grid::anchor
+    def grid_anchor(anchor = None)
+      Grid.anchor(self, anchor)
+    end
+
+    # @see Grid::bbox
+    def grid_bbox(col1 = None, row1 = None, col2 = None, row2 = None)
+      Grid.bbox(self, col1, row1, col2, row2)
+    end
+
+    # @see Grid::columnconfigure
+    def grid_columnconfigure(index, options = {})
+      Grid.columnconfigure(self, index, options.to_tcl_options)
+    end
+
+    # @see Grid::configure
+    def grid_configure(options = None)
+      Grid.configure(self, options)
+    end
+
+    # @see Grid::forget
+    def grid_forget
+      Grid.forget(self)
+    end
+
+    # @see Grid::info
+    def grid_info
+      Grid.info(self)
+    end
+
+    # @see Grid::location
+    def grid_location(x, y)
+      Grid.location(self, x, y)
+    end
+
+    # @see Grid::propagte
+    def grid_propagate(boolean = None)
+      Grid.propagate(self, boolean)
+    end
+
+    # @see grid::rowconfigure
+    def grid_rowconfigure(index, options = None)
+      Grid.rowconfigure(self, index, options)
+    end
+
+    # @see Grid::remove
+    def grid_remove
+      Grid.remove(self)
+    end
+
+    # @see Grid::size
+    def grid_size
+      Grid.size(self)
+    end
+
+    # @see Grid::slaves
+    def grid_slaves(options = {})
+      Grid.slaves(self, options)
+    end
+  end
+end

data/lib/ffi-tk/command/image.rb

@@ -0,0 +1,79 @@
+module Tk
+  module Image
+    module_function
+
+    # Creates an image and a commend of the same name.
+    # Returns the name of the command containing the image.
+    #
+    # +type+ specifies the type of the image, which must be one of the types
+    # currently defined (e.g., bitmap or photo).
+    #
+    # +name+ specifies the name for the image; if it is ommitted then Tk picks a
+    # name of the form imagex, where x is an integer.
+    #
+    # +options+ may be a Hash containing configuration options for the new
+    # image.
+    #
+    # The legal set of +options+ is defined separately for each image type; see
+    # documentation of [Image] for built-in image types.
+    #
+    # If a proc already exists with the given name, then it is replaced with
+    # the new image and any instances of that image will redisplay with the new
+    # contents.
+    # It is important to note that [create] will silently overwrite any existing
+    # images of the same name, so choose the name wisely.
+    #
+    # It is recommended to use a separate namespace for image names, like
+    # "::img::logo" or "::img::large"
+    def create(type, name = None, options = None)
+      if None == name
+        Tk.execute(:image, :create, type)
+      elsif None == options && name.respond_to?(:to_hash)
+        Tk.execute(:image, :create, name.to_tcl_options)
+      elsif None != name && None != options
+        Tk.exeucte(:image, :create, name, options.to_tcl_options)
+      end
+    end
+
+    # Deletes each of the named images and returns an empty string.
+    # If there are instances of the images displayed in widgets, the images
+    # will not actually be deleted until all of the instances are released.
+    # However, the association between the instances and the image manager will
+    # be dropped.
+    # Existing instances will retain their sizes but redisplay as empty areas.
+    # If a deleted image is recreated with another call to image create, the
+    # existing instances will use the new image.
+    def delete(*names)
+      Tk.execute(:image, :delete, *names)
+    end
+
+    # Returns a decimal string giving the height of image name in pixels.
+    def height(name)
+      Tk.execute(:image, :height, name)
+    end
+
+    # Returns a boolean value indicating whether or not the image given by name
+    # is in use by any widgets.
+    def inuse(name)
+      Tk.execute(:image, :inuse, name).to_boolean
+    end
+
+    # Returns a list containing the names of all existing images.
+    def names
+      Tk.execute(:image, :names).to_a
+    end
+
+    # Returns the type of image name (the value of the type argument to image
+    # create when the image was created).
+    def type(name)
+      Tk.execute(:image, :type, name).to_sym
+    end
+
+    # Returns a list whose elements are all of the valid image types (i.e., all
+    # of the values that may be supplied for the type argument to image
+    # create).
+    def types
+      Tk.execute(:image, :types).to_sym
+    end
+  end
+end

data/lib/ffi-tk/command/lower.rb

@@ -0,0 +1,23 @@
+module Tk
+  # Change a window's position in the stacking order
+  module Lower
+    def lower(below = None)
+      Lower.lower(self, below)
+    end
+
+    module_function
+
+    # If the +below+ argument is omitted then the command lowers window so that
+    # it is below all of its siblings in the stacking order (it will be obscured
+    # by any siblings that overlap it and will not obscure any siblings).
+    #
+    # If +below+ is specified then it must be the path name of a window that is
+    # either a sibling of window or the descendant of a sibling of window.
+    # In this case the lower command will insert window into the stacking order
+    # just below +below+ or the ancestor of +below+ that is a sibling of
+    # window); this could end up either raising or lowering window.
+    def lower(below = None)
+      Tk.execute_only(:lower, window, below)
+    end
+  end
+end

data/lib/ffi-tk/command/message_box.rb

@@ -0,0 +1,65 @@
+module Tk
+  module_function
+
+  # Pops up a message window and waits for user response.
+  # This procedure creates and displays a message window with an
+  # application-specified message, an icon and a set of buttons.
+  # Each of the buttons in the message window is identified by a unique symbolic
+  # name (see the :type options).
+  #
+  # After the message window is popped up, [message_box] waits for the user to
+  # select one of the buttons.
+  # Then it returns the symbolic name of the selected button.
+  #
+  # The following options pairs are supported:
+  #
+  #   default: name
+  #     Name gives the symbolic name of the default button for this message
+  #     window (:ok, :cancel, and so on).
+  #     See :type for a list of the symbolic names.
+  #     If this option is not specified, the first button in the dialog will be
+  #     made the default.
+  #
+  #   detail: string
+  #     Specifies an auxiliary message to the main message given by the :message
+  #     option. Where supported by the underlying OS, the message detail will be
+  #     presented in a less emphasized font than the main message.
+  #
+  #   icon: icon_image
+  #     Specifies an icon to display.
+  #     icon_image must be one of the following: :error, :info, :question or
+  #     :warning. If this option is not specified, then the info icon will be
+  #     displayed.
+  #
+  #   message: string
+  #     Specifies the message to display in this message box.
+  #
+  #   parent: window
+  #     Makes window the logical parent of the message box.
+  #     The message box is displayed on top of its parent window.
+  #
+  #   title: string
+  #     Specifies a string to display as the title of the message box.
+  #     The default value is an empty string.
+  #
+  #   type: predefined_type
+  #     Arranges for a predefined set of buttons to be displayed.
+  #
+  # The following values are possible for predefined_type:
+  #
+  # :abortretryignore
+  #   Displays three buttons whose symbolic names are :abort, :retry and :ignore.
+  # :ok
+  #   Displays one button whose symbolic name is :ok.
+  # :okcancel
+  #   Displays two buttons whose symbolic names are :ok and :cancel.
+  # :retrycancel
+  #   Displays two buttons whose symbolic names are :retry and :cancel.
+  # :yesno
+  #   Displays two buttons whose symbolic names are :yes and :no.
+  # :yesnocancel
+  #   Displays three buttons whose symbolic names are :yes, :no and :cancel.
+  def message_box(options = None)
+    Tk.execute(:tk_messageBox, options.to_tcl_options?).to_sym
+  end
+end

data/lib/ffi-tk/command/option_menu.rb

@@ -0,0 +1,8 @@
+module Tk
+  def self.option_menu(pathname, *values)
+    variable = Variable.new('the_option_menu')
+
+    Tk.execute_only(:tk_optionMenu, pathname, variable, *values)
+    return variable
+  end
+end

data/lib/ffi-tk/command/pack.rb

@@ -0,0 +1,99 @@
+module Tk
+  # Geometry manager that packs around edges of cavity
+  #
+  # The pack command is used to communicate with the packer, a geometry manager
+  # that arranges the children of a parent by packing them in order around the
+  # edges of the parent.
+  module Pack
+    # If the first argument to pack is a window name (any value starting with
+    # "."), then the command is processed in the same way as [configure].
+    def self.pack(*args)
+      Tk.execute('pack', *args)
+    end
+
+    # The arguments consist of the names of one or more slave windows followed
+    # by a hash of arguments that specify how to manage the slaves.
+    # See THE PACKER ALGORITHM for details on how the options are used by the
+    # packer.
+    def self.configure(*arguments)
+      Tk.execute('pack', 'configure', *arguments)
+    end
+
+    # Removes each of the +slaves+ from the packing order for its master and
+    # unmaps their windows.
+    # The +slaves+ will no longer be managed by the packer.
+    def self.forget(*slaves)
+      Tk.execute_only('pack', 'forget', *slaves)
+    end
+
+    # Returns a hash whose elements are the current configuration state of the
+    # +slave+ given by in the same option-value form that might be specified
+    # to pack configure.
+    # The hash contains`in: master` where master is the +slave+'s master.
+    def self.info(slave)
+      info = Tk.execute('pack', 'info', slave)
+
+      array = info.split.each_slice(2).map{|key, value|
+        case key = key[1..-1].to_sym
+        when :expand
+          [key, Tk.boolean(value)]
+        when :ipadx, :ipady, :padx, :pady
+          [key, value.to_i]
+        when :fill, :side
+          [key, value.to_sym]
+        when :after, :anchor, :before, :in
+          [key, value]
+        else
+          raise "Unknown info pair: %p => %p" % [key, value]
+        end
+      }
+
+      Hash[array]
+    end
+
+    # If +boolean+ is true then propagation is enabled for +master+, which must
+    # be a window (see GEOMETRY PROPAGATION below).
+    # If +boolean+ is false, then propagation is disabled for +master+.
+    # In either of these cases nil is returned.
+    # If boolean is omitted then the command returns 0 or 1 to indicate whether
+    # propagation is currently enabled for master.
+    # Propagation is enabled by default.
+    def self.propagate(master, boolean = true)
+      Tk.execute_only('pack', 'propagate', master, boolean)
+    end
+
+    # Returns a list of all of the slaves in the packing order for master. The
+    # order of the slaves in the list is the same as their order in the packing
+    # order.
+    def self.slaves(master)
+      Tk.execute('pack', 'slaves', master)
+    end
+
+    def pack(options = {})
+      Pack.pack(self, options.to_tcl_options)
+      self
+    end
+
+    def pack_configure(options = {})
+      Tk.execute_only('pack', 'configure', self, options)
+      self
+    end
+
+    def pack_forget
+      Pack.forget(self)
+      self
+    end
+
+    def pack_info
+      Pack.info(self)
+    end
+
+    def pack_propagate(boolean = true)
+      Pack.propagate(self, boolean)
+    end
+
+    def pack_slaves
+      Pack.slaves(self)
+    end
+  end
+end