ffi-tk 2009.11.29

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

@@ -0,0 +1,92 @@
+module Tk
+  module Cget
+    CGET_MAP = {}
+
+    insert = lambda{|type, array|
+      array.each{|option| CGET_MAP["-#{option}"] = type } }
+
+    insert[:integer, %w[
+      height width maxundo spacing1 spacing2 spacing3 borderwidth bd
+      highlightthickness insertborderwidth insertofftime insertontime
+      insertwidth padx pady selectborderwidth endline startline length
+      maximum
+    ]]
+    insert[:boolean, %w[
+      autoseparators blockcursor undo exportselection setgrid takefocus
+    ]]
+    insert[:color, %w[
+      inactiveselectbackground disabledbackground disabledforeground background
+      bg foreground fg highlightbackground highlightcolor insertbackground
+      selectbackground selectforeground readonlybackground
+    ]]
+    insert[:command, %w[
+      invalidcommand invcmd yscrollcommand xscrollcommand validatecommand
+      command vcmd
+    ]]
+    insert[:string, %w[ tabs cursor text show default class ]]
+    insert[:font, %w[ font ]]
+    insert[:symbol, %w[ wrap tabstyle relief justify validate orient mode selectmode ]]
+    insert[:variable, %w[ textvariable ]]
+    insert[:bitmap, %w[ stipple ]]
+    insert[:list, %w[ padding state style columns displaycolumns ]]
+
+    def cget(option)
+      option = option.to_tcl_option
+      Cget.option_to_ruby(option, execute('cget', option))
+    end
+
+    module_function
+
+    def option_to_ruby(name, value)
+      if type = CGET_MAP[name.to_tcl_option]
+        type_to_ruby(type, value)
+      else
+        raise "Unknown type for %p: %p" % [name, value]
+      end
+    end
+
+    def type_to_ruby(type, value)
+      case type
+      when :integer
+        value.to_i
+      when :symbol
+        value.to_sym?
+      when :boolean
+        Tk.boolean(value)
+      when :color, :string, :font, :bitmap
+        value.respond_to?(:to_s?) ? value.to_s? : value
+      when :variable
+        if name = value.to_s?
+          Variable.new(name)
+        end
+      when :list
+        value.to_a
+      when :float
+        value.to_f
+      when :pathname
+        Tk.pathname_to_widget(value.to_s)
+      when :command
+        string = value.to_s
+        string unless string.empty?
+      else
+        raise "Unknown type: %p: %p" % [type, value]
+      end
+    end
+
+    def option_hash_to_tcl(hash)
+      result = {}
+
+      hash.each do |key, value|
+        case type = CGET_MAP[option = key.to_tcl_option]
+        when :command
+          command = register_command(key, &value)
+          result[option] = command
+        else
+          result[option] = value
+        end
+      end
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Tk
+  module_function
+
+  # Pops up a dialog box for the user to select a color.
+  #
+  # If the user selects a color, this method will return the name of the color.
+  # If the user cancels the dialog, nil will be returned.
+  #
+  # The following options are possible:
+  #
+  #   initialcolor: color
+  #     Specifies the color to display in the dialog.
+  #
+  #   parent: window
+  #     Makes window the logical parent of the color dialog.
+  #     The dialog is displayed on top of its parent window.
+  #
+  #   title: string
+  #     Specifies a string to display as the title of the dialog box.
+  #     If this option is not specified, then a default title will be displayed.
+  #
+  # @example usage
+  #
+  #   Tk::Button.new(Tk.root,
+  #     bg: Tk.choose_color(initial_color: 'gray', title: 'Choose color'))
+  def choose_color(options = None)
+    Tk.execute(:tk_chooseColor, options.to_tcl_options?).to_s?
+  end
+end

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

