autocad 0.4.6 → 0.5

data/lib/autocad/element.rb

@@ -1,8 +1,13 @@
 # rbs_inline: enabled
-
+require_relative "bounding_box"
+require "win32ole_helper"
 # require "autocad/property_handler"
 
 class WIN32OLE
+  def ole_respond_to?(name)
+    ole_methods.any? { |m| m.name.casecmp?(name.to_s) }
+  end
+
   def to_ole
     self
   end
@@ -45,75 +50,231 @@ module Autocad
     def move_to
     end
 
-    def update
-    end
-
     def transform_by(matrix)
     end
   end
 
   module ElementTrait
+    # Get the parent drawing of this element
+    # @rbs return Drawing?
+    def drawing
+      app.current_drawing
+    end
+
+    # Check if this element is a paper space viewport
+    # @rbs return bool
+    def pviewport?
+      false
+    end
+
+    # Check if this element is a block reference
+    # @rbs return bool
     def block_reference?
       false
     end
 
+    # def bounds
+    #   minpoint = WIN32OLE::Variant.new([0.0, 0.0, 0.0], WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
+    #   maxpoint = WIN32OLE::Variant.new([0.0, 0.0, 0.0], WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
     #
+    #   ole_obj.GetBoundingBox(minpoint, maxpoint)
+    #
+    #   min_pt = Point3d.new(minpoint[0], minpoint[1], minpoint[2])
+    #   max_pt = Point3d.new(maxpoint[0], maxpoint[1], maxpoint[2])
+    #
+    #   BoundingBox.from_min_max(min_pt, max_pt)
+    # rescue => e
+    #   raise Autocad::Error.new("Error getting bounds: #{e.message}")
+    # end
+
+    def bounds
+      # For testing purposes, check if we're in a test environment
+      # This is a workaround for the test environment where we don't have actual OLE objects
+
+      begin
+        if ole_obj.ole_respond_to?(:GetBoundingBox)
+          # Create VARIANT objects for output parameters
+          minpoint = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT | WIN32OLE::VARIANT::VT_BYREF)
+          maxpoint = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT | WIN32OLE::VARIANT::VT_BYREF)
+          # Last resort - try GetBoundingBox if available
+
+
+          # Get the bounding box coordinates
+          ole_obj.GetBoundingBox(minpoint, maxpoint)
+
+
+          # Convert the VARIANT arrays to Point3d objects
+          min_pt = Point3d.new(minpoint.value[0], minpoint.value[1], minpoint.value[2])
+          max_pt = Point3d.new(maxpoint.value[0], maxpoint.value[1], maxpoint.value[2])
+
+
+          BoundingBox.from_min_max(min_pt, max_pt)
+        # Try different approaches based on object type
+        elsif ole_obj.ole_respond_to?(:Coordinates)
+          # For objects like lines that have Coordinates property
+          coords = ole_obj.Coordinates
+
+          # Find min and max values
+          x_values = []
+          y_values = []
+          z_values = []
+
+          (0...coords.size).step(3) do |i|
+            x_values << coords[i]
+            y_values << coords[i + 1]
+            z_values << coords[i + 2] if i + 2 < coords.size
+          end
+          puts ole_obj.ObjectName
+          binding.irb
+
+          min_pt = Point3d.new(x_values.min, y_values.min, z_values.min || 0)
+          max_pt = Point3d.new(x_values.max, y_values.max, z_values.max || 0)
+          binding.irb
+
+          BoundingBox.from_min_max(min_pt, max_pt)
+        elsif ole_obj.ole_respond_to?(:Center) && ole_obj.respond_to?(:Radius)
+          # For circles
+          center = Point3d.new(ole_obj.Center)
+          radius = ole_obj.Radius
+
+          min_pt = Point3d.new(center.x - radius, center.y - radius, center.z)
+          max_pt = Point3d.new(center.x + radius, center.y + radius, center.z)
+          binding.irb
+
+          BoundingBox.from_min_max(min_pt, max_pt)
+        elsif ole_obj.ole_respond_to?(:StartPoint) && ole_obj.respond_to?(:EndPoint)
+          # For lines with start and end points
+          start_pt = Point3d.new(ole_obj.StartPoint)
+          end_pt = Point3d.new(ole_obj.EndPoint)
+          puts ole_obj.ObjectName
+
+          binding.irb
+
+          min_x = [start_pt.x, end_pt.x].min
+          min_y = [start_pt.y, end_pt.y].min
+          min_z = [start_pt.z, end_pt.z].min
+
+          max_x = [start_pt.x, end_pt.x].max
+          max_y = [start_pt.y, end_pt.y].max
+          max_z = [start_pt.z, end_pt.z].max
+
+          min_pt = Point3d.new(min_x, min_y, min_z)
+          max_pt = Point3d.new(max_x, max_y, max_z)
+
+          binding.irb
+
+          BoundingBox.from_min_max(min_pt, max_pt)
+        else
+          binding.irb
+          nil
+          # If we can't determine bounds, create a default bounding box
+          # This is better than raising an error in many cases
+        end
+      rescue => e
+        puts e.message
+        binding.irb
+        load "win32ole_helper"
+        ole_obj.extend WIN32OLE::Helper
+        load "autocad\element.rb"
+        retry
+        # If all methods fail, return an empty bounding box instead of raising an error
+        # This makes the code more robust when dealing with various object types
+        nil
+      end
+    end
+
     #
     #
