wxruby3-shapes 0.9.0.pre.beta.3

data/lib/wx/shapes/shapes/bitmap_shape.rb

@@ -0,0 +1,257 @@
+# Wx::SF::BitmapShape - Bitmap shape class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/shapes/rect_shape'
+require 'pathname'
+
+module Wx::SF
+
+  # Class encapsulating the bitmap shape. The shape can display and control
+  # files stored in formats supported by Wx::Bitmap class loaded from a file or created
+  # from XPM image.
+  class BitmapShape < RectShape
+
+    property :can_scale, :bitmap
+
+    # @overload initialize()
+    #   Default constructor.
+    # @overload initialize(pos, bmp_path, diagram)
+    #   User constructor.
+    #   @param [Wx::RealPoint] pos Initial position
+    #   @param [String] bmp_path Bitmap path
+    #   @param [Wx::SF::Diagram] diagram parent diagram
+    def initialize(*args)
+      @bitmap = Wx::NULL_BITMAP
+      @art_path = @art_section = nil
+      if args.empty?
+        super
+        @bitmap_path = nil
+        @original_bitmap = @bitmap = nil
+        @bitmap_type = nil
+      else
+        pos, bmp_path, diagram = args
+        super(pos, RectShape::DEFAULT::SIZE.dup, diagram)
+        create_from_file(bmp_path)
+      end
+      @rescale_in_progress = false
+      @can_scale = true
+    end
+
+	  # Get full name of a source BMP file.
+	  # @return [String] String containing full file name
+    def get_bitmap_path
+      @bitmap_path
+    end
+
+	  # Enable/disable scaling mode of the bitmap.
+	  # @param [Boolean] canscale Set true if the bitmap shape could be scaled
+    def enable_scale(canscale)
+      @can_scale = canscale
+    end
+    alias :set_can_scale :enable_scale
+
+	  # Get information about the possibility of the shape scaling.
+	  # @return [Boolean] true if the shape can be scaled, otherwise false
+    def can_scale?
+      @can_scale
+    end
+    alias :get_can_scale :can_scale?
+
+	  # Load a bitmap from the file.
+    # @param [String,Symbol] file File name (absolute or relative) or base name for art file (for Wx::ArtLocator)
+    # @param [Wx::BitmapType,nil] type Bitmap type (see the wxBitmap class reference)
+    # @param [String] art_path base path to look up the art file for Wx::ArtLocator
+    # @param [String,nil] art_section optional owner folder name for art files for Wx::ArtLocator
+    # @return [Boolean] true on success, otherwise false
+    # @see Wx::ArtLocator
+    def create_from_file(file, type = nil, art_path: nil, art_section: nil)
+      # load bitmap from the file
+      @bitmap_path = file
+      @bitmap_type = type
+      if File.file?(@bitmap_path.to_s)
+        @bitmap = Wx::Bitmap.new
+        success = @bitmap.load_file(@bitmap_path, type ? type : Wx::BITMAP_TYPE_ANY)
+      else
+        art_path ||= File.dirname(caller_locations(1).first.absolute_path)
+        art_section ||= File.basename(caller_locations(1).first.absolute_path, '.*')
+        path = Wx::ArtLocator.find_art(@bitmap_path, art_path: art_path, art_section: art_section, art_type: :bitmap, bmp_type: type)
+        if path
+          @bitmap = Wx::Bitmap.new
+          success = @bitmap.load_file(path, type ? type : Wx::BITMAP_TYPE_ANY)
+          if success
+            p = Pathname.new(art_path)
+            @art_path = p.relative? ? art_path : p.relative_path_from(Dir.getwd).to_s
+            @art_section = art_section
+          end
+        else
+          @bitmap = nil
+          success = false
+        end
+      end
+
+      @original_bitmap = @bitmap
+
+      if success
+        @rect_size.x = @bitmap.width
+        @rect_size.y = @bitmap.height
+
+        if @can_scale
+          add_style(Shape::STYLE::SIZE_CHANGE)
+        else
+          remove_style(Shape::STYLE::SIZE_CHANGE)
+        end
+      end
+
+      success
+    end
+
+	  # Event handler called during dragging of the shape handle. The function can be overridden if necessary.
+	  # @param [Shape::Handle] handle Reference to the dragged shape handle
+    def on_handle(handle)
+      if @can_scale
+        super
+      else
+        remove_style(STYLE::SIZE_CHANGE)
+      end
+    end
+
+	  # Event handler called when the user finished dragging of the shape handle. The function can be overridden if necessary.
+	  # @param [Shape::Handle] handle Reference to the dragged shape handle
+    def on_end_handle(handle)
+      if @can_scale
+        @rescale_in_progress = false
+        rescale_image(@rect_size)
+      end
+
+      super
+    end
+
+    protected
+
+    # Event handler called by ShapeCanvas to request,report canvas changes.
+    # @param [ShapeCanvas::CHANGE] change change type indicator
+    # @param [Array] _args any additional arguments
+    # @return [Boolean,nil]
+    def _on_canvas(change, *_args)
+      if change == ShapeCanvas::CHANGE::RESCALED
+        self.scale(1, 1)
+      end
+      super
+    end
+
+    # Handle action at handle drag beginning
+    def do_begin_handle
+      if @can_scale
+        @rescale_in_progress = true
+        @prev_pos = get_absolute_position
+      end
+    end
+
+    # Scale the rectangle size for this shape.
+    # @param [Float] x Horizontal scale factor
+    # @param [Float] y Vertical scale factor
+    def scale_rectangle(x, y)
+      if @can_scale
+        @rect_size.x *= x
+        @rect_size.y *= y
+
+        rescale_image(@rect_size) unless @rescale_in_progress
+      end
+    end
+
+	  # Rescale the bitmap shape so it will fit the given extent. The
+    # shape position is not involved (the left-top bitmap corner is not moved).
+	  # @param [Wx::RealPoint] size New bitmap size
+    def rescale_image(size)
+      if get_parent_canvas && @original_bitmap && @original_bitmap.ok?
+        size = size.to_real_point
+        if ShapeCanvas.gc_enabled?
+          Wx::Bitmap.rescale(@bitmap = Wx::Bitmap.new(@original_bitmap), size.to_size)
+        else
+          scale = get_parent_canvas.get_scale
+          Wx::Bitmap.rescale(@bitmap = Wx::Bitmap.new(@original_bitmap), (size * scale).to_size)
+        end
+      end
+    end
+
+	  # Draw the shape in the normal way. The function can be overridden if necessary.
+	  # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_normal(dc)
+      # HINT: overload it for custom actions...
+      if @rescale_in_progress
+        _draw_bitmap(dc, @prev_pos.to_point)
+    
+        dc.with_brush(Wx::TRANSPARENT_BRUSH) do
+          dc.with_pen(Wx::Pen.new(Wx::Colour.new(100, 100, 100), 1, Wx::PenStyle::PENSTYLE_DOT)) do
+            dc.draw_rectangle(get_absolute_position.to_point, @rect_size.to_size)
+          end
+        end
+      else
+        _draw_bitmap(dc, get_absolute_position.to_point)
+      end
+    end
+
+	  # Draw the shape in the hover mode (the mouse cursor is above the shape). The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_hover(dc)
+      _draw_bitmap(dc, get_absolute_position.to_point)
+
+      dc.with_brush(Wx::TRANSPARENT_BRUSH) do
+        dc.with_pen(Wx::Pen.new(@hover_color, 1)) do
+          dc.draw_rectangle(get_absolute_position.to_point, @rect_size.to_size)
+        end
+      end
+    end
+
+	  # Draw the shape in the highlighted mode (another shape is dragged over this shape and this shape will accept the
+    # dragged one if it will be dropped on it). The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_highlighted(dc)
+      _draw_bitmap(dc, get_absolute_position.to_point)
+
+      dc.with_brush(Wx::TRANSPARENT_BRUSH) do
+        dc.with_pen(Wx::Pen.new(@hover_color, 2)) do
+          dc.draw_rectangle(get_absolute_position.to_point, @rect_size.to_size)
+        end
+      end
+    end
+
+    private
+
+    # draw the bitmap
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    # @param [Wx::Point] pos
+    def _draw_bitmap(dc, pos)
+      if @bitmap && @bitmap.ok?
+        dc.draw_bitmap(@bitmap, pos)
+      else
+        dc.with_brush(Wx::TRANSPARENT_BRUSH) do
+          dc.with_pen(Wx::BLACK_PEN) do
+            dc.draw_rectangle(pos, @rect_size.to_size)
+            dc.draw_line(pos, [pos.x+@rect_size.x.to_i-1, pos.y+@rect_size.y.to_i-1])
+            dc.draw_line([pos.x, pos.y+@rect_size.y.to_i-1], [pos.x+@rect_size.x.to_i-1, pos.y])
+          end
+        end
+      end
+    end
+
+    # Serialization only.
+    def get_bitmap
+      if @bitmap && @bitmap.ok?
+        [@bitmap_path, @bitmap_type, @art_path, @art_section]
+      else
+        [nil,nil]
+      end
+    end
+
+    # Deserialization only.
+    def set_bitmap(bmp_data)
+      file, type, art_path, art_section = bmp_data
+      if file
+        create_from_file(file, type, art_path: art_path, art_section: art_section)
+      end
+    end
+
+  end
+
+end