@@ -0,0 +1,45 @@
+module Tk
+  module_function
+
+  # Pops up a dialog box for the user to select a directory.
+  #
+  # The following options are possible:
+  #
+  #   initialdir: dirname
+  #     Specifies that the directories in directory should be displayed when the
+  #     dialog pops up.
+  #     If this parameter is not specified, then the directories in the current
+  #     working directory are displayed.
+  #     If the parameter specifies a relative path, the return value will
+  #     convert the relative path to an absolute path.
+  #
+  #   mustexist: boolean
+  #     Specifies whether the user may specify non-existent directories.
+  #     If this parameter is true, then the user may only select directories
+  #     that already exist.
+  #     The default value is false.
+  #
+  #   parent: window
+  #     Makes window the logical parent of the dialog.
+  #     The dialog is displayed on top of its parent window.
+  #     On Mac OS X, this turns the file dialog into a sheet attached to the
+  #     parent window.
+  #
+  #   title: string
+  #     Specifies a string to display as the title of the
+  #     dialog box.
+  #     If this option is not specified, then a default title will be displayed.
+  #
+  # @example usage
+  #
+  #   dir = Tk.choose_directory(initialdir: '~', title: 'Choose a directory')
+  #
+  #   if dir
+  #     Tk::Label.new(Tk.root, text: "Selected #{dir}")
+  #   else
+  #     Tk::Label.new(Tk.root, text: 'No directory selected')
+  #   end
+  def choose_directory(options = None)
+    Tk.execute(:tk_chooseDirectory, options.to_tcl_options?).to_s?
+  end
+end

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