-    # @rbs return bool -- true if ole type is Text
     #
+    #
+    # @rbs return bool -- true if ole type is Text
+    # def text?
+    # Check if this element is a text object
+    # @rbs return bool
     def text?
       ole_obj.ole_type == "IAcadText"
     end
 
-    # @rbs return bool -- true if ole type is TextNode
-    def mtext?
-      ole_obj.ole_type == "IAcadMText"
+    # Explode this element into its component parts
+    # @rbs &: (Element) -> void
+    # @rbs return Enumerator[Element]
+    def explode
+      return enum_for(__callee__) unless block_given?
+
+      ole = ole_obj.explode
+      ole.each do |ole|
+        yield app.wrap(ole)
+      end
+    rescue => e
+      binding.irb
     end
 
+    # Check if this element has any tags
+    # @rbs return bool
     def has_tags?
       ole_obj.HasAnyTags
     end
 
+    # Get the underlying OLE object
+    # @rbs return WIN32OLE
     def to_ole
       ole_obj
     end
 
-    # @rbs return bool -- true if object is of type cell
+    # Check if this element is a cell
+    # @rbs return bool
     def cell?
       ole_obj.Type == ::ACAD::MsdElementTypeCellHeader
     end
 
-    # def complex
-    #   ole_obj.IsComplexElement
-    # end
-
-    # @rbs return bool -- true if Text or TextNode
-    def textual?
-      text? || mtext?
+    # Highlight this element in the drawing
+    # @rbs flag: bool
+    # @rbs return void
+    def highlight(flag = true)
+      ole_obj.Highlight(flag)
+      ole_obj.Update
     end
 
+    def
+
+    # Get the AutoCAD object ID
+    # @rbs return Integer?
     def autocad_id
       @ole_obj.ObjectId
+    rescue
+      nil
     end
 
+    # Check if this element is visible
+    # @rbs return bool
     def visible?
       @ole_obj.Visible
     end
 
-    # @rbs return bool -- true if ole type is TypeLine
+    # Check if this element is a line
+    # @rbs return bool
     def line?
       ole_obj.ObjectName == "AcdbLine"
     end
 
+    # Check if this element is graphical
+    # @rbs return bool
     def graphical?
       ole_obj.IsGraphical
     end
 
+    # Get string representation of this element
+    # @rbs return String
     def inspect
-      "<#{self.class}: #{autocad_id}>"
+      "<#{self.class} -name: #{begin
+        name
+      rescue
+        nil
+      end}> #{acad_type}"
     end
 
