fxruby 1.6.0 → 1.6.1

data/lib/fox16/aliases.rb

@@ -3695,6 +3695,69 @@ module Fox
     end
   end
 
+  class FXRulerView
+    alias documentX		getDocumentX
+    alias documentY		getDocumentY
+    alias documentColor		getDocumentColor
+    alias documentColor=	setDocumentColor
+    alias documentWidth		getDocumentWidth
+    alias documentWidth=	setDocumentWidth
+    alias documentHeight	getDocumentHeight
+    alias documentHeight=	setDocumentHeight
+    alias hEdgeSpacing 		getHEdgeSpacing
+    alias hEdgeSpacing=		setHEdgeSpacing
+    alias vEdgeSpacing		getVEdgeSpacing
+    alias vEdgeSpacing=		setVEdgeSpacing
+    alias hMarginLower		getHMarginLower
+    alias hMarginLower=		setHMarginLower
+    alias hMarginUpper		getHMarginUpper
+    alias hMarginUpper=		setHMarginUpper
+    alias vMarginLower 		getVMarginLower
+    alias vMarginLower=		setVMarginLower
+    alias vMarginUpper 		getVMarginUpper
+    alias vMarginUpper=		setVMarginUpper
+    alias hAlignment		getHAlignment
+    alias hAlignment=		setHAlignment
+    alias vAlignment		getVAlignment
+    alias vAlignment=		setVAlignment
+    alias hRulerFont		getHRulerFont
+    alias hRulerFont=		setHRulerFont
+    alias vRulerFont 		getVRulerFont
+    alias vRulerFont=		setVRulerFont
+    alias hNumberTicks 		getHNumberTicks
+    alias hNumberTicks=		setHNumberTicks
+    alias vNumberTicks 		getVNumberTicks
+    alias vNumberTicks=		setVNumberTicks
+    alias hMajorTicks 		getHMajorTicks
+    alias hMajorTicks=		setHMajorTicks
+    alias vMajorTicks 		getVMajorTicks
+    alias vMajorTicks=		setVMajorTicks
+    alias hMediumTicks 		getHMediumTicks
+    alias hMediumTicks=		setHMediumTicks
+    alias vMediumTicks 		getVMediumTicks
+    alias vMediumTicks=		setVMediumTicks
+    alias hTinyTicks 		getHTinyTicks
+    alias hTinyTicks=		setHTinyTicks
+    alias vTinyTicks 		getVTinyTicks
+    alias vTinyTicks=		setVTinyTicks
+    alias hPixelsPerTick 	getHPixelsPerTick
+    alias hPixelsPerTick=	setHPixelsPerTick
+    alias vPixelsPerTick 	getVPixelsPerTick
+    alias vPixelsPerTick=	setVPixelsPerTick
+    alias arrowPosX		getArrowPosX
+    alias arrowPosX=		setArrowPosX
+    alias arrowPosY		getArrowPosY
+    alias arrowPosY=		setArrowPosY
+    alias hRulerStyle		getHRulerStyle
+    alias hRulerStyle=		setHRulerStyle
+    alias vRulerStyle		getVRulerStyle
+    alias vRulerStyle=		setVRulerStyle
+    alias helpText		getHelpText
+    alias helpText=		setHelpText
+    alias tipText		getTipText
+    alias tipText=		setTipText
+  end
+
   class FXScrollArea
     def viewportWidth(*args) # :nodoc:
       getViewportWidth(*args)

data/lib/fox16/chore.rb

@@ -3,7 +3,9 @@ require 'fox16'
 module Fox
   class FXApp
 
-    alias addChoreOrig addChore # :nodoc:
+    alias addChoreOrig		addChore # :nodoc:
+    alias removeChoreOrig	removeChore # :nodoc:
+    alias hasChoreOrig?		hasChore? # :nodoc:
 
     #
     # Add a idle processing message to be sent to a target object when
@@ -11,11 +13,13 @@ module Fox
     # There are several forms for #addChore; the original form (from FOX)
     # takes two arguments, a target object and a message identifier:
     #
-    #   anApp.addChore(anObject, aMessageId)
+    #     app.addChore(tgt, sel)
+    #
+    # If a chore with the same target and message already exists, it will be rescheduled.
     #
     # A second form takes a Method instance as its single argument:
     #