@@ -0,0 +1,102 @@
+module Tk
+  # Manipulate Tk clipboard
+  #
+  # This command provides an interface to the Tk clipboard, which stores data
+  # for later retrieval.
+  # In order to copy data into the clipboard, [Clipboard.clear] must be called,
+  # followed by a sequence of one or more calls to [Clipboard.append].
+  # To ensure that the clipboard is updated atomically, all appends should be
+  # completed before returning to the event loop.
+  module Clipboard
+    def clipboard_clear
+      Clipboard.clear(self)
+    end
+
+    def clipboard_append(options = {})
+      Clipboard.append({displayof: self}.merge(options))
+    end
+
+    def clipboard_get(type = None)
+      Clipboard.get(self, type)
+    end
+
+    def clipboard_set(string, options = {})
+      clipboard_clear
+      clipboard_append(options.merge(data: string))
+    end
+
+    module_function
+
+    # Claims ownership of the clipboard on window's display and removes any
+    # previous contents.
+    # Window defaults to ".".
+    def clear(window = None)
+      if None == window
+        Tk.execute_only(:clipboard, :clear)
+      else
+        Tk.execute_only(:clipboard, :clear, '-displayof', window)
+      end
+    end
+
+    # Appends data to the clipboard on window's display in the form given by
+    # +type+ with the representation given by +format+ and claims ownership of
+    # the clipboard on window's display.
+    #
+    # +type+ specifies the form in which the selection is to be returned (the
+    # desired "target" for conversion, in ICCCM terminology), and should be an
+    # atom name such as STRING or FILE_NAME; see the Inter-Client Communication
+    # Conventions Manual for complete details.
+    # +type+ defaults to STRING.
+    #
+    # The +format+ argument specifies the representation that should be used to
+    # transmit the selection to the requester (the second column of Table 2 of
+    # the ICCCM), and defaults to STRING.
+    #
+    # If +format+ is STRING, the selection is transmitted as 8-bit ASCII
+    # characters. If +format+ is ATOM, then the data is divided into fields
+    # separated by white space; each field is converted to its atom value, and
+    # the 32-bit atom value is transmitted instead of the atom name.
+    # For any other +format+, data is divided into fields separated by white
+    # space and each field is converted to a 32-bit integer; an array of
+    # integers is transmitted to the selection requester.
+    # Note that strings passed to clipboard append are concatenated before
+    # conversion, so the caller must take care to ensure appropriate spacing
+    # across string boundaries.
+    # All items appended to the clipboard with the same +type+ must have the
+    # same +format+.
+    # The +format+ is needed only for compatibility with clipboard requesters
+    # that do not use Tk.
+    # If the Tk toolkit is being used to retrieve the CLIPBOARD selection then
+    # the value is converted back to a string at the requesting end, so +format+
+    # is irrelevant.
+    def append(options = {})
+      args = []
+
+      displayof, format, type, data =
+        options.values_at(:displayof, :format, :type, :data)
+
+      format = format.to_s.upcase if format
+
+      args << "-displayof" << displayof if displayof
+      args << "-format" << format.to_s.upcase if format
+      args << "-type" << type.to_s.upcase if type
+      args << "--" << data.to_s
+
+      Tk.execute_only(:clipboard, :append, *args)
+    end
+
+    # Retrieve data from the clipboard on +window+'s display.
+    # +window+ defaults to ".".
+    # +type+ specifies the form in which the data is to be returned and should be
+    # an atom name such as STRING or FILE_NAME.
+    # +type+ defaults to STRING.
+    # This is equivalent to `Selection.get(selection: :clipboard)`.
+    def get(window = None, type = None)
+      options = {}
+      options[:displayof] = window unless None == window
+      options[:type] = type.to_s.upcase unless None == type
+
+      Tk.execute(:clipboard, :get, options.to_tcl_options).to_s
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Tk
+  module Configure
+    # Query or modify the configuration options of the widget.
+    # 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.
+    # Option may have any of the values accepted by the text command.
+    #
+    # @example Usage
+    #   text.configure(width: 100, height: 200)
+    #   text.configure(:width)
+    #   text.configure
+    def configure(argument = None, hints = {})
+      common_configure([:configure], argument, hints)
+    end
+
+    private
+
+    def self.common(receiver, invocation, argument, hints = {})
+      result =
+        if None == argument
+          receiver.execute(*invocation)
+        elsif argument.respond_to?(:to_tcl_options)
+          receiver.execute_only(*invocation, argument.to_tcl_options)
+        elsif argument.respond_to?(:to_tcl_option)
+          receiver.execute(*invocation, argument.to_tcl_option)
+        else
+          raise ArgumentError, "Invalid argument: %p" % [argument]
+        end
+
+      if result.respond_to?(:tcl_options_to_hash)
+        result.tcl_options_to_hash(hints)
+      else
+        result
+      end
+    end
+
+    def common_configure(invocation, argument, hints = {})
+      Configure.common(self, invocation, argument, hints)
+    end
+
+    def register_command(name, &block)
+      case name
+      when :validatecommand
+        # %d Type of action: 1 for insert, 0 for delete, or -1 for focus, forced
+        #    or textvariable validation.
+        # %i Index of char string to be inserted/deleted, if any, otherwise -1.
+        # %P The value of the entry if the edit is allowed.
+        #    If you are configuring the entry widget to have a new textvariable,
+        #    this will be the value of that textvariable.
+        # %s The current value of entry prior to editing.
+        # %S The text string being inserted/deleted, if any, {} otherwise.
+        # %v The type of validation currently set.
+        # %V The type of validation that triggered the callback (key, focusin,
+        #    focusout, forced).
+        # %W The name of the entry widget.
+        arg = '%d %i %P %s %S %v %V %W'
+      else
+        arg = ''
+      end
+
+      @commands ||= {}
+
+      unregister_command(name)
+      id, command = Tk.register_proc(block, arg)
+      @commands[name] = id
+
+      return command
+    end
+
+    def unregister_command(name, id = @commands[name])
+      return unless id
+      @commands.delete(id)
+      Tk.unregister_proc(id)
+    end
+
+    def unregister_commands
+      return unless @commands
+      @commands.each{|name, id| unregister_command(name, id) }
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Tk
+  module Destroy
+    def self.destroy(*windows)
+      Tk.unregister_objects(*windows)
+      Tk.execute_only('destroy', *windows)
+    end
+
+    def destroy
+      Destroy.destroy(self)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Tk
+  module_function
+
+  # Create modal dialog and wait for response
+  #
+  # @param window
+  #   Name of top-level window to use for dialog.
+  #   Any existing window by this name is destroyed.
+  #
+  # @param title [String]
+  #   Text to appear in the window manager's title bar for the dialog.
+  #
+  # @param text [String]
+  #   Message to appear in the top portion of the dialog box.
+  #
+  # @param bitmap [nil String]
+  #   If non-nil, specifies a bitmap to display in the top portion of the
+  #   dialog, to the left of the text.
+  #   If this is nil then no bitmap is displayed in the dialog.
+  #
+  # @param default [nil Fixnum]
+  #   If this is an integer greater than or equal to zero, then it gives the
+  #   index of the button that is to be the default button for the dialog (0 for
+  #   the leftmost button, and so on).
+  #   If less than zero or nil then there will not be any default button.
+  #
+  # @param answers
+  #   There will be one button for each of these arguments.
+  #   Each answer element specifies text to display in a button, in order from
+  #   left to right.
+  #
+  # After creating a dialog box, [dialog] waits for the user to select one of
+  # the buttons either by clicking on the button with the mouse or by typing
+  # return to invoke the default button (if any).
+  #
+  # Then it returns the index of the selected button: 0 for the leftmost button,
+  # 1 for the button next to it, and so on.
+  # If the dialog's window is destroyed before the user selects one of the
+  # buttons, then nil is returned.
+  #
+  # While waiting for the user to respond, [dialog] sets a local grab.
+  # This prevents the user from interacting with the application in any way
+  # except to invoke the dialog box.
+  #
+  # @example usage
+  #
+  #   reply = Tk.dialog('.foo', 'The Title', 'Do you want to say yes?',
+  #     'questhead', 0, 'Yes', 'No', "I'm not sure")
+  def dialog(window, title, text, bitmap, default, *answers)
+    answer = Tk.execute(:tk_dialog,
+      window, title, text, bitmap, default, *answers).to_i
+    return answer unless answer == -1
+  end
+end

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

