wxruby3-shapes 0.9.0.pre.beta.3

data/lib/wx/shapes/shape_data_object.rb

@@ -0,0 +1,43 @@
+# Wx::SF::ShapeDataObject - shape data object class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx::SF
+
+  # Class encapsulating data object used during clipboard operations with shapes.
+  class ShapeDataObject < Wx::DataObjectSimpleBase
+
+    DataFormatID = 'ShapeFrameWorkDataFormat1_0'
+
+    # @overload initialize()
+    #   Default constructor
+    # @overload initialize(selection)
+    #   User constructor
+    #   @param [Array<Wx::SF::Shape>] selection List of shapes which should be stored in the data object
+    def initialize(selection = nil)
+      super(Wx::DataFormat.new(DataFormatID))
+      @data = selection ? selection.serialize : ''
+    end
+
+    # Returns size of the data object
+    # @return [Integer]
+    def _get_data_size
+      @data.bytesize
+    end
+
+    # Exports data from data object.
+    # @return [Boolean] true on success, otherwise false
+    def _get_data
+      @data
+    end
+
+    # Function should inport data from data object from given buffer.
+    # @param [String] buf External input data buffer
+    # @return [Boolean] true on success, otherwise false
+    def _set_data(buf)
+      @data = buf ? buf : ''
+      true
+    end
+
+  end
+
+end

data/lib/wx/shapes/shape_handle.rb