+    # Get the parent element
+    # @rbs return Element?
     def parent
       parent_id = ole_obj.ParentID
       return nil unless parent_id
@@ -122,6 +283,9 @@ module Autocad
       app.active_design_file.find_by_id(id)
     end
 
+    # Convert record ID to element ID
+    # @rbs id: WIN32OLE_RECORD
+    # @rbs return Integer?
     def id_from_record(id)
       return unless id.instance_of?(WIN32OLE_RECORD)
       return id.Low if id.Low > id.High
@@ -129,18 +293,20 @@ module Autocad
       id.High
     end
 
+    # Select this element in the drawing
+    # @rbs return void
     def select
       app.active_model_reference.select_element(self)
     end
 
-    # def Type
-    #   ole_obj.Type
-    # end
-
+    # Get the AutoCAD object type name
+    # @rbs return String
     def autocad_type
       ole_obj.ObjectName
     end
 
+    # Get the model containing this element
+    # @rbs return Model
     def model
       Model.new(app, app.current_drawing, ole_obj.ModelReference)
     end
@@ -199,18 +365,43 @@ module Autocad
           ::Autocad::Linetype.new(ole, app, typ)
         when "IAcadText"
           ::Autocad::Text.new(ole, app, typ)
+        when "IAcadModelSpace"
+          ::Autocad::ModelSpace.new(ole, app, typ)
+        when "IAcadPaperSpace"
+          ::Autocad::PaperSpace.new(ole, app, typ)
         when "IAcadMText"
           ::Autocad::MText.new(ole, app, typ)
         when "IAcadPViewport"
           ::Autocad::PViewport.new(ole, app, typ)
         when "IAcadBlockReference"
           ::Autocad::BlockReference.new(ole, app, typ)
+        when "IAcadBlock"
+          ::Autocad::Block.new(ole, app, typ)
         when "IAcadExternalReference"
           ::Autocad::ExternalReference.new(ole, app, typ)
         when "IAcadAttributeReference"
           ::Autocad::AttributeReference.new(ole, app, typ)
+        when "IAcadLayout"
+          ::Autocad::Layout.new(ole, app, typ)
+        when "IAcadPlotConfiguration"
+          ::Autocad::PlotConfiguration.new(ole, app, typ)
+        when "IAcadDimStyle"
+          ::Autocad::DimStyle.new(ole, app, typ)
+        when "IAcadTextStyle"
+          ::Autocad::TextStyle.new(ole, app, typ)
+        when "IAcadArc"
+          ::Autocad::Arc.new(ole, app, typ)
+        when "IAcadPlot"
+          ::Autocad::Plot.new(ole, app, typ)
+        when "IAcadSpline"
+          ::Autocad::Spline.new(ole, app, typ)
+        when "IAcadViewport"
+          ::Autocad::Viewport.new(ole, app, typ)
+        when "IAcadPoint"
+          ::Autocad::Point.new(ole, app, typ)
 
         else
+          # binding.irb
           Element.new(ole, app, typ)
         end
 
@@ -304,16 +495,17 @@ module Autocad
     def redraw(el = ole_obj)
       # el.Redraw ::Autocad::MSD::MsdDrawingModeNormal if el.IsGraphical
       el.Update
-    rescue => e
-      app.error_proc.call(e, nil)
+    rescue
+      nil
     end
 
     def app_ole_obj
       app.ole_obj
     end
 
-    def delete
+    def delete(regen: true)
       ole_obj.Delete
+      drawing.regen if regen
     rescue => ex
       raise Autocad::Error.new("Error deleting object #{self} #{ex}")
     end

data/lib/autocad/errors.rb

@@ -28,6 +28,15 @@ module Autocad
     end
   end
 
+  class DrawingClose < Error
+    attr_reader :drawing_name
+
+    def initialize(message, drawing_name)
+      @drawing_name = drawing_name
+      super("#{message}")
+    end
+  end
+
   class ExistingFile < Error
     def initialize(path)
       msg = "File at path #{path} already exists"