@@ -0,0 +1,79 @@
+module Tk
+  # Miscellaneous event facilities: define virtual events and generate events
+  #
+  # The event command provides several facilities for dealing with window system
+  # events, such as defining virtual events and synthesizing events.
+  #
+  # Please note that virtual event means events that are generated inside the
+  # application and are written as "<<virtual>>", where virtual is the name of the
+  # event.
+  #
+  # Sequences are names for single keys, or key combinations, also various other
+  # actions create events, such as <MouseWheel> or <Destroy>.
+  # A sequence is written as "<Control-Alt-Delete>", so only one enclosing <>
+  # pair to distinguish them from virtual events.
+  module Event
+    # Associates the virtual event virtual with the physical event sequence(s)
+    # given by the sequence arguments, so that the virtual event will trigger
+    # whenever any one of the sequences occurs.
+    # Virtual may be any string value and sequence may have any of the values
+    # allowed for the sequence argument to the bind command.
+    # If virtual is already defined, the new physical event sequences add to the
+    # existing sequences for the event.
+    def self.add(virtual, *sequences)
+      Tk.execute_only(:event, :add, virtual, *sequences)
+    end
+
+    # Deletes each of the sequences from those associated with the virtual event
+    # given by virtual.
+    # Virtual may be any string value and sequence may have any of the values
+    # allowed for the sequence argument to the bind command.
+    # Any sequences not currently associated with virtual are ignored.
+    # If no sequence argument is provided, all physical event sequences are
+    # removed for virtual, so that the virtual event will not trigger anymore.
+    def self.delete(virtual, *sequences)
+      Tk.execute_only(:event, :delete, virtual, *sequences)
+    end
+
+    # Generates a window event and arranges for it to be processed just as if it
+    # had come from the window system.
+    # +window+ gives the path name of the window for which the event will be
+    # generated; it may also be an identifier (such as returned by winfo id) as
+    # long as it is for a window in the current application.
+    # Event provides a basic description of the event, such as <Shift-Button-2>
+    # or <<Paste>>.
+    # If +window+ is empty the whole screen is meant, and coordinates are
+    # relative to the screen.
+    # Event may have any of the forms allowed for the sequence argument of the
+    # bind command except that it must consist of a single event pattern, not a
+    # sequence.
+    #
+    # +options+ may be used to specify additional attributes of the event, such
+    # as the x and y mouse position.
+    # See the documentation of [EventData] for a comprehensive list.
+    #
+    # If the :when option is not specified, the event is processed immediately:
+    # all of the handlers for the event will complete before the event generate
+    # command returns
+    #
+    # If the :when option is specified then it determines when the event is
+    # processed. Certain events, such as key events, require that the window has
+    # focus to receive the event properly.
+    def self.generate(window = None, event = None, options = {})
+      Tk.execute_only(:event, :generate, window, event, options)
+    end
+
+    # Returns information about virtual events.
+    # If the <<virtual>> argument is omitted, the return value is a list of all
+    # the virtual events that are currently defined.
+    #
+    # If <<virtual>> is specified then the return value is a list whose elements
+    # are the physical event sequences currently defined for the given virtual
+    # event; if the virtual event is not defined then an empty string is
+    # returned. Note that virtual events that that are not bound to physical
+    # event sequences are not returned by event info.
+    def self.info(virtual = None)
+      Tk.execute(:event, :info, virtual).to_a
+    end
+  end
+end