@@ -0,0 +1,287 @@
+# Wx::SF::Shape::Handle - shape handle class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx::SF
+
+  class Shape
+
+    # Class encapsulates shape's handle. The class shouldn't be used separately; see
+    # Wx::Shape class for more detailed information about functions used for managing of shape
+    # handles and handling their events
+    class Handle
+
+      # Handle type
+      class TYPE < Wx::Enum
+        LEFTTOP = self.new(0)
+        TOP = self.new(1)
+        RIGHTTOP = self.new(2)
+        RIGHT = self.new(3)
+        RIGHTBOTTOM = self.new(4)
+        BOTTOM = self.new(5)
+        LEFTBOTTOM = self.new(6)
+        LEFT = self.new(7)
+        LINECTRL = self.new(8)
+        LINESTART = self.new(9)
+        LINEEND = self.new(10)
+        UNDEF = self.new(11)
+      end
+
+      # Constructor
+      # @param [Wx::Shape] parent Parent shape
+      # @param [TYPE] type Handle type
+      # @param [Integer] id Handle ID (useful only for line controls handles)
+      def initialize(parent=nil, type=TYPE::UNDEF, id=-1)
+        @parent_shape = parent
+        @type = type
+        @id = id
+        @start_pos = Wx::Point.new
+        @prev_pos = Wx::Point.new
+        @curr_pos = Wx::Point.new
+
+        @visible = false
+        @mouse_over = false
+      end
+
+      # Set or get handle's ID.
+      attr_accessor :id
+
+      # Get Handle type
+      # @return [TYPE] Handle type
+      def get_type
+        @type
+      end
+      alias :type :get_type
+
+      # Set Handle type
+      # @param [TYPE] type Handle type to set
+      def set_type(type)
+        @type = type
+      end
+      alias :type= :set_type
+
+      # Get parent shape.
+      # @return [Wx::Shape] parent shape
+      def get_parent_shape
+        @parent_shape
+      end
+      alias :parent_shape :get_parent_shape
+
+      # Get current handle position.
+      # @return [Wx::Point] Handle position
+      def get_position
+        @curr_pos
+      end
+      alias :position :get_position
+
+      # Get current handle delta (difference between current and previous position).
+      # @return [Wx::Point] Handle delta
+      def get_delta
+        @curr_pos - @prev_pos
+      end
+      alias :delta :get_delta
+
+      # Get current total handle delta (difference between current and starting position
+      # stored at the beginning of the dragging process).
+      # @return [Wx::Point] Total handle delta
+      def get_total_delta
+        @curr_pos - @start_pos
+      end
+      alias :total_delta :get_total_delta
+
+      # Show/hide handle
+      # @param [Boolean] show true if the handle should be visible (active), otherwise false
+      def show(show = true)
+        @visible = !!show
+      end
+
+      # Returns true if the handle is visible, otherwise false
+      def visible?
+        @visible
+      end
+
+      # Refresh (repaint) the handle
+      # @return [void]
+      def refresh
+        @parent_shape.refresh(DELAYED) if @parent_shape
+      end
+
+      # Find out whether given point is inside the handle.
+      # @param [Wx::Point,Array(Integer,Integer)] pos Examined point
+      # @return [Boolean] true if the point is inside the handle, otherwise false
+      def contains(pos)
+        handle_rect.contains?(pos)
+      end
+      alias contains? :contains
+
+      protected
+
+      # Draw handle.
+      # @param [Wx::DC] dc Device context where the handle will be drawn
+      def draw(dc)
+        if @visible && @parent_shape
+          if @mouse_over
+            draw_hover(dc)
+          else
+            draw_normal(dc)
+          end
+        end
+      end
+
+      # Draw handle in the normal way.
+      # @param [Wx::DC] dc Device context where the handle will be drawn
+      def draw_normal(dc)
+        dc.with_pen(Wx::PLATFORM == 'WXGTK' ? Wx::TRANSPARENT_PEN : Wx::BLACK_PEN) do
+          if ShapeCanvas::gc_enabled?
+            dc.brush = Wx::Brush.new(Wx::Colour.new(0, 0, 0, 128))
+          else
+            dc.brush = Wx::BLACK_BRUSH
+            # dc.logical_function = Wx::RasterOperationMode::INVERT
+          end
+
+          dc.draw_rectangle(handle_rect)
+          # dc.logical_function = Wx::RasterOperationMode::COPY
+
+          dc.brush = Wx::NULL_BRUSH
+        end
+      end
+
+      # Draw handle in the "hover" way (the mouse pointer is above the handle area).
+      # @param [Wx::DC] dc Device context where the handle will be drawn
+      def draw_hover(dc)
+        if @parent_shape.contains_style(Shape::STYLE::SIZE_CHANGE)
+          dc.with_pen(Wx::BLACK_PEN) do
+            dc.with_brush(Wx::Brush.new(@parent_shape.hover_colour)) do
+              dc.draw_rectangle(handle_rect)
+            end
+          end
+        else
+          draw_normal(dc)
+        end
+      end
+
+      # Set parent shape.
+      # @param [Wx::Shape] parent parent shape to set
+      def parent_shape=(parent)
+        @parent_shape = parent
+      end
+
+      # Get handle rectangle.
+      # @return [Wx::Rect] Handle rectangle
+      def handle_rect
+        if @parent_shape
+          brct = @parent_shape.get_bounding_box
+          case @type
+          when TYPE::LEFTTOP
+            hrct = Wx::Rect.new(brct.top_left, Wx::Size.new(7,7))
+          when TYPE::TOP
+            hrct = Wx::Rect.new(Wx::Point.new(brct.left + brct.width/2, brct.top), Wx::Size.new(7,7))
+          when TYPE::RIGHTTOP
+            hrct = Wx::Rect.new(brct.top_right, Wx::Size.new(7,7))
+          when TYPE::RIGHT
+            hrct = Wx::Rect.new(Wx::Point.new(brct.right, brct.top + brct.height/2), Wx::Size.new(7,7))
+          when TYPE::RIGHTBOTTOM
+            hrct = Wx::Rect.new(brct.bottom_right, Wx::Size.new(7,7))
+          when TYPE::BOTTOM
+            hrct = Wx::Rect.new(Wx::Point.new(brct.left + brct.width/2, brct.bottom), Wx::Size.new(7,7))
+          when TYPE::LEFTBOTTOM
+            hrct = Wx::Rect.new(brct.bottom_left, Wx::Size.new(7,7))
+          when TYPE::LEFT
+            hrct = Wx::Rect.new(Wx::Point.new(brct.left, brct.top + brct.height/2), Wx::Size.new(7,7))
+          when TYPE::LINECTRL
+            pt = @parent_shape.get_control_points[@id]
+            hrct = Wx::Rect.new(Wx::Point.new(pt.x.to_i, pt.y.to_i), Wx::Size.new(7,7))
+          when TYPE::LINEEND, TYPE::LINESTART
+            pt = @type == TYPE::LINESTART ? @parent_shape.src_point : @parent_shape.trg_point
+            hrct = Wx::Rect.new(Wx::Point.new(pt.x.to_i, pt.y.to_i), Wx::Size.new(7,7))
+          else
+            hrct = Wx::Rect.new
+          end
+
+          hrct.offset!(-3, -3)
+        else
+          Wx::Rect.new
+        end
+      end
+
+      private
+
+      # Event handler called when the mouse pointer is moving above shape canvas.
+      # @param [Wx::Point] pos Current mouse position
+      def _on_mouse_move(pos)
+        if @visible
+          if contains?(pos)
+            unless @mouse_over
+              @mouse_over = true
+              refresh
+            end
+          else
+            if @mouse_over
+              @mouse_over = false
+              refresh
+            end
+          end
+        end
+      end
+
+      # Event handler called when the handle is started to be dragged.
+      # @param [Wx::Point] pos Current mouse position
+      def _on_begin_drag(pos)
+        @prev_pos = @start_pos = @curr_pos = pos
+        @parent_shape.on_begin_handle(self) if @parent_shape
+      end
+
+      # Event handler called when the handle is dragged.
+      # @param [Wx::Point] pos Current mouse position
+      def _on_dragging(pos)
+        if @visible && @parent_shape && @parent_shape.contains_style(Shape::STYLE::SIZE_CHANGE)
+          if pos != @prev_pos
+            prev_rct = @parent_shape.get_bounding_box
+
+            @curr_pos = pos
+
+            case @type
+            when TYPE::LEFTTOP
+              @parent_shape.send(:_on_handle, self) if (pos.x < prev_rct.right) && (pos.y < prev_rct.bottom)
+
+            when TYPE::TOP
+              @parent_shape.send(:_on_handle, self) if (pos.y < prev_rct.bottom)
+
+            when TYPE::RIGHTTOP
+              @parent_shape.send(:_on_handle, self) if ((pos.x > prev_rct.left) && (pos.y < prev_rct.bottom))
+
+            when TYPE::RIGHT
+              @parent_shape.send(:_on_handle, self) if (pos.x > prev_rct.left)
+
+            when TYPE::RIGHTBOTTOM
+              @parent_shape.send(:_on_handle, self) if ((pos.x > prev_rct.left) && (pos.y > prev_rct.top))
+
+            when TYPE::BOTTOM
+              @parent_shape.send(:_on_handle, self) if (pos.y > prev_rct.top)
+
+            when TYPE::LEFTBOTTOM
+              @parent_shape.send(:_on_handle, self) if ((pos.x < prev_rct.right) && (pos.y > prev_rct.top))
+
+            when TYPE::LEFT
+              @parent_shape.send(:_on_handle, self) if (pos.x < prev_rct.right)
+
+            when TYPE::LINESTART, TYPE::LINEEND, TYPE::LINECTRL
+              @parent_shape.send(:_on_handle, self)
+
+            end
+          end
+
+          @prev_pos = pos
+        end
+      end
+
+      # Event handler called when the handle is released.
+      # @param [Wx::Point] _pos Current mouse position
+      def _on_end_drag(_pos)
+        @parent_shape.on_end_handle(self) if @parent_shape
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/shapes/shape_list.rb

