autocad 0.4.6 → 0.5

data/lib/autocad/model.rb

@@ -1,89 +1,217 @@
-# require_relative 'scan/scan_trait'
-# require_relative "model_trait"
-
-# require_relative 'ts/tagset_trait'
-# require_relative 'graphics'
-# require_relative 'ts/instance'
-
-module Autocad
-  module ModelTrait
-    def each
-      return enum_for(:each) unless block_given?
-
-      @ole_obj.each do |ole|
-        yield app.wrap(ole)
-      end
-    end
-
-    # @rbs pt1: Autocad::Point3d
-    # @rbs return Autocad::Line
-    def add_line(pt1, pt2, layer: nil)
-      pt1 = Point3d.new(pt1)
-      pt2 = Point3d.new(pt2)
-      ole_line = ole_obj.AddLine(pt1.to_ole, pt2.to_ole)
-      if layer
-        layer = app.create_layer(layer)
-        ole_line.layer = layer.ole_obj
-      end
-      app.wrap(ole_line)
-    rescue ex
-      puts ex.message
-    end
-
-    # @rbs center: [] | Point3d -- center of circle
-    # @rbs radius:
-    def add_circle(center, radius)
-      pt = Point3d(center)
-      ole_circle = ole_obj.AddCircle(pt.to_ole, radius)
-      app.wrap(ole_circle)
-    rescue
-      raise Autocad::Error.new('Error adding circle #{ex}')
-    end
-
-    def add_rectangle(upper_left, lower_right)
-      x1, y1, _z = Point3d(upper_left).to_a
-      x2, y2, _z2 = Point3d(lower_right)
-      pts = [x1, y1, x2, y1, x2, y1, x2, y2]
-      pts_variant = WIN32OLE::Variant.new(pts, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
-      ole = ole_obj.AddLightweightPolyline(pts_variant)
-      app.wrap(ole)
-    rescue => e
-      raise Autocad::Error.new("Error adding rectangle #{e}")
-    end
-
-    def add_spline(points)
-      pts = Point3d.pts_to_array(points)
-      pts_variant = Point3d.array_to_ole(pts)
-      ole = ole_obj.AddSpline(pts_variant)
-      puts "pts #{pts}"
-      puts "pts_variant #{pts_variant.class} #{pts_variant}"
-      app.wrap(ole)
-    rescue => e
-      raise Autocad::Error.new("Error adding spline #{e}")
-    end
-
-    def drawing
-      @drawing ||= ::Autocad::Drawing.from_ole_obj(app, ole_obj.Document)
-    end
-  end
-
-  class PaperSpace
-    include ModelTrait
-    attr_reader :app, :ole_obj
-
-    def initialize(ole, app)
-      @ole_obj = ole
-      @app = app
-    end
-  end
-
-  class ModelSpace
-    include ModelTrait
-    attr_reader :app, :ole_obj
-
-    def initialize(ole, app)
-      @ole_obj = ole
-      @app = app
-    end
-  end
-end
+# require_relative 'scan/scan_trait'
+# require_relative "model_trait"
+
+# require_relative 'ts/tagset_trait'
+# require_relative 'graphics'
+# require_relative 'ts/instance'
+
+module Autocad
+  module ModelTrait
+    # Iterate through all elements in the model space
+    # @rbs return Enumerator[Autocad::Element]
+    # @rbs &: (Autocad::Element) -> void
+    def each
+      return enum_for(:each) unless block_given?
+
+      @ole_obj.each do |ole|
+        yield app.wrap(ole)
+      end
+    end
+
+    # Check if this model is an external reference
+    # @rbs return bool
+    def xref?
+      @ole_obj.IsXRef
+    rescue StandardError
+      false
+    end
+
+    # Attach an external reference to the model
+    # @rbs path: String
+    # @rbs name: String
+    # @rbs pt: Array[Numeric] | Autocad::Point3d
+    # @rbs x_scale: Numeric
+    # @rbs y_scale: Numeric
+    # @rbs z_scale: Numeric
+    # @rbs rotation: Numeric
+    # @rbs overlay: bool
+    # @rbs password: String?
+    # @rbs return Autocad::BlockReference?
+    def attach_external_reference(path, name:, pt: [0, 0, 0], x_scale: 1.0, y_scale: 1.0, z_scale: 1.0, rotation: 0.0,
+                                  overlay: false, password: nil)
+      windows_path = app.windows_path(path)
+      pt3d = Point3d.new(insertion_point)
+      ole_reference = ole_obj.AttachExternalReference(windows_path, name, pt3d.to_ole, x_scale, y_scale, z_scale,
+                                                      rotation, overlay, password)
+      app.wrap(ole_reference)
+    rescue StandardError => e
+      app.error_proc.call(e, self)
+    end
+
+    # Add a line to the model
+    # @rbs pt1: Array[Numeric] | Autocad::Point3d
+    # @rbs pt2: Array[Numeric] | Autocad::Point3d
+    # @rbs layer: String?
+    # @rbs return Autocad::Line?
+    def add_line(pt1, pt2, layer: nil)
+      pt1 = Point3d.new(pt1)
+      pt2 = Point3d.new(pt2)
+      ole_line = ole_obj.AddLine(pt1.to_ole, pt2.to_ole)
+      if layer
+        layer_obj = create_layer(layer)
+        ole_line.Layer = layer_obj.name
+      end
+      app.wrap(ole_line)
+    rescue StandardError => e
+      puts e.message
+      nil
+    end
+
+    # Get the layout associated with this model
+    # @rbs return Autocad::Layout
+    def layout
+      ole_layout = ole_obj.Layout
+      app.wrap(ole_layout)
+    end
+
+    # Add an arc to the model
+    # @rbs center: Array[Numeric] | Autocad::Point3d
+    # @rbs radius: Numeric
+    # @rbs start_angle: Numeric
+    # @rbs end_angle: Numeric
+    # @rbs return Autocad::Arc
+    # @raise [Autocad::Error] If arc creation fails
+    def add_arc(center, radius, start_angle, end_angle)
+      pt = Point3d(center)
+      ole_arc = ole_obj.AddArc(pt.to_ole, radius, start_angle, end_angle)
+      app.wrap(ole_arc)
+    rescue StandardError => e
+      raise Autocad::Error.new("Error adding arc #{e}")
+    end
+
+    # Add a circle to the model
+    # @rbs center: Array[Numeric] | Autocad::Point3d
+    # @rbs radius: Numeric
+    # @rbs return Autocad::Circle
+    # @raise [Autocad::Error] If circle creation fails
+    def add_circle(center, radius)
+      pt = Point3d(center)
+      ole_circle = ole_obj.AddCircle(pt.to_ole, radius)
+      app.wrap(ole_circle)
+    rescue StandardError => e
+      raise Autocad::Error.new("Error adding circle #{e.message}")
+    end
+
+    # Add a rectangular polyline to the model
+    # @rbs lower_left: Array[Numeric] | Autocad::Point3d
+    # @rbs upper_right: Array[Numeric] | Autocad::Point3d
+    # @rbs return Autocad::Element
+    # @raise [Autocad::Error] If rectangle creation fails
+    def add_rectangle(lower_left, upper_right)
+      x1, y1 = Point3d(lower_left).to_xy
+      x2, y2 = Point3d(upper_right).to_xy
+      pts = [x1, y1, x2, y1, x2, y2, x1, y2, x1, y1]
+      pts_variant = WIN32OLE::Variant.new(pts, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
+      ole = ole_obj.AddLightweightPolyline(pts_variant)
+      app.wrap(ole)
+    rescue StandardError => e
+      raise Autocad::Error.new("Error adding rectangle #{e}")
+    end
+
+    # Add an ellipse to the model
+    # @rbs center: Array[Numeric] | Autocad::Point3d
+    # @rbs major_axis: Numeric
+    # @rbs radius_ratio: Numeric
+    # @rbs return Autocad::Ellipse
+    # @raise [Autocad::Error] If ellipse creation fails
+    def add_ellipse(center, major_axis, radius_ratio)
+      pt = Point3d(center)
+      ole_ellipse = ole_obj.AddEllipse(pt.to_ole, major_axis, radius_ratio)
+      app.wrap(ole_ellipse)
+    rescue StandardError => e
+      raise Autocad::Error.new("Error adding ellipse #{e}")
+    end
+
+    # Add a spline to the model
+    # @rbs points: Array[Array[Numeric] | Autocad::Point3d]
+    # @rbs start_tangent: Array[Numeric] | Autocad::Point3d
+    # @rbs end_tangent: Array[Numeric] | Autocad::Point3d
+    # @rbs return Autocad::Spline
+    # @raise [Autocad::Error] If spline creation fails
+    def add_spline(points, start_tangent, end_tangent)
+      pts = Point3d.pts_to_array(points)
+      pts_variant = Point3d.array_to_ole(pts)
+
+      start_tangent_ole = Point3d.new(start_tangent).to_ole
+      end_tangent_ole = Point3d.new(end_tangent).to_ole
+
+      ole = ole_obj.AddSpline(pts_variant, start_tangent_ole, end_tangent_ole)
+      app.wrap(ole)
+    rescue StandardError => e
+      raise Autocad::Error.new("Error adding spline #{e.message}")
+    end
+
+    # Get the parent drawing document
+    # @rbs return Autocad::Drawing
+    def drawing
+      @drawing ||= ::Autocad::Drawing.from_ole_obj(app, ole_obj.Document)
+    end
+
+    private
+
+    # Internal method to create/get a layer
+    # @rbs name: String
+    # @rbs color: Numeric | Symbol | String?
+    # @rbs return Autocad::Layer
+    def create_layer(name, color = nil)
+      drawing.create_layer(name, color)
+    end
+  end
+
+  # Paper space container class
+  class PaperSpace < Element
+    include ModelTrait
+
+    # Add a paper space viewport
+    # @rbs center: Array[Numeric] | Autocad::Point3d
+    # @rbs width: Numeric
+    # @rbs height: Numeric
+    # @rbs return Autocad::PViewport
+    # @raise [StandardError] If viewport creation fails
+    def add_pv_viewport(center, width:, height:)
+      center = Point3d(center)
+      ole = ole_obj.AddPViewport(center.to_ole, width.to_f, height.to_f)
+      if ole
+        ole.Display(true)
+        ole.ViewportOn = true
+        layer = drawing.create_layer('Vport', 9)
+        layer.Plottable = false
+        ole.Layer = layer.name
+        ole.StandardScale = ACAD::AcVpScaleToFit
+        app.wrap(ole)
+      else
+        nil
+      end
+    rescue StandardError => e
+      nil
+    end
+
+    # Get all paper space viewports
+    # @rbs return Array[Autocad::PViewport]
+    def pviewports
+      each.select { it.pviewport? }
+    end
+
+    # Delete all paper space viewports
+    # @rbs return void
+    def clear_pviewports
+      pviewports.each(&:delete)
+    end
+  end
+
+  # Model space container class
+  class ModelSpace < Element
+    include ModelTrait
+    # Inherits all ModelTrait functionality for model space entities
+  end
+end

data/lib/autocad/mtext.rb

@@ -1,110 +1,189 @@
-module Autocad
-  class MText < Element
-    attr_reader :original, :ole_obj
-
-    def to_regexp
-      Regexp.new(original.to_s)
-    end
-
-    def empty?
-      ole_obj.TextLinesCount == 0
-    end
-
-    def mtext?
-      true
-    end
-
-    def text?
-      false
-    end
-
-    def size
-      ole_obj.TextLinesCount
-    end
-
-    def read_ole(ole)
-      ole.TextString
-    end
-
-    # def _update(text)
-    #   update_ole!(text)
-    #   @original = text
-    # end
-
-    def write_ole(text)
-      if in_cell?
-        write_ole_in_cell(text)
-      else
-        write_ole_regular(text)
-      end
-    end
-
-    def write_ole_regular(text)
-      ole_obj.TextString = text
-    end
-
-    def write_ole_in_cell(text)
-      orig_ole = ole_obj
-      new_text_ole = ole_obj.Clone
-      new_text_ole.DeleteAllTextLines
-      text.each_line do |line|
-        new_text_ole.AddTextLine(line)
-      end
-      @ole_obj = new_text_ole
-    rescue
-      @ole_obj = orig_ole
-    end
-
-    def update_ole!(text)
-      ole_obj.DeleteAllTextLines
-      text.each_line do |line|
-        ole_obj.AddTextLine(line)
-      end
-      ole_obj.Redraw Autocad::MSD::MsdDrawingModeNormal
-      ole_obj.Rewrite
-    end
-
-    def to_s
-      @original.to_s
-    end
-
-    def =~(reg)
-      @original =~ reg
-    end
-
-    def template?
-      !!(@original =~ /{{.+}}/)
-    end
-
-    def render(h = {})
-      return self unless template?
-
-      template = Liquid::Template.parse(to_s)
-      result = template.render(h)
-      update(result) unless result == @original
-      self
-    end
-
-    def method_missing(meth, *, &)
-      if /^[A-Z]/.match?(meth)
-        ole_obj.send(meth, *)
-      else
-        copy = @original.dup
-        result = copy.send(meth, *, &)
-        update(result) unless copy == @original
-        result
-      end
-    end
-
-    # def method_missing2(meth,*args,&block)
-    #   if meth.to_s =~ /^[A-Z]/
-    #     ole_obj.send(meth,*args)
-    #   else
-    #     dup = @original.dup
-    #     result = dup.send(meth,*args,&block)
-    #     _update(dup) unless dup == @original
-    #     result
-    #   end
-    # end
-  end
-end
+# rbs_inline: enabled
+
+module Autocad
+  # Multi-line formatted text container in AutoCAD
+  #
+  # Represents a rich text entity with multiple lines and formatting.
+  # Supports Liquid templates, table cell awareness, and line-by-line operations.
+  #
+  # @example Create and render a template
+  #   specs = drawing.model.add_mtext("Project: {{name}}")
+  #   specs.render(name: "Tower A")
+  class MText < Element
+    # @rbs attr_reader original: String
+    # @rbs attr_reader ole_obj: WIN32OLE
+    attr_reader :original, :ole_obj
+
+    # Convert content to regex pattern
+    #
+    # @return [Regexp] A regular expression based on the text content
+    # @rbs return Regexp
+    def to_regexp
+      Regexp.new(original.to_s)
+    end
+
+    # Check for empty content
+    #
+    # @return [Boolean] True if the MText has no content
+    # @rbs return bool
+    def empty?
+      ole_obj.TextLinesCount == 0
+    end
+
+    # Type check for multi-line text (always true)
+    #
+    # @return [Boolean] Always returns true for MText objects
+    # @rbs return bool
+    def mtext?
+      true
+    end
+
+    # Override text type check (always false)
+    #
+    # @return [Boolean] Always returns false for MText objects
+    # @rbs return bool
+    def text?
+      false
+    end
+
+    # Get number of text lines
+    #
+    # @return [Integer] The number of lines in the MText
+    # @rbs return Integer
+    def size
+      ole_obj.TextLinesCount
+    end
+
+    # Read content from OLE object
+    #
+    # @param ole [WIN32OLE] The OLE object to read from
+    # @return [String] The text content
+    # @rbs ole: WIN32OLE -> String
+    def read_ole(ole)
+      ole.TextString
+    end
+
+    # Update text content with cell awareness
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
+    def write_ole(text)
+      if in_cell?
+        write_ole_in_cell(text)
+      else
+        write_ole_regular(text)
+      end
+    end
+
+    # Update text content for regular MText
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
+    def write_ole_regular(text)
+      ole_obj.TextString = text
+    end
+
+    # Update text content for MText in table cell
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
+    def write_ole_in_cell(text)
+      orig_ole = ole_obj
+      new_text_ole = ole_obj.Clone
+      new_text_ole.DeleteAllTextLines
+      text.each_line do |line|
+        new_text_ole.AddTextLine(line)
+      end
+      @ole_obj = new_text_ole
+    rescue
+      @ole_obj = orig_ole
+    end
+
+    # Full content rewrite with line-by-line updates
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
+    def update_ole!(text)
+      ole_obj.DeleteAllTextLines
+      text.each_line do |line|
+        ole_obj.AddTextLine(line)
+      end
+      ole_obj.Redraw Autocad::MSD::MsdDrawingModeNormal
+      ole_obj.Rewrite
+    end
+
+    # Get content as string
+    #
+    # @return [String] The text content
+    # @rbs return String
+    def to_s
+      @original.to_s
+    end
+
+    # Regex pattern matching against text content
+    #
+    # @param reg [Regexp] The regular expression to match against
+    # @return [Integer, nil] Match position or nil if no match
+    # @rbs reg: Regexp -> Integer?
+    def =~(reg)
+      @original =~ reg
+    end
+
+    # Check for Liquid template placeholders
+    #
+    # @return [Boolean] True if the text contains template placeholders
+    # @rbs return bool
+    def template?
+      !!(@original =~ /{{.+}}/)
+    end
+
+    # Render Liquid template with provided context
+    #
+    # @param h [Hash] The template variables
+    # @return [self] The MText object
+    # @example Render a template with variables
+    #   mtext.render(client: "ABC Corp", floors: 42)
+    # @rbs h: Hash[Symbol, untyped] -> self
+    def render(h = {})
+      return self unless template?
+
+      template = Liquid::Template.parse(to_s)
+      result = template.render(h)
+      update(result) unless result == @original
+      self
+    end
+
+    # Delegate uppercase methods to OLE object, lowercase to string methods
+    #
+    # @param meth [Symbol] The method name
+    # @param * [Array] Method arguments
+    # @param & [Proc] Optional block
+    # @return [Object] Result of the method call
+    # @rbs (Symbol, *untyped) -> untyped
+    def method_missing(meth, *, &)
+      if /^[A-Z]/.match?(meth)
+        ole_obj.send(meth, *)
+      else
+        copy = @original.dup
+        result = copy.send(meth, *, &)
+        update(result) unless copy == @original
+        result
+      end
+    end
+
+    # def method_missing2(meth,*args,&block)
+    #   if meth.to_s =~ /^[A-Z]/
+    #     ole_obj.send(meth,*args)
+    #   else
+    #     dup = @original.dup
+    #     result = dup.send(meth,*args,&block)
+    #     _update(dup) unless dup == @original
+    #     result
+    #   end
+    # end
+  end
+end

data/lib/autocad/plot.rb

@@ -0,0 +1,45 @@
+module Autocad
+  class Plot < Element
+    # Configure which layouts to include in the plot
+    # @rbs *layouts: Array[String | Autocad::Layout] | String | Autocad::Layout
+    # @rbs return void
+    def set_layouts_to_plot(*layouts)
+      layouts = layouts.first if layouts.size == 1 && layouts.first.is_a?(Array)
+      ole_layouts = layouts.map { |l| l.is_a?(Autocad::Layout) ? l.name : l.to_s }
+      
+      ole_layout_values = WIN32OLE::Variant.new(
+        ole_layouts,
+        WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_BSTR
+      )
+      ole_obj.SetLayoutsToPlot(ole_layout_values)
+    end
+
+    # Display full plot preview window
+    # @rbs return void
+    def plot_preview
+      ole_obj.DisplayPlotPreview(1) # 1 = acFullPreview
+    end
+
+    # Execute plot using configured device
+    # @rbs return void
+    # @raise [Autocad::Error] If device communication fails
+    def plot_to_device
+      ole_obj.PlotToDevice
+    rescue => e
+      raise Autocad::Error.new("Device plot failed: #{e.message}")
+    end
+
+    # Plot to file with specified configuration
+    # @rbs filename: String | Pathname
+    # @rbs plot_config: String | Autocad::PlotConfiguration?
+    # @rbs return void
+    # @raise [Autocad::Error] If file creation fails
+    def plot_to_file(filename, plot_config: nil)
+      path = app.windows_path(filename)
+      config_name = plot_config.respond_to?(:name) ? plot_config.name : plot_config
+      ole_obj.PlotToFile(path, config_name)
+    rescue => e
+      raise Autocad::Error.new("File plot failed: #{e.message}\nPath: #{path}")
+    end
+  end
+end