fxruby 1.6.19-x86-mingw32

data/lib/fox16/input.rb

@@ -0,0 +1,59 @@
+module Fox
+  
+  class FXApp
+
+    alias addInputOrig addInput # :nodoc:
+
+    #
+    # Add a file descriptor _fileDesc_ to be watched for activity as determined
+    # by _mode_, where _mode_ is a bitwise OR (+INPUT_READ+, +INPUT_WRITE+, +INPUT_EXCEPT+).
+    # A message of type +SEL_IO_READ+, +SEL_IO_WRITE+, or +SEL_IO_EXCEPT+ will be sent 
+    # to the target when the specified activity is detected on the file descriptor.
+    #
+    # There are several forms for #addInput; the original form (from FOX)
+    # takes four arguments:
+    #
+    #   anApp.addInput(fileDesc, mode, anObject, aMessageId)
+    #
+    # A second form takes three arguments:
+    #
+    #   anApp.addInput(fileDesc, mode, aMethod)
+    #
+    # For this form, _aMethod_ should have the standard argument list
+    # for a FOX message handler. That is, the method should take three
+    # arguments, for the message _sender_ (an FXObject), the message _selector_,
+    # and the message _data_ (if any).
+    #
+    # The last form of #addInput takes a block:
+    #
+    #   anApp.addInput(fileDesc, mode) { |sender, sel, data|
+    #     ... handle the I/O event ...
+    #   }
+    #
+
+    def addInput(fd, mode, *args, &block)
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      tgt, sel = nil, 0
+      if args.length > 0
+        if args[0].respond_to? :call
+          tgt = FXPseudoTarget.new
+          tgt.pconnect(SEL_IO_READ, args[0], params)
+          tgt.pconnect(SEL_IO_WRITE, args[0], params)
+          tgt.pconnect(SEL_IO_EXCEPT, args[0], params)
+        else # it's some other kind of object
+          tgt = args[0]
+          sel = args[1]
+        end
+      else
+        tgt = FXPseudoTarget.new
+        tgt.pconnect(SEL_IO_READ, block, params)
+        tgt.pconnect(SEL_IO_WRITE, block, params)
+        tgt.pconnect(SEL_IO_EXCEPT, block, params)
+      end
+      addInputOrig(fd, mode, tgt, sel)
+    end
+    
+  end # class FXApp
+  
+end # module Fox

data/lib/fox16/irb.rb

