fxruby 1.6.27-x64-mingw32

data/lib/fox16/bitmapview.rb

@@ -0,0 +1,222 @@
+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 = Fox.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, Fox.FXSEL(SEL_FOCUS_SELF, 0), ev)
+      if enabled?
+        grab
+        if target && target.handle(self, Fox.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, Fox.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/canvas.rb

@@ -0,0 +1,606 @@
+module Fox
+  #
+  # The Canvas module defines a framework similar to that provided by Tk's Canvas
+  # widget (and subsequent improvements, such as GNOME's Canvas and wxWindows'
+  # Object Graphics Library).
+  #
+  # Links
+  # =====
+  #
+  # Tk's Canvas Widget
+  #     http://starship.python.net/crew/fredrik/tkmanual/canvas.html
+  #     http://www.dci.clrc.ac.uk/Publications/Cookbook/chap4.html
+  #
+  # GNOME's Canvas Widget
+  #     http://developer.gnome.org/doc/whitepapers/canvas/canvas.html
+  #
+  module Canvas
+
+    class CanvasError < Exception
+    end
+
+    class Shape
+
+      attr_accessor :x, :y, :foreground, :target, :selector
+
+      def initialize(x, y)
+        @enabled = true
+        @visible = true
+        @selected = false
+        @draggable = false
+        @x = x
+        @y = y
+        @foreground = FXRGB(0, 0, 0)
+        @target = nil
+        @selector = 0
+      end
+
+      # Return the bounding box for this shape
+      def bounds
+        FXRectangle.new(x, y, width, height)
+      end
+
+      # Hit test
+      def hit?(xpos, ypos)
+        (xpos >= x) && (xpos < x+width) && (ypos >= y) && (ypos < y+height)
+      end
+
+      # Move shape to specified position
+      def move(x, y)
+        @x, @y = x, y
+      end
+
+      # Resize shape to specified width and height
+      def resize(w, h)
+      end
+
+      # Move and resize the shape
+      def position(x, y, w, h)
+        move(x, y)
+        resize(w, h)
+      end
+
+      # Enable this shape
+      def enable
+        @enabled = true
+      end
+
+      # Disable this shape
+      def disable
+        @enabled = false
+      end
+
+      # Is this shape enabled?
+      def enabled?
+        @enabled
+      end
+
+      # Show this shape
+      def show
+        @visible = true
+      end
+
+      # Hide this shape
+      def hide
+        @visible = false
+      end
+
+      # Is this shape visible?
+      def visible?
+        @visible
+      end
+
+      # Select this shape
+      def select
+        @selected = true
+      end
+
+      # Deselect this shape
+      def deselect
+        @selected = false
+      end
+
+      # Is this shape selected?
+      def selected?
+        @selected
+      end
+
+      # Set this shape's draggability
+      def draggable=(d)
+        @draggable = d
+      end
+
+      # Is this shape draggable?
+      def draggable?
+        @draggable
+      end
+
+      # Draw this shape into the specificed device context
+      def draw(dc)
+      end
+
+      # Draws outline
+      def drawOutline(dc, x, y, w, h)
+        points = []
+        points << FXPoint.new(x - 0.5*w, y - 0.5*h)
+        points << FXPoint.new(x + 0.5*w, y)
+        points << FXPoint.new(x + 0.5*w, y + 0.5*h)
+        points << FXPoint.new(x - 0.5*w, y + 0.5*h)
+        points << points[0]
+        dc.drawLines(points)
+      end
+
+      # Default: make 6 control points
+      def makeControlPoints
+      end
+    end
+
+    class ShapeGroup
+
+      include Enumerable
+
+      # Initialize this shape group
+      def initialize
+        @shapes = []
+      end
+
+      # Does the group contain this shape?
+      def include?(shape)
+        @shapes.include?(shape)
+      end
+
+      # Add a shape to this group
+      def addShape(shape)
+        @shapes << shape
+      end
+
+      # Remove a shape from this group
+      def removeShape(shape)
+        @shapes.remove(shape)
+      end
+
+      def each
+        @shapes.each { |shape| yield shape }
+      end
+
+      def reverse_each
+        @shapes.reverse_each { |shape| yield shape }
+      end
+    end
+
+    class LineShape < Shape
+
+      attr_accessor :lineWidth, :lineCap, :lineJoin, :lineStyle
+      attr_accessor :x1, :y1, :x2, :y2
+
+      def initialize(x1, y1, x2, y2)
+        super(x1, y1)
+        @x1, @y1, @x2, @y2 = x1, y1, x2, y2
+        @lineWidth = 1
+        @lineCap = CAP_NOT_LAST
+        @lineJoin = JOIN_MITER
+        @lineStyle = LINE_SOLID
+      end
+
+      def width
+        0
+      end
+
+      def height
+        0
+      end
+
+      def draw(dc)
+        # Save old values
+        oldForeground = dc.foreground
+        oldLineWidth = dc.lineWidth
+        oldLineCap = dc.lineCap
+        oldLineJoin = dc.lineJoin
+        oldLineStyle = dc.lineStyle
+
+        # Set properties for this line
+        dc.foreground = foreground
+        dc.lineWidth = lineWidth
+        dc.lineCap = lineCap
+        dc.lineJoin = lineJoin
+        dc.lineStyle = lineStyle
+
+        # Draw the line
+        dc.drawLine(x1, y1, x2, y2)
+
+        # Restore old properties
+        dc.lineWidth = oldLineWidth
+        dc.lineCap = oldLineCap
+        dc.lineJoin = oldLineJoin
+        dc.lineStyle = oldLineStyle
+        dc.foreground = oldForeground
+      end
+    end
+
+    class RectangleShape < Shape
+
+      attr_accessor :width, :height
+
+      def initialize(x, y, w, h)
+        super(x, y)
+        @width = w
+        @height = h
+      end
+
+      def draw(dc)
+        oldForeground = dc.foreground
+        dc.foreground = foreground
+        dc.drawRectangle(x, y, width, height)
+        dc.foreground = oldForeground
+      end
+    end
+
+    class TextShape < RectangleShape
+
+      attr_reader :font, :text
+
+      def initialize(x, y, w, h, text=nil)
+        super(x, y, w, h)
+        @text = text
+        @font = FXApp.instance.normalFont
+      end
+
+      def draw(dc)
+        super(dc)
+        oldForeground = dc.foreground
+        oldTextFont = dc.font
+        dc.font = @font
+        dc.drawImageText(x, y, text)
+        dc.font = oldTextFont if oldTextFont
+        dc.foreground = oldForeground
+      end
+    end
+
+    class CircleShape < Shape
+
+      attr_accessor :radius
+
+      def initialize(x, y, radius)
+        super(x, y)
+        @radius = radius
+      end
+
+      def width
+        2*radius
+      end
+
+      def height
+        2*radius
+      end
+
+      def draw(dc)
+        oldForeground = dc.foreground
+        oldLineWidth = dc.lineWidth
+        dc.foreground = foreground
+        dc.lineWidth = 5 if selected?
+        dc.drawArc(x, y, width, height,      0, 64*180)
+        dc.drawArc(x, y, width, height, 64*180, 64*360)
+        dc.foreground = oldForeground
+        dc.lineWidth = oldLineWidth
+      end
+    end
+
+    class PolygonShape < Shape
+    end
+
+    class ImageShape < Shape
+
+      attr_accessor :image
+
+      def initialize(x, y, image)
+        @image = image
+      end
+
+      def draw(dc)
+        dc.drawImage(image)
+      end
+    end
+
+    # Base class for canvas selection policies
+    class SelectionPolicy
+      def initialize(canvas)
+        @canvas = canvas
+      end
+
+      def selectShape(shape, notify)
+        unless shape.selected?
+          shape.select
+          @canvas.updateShape(shape)
+          if notify && (@canvas.target != nil)
+            @canvas.target.handle(@canvas, MKUINT(@canvas.message, SEL_SELECTED), shape)
+          end
+        end
+      end
+
+      def deselectShape(shape, notify)
+        if shape.selected?
+          shape.deselect
+          @canvas.updateShape(shape)
+          if notify && (@canvas.target != nil)
+            @canvas.target.handle(@canvas, MKUINT(@canvas.message, SEL_DESELECTED), shape)
+          end
+        end
+      end
+    end
+
+    # Single shape selected at one time
+    class SingleSelectionPolicy < SelectionPolicy
+      def initialize(canvas)
+        super
+      end
+
+      def selectShape(shape, notify)
+        unless shape.selected?
+          @canvas.killSelection(notify)
+        end
+        super
+      end
+    end
+
+    class ShapeCanvas < FXCanvas
+
+      # Window state flags
+      FLAG_SHOWN        = 0x00000001 # Is shown
+      FLAG_ENABLED      = 0x00000002 # Able to receive input
+      FLAG_UPDATE       = 0x00000004 # Is subject to GUI update
+      FLAG_DROPTARGET   = 0x00000008 # Drop target
+      FLAG_FOCUSED      = 0x00000010 # Has focus
+      FLAG_DIRTY        = 0x00000020 # Needs layout
+      FLAG_RECALC       = 0x00000040 # Needs recalculation
+      FLAG_TIP          = 0x00000080 # Show tip
+      FLAG_HELP         = 0x00000100 # Show help
+      FLAG_DEFAULT      = 0x00000200 # Default widget
+      FLAG_INITIAL      = 0x00000400 # Initial widget
+      FLAG_SHELL        = 0x00000800 # Shell window
+      FLAG_ACTIVE       = 0x00001000 # Window is active
+      FLAG_PRESSED      = 0x00002000 # Button has been pressed
+      FLAG_KEY          = 0x00004000 # Keyboard key pressed
+      FLAG_CARET        = 0x00008000 # Caret is on
+      FLAG_CHANGED      = 0x00010000 # Window data changed
+      FLAG_LASSO        = 0x00020000 # Lasso mode
+      FLAG_TRYDRAG      = 0x00040000 # Tentative drag mode
+      FLAG_DODRAG       = 0x00080000 # Doing drag mode
+      FLAG_SCROLLINSIDE = 0x00100000 # Scroll only when inside
+      FLAG_SCROLLING    = 0x00200000 # Right mouse scrolling
+
+      include Responder
+
+      attr_accessor :scene
+
+      def initialize(p, tgt=nil, sel=0, opts=FRAME_NORMAL, x=0, y=0, w=0, h=0)
+        # Initialize base class
+        super(p, tgt, sel, opts, x, y, w, h)
+
+        # Start with an empty group
+        @scene = ShapeGroup.new
+
+        # Selection policy
+        @selectionPolicy = SingleSelectionPolicy.new(self)
+
+        @flags = 0
+
+        # Map
+        FXMAPFUNC(SEL_PAINT, 0, "onPaint")
+        FXMAPFUNC(SEL_MOTION, 0, "onMotion")
+        FXMAPFUNC(SEL_LEFTBUTTONPRESS, 0, "onLeftBtnPress")
+        FXMAPFUNC(SEL_LEFTBUTTONRELEASE, 0, "onLeftBtnRelease")
+        FXMAPFUNC(SEL_CLICKED,0,"onClicked")
+        FXMAPFUNC(SEL_DOUBLECLICKED,0,"onDoubleClicked")
+        FXMAPFUNC(SEL_TRIPLECLICKED,0,"onTripleClicked")
+        FXMAPFUNC(SEL_COMMAND,0,"onCommand")
+      end
+
+      # Find the shape of the least depth containing this point
+      def findShape(x, y)
+        @scene.reverse_each do |shape|
+          return shape if shape.hit?(x, y)
+        end
+        nil
+      end
+
+      # Repaint
+      def updateShape(shape)
+        if @scene.include?(shape)
+          update
+        else
+          raise CanvasError
+        end
+      end
+
+      # Enable one shape
+      def enableShape(shape)
+        if @scene.include?(shape)
+          unless shape.enabled?
+            shape.enable
+            updateShape(shape)
+          end
+        else
+          raise CanvasError
+        end
+      end
+
+      # Disable one shape
+      def disableShape(shape)
+        if @scene.include?(shape)
+          if shape.enabled?
+            shape.disable
+            updateShape(shape)
+          end
+        else
+          raise CanvasError
+        end
+      end
+
+      # Select one shape
+      def selectShape(shape, notify=false)
+        if @scene.include?(shape)
+          @selectionPolicy.selectShape(shape, notify)
+        else
+          raise CanvasError
+        end
+      end
+
+      # Deselect one shape
+      def deselectShape(shape, notify=false)
+        if @scene.include?(shape)
+          @selectionPolicy.deselectShape(shape, notify)
+        else
+          raise CanvasError
+        end
+      end
+
+      # Kill selection
+      def killSelection(notify)
+        changes = false
+        @scene.each do |shape|
+          if shape.selected?
+            shape.deselect
+            updateShape(shape)
+            changes = true
+            if notify && (target != nil)
+              target.handle(self, MKUINT(message, SEL_DESELECTED), shape)
+            end
+          end
+        end
+        changes
+      end
+
+      # Paint
+      def onPaint(sender, sel, evt)
+        dc = FXDCWindow.new(self, evt)
+        dc.foreground = backColor
+        dc.fillRectangle(evt.rect.x, evt.rect.y, evt.rect.w, evt.rect.h)
+        @scene.each do |shape|
+          shape.draw(dc)
+        end
+        dc.end
+        return 1
+      end
+
+      # Motion
+      def onMotion(sender, sel, evt)
+        # Drag and drop mode
+        if (@flags & FLAG_DODRAG) != 0
+          handle(self, MKUINT(0, SEL_DRAGGED), evt)
+          return 1
+        end
+
+        # Tentative drag and drop
+        if (@flags & FLAG_TRYDRAG) != 0
+          if evt.moved?
+            @flags &= ~FLAG_TRYDRAG
+            if handle(this, MKUINT(0, SEL_BEGINDRAG), evt) != 0
+              @flags |= FLAG_DODRAG
+            end
+          end
+          return 1
+        end
+      end
+
+      # Left button press
+      def onLeftBtnPress(sender, sel, evt)
+        handle(self, MKUINT(0, SEL_FOCUS_SELF), evt)
+        if enabled?
+          grab
+          flags &= ~FLAG_UPDATE
+
+          # Give target the first chance at handling this
+          return 1 if target && (target.handle(self, MKUINT(message, SEL_LEFTBUTTONPRESS), evt) != 0)
+
+          # Locate shape
+          shape = findShape(evt.win_x, evt.win_y)
+
+          # No shape here
+          if shape.nil?
+            return 1
+          end
+
+          # Change current shape
+          @currentShape = shape
+
+          # Change item selection
+          if shape.enabled? && !shape.selected?
+            selectShape(shape, true)
+          end
+
+          # Are we dragging?
+          if shape.selected? && shape.draggable?
+            flags |= FLAG_TRYDRAG
+          end
+
+          flags |= FLAG_PRESSED
+          return 1
+        end
+        return 0
+      end
+
+      # Left button release
+      def onLeftBtnRelease(sender, sel, evt)
+        flg = @flags
+        if enabled?
+          ungrab
+          @flags |= FLAG_UPDATE
+          @flags &= ~(FLAG_PRESSED|FLAG_TRYDRAG|FLAG_LASSO|FLAG_DODRAG)
+
+          # First chance callback
+          return 1 if target && target.handle(self, MKUINT(message, SEL_LEFTBUTTONRELEASE), evt) != 0
+
+          # Was dragging
+          if (flg & FLAG_DODRAG) != 0
+            handle(self, MKUINT(0, SEL_ENDDRAG), evt)
+            return 1
+          end
+
+          # Must have pressed
+          if (flg & FLAG_PRESSED) != 0
+            # Change selection
+            if @currentShape && @currentShape.enabled?
+              deselectShape(@currentShape, true)
+            end
+
+            # Generate clicked callbacks
+            if evt.click_count == 1
+              handle(self, MKUINT(0, SEL_CLICKED), @currentShape)
+            elsif evt.click_count == 2
+              handle(self, MKUINT(0, SEL_DOUBLECLICKED), @currentShape)
+            elseif evt.click_count == 3
+              handle(self, MKUINT(0, SEL_TRIPLECLICKED), @currentShape)
+            end
+
+            # Generate command callback only when clicked on item
+            if @currentShape && @currentShape.enabled?
+              handle(self, MKUINT(0, SEL_COMMAND), @currentShape)
+            end
+            return 1
+          end
+          return 0
+        end
+      end
+
+      # Command message
+      def onCommand(sender, sel, ptr)
+        return target && target.handle(self, MKUINT(message, SEL_COMMAND), ptr)
+      end
+
+      # Clicked on canvas
+      def onClicked(sender, sel, ptr)
+        return target && target.handle(self, MKUINT(message, SEL_CLICKED), ptr)
+      end
+
+      # Double-clicked on canvas
+      def onDoubleClicked(sender, sel, ptr)
+        return target && target.handle(self, MKUINT(message, SEL_DOUBLECLICKED), ptr)
+      end
+
+      # Triple-clicked on canvas
+      def onTripleClicked(sender, sel, ptr)
+        return target && target.handle(self, MKUINT(message, SEL_TRIPLECLICKED), ptr)
+      end
+    end
+  end
+end