canvas.rb

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