data/lib/wx/shapes/shapes/circle_shape.rb

@@ -0,0 +1,136 @@
+# Wx::SF::CircleShape - circle shape class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/shapes/square_shape'
+
+module Wx::SF
+
+  # Class encapsulating the circle shape.
+  class CircleShape < SquareShape
+
+    # @overload initialize()
+    #   Default constructor.
+    # @overload initialize(pos, size, diagram)
+    #   User constructor.
+    #   @param [Wx::RealPoint] pos Initial position
+    #   @param [Float] radius Initial circle radius
+    #   @param [Wx::SF::Diagram] diagram parent diagram
+    def initialize(*args)
+      if args.empty?
+        super
+        set_rect_size(50,50)
+      else
+        pos, rad, diagram = args
+        super(pos, rad*2, diagram)
+      end
+    end
+
+    def get_radius
+      @rect_size.x/2
+    end
+    alias :radius :get_radius
+
+    def set_radius(rad)
+      set_rect_size(rad*2, rad*2)
+    end
+    alias :radius= :set_radius
+
+	  # Test whether the given point is inside the shape. The function
+    # can be overridden if necessary.
+    # @param [Wx::Point] pos Examined point
+    # @return [Boolean] true if the point is inside the shape area, otherwise false
+    def contains?(pos)
+      get_center.distance_to(pos) <= radius
+    end
+
+    # Get intersection point of the shape border and a line leading from
+    # 'start' point to 'end' point. The function can be overridden if necessary.
+    # @param [Wx::RealPoint] start Starting point of the virtual intersection line
+    # @param [Wx::RealPoint] end_pt Ending point of the virtual intersection line
+    # @return [Wx::RealPoint] Intersection point
+    def get_border_point(start, end_pt)
+      start = start.to_real_point; end_pt.to_real_point
+      dist = start.distance_to(end_pt)
+      center = get_center
+    
+      if dist != 0.0
+        rad = radius
+        src_dx = rad*(end_pt.x-start.x)/dist - (start.x-center.x)
+        src_dy = rad*(end_pt.y-start.y)/dist - (start.y-center.y)
+    
+        Wx::RealPoint.new(start.x + src_dx, start.y + src_dy)
+      else
+        center
+      end
+    end
+
+    protected
+
+    # Draw the shape in the normal way. The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_normal(dc)
+      # HINT: overload it for custom actions...
+      pos = get_absolute_position
+
+      dc.with_pen(@border) do
+        dc.with_brush(@fill) do
+          dc.draw_circle((pos.x + @rect_size.x/2).to_i,
+                         (pos.y + @rect_size.y/2).to_i,
+                         (@rect_size.x/2).to_i)
+        end
+      end
+    end
+
+    # Draw the shape in the hover mode (the mouse cursor is above the shape).
+    # The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_hover(dc)
+      # HINT: overload it for custom actions...
+      pos = get_absolute_position
+
+      dc.with_pen(Wx::Pen.new(@hover_color, 1)) do
+        dc.with_brush(@fill) do
+          dc.draw_circle((pos.x + @rect_size.x/2).to_i,
+                         (pos.y + @rect_size.y/2).to_i,
+                         (@rect_size.x/2).to_i)
+        end
+      end
+    end
+
+    # Draw the shape in the highlighted mode (another shape is dragged over this
+    # shape and this shape will accept the dragged one if it will be dropped on it).
+    # The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_highlighted(dc)
+      # HINT: overload it for custom actions...
+      pos = get_absolute_position
+
+      dc.with_pen(Wx::Pen.new(@hover_color, 2)) do
+        dc.with_brush(@fill) do
+          dc.draw_circle((pos.x + @rect_size.x/2).to_i,
+                         (pos.y + @rect_size.y/2).to_i,
+                         (@rect_size.x/2).to_i)
+        end
+      end
+    end
+
+    # Draw shadow under the shape. The function can be overridden if necessary.
+    # @param [Wx::DC] dc Reference to device context where the shadow will be drawn to
+    def draw_shadow(dc)
+      # HINT: overload it for custom actions...
+      pos = get_absolute_position
+
+      if @fill.style != Wx::BrushStyle::BRUSHSTYLE_TRANSPARENT
+        dc.with_pen(Wx::TRANSPARENT_PEN) do
+          dc.with_brush(get_parent_canvas.get_shadow_fill) do
+            dc.draw_circle((pos.x + @rect_size.x/2 + get_parent_canvas.get_shadow_offset.x).to_i,
+                           (pos.y + @rect_size.y/2 + get_parent_canvas.get_shadow_offset.y).to_i,
+                           (@rect_size.x/2).to_i)
+          end
+        end
+      end
+    end
+
+  end
+
+end