-    #   anApp.addChore(aMethod)
+    #     app.addChore(mthd)
     #
     # For this form, the method should have the standard argument list
     # for a FOX message handler. That is, the method should take three
@@ -24,9 +28,9 @@ module Fox
     #
     # The last form takes a block:
     #
-    #   anApp.addChore() { |sender, sel, data|
-    #     ... handle the chore ...
-    #   }
+    #     app.addChore() { |sender, sel, data|
+    #         ... handle the chore ...
+    #     }
     #
     # All of these return a reference to an opaque FXChore instance that
     # can be passed to #removeChore if it is necessary to remove the chore
@@ -46,6 +50,44 @@ module Fox
 	tgt.pconnect(SEL_CHORE, nil, block)
       end
       addChoreOrig(tgt, sel)
+      return { :target => tgt, :selector => sel }
+    end
+
+    #
+    # Remove idle processing message identified by _tgt_ and _sel_.
+    # See the documentation for #hasChore? for an example of how to use
+    # the #removeChore method.
+    #
+    def removeChore(*args)
+      if args.length == 2
+        removeChoreOrig(args[0], args[1])
+      else
+        hsh = args[0]
+        removeChoreOrig(hsh[:target], hsh[:selector])
+      end
+    end
+
+    #
+    # Return +true+ if given chore has been set, otherwise return +false+.
+    #
+    # For example, you might set up a chore at some point in the execution:
+    #
+    #     chore = app.addChore { ... }
+    #
+    # but decide that you want to "cancel" that chore later (before it's had a chance to run):
+    #
+    #     if app.hasChore?(chore)
+    #       app.removeChore(chore)
+    #     end
+    #
+    def hasChore?(*args)
+      if args.length == 2
+        hasChoreOrig?(args[0], args[1])
+      else
+        hsh = args[0]
+        hasChoreOrig?(hsh[:target], hsh[:selector])
+      end
     end
+
   end
 end

data/lib/fox16/core.rb

@@ -567,22 +567,6 @@ module Fox
     end
   end
   
-  def FXDockBar
-    #
-    # Return +true+ if _side_ is an allowed side.
-    #
-    def allowedSide?(side)
-      (allowedSides & side) != 0
-    end
-    
-    #
-    # Add _side_ as an allowed side.
-    #
-    def allowSide(side)
-      self.allowedSides = allowedSides & side
-    end
-  end
-
   class FXHVec
     def normalize!
       normalized = self.normalize

data/lib/fox16/timeout.rb

@@ -3,25 +3,31 @@ require 'fox16'
 module Fox
   class FXApp
 
-    alias addTimeoutOrig addTimeout # :nodoc:
+    alias addTimeoutOrig	addTimeout # :nodoc:
+    alias removeTimeoutOrig	removeTimeout # :nodoc:
+    alias hasTimeoutOrig	hasTimeout? # :nodoc:
+    alias remainingTimeoutOrig	remainingTimeout # :nodoc:
 
     #
-    # Register a timeout message to be sent to a target object;
-    # the timer fires only once after the interval expires.
+    # Add a timeout message to be sent to target object in _ms_ milliseconds;
+    # the timer fires only once after the interval expires.  The last argument
+    # is optional user data which will be passed along as the _ptr_ argument of
+    # the message handler. If a timer with the same target and message already exists,
+    # it will be rescheduled.
     #
     # There are several forms for #addTimeout; the original form (from FOX)
     # takes three arguments:
     #
-    #   anApp.addTimeout(aDelay, anObject, aMessageId)
+    #     timeout = app.addTimeout(delay, tgt, sel)
     #
-    # Here, _aDelay_ is the time interval (in milliseconds) to wait
+    # Here, _delay_ is the time interval (in milliseconds) to wait
     # before firing this timeout. The second and third arguments are the
     # target object and message identifier for the message to be sent when
     # this timeout fires.
     #
     # A second form of #addTimeout takes a Method instance as its single argument:
     #
-    #   anApp.addTimeout(aDelay, aMethod)
+    #     timeout = app.addTimeout(delay, mthd)
     #
     # For this form, the method should have the standard argument list
     # for a FOX message handler. That is, the method should take three
@@ -30,11 +36,11 @@ module Fox
     #
     # The last form of #addTimeout takes a block:
     #
