fxruby 1.6.20-x86-linux

data/lib/fox16/bitmapview.rb

@@ -0,0 +1,223 @@
+module Fox
+  #
+  # The FXBitmapView widget displays a scrollable view of a bitmap.
+  #
+  # === Bitmap alignment styles
+  #
+  # +BITMAPVIEW_NORMAL+::	Normal mode is centered
+  # +BITMAPVIEW_CENTER_X+::	Centered horizontally
+  # +BITMAPVIEW_LEFT+::		Left-aligned
+  # +BITMAPVIEW_RIGHT+::	Right-aligned
+  # +BITMAPVIEW_CENTER_Y+::	Centered vertically
+  # +BITMAPVIEW_TOP+::		Top-aligned
+  # +BITMAPVIEW_BOTTOM+::	Bottom-aligned
+  #
+  # === Events
+  #
+  # +SEL_RIGHTBUTTONPRESS+::	sent when the right mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_RIGHTBUTTONRELEASE+::	sent when the right mouse button goes up; the message data is an FXEvent instance.
+  #
+  class FXBitmapView < FXScrollArea
+  
+    # Bitmap alignment styles
+    BITMAPVIEW_NORMAL    = 0          # Normal mode is centered
+    BITMAPVIEW_CENTER_X  = 0          # Centered horizontally
+    BITMAPVIEW_LEFT      = 0x00100000 # Left-aligned
+    BITMAPVIEW_RIGHT     = 0x00200000 # Right-aligned
+    BITMAPVIEW_CENTER_Y  = 0,         # Centered vertically
+    BITMAPVIEW_TOP       = 0x00400000 # Top-aligned
+    BITMAPVIEW_BOTTOM    = 0x00800000 # Bottom-aligned
+
+    #
+    # Return an initialized FXBitmapView instance.
+    #
+    def initialize(p, bmp=nil, tgt=nil, sel=0, opts=0, x=0, y=0, w=0, h=0) # :yields: theBitmapView
+      super(p, opts, x, y, w, h)
+      self.flags |= FLAG_ENABLED
+      self.target = tgt
+      self.message = sel
+      @bitmap = bmp
+      @onColor = FXRGB(0, 0, 0)
+      @offColor = backColor
+      @grabx = 0
+      @graby = 0
+    end
+
+    def create
+      super
+      bitmap.create unless bitmap.nil?
+    end
+
+    def detach
+      super
+      bitmap.detach unless bitmap.nil?
+    end
+
+    def canFocus
+      true
+    end
+
+    def getContentWidth
+      bitmap.nil? 1 : bitmap.width
+    end
+
+    def getContentHeight
+      bitmap.nil? 1 : bitmap.height
+    end
+
+    def layout
+      super
+      update
+      self.flags &= ~FLAG_DIRTY
+    end
+
+    # Handle expose (paint) event
+    def onPaint(sender, sel, event)
+      FXDCWindow.new(self, event) do |dc|
+        unless bitmap.nil?
+          ww = bitmap.width
+          hh = bitmap.height
+          xx = pos_x
+          yy = pos_y
+          if ww < viewport_w
+            if (options & BITMAPVIEW_LEFT) != 0
+              xx = 0
+            elsif (options & BITMAPVIEW_RIGHT) != 0
+              xx = viewport_w - ww
+            else
+              xx = (viewport_w - ww)/2
+            end
+          end
+          if hh < viewport_h
+            if (options & BITMAPVIEW_TOP) != 0
+              yy = 0
+            elsif (options & BITMAPVIEW_BOTTOM) != 0
+              yy = viewport_h - hh
+            else
+              yy = (viewport_h - hh)/2
+            end
+          end
+          dc.foreground = onColor
+          dc.background = offColor
+          dc.drawBitmap(bitmap, xx, yy)
+          dc.foreground = backColor
+          xl = xx; xr = xx + ww
+          yt = yy; yb = yy + hh
+          xl = 0 if (xl < 0)
+          xr = viewport_w if (xr > viewport_w)
+          yt = 0 if (yt < 0)
+          yb = viewport_h if (yb > viewport_h)
+          dc.fillRectangle(0, 0, xr, yt)
+          dc.fillRectangle(0, yt, xl, viewport_h - yt)
+          dc.fillRectangle(xr, 0, viewport_w - xr, yb)
+          dc.fillRectangle(xl, yb, viewport_w - xl, viewport_h - yb)
+        else
+          dc.foreground = backColor
+          dc.fillRectangle(0, 0, width, height)
+        end
+      end
+    end
+
+    # Handle right mouse button press
+    def onRightBtnPress(sender, sel, ev)
+      self.flags &= ~FLAG_TIP
+      handle(self, FXSEL(SEL_FOCUS_SELF, 0), ev)
+      if enabled?
+        grab
+        if target && target.handle(self, FXSEL(SEL_RIGHTBUTTONPRESS, message), ev) != 0
+          return 1
+        end
+        self.flags &= ~FLAG_UPDATE
+        self.flags |= FLAG_PRESSED|FLAG_SCROLLING
+        @grabx = ev.win_x - pos_x
+        @graby = ev.win_y - pos_y
+        return 1
+      end
+      return 0
+    end
+
+    # Handle right mouse button release
+    def onRightBtnRelease(sender, sel, ev)
+      if enabled?
+        ungrab
+        self.flags &= ~(FLAG_PRESSED|FLAG_SCROLLING)
+        self.flags |= FLAG_UPDATE
+        if target && target.handle(self, FXSEL(SEL_RIGHTBUTTONPRESS, message), ev) != 0 
+          return 1
+        end
+        return 1
+      end
+      return 0
+    end
+
+    # Handle real or simulated mouse motion
+    def onMotion(sender, sel, ev)
+      if (flags & FLAG_SCROLLING) != 0
+        setPosition(ev.win_x - @grabx, ev.win_y - @graby)
+        return 1
+      end
+      return 0
+    end
+
+    #
+    # Set the bitmap for this FXBitmapView, where _bmp_ is either +nil+ or
+    # a reference to an FXBitmap instance.
+    #
+    def bitmap=(bmp)
+      @bitmap = bmp
+      recalc
+      update
+    end
+
+    #
+    # Return a reference to the bitmap (an FXBitmap instance) for this FXBitmapView,
+    # or +nil+ if no bitmap has been set.
+    #
+    def bitmap; @bitmap; end
+
+    # Set the color used for the "on" bits in the bitmap.
+    def onColor=(clr)
+      if clr != onColor
+        @onColor = clr
+        update
+      end
+    end
+
+    # Return the color used for the "on" bits in the bitmap.
+    def onColor; @onColor; end
+
+    # Set the color used for the "off" bits in the bitmap.
+    def offColor=(clr)
+      if clr != offColor
+        @offColor = clr
+        update
+      end
+    end
+
+    # Return the color used for the "off" bits in the bitmap.
+    def offColor; @offColor; end
+
+    #
+    # Set the current alignment for the bitmap inside the FXBitmapView,
+    # where _mode_ is some combination of the bitmap alignment flags
+    # listed above.
+    #
+    def alignment=(mode)
+      opts = (options & ~(BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM)) |
+             (mode & (BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM))
+      if options != opts
+        @options = opts
+        update
+      end
+    end
+
+    #
+    # Return the current alignment for the bitmap inside the
+    # FXBitmapView.
+    #
+    def alignment
+      options & (BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM)
+    end
+  end
+end
+