@@ -0,0 +1,178 @@
+#! /usr/bin/env ruby
+
+#
+# This is version 0.1.1 of Gilles Filippini's FXIrb, an attempt to embed
+# IRB into an FXRuby FXText widget. The master page for this is here:
+#
+#	http://www.rubygarden.org/ruby?FXIrb
+#
+# TODO
+# - handle user input redirection
+# - ^D
+# - readonly everywhere but for the command line
+# - readline
+
+require "irb"
+require "singleton"
+require "fcntl"
+
+module IRB
+  def IRB.start_in_fxirb(redir)
+    IRB.initialize(nil)
+    IRB.parse_opts
+    IRB.load_modules
+
+    irb = Irb.new(nil, redir)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+    
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+    print "\n"
+  end
+end
+
+class Redirect < IRB::StdioInputMethod
+	def initialize(dest)
+		super()
+		@dest = dest
+	end
+
+	def gets 
+		close
+		@dest.write(prompt)
+		str = @dest.gets(@prompt)
+		if /^exit/ =~ str
+			exit
+		end
+		@line[@line_no += 1] = str
+	end
+
+	def close
+		if @thread
+			$defout = @old_out.dup
+			$stderr = @old_err.dup
+			$stdin = @old_in.dup
+			@output[1].close
+			@thread.join
+		end
+	end
+
+	def redir
+		@output = IO.pipe
+		@old_out = $defout.dup
+		@old_err = $stderr.dup
+		@old_in = $stdin.dup
+		$stdin = @dest.input[0]
+		$defout = $stderr = @output[1]
+		@output[1].fcntl(Fcntl::F_SETFL, File::NONBLOCK)
+		@thread = Thread.new {
+			while not @output[0].eof?
+				select([@output[0]])
+				@dest.write(@output[0].read)
+			end
+			@output[0].close
+		}
+	end
+end
+
+module Fox
+  class FXIrb < FXText
+	  include Singleton
+	  include Responder
+
+	  attr_reader :input
+
+	  def FXIrb.init(p, tgt, sel, opts)
+		  unless @__instance__
+			  Thread.critical = true
+			  begin
+				  @__instance__ ||= new(p, tgt, sel, opts)
+			  ensure
+				  Thread.critical = false
+			  end
+		  end
+		  return @__instance__
+	  end
+
+	  def initialize(p, tgt, sel, opts)
+		  FXMAPFUNC(SEL_KEYRELEASE, 0, "onKeyRelease")
+
+		  super
+		  setFont(FXFont.new(FXApp.instance, "-misc-fixed-medium-r-semicondensed-*-*-120-*-*-c-*-iso8859-1"))
+	  end
+
+	  def create
+		  super
+		  setFocus
+		  # IRB initialization
+		  @redir = Redirect.new(self)
+		  @input = IO.pipe
+		  @irb = Thread.new {
+			  IRB.start_in_fxirb(@redir)
+		  }
+	  end
+
+	  def onKeyRelease(sender, sel, event)
+		  if [Fox::KEY_Return, Fox::KEY_KP_Enter].include?(event.code)
+			  newLineEntered
+		  end
+		  return 1
+	  end
+
+	  def newLineEntered
+		  if @running
+			  start = prevLine(getLength)
+			  @input[1].puts(extractText(start, getLength - start))
+		  else
+			  processCommandLine(extractText(@anchor, getLength-@anchor))
+		  end
+	  end
+
+	  def processCommandLine(cmd)
+		  @redir.redir
+		  @running = true
+		  @input[1].puts cmd
+	  end
+
+	  def sendCommand(cmd)
+		  setCursorPos(getLength)
+		  makePositionVisible(getLength) unless isPosVisible(getLength)
+		  cmd += "\n"
+		  appendText(cmd)
+		  processCommandLine(cmd)
+	  end
+
+	  def write(obj)
+		  str = obj.to_s
+		  appendText(str)
+		  setCursorPos(getLength)
+		  makePositionVisible(getLength) unless isPosVisible(getLength)
+		  return str.length
+	  end
+
+	  def gets(prompt)
+		  @running = false
+		  @anchor = getLength
+		  return @input[0].gets
+	  end
+  end
+end
+
+# Stand alone run
+if __FILE__ == $0
+  include Fox
+  application = FXApp.new("FXIrb", "ruby")
+  Thread.abort_on_exception = true
+  application.init(ARGV)
+  window = FXMainWindow.new(application, "FXIrb", nil, nil, DECOR_ALL, 0, 0, 580, 600)
+  FXIrb.init(window, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+  application.create
+  window.show(PLACEMENT_SCREEN)
+  application.run
+end

data/lib/fox16/iterators.rb

@@ -0,0 +1,420 @@
+module Fox
+
+  class FXComboBox
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+    
+    #
+    # Calls block once for each item in the list, passing the item's text and
+    # user data as parameters.
+    #
+    def each # :yields: itemText, itemData
+      0.upto(numItems - 1) do |i|
+        yield getItemText(i), getItemData(i)
+      end
+      self
+    end
+  end
+
+  class FXFoldingList
+
+    include Enumerable
+
+    #
+    # Calls block once for each root-level folding list item, passing a
+    # reference to that item as a parameter.
+    #
+    def each # :yields: aFoldingItem
+      current = firstItem
+      while current != nil
+        next_current = current.next
+        yield current
+        current = next_current
+      end
+      self
+    end
+  end
+
+  class FXFoldingItem
+
+    include Enumerable
+
+    #
+    # Calls block once for each child of this folding list item, passing a
+    # reference to that child item as a parameter.
+    #
+    def each # :yields: aFoldingItem
+      current = first
+      while current != nil
+        next_current = current.next
+        yield current
+        current = next_current
+      end
+      self
+    end
+  end
+
+  class FXHeader
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each item in the list, passing a reference to that
+    # item as a parameter.
+    #
+    def each # :yields: aHeaderItem
+      0.upto(numItems - 1) do |i|
+        yield getItem(i)
+      end
+      self
+    end
+  end
+
+  class FXIconList
+
+    include Enumerable
+
+    #
+    # Calls block once for each item in the list, passing a reference to that
+    # item as a parameter.
+    #
+    def each # :yields: anIconItem
+      0.upto(numItems - 1) do |i|
+        yield getItem(i)
+      end
+      self
+    end
+  end
+
+  class FXList
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each item in the list, passing a reference to that
+    # item as a parameter.
+    #
+    def each # :yields: aListItem
+      0.upto(numItems - 1) do |i|
+        yield getItem(i)
+      end
+      self
+    end
+  end
+
+  class FXListBox
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each item in the list, passing the item's text,
+    # icon and user data as parameters.
+    #
+    def each
+      0.upto(numItems - 1) do |i|
+        yield getItemText(i), getItemIcon(i), getItemData(i)
+      end
+      self
+    end
+  end
+
+  class FXTable
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each row in the table, passing an array of
+    # references (one element per column) as a parameter.
+    #
+    def each_row # :yields: itemArray
+      0.upto(numRows - 1) do |i|
+        tableRow = []
+        0.upto(numColumns - 1) do |j|
+          tableRow << getItem(i, j)
+        end
+        yield tableRow
+      end
+      self
+    end
+
+    #
+    # Calls block once for each column in the table, passing an array of
+    # references (one element per row) as a parameter.
+    #
+    def each_column # :yields: itemArray
+      0.upto(numColumns - 1) do |j|
+        tableCol = []
+        0.upto(numRows - 1) do |i|
+          tableCol << getItem(i, j)
+        end
+        yield tableCol
+      end
+      self
+    end
+
+    alias each each_row
+  end
+
+  class FXTreeItem
+
+    include Enumerable
+
+    #
+    # Calls block once for each child of this tree item, passing a
+    # reference to that child item as a parameter.
+    #
+    def each # :yields: aTreeItem
+      current = first
+      while current != nil
+        next_current = current.next
+        yield current
+        current = next_current
+      end
+      self
+    end
+  end
+
+  class FXTreeList
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each root-level tree item, passing a
+    # reference to that item as a parameter.
+    #
+    def each # :yields: aTreeItem
+      current = firstItem
+      while current != nil
+        next_current = current.next
+        yield current
+        current = next_current
+      end
+      self
+    end
+  end
+
+  class FXTreeListBox
+
+    include Enumerable
+
+    #
+    # Override Enumerable#first with FXWindow#first for backwards compatibility.
+    #
+    def first
+      getFirst
+    end
+
+    #
+    # Calls block once for each root-level tree item, passing a
+    # reference to that item as a parameter.
+    #
+    def each # :yields: aTreeItem
+      current = firstItem
+      while current != nil
+        next_current = current.next
+        yield current
+        current = next_current
+      end
+      self
+    end
+  end
+
+  class FXStream
+  end
+
+  class FXFileStream
+    #
+    # Construct a new FXFileStream object with the specified data flow
+    # direction (<em>save_or_load</em>) and _container_ object.
+    # If an optional code block is given, it will be passed this file
+    # stream as an argument, and the file stream will automatically be
+    # closed when the block terminates.
+    # If no code block is provided, this method just returns the
+    # new file stream in an opened state.
+    #
+    # Raises FXStreamNoWriteError if <em>save_or_load</em> is +FXStreamSave+
+    # but the file cannot be opened for writing. Raises FXStreamNoReadError
+    # if <em>save_or_load</em> is +FXStreamLoad+ but the file cannot be opened
+    # for reading.
+    #
+
+    def FXFileStream.open(filename, save_or_load, size=8192, container=nil) # :yields: theFileStream
+      fstream = FXFileStream.new(container)
+      if fstream.open(filename, save_or_load, size)
+      	if block_given?
+      	  begin
+      	    yield fstream
+      	  ensure
+      	    fstream.close
+      	  end
+      	else
+      	  fstream
+      	end
+      else
+        # FXFileStream#open returned false, so report error
+      	raise FXStreamError.makeStreamError(fstream.status)
+      end
+    end
+  end
+
+  class FXMemoryStream
+    #
+    # Construct a new FXMemoryStream object with the specified data flow
+    # direction, data and container object.
+    # If an optional code block is given, it will be passed this memory
+    # stream as an argument, and the memory stream will automatically be
+    # closed when the block terminates.
+    # If no code block is provided, this method just returns the
+    # new memory stream in an opened state.
+    #
+    # Raises FXStreamAllocError if some kind of memory allocation failed
+    # while initializing the stream.
+    #
+    # ==== Parameters:
+    #
+    # +save_or_load+::	access mode, either +FXStreamSave+ or +FXStreamLoad+ [Integer]
+    # +data+::		memory buffer used for the stream, or +nil+ if the buffer is to be initially empty [String].
+    # +cont+::		the container object, or +nil+ if there is none [FXObject]
+    #
+    def FXMemoryStream.open(save_or_load, data, cont=nil) # :yields: theMemoryStream
+      stream = FXMemoryStream.new(cont)
+      if stream.open(save_or_load, data)
+      	if block_given?
+      	  begin
+      	    yield stream
+      	  ensure
+      	    stream.close
+      	  end
+      	else
+      	  stream
+      	end
+      else
+        # FXFileStream#open returned false, so report error
+      	raise FXStreamError.makeStreamError(stream.status)
+      end
+    end
+  end
+
+  class FXApp
+
+    alias beginWaitCursor0 beginWaitCursor # :nodoc:
+
+    #
+    # Changes the default application cursor to an hourglass shape,
+    # to provide a visual cue to the user that it's time to wait.
+    # To revert the default application cursor to its normal shape,
+    # call the #endWaitCursor method. For example,
+    #
+    #    getApp().beginWaitCursor()
+    #      ... time-consuming operation ...
+    #    getApp().endWaitCursor()
+    #
+    # Invocations of #beginWaitCursor may be nested, and if so, the
+    # call to #endWaitCursor is matched with the most recent call to
+    # #beginWaitCursor.
+    #
+    # If an optional code block is provided, #endWaitCursor is
+    # automatically called after the block terminates, e.g.
+    #
+    #    getApp().beginWaitCursor() {
+    #              ... time-consuming operation ...
+    #      ... endWaitCursor() is called automatically ...
+    #    }
+    #
+    def beginWaitCursor
+      beginWaitCursor0
+      if block_given?
+        begin
+      	  yield
+      	ensure
+      	  endWaitCursor
+      	end
+      end
+    end
+  end
+  
+  class FXDCPrint
+
+    alias beginPrint0 beginPrint # :nodoc:
+
+    #
+    # Begin print session described by _job_ (an FXPrinter instance).
+    # If an optional code block is provided, #endPrint is automatically
+    # called after the block terminates.
+    #
+    def beginPrint(job) # :yields: theDC
+      result = beginPrint0(job)
+      if block_given?
+        begin
+      	  yield self
+      	ensure
+      	  endPrint
+      	end
+      else
+        result
+      end
+    end
+
+    alias beginPage0 beginPage # :nodoc:
+
+    #
+    # Generate beginning of _page_ (the page number).
+    # If an optional code block is provided, #endPage is automatically
+    # called after the block terminates.
+    #
+    def beginPage(page=1) # :yields: theDC
+      result = beginPage0(page)
+      if block_given?
+        begin
+      	  yield self
+      	ensure
+      	  endPage
+      	end
+      else
+        result
+      end
+    end
+  end
+end