-    #   anApp.addTimeout(aDelay) { |sender, sel, data|
-    #     ... handle the chore ...
-    #   }
+    #     timeout = app.addTimeout(delay) { |sender, sel, data|
+    #         ... handle the timeout ...
+    #     }
     #
-    # All of these return a reference to an opaque FXTimer instance that
+    # All of these return a reference to an opaque object (actually, a hash) that
     # can be passed to #removeTimeout if it is necessary to remove the timeout
     # before it fires.
     #
@@ -53,6 +59,64 @@ module Fox
 	tgt.pconnect(SEL_TIMEOUT, nil, block)
       end
       addTimeoutOrig(tgt, sel, ms)
+      return { :target => tgt, :selector => sel }
+    end
+
+    #
+    # Remove timeout previously registered using #addTimeout; returns +nil+.
+    # For an example of how to use #removeTimeout, see the documentation for
+    # the #hasTimeout? method.
+    #
+    def removeTimeout(*args)
+      if args.length == 2
+        removeTimeoutOrig(args[0], args[1])
+      else
+        hsh = args[0]
+        removeTimeoutOrig(hsh[:target], hsh[:selector])
+      end
+    end
+
+    #
+    # Return +true+ if given timeout has been set, otherwise return +false+.
+    #
+    # For example, suppose you set up a timeout event to run ten seconds from
+    # now:
+    #
+    #     timeout = app.addTimeout(10*1000, ...)
+    #
+    # but in the meantime, you decide that you want to cancel it if it hasn't
+    # run yet:
+    #
+    #     if app.hasTimeout?(timeout)
+    #       app.removeTimeout(timeout)
+    #     end
+    #
+    def hasTimeout?(*args)
+      if args.length == 2
+        hasTimeoutOrig?(args[0], args[1])
+      else
+        hsh = args[0]
+        hasTimeoutOrig?(hsh[:target], hsh[:selector])
+      end
+    end
+
+    #
+    # Return the time remaining (in milliseconds) until the given timer fires.
+    # If the timer is past due, zero is returned. If there is no such
+    # timer, infinity (UINT_MAX) is returned.
+    #
+    # For example:
+    #
+    #     timeout = app.addTimeout(ms, ...)
+    #     time_left = app.remainingTimeout(timeout)
+    #
+    def remainingTimeout(*args)
+      if args.length == 2
+        remainingTimeoutOrig(args[0], args[1])
+      else
+        hsh = args[0]
+        remainingTimeoutOrig(hsh[:target], hsh[:selector])
+      end
     end
   end
 end

data/lib/fox16/version.rb

@@ -5,7 +5,7 @@ module Fox
   # Returns the FXRuby version number as a string, e.g. "1.0.19".
   #
   def Fox.fxrubyversion
-    "1.6.0"
+    "1.6.1"
   end
 end
 

data/rdoc-sources/FXApp.rb

@@ -300,83 +300,11 @@ module Fox
     # Return +true+ if input methods are supported.
     def hasInputMethod?; end
 
-    #
-    # Add timeout message to be sent to target object in _ms_ milliseconds;
-    # the timer fires only once after the interval expires.  The last argument
-    # is optional user data which will be passed along as the _ptr_ argument of
-    # the message handler. If a timer with the same target and message already exists,
-    # it will be rescheduled.
-    #
-    # ==== Parameters:
-    #
-    # +ms+::	timeout interval, in milliseconds [Integer]
-    # +tgt+::	target object for the timeout [FXObject]
-    # +sel+::	message identifier for the timeout [Integer]
-    # +ptr+::	user data [Object]
-    #
-    def addTimeout(ms, tgt, sel, ptr=nil) ; end
-
-    #
-    # Remove timeout identified by _tgt_ and _sel_; returns +nil+.
-    #
-    # ==== Parameters:
-    #
-    # +tgt+::	target object for the timeout [FXObject]
-    # +sel+::	message identifier for the timeout [Integer]
-    #
-    def removeTimeout(tgt, sel); end
-
-    #
-    # Return +true+ if given timeout has been set, otherwise return +false+.
-    #
-    # ==== Parameters:
-    #
-    # +tgt+::	target object for the timeout [FXObject]
-    # +sel+::	message identifier for the timeout [Integer]
-    #
-    def hasTimeout?(tgt, sel); end
-
-    #
-    # Return the time remaining (in milliseconds) until the given timer fires.
-    # If the timer is past due, zero is returned.  If there is no such
-    # timer, infinity (UINT_MAX) is returned.
-    #
-    # ==== Parameters:
-    #
-    # +tgt+::	target object for the timeout [FXObject]
-    # +sel+::	message identifier for the timeout [Integer]
-    #
-    def remainingTimeout(tgt, sel); end
-    
     #
     # Process any timeouts due at this time.
     #
     def handleTimeouts(); end
     
-    #
-    # Add a idle processing message to be sent to target object when
-    # the system becomes idle, i.e. there are no events to be processed.
-    # The void* ptr is user data which will be passed into the void* ptr
-    # of the message handler. If a chore with the same target and message
-    # already exists, it will be rescheduled.
-    #
-    def addChore(tgt, sel, ptr=nil) ; end
-
-    #
-    # Remove idle processing message identified by _tgt_ and _sel_.
-    #
-    def removeChore(tgt, sel); end
-
-    #
-    # Return +true+ if given chore has been set, otherwise return +false+.
-    #
-    # ==== Parameters:
-    #
-    # +tgt+::	target object for the chore [FXObject]
-    # +sel+::	message identifier for the chore [Integer]
-    #
-    def hasChore?(tgt, sel); end
-
     #
     # Add signal processing message to be sent to target object when 
     # the signal _sig_ is raised; flags are to be set as per POSIX definitions.

data/rdoc-sources/FXFont.rb

@@ -219,6 +219,9 @@ module Fox
     
     # Font angle [Integer]
     attr_accessor :angle
+    
+    # Font description as a string [String]
+    attr_accessor :font.
 
     # First character glyph in font [Integer]
     attr_reader	:minChar

data/rdoc-sources/FXRulerView.rb

@@ -0,0 +1,225 @@
+module Fox
+  #
+  # The Ruler View provides viewing of a document with rulers.
+  # It is intended to be subclassed in order to draw actual contents
+  # and provide editing behavior for the document.
+  # The ruler view itself simply manages the geometry of the document
+  # being edited, and coordinates the movement of the ruler displays
+  # as the document is being scrolled.
+  #
+  class FXRulerView < FXScrollArea
+
+    # Return a reference to the horizontal ruler [FXRuler]
+    attr_reader :horizontalRuler
+
+    # Return a reference to the vertical ruler [FXRuler]
+    attr_reader :verticalRuler
+
+    # Get document position X [Integer]
+    attr_reader :documentX
+
+    # Get document position Y [Integer]
+    attr_reader :documentY
+
+    # Current document color [FXColor]
+    attr_accessor :documentColor
+
+    # X arrow position, relative to document position [Integer]
+    attr_accessor :arrowPosX
+
+    # Y arrow position in document, relative to document position [Integer]
+    attr_accessor :arrowPosY
+
+    # Horizontal ruler style[Integer]
+    attr_accessor :hRulerStyle
+
+    # Vertical ruler style [Integer]
+    attr_accessor :vRulerStyle
+
+    # Status line help text [String]
+    attr_accessor :helpText
+
+    # Tool tip message [String]
+    attr_accessor :tipText
+    
+    # Document width [Integer]
+    attr_accessor :documentWidth
+    
+    # Document height [Integer]
+    attr_accessor :documentHeight
+    
+    # Horizontal edge spacing around document [Integer]
+    attr_accessor :hEdgeSpacing
+    
+    # Vertical edge spacing around document [Integer]
+    attr_accessor :vEdgeSpacing
+    
+    # Horizontal lower margin [Integer]
+    attr_accessor :hMarginLower
+    
+    # Horizontal upper margin [Integer]
+    attr_accessor :hMarginUpper
+    
+    # Vertical lower margin [Integer]
+    attr_accessor :vMarginLower
+    
+    # Vertical upper margin [Integer]
+    attr_accessor :vMarginUpper
+    
+    # Horizontal alignment; the default is +RULER_ALIGN_NORMAL+ [Integer]
+    attr_accessor :hAlignment
+    
+    # Vertical alignment; the default is +RULER_ALIGN_NORMAL+ [Integer]
+    attr_accessor :vAlignment
+
+    # Horizontal ruler font [FXFont]
+    attr_accessor :hRulerFont
+    
+    # Vertical ruler font [FXFont]
+    attr_accessor :vRulerFont
+    
+    # Horizontal document number placement [Integer]
+    attr_accessor :hNumberTicks
+    
+    # Vertical document number placement [Integer]
+    attr_accessor :vNumberTicks
+    
+    # Horizontal major ticks [Integer]
+    attr_accessor :hMajorTicks
+    
+    # Vertical major ticks [Integer]
+    attr_accessor :vMajorTicks
+
+    # Horizontal medium ticks [Integer]
+    attr_accessor :hMediumTicks
+    
+    # Vertical medium ticks [Integer]
+    attr_accessor :vMediumTicks
+
+    # Horizontal tiny ticks [Integer]
+    attr_accessor :hTinyTicks
+    
+    # Vertical tiny ticks [Integer]
+    attr_accessor :vTinyTicks
+    
+    # Horizontal pixels per tick spacing [Float]
+    attr_accessor :hPixelsPerTick
+    
+    # Vertical pixels per tick spacing [Float]
+    attr_accessor :vPixelsPerTick
+
+    #
+    # Return an initialized FXRulerView instance.
+    #
+    def initialize(p, tgt=nil, sel=0, opts=0, x=0, y=0, w=0, h=0) # :yields: theRulerView
+    end
+ 
+    # Set document width (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the document size is changed.
+    def setDocumentWidth(w, notify=false); end
+    
+    # Set document height (in pixels).
+    def setDocumentHeight(h, notify=false); end
+    
+    # Set horizontal edge spacing around document (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the edge spacing is changed.
+    def setHEdgeSpacing(es, notify=false); end
+    
+    # Set vertical edge spacing around document (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the edge spacing is changed.
+    def setVEdgeSpacing(es, notify=false); end
+    
+    # Set horizontal lower margin (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the margin is changed.
+    def setHMarginLower(marg, notify=false); end
+    
+    # Set horizontal upper margin (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the margin is changed.
+    def setHMarginUpper(marg, notify=false); end
+    
+    # Set vertical lower margin (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the margin is changed.
+    def setVMarginLower(marg, notify=false); end
+    
+    # Set vertical upper margin (in pixels).
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the margin is changed.
+    def setVMarginUpper(marg, notify=false); end
+    
+    # Set horizontal alignment; the default is +RULER_ALIGN_NORMAL+.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the alignment is changed.
+    def setHAlignment(align, notify=false); end
+    
+    # Set vertical alignment; the default is +RULER_ALIGN_NORMAL+.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the alignment is changed.
+    def setVAlignment(align, notify=false); end
+
+    # Set horizontal ruler font.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the font is changed.
+    def setHRulerFont(font, notify=false); end
+    
+    # Set vertical ruler font.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the font is changed.
+    def setVRulerFont(font, notify=false); end
+    
+    # Set number of horizontal "number" ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the number of ticks is changed.
+    def setHNumberTicks(ticks, notify=false); end
+    
+    # Set number of vertical "number" ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the number of ticks is changed.
+    def setVNumberTicks(ticks, notify=false); end
+    
+    # Set number of horizontal major ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the number of ticks is changed.
+    def setHMajorTicks(ticks, notify=false); end
+    
+    # Set number of vertical major ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the number of ticks is changed.
+    def setVMajorTicks(ticks, notify=false); end
+
+    # Set number of horizontal medium ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the number of ticks is changed.
+    def setHMediumTicks(ticks, notify=false); end
+    
+    # Set number of vertical medium ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the number of ticks is changed.
+    def setVMediumTicks(ticks, notify=false); end
+
+    # Set number of horizontal tiny ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the number of ticks is changed.
+    def setHTinyTicks(ticks, notify=false); end
+    
+    # Set number of vertical tiny ticks.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the number of ticks is changed.
+    def setVTinyTicks(ticks, notify=false); end
+    
+    # Set horizontal pixels per tick spacing
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the horizontal
+    # ruler's target after the spacing is changed.
+    def setHPixelsPerTick(space, notify=false); end
+    
+    # Set vertical pixels per tick spacing
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the vertical
+    # ruler's target after the spacing is changed.
+    def setVPixelsPerTick(space, notify=false); end
+  end
+end