data/lib/fox16/calendar.rb

@@ -0,0 +1,217 @@
+#
+# Calendar widget, contributed by
+# David Naseby (david.naseby@eonesolutions.com.au).
+#
+# Still could use methods for:
+#
+# * Get and set the day-of-the-month button properties (e.g. "poppy"
+#   style buttons versus regular pushbuttons)
+# * Setting the date explicitly, possibly also messages like
+#   "advance/back up one day", "advance/back up one month", etc.
+#
+# * Should it have a display-only mode? In other words, buttons
+#   aren't clickable, just labels?
+#
+# Harry Ohlsen (harryo@zip.com.au) also suggests a facility to jump
+# backward or forward a year at a time.
+#
+
+require 'fox16/colors'
+
+module Fox
+
+  # Calendar-specific options
+  CALENDAR_NORMAL = 0
+  CALENDAR_READONLY = 0x00020000
+
+  #
+  # Calendar widget
+  #
+  # == Events
+  #
+  # The following messages are sent by FXCalendar to its target:
+  #
+  # +SEL_COMMAND+::	sent when a day button is clicked; the message data is a Time object indicating the selected date
+  #
+  # == Calendar options
+  #
+  # +CALENDAR_NORMAL+::		normal display mode
+  # +CALENDAR_READONLY+::	read-only mode
+  #
+  class FXCalendar < FXVerticalFrame
+
+    DAYS = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
+
+    # Currently selected date [Time]
+    attr_reader :selected
+    
+    # Font used for days [FXFont]
+    attr_reader :dayLabelFont
+    
+    #
+    # Returns an initialized calendar widget
+    #
+    def initialize(parent, initial_date=Time.now, tgt=nil, sel=0, opts=0, x=0, y=0, w=0, h=0, pl=DEFAULT_PAD, pr=DEFAULT_PAD, pt=DEFAULT_PAD, pb=DEFAULT_PAD)
+      # Initialize the base class first
+      super(parent, opts, x, y, w, h, pl, pr, pt, pb)
+
+      # Save target and selector
+      self.target = tgt
+      self.selector = sel
+
+      @headerBGColor = FXColor::Black
+      @headerFGColor = FXColor::White
+      @dayLabelFont = FXFont.new(getApp, "helvetica", 7)
+      
+      @date_showing = initial_date
+      
+      # Header row
+      @header = FXHorizontalFrame.new(self, LAYOUT_FILL_X)
+      @header.backColor = @headerBGColor
+      @backBtn = FXArrowButton.new(@header, nil, 0, FRAME_RAISED|FRAME_THICK|ARROW_LEFT|ARROW_REPEAT)
+      @backBtn.connect(SEL_COMMAND) do |send, sel, ev|
+        @date_showing = _last_month
+        _build_date_matrix
+        @current_month.text = _header_date
+      end  
+      @current_month = FXLabel.new(@header, _header_date, nil,
+        LAYOUT_FILL_X|JUSTIFY_CENTER_X|LAYOUT_FILL_Y)
+      @current_month.backColor = @headerBGColor
+      @current_month.textColor = @headerFGColor
+      @foreBtn = FXArrowButton.new(@header, nil, 0, FRAME_RAISED|FRAME_THICK|ARROW_RIGHT|ARROW_REPEAT)
+      @foreBtn.connect(SEL_COMMAND) do |send, sel, ev|
+        @date_showing = _next_month
+        _build_date_matrix
+        @current_month.text = _header_date
+      end
+      
+      @matrix = FXMatrix.new(self, 7,
+        MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|PACK_UNIFORM_WIDTH|FRAME_RAISED,
+        0, 0, 0, 0, 0, 0, 0, 0)
+      DAYS.each { |day| _add_matrix_label(day) }
+      (7*6 - 1).times do
+        s = FXSwitcher.new(@matrix,
+          LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FILL_ROW|LAYOUT_FILL_COLUMN, 0,0,0,0,0,0,0,0)
+        FXFrame.new(s, LAYOUT_FILL_X|LAYOUT_FILL_Y, 0,0,0,0,0,0,0,0)
+        btn = FXButton.new(s, '99', nil, nil, 0,
+          LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK,
+          0,0,0,0,0,0,0,0)
+        btn.connect(SEL_COMMAND) do |send, sel, ev|
+          @selected = Time.local(@date_showing.year, @date_showing.month,
+                                 send.text.to_i)
+          target.handle(self, MKUINT(selector, SEL_COMMAND), @selected) if target 
+        end
+      end
+      _build_date_matrix()
+    end
+    
+    # Return the current header background color
+    def headerBackColor
+      @headerBGColor
+    end
+    
+    # Set the header background color
+    def headerBackColor=(clr)
+      @headerBGColor = clr
+      @header.backColor = clr
+      @current_month.backColor = clr
+      DAYS.each_index { |i| @matrix.childAtIndex(i).backColor = clr }
+    end
+    
+    # Return the current header text color
+    def headerTextColor
+      @headerFGColor
+    end
+    
+    # Set the header text color
+    def headerTextColor=(clr)
+      @headerFGColor = clr
+      @current_month.textColor = clr
+      DAYS.each_index { |i| @matrix.childAtIndex(i).textColor = clr }
+    end
+    
+    # Change the font used for the days of the weeks
+    def dayLabelFont=(font)
+      if @dayLabelFont != font
+        @dayLabelFont = font
+        DAYS.each_index { |i| @matrix.childAtIndex(i).font = font }
+	update
+      end
+    end
+    
+    private   
+    def _header_date()
+      @date_showing.strftime("%B, %Y")
+    end
+    
+    def _first_day
+      Time.local(@date_showing.year, @date_showing.month, 1)
+    end
+    
+    def _last_day
+      year = @date_showing.year
+      month = @date_showing.month+1
+      if month > 12
+        year += 1
+        month = 1
+      end
+      Time.local(year, month, 1) - (60*60*24)
+    end
+    
+    def _last_month
+      year = @date_showing.year
+      month = @date_showing.month - 1
+      if month < 1
+        year -= 1
+        month = 12
+      end
+      Time.local(year, month)
+    end
+    
+    def _next_month
+      year = @date_showing.year
+      month = @date_showing.month + 1
+      if month > 12
+        year +=1
+        month = 1
+      end
+      Time.local(year, month)
+    end
+    
+    def _build_date_matrix
+      (0...6*7-1).each do |index|
+        @matrix.childAtRowCol(index/7+1, index.modulo(7)).setCurrent(0)
+      end
+      (_first_day.wday... _last_day.day+_first_day.wday).each do |index|
+        day = index - _first_day.wday + 1
+        switcher = @matrix.childAtRowCol(index/7 + 1, index.modulo(7))
+        switcher.setCurrent(1)
+        switcher.childAtIndex(1).text = day.to_s
+      end
+    end
+    
+    def _add_matrix_label(label)
+      l = FXLabel.new(@matrix, label, nil,
+        LAYOUT_FILL_X|LAYOUT_FILL_COLUMN|JUSTIFY_CENTER_X|FRAME_SUNKEN)
+      l.backColor = @headerBGColor
+      l.textColor = @headerFGColor
+      l.font = @dayLabelFont
+    end
+  end
+end       
+
+if __FILE__ == $0
+
+  include Fox
+
+  app = FXApp.new('Calendar', 'FXRuby')
+  app.init(ARGV)
+  mainwin = FXMainWindow.new(app, "Calendar Test", nil, nil, DECOR_ALL, 0, 0, 500, 500)
+  calendar = FXCalendar.new(mainwin, Time.now, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+  calendar.connect(SEL_COMMAND) do |sender, sel, data|
+    puts data.to_s
+  end
+  app.create
+  mainwin.show(PLACEMENT_SCREEN)
+  app.run
+end

data/lib/fox16/chore.rb

@@ -0,0 +1,105 @@
+module Fox
+  
+  class FXApp
+
+    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
+    # the system becomes idle, i.e. when there are no more events to be processed.
+    # There are several forms for #addChore; the original form (from FOX)
+    # takes two arguments, a target object and a message identifier:
+    #
+    #     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:
+    #
+    #     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
+    # arguments, for the message _sender_ (an FXObject), the message _selector_,
+    # and the message _data_ (if any).
+    #
+    # The last form takes a block:
+    #
+    #     app.addChore() do |sender, sel, data|
+    #         ... handle the chore ...
+    #     end
+    #
+    # 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
+    # before it fires.
+    #
+    # For the last two forms, you can pass in the optional +:repeat+ parameter to
+    # cause the chore to be re-registered after it fires, e.g.
+    #
+    #     chore = app.addChore(:repeat => true) do |sender, sel, data|
+    #         ... handle the chore ...
+    #         ... re-add the chore ...
+    #     end
+    #
+    def addChore(*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 = params[:target] || FXPseudoTarget.new
+          tgt.pconnect(SEL_CHORE, args[0], params)
+        else
+          tgt, sel = args[0], args[1]
+        end
+      else
+        tgt = params[:target] || FXPseudoTarget.new
+        tgt.pconnect(SEL_CHORE, block, params)
+      end
+      addChoreOrig(tgt, sel)
+      params[:target] = tgt
+      params[:selector] = sel
+      params
+    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
+        params = args[0]
+        removeChoreOrig(params[:target], params[: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 # class FXApp
+  
+end # module Fox