@@ -0,0 +1,161 @@
+# Wx::SF::Shape - shape list class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/serializable'
+
+module Wx::SF
+
+  # This class implements an indexed container for unique, non-nil, shapes (no duplicates).
+  class ShapeList
+
+    include Serializable
+    include ::Enumerable
+
+    property :list
+
+    # Constructor.
+    # @param [ShapeList,::Enumerable,Shape,nil] enum shape container to copy, single shape to add or nil
+    def initialize(enum = nil)
+      if enum
+        if enum.is_a?(ShapeList)
+          @list = enum.instance_variable_get('@list').dup
+          @index = enum.instance_variable_get('@index').dup
+        elsif enum.is_a?(::Enumerable)
+          @list = []
+          @index = {}
+          enum.each { |elem| self << elem }
+        else
+          @list = []
+          @index = {}
+          self << enum
+        end
+      else
+        @list = []
+        @index = {}
+      end
+    end
+
+    # Iterates over contained shapes.
+    # When a block given, passes each successive shape to the block.
+    # Allows the array to be modified during iteration.
+    # When no block given, returns a new ::Enumerator.
+    # @yieldparam [Shape] shape
+    # @return [self]
+    def each(&block)
+      @list.each(&block)
+      self
+    end
+
+    # Recursively collects shapes and returns collection.
+    # @param [Array<Shape>] collection container to return collected shapes in
+    def all(collection = [])
+      @list.inject(collection) { |list, shape| shape.instance_variable_get('@child_shapes').all(list << shape) }
+    end
+
+    # Returns true if the no shapes are contained, false otherwise.
+    # @return [Boolean]
+    def empty?
+      @list.empty?
+    end
+
+    # Empties the shape list.
+    # @return [self]
+    def clear
+      @list.clear
+      @index.clear
+      self
+    end
+
+    # Appends a new shape to the list if not yet in list.
+    # @param [Shape] shape shape to add
+    # @return [self]
+    def append(shape)
+      unless @index.has_key?(check_elem(shape).id)
+        @list << shape
+        @index[shape.id] = shape
+      end
+      self
+    end
+    alias :push :append
+    alias :<< :append
+
+    # Removes the first shape from the list (if any) and returns that.
+    # @return [Shape,nil] removed shape or nil if list empty
+    def shift
+      return nil if @list.empty?
+      @index.delete(@list.shift.id)
+    end
+
+    # Removes the last shape from the list (if any) and returns that.
+    # @return [Shape,nil] removed shape or nil if list empty
+    def pop
+      return nil if @list.empty?
+      @index.delete(@list.pop.id)
+    end
+
+    # Removes a shape matching the key given from the list and returns that.
+    # @param [Shape,Serializable::ID] key shape or shape ID to match
+    # @return [Shape,nil] removed shape or nil if none matched
+    def delete(key)
+      if key.is_a?(Shape)
+        return @list.delete(key) if @index.delete(key.id)
+      elsif key.is_a?(Serializable::ID)
+        return @list.delete(@index.delete(key)) if @index.has_key?(key)
+      end
+      nil
+    end
+
+    # Returns true if a shape matches the given key or false if no shape matches.
+    # @param [Shape,Serializable::ID] key shape or shape ID to match
+    # @param [Boolean] recursive pass true to search recursively, false for non-recursive
+    # @return [Boolean]
+    def include?(key, recursive = false)
+      found = if key.is_a?(Serializable::ID)
+                @index.has_key?(key)
+              else
+                @list.include?(key)
+              end
+      found || (recursive && @list.any? { |child| child.instance_variable_get('@child_shapes').include?(key, recursive) })
+    end
+
+    # Returns the shape matching the given key or nil if no shape matches.
+    # Does not modify the list.
+    # @param [Integer,Serializable::ID] key shape list index or shape ID to match
+    # @param [Boolean] recursive pass true to search recursively, false for non-recursive
+    # @return [Shape,nil] matched shape or nil if none matched
+    def get(key, recursive = false)
+      shape = if key.is_a?(Serializable::ID)
+                @index[key]
+              else
+                @list.at(key.to_i)
+              end
+      shape || (recursive && @list.find { |child| child.get(key, recursive) })
+    end
+    alias :[] :get
+
+    private
+
+    # Get shape array. Serialization only.
+    # @return [Array<Shape>]
+    def get_list
+      @list
+    end
+
+    # Set shape array from deserialization.
+    # @param [Array<Shape>] list
+    def set_list(list)
+      @list = list
+      @list.each { |shape| @index[shape.id] = shape }
+    end
+
+    # Check intended list item
+    # @param [Shape] shape intended list item
+    # @return [Shape] checked shape
+    def check_elem(shape)
+      ::Kernel.raise TypeError, 'Expected a Wx::SF::Shape' unless shape.is_a?(Wx::SF::Shape)
+      shape
+    end
+
+  end
+
+end