autocad 0.4.6 → 0.5

data/sig/generated/autocad/selection_set.rbs

@@ -1,37 +1,112 @@
-# Generated from lib/autocad/selection_set.rb with RBS::Inline
-
-module Autocad
-  class SelectionSet
-    attr_reader filter_types: untyped
-
-    attr_reader filter_values: untyped
-
-    attr_reader name: untyped
-
-    def initialize: (untyped name) -> untyped
-
-    def has_filter?: () -> untyped
-
-    def filter_text: (?untyped str) -> untyped
-
-    def to_ole_filter_type: () -> untyped
-
-    def to_ole_filter_value: () -> untyped
-
-    # filter do |f|
-    #   st = f.type('Circle').or(f.type('Arc'))
-    #   st2 = f.layer('0').or(f.layer('1'))
-    #   f.and(st, st2)
-    # end
-    def filter: () -> untyped
-
-    # Helper methods for common operations
-    def filter_by_type: (*untyped types) -> untyped
-
-    def filter_by_layer: (*untyped layers) -> untyped
-
-    def filter_text_containing: (untyped text) -> untyped
-
-    def filter_block_references: (?untyped name) -> untyped
-  end
-end
+# Generated from lib/autocad/selection_set.rb with RBS::Inline
+
+module Autocad
+  # Manages named selection criteria for AutoCAD entities
+  #
+  # Stores filter criteria for entity selection without executing the selection.
+  # Works with SelectionSetAdapter to apply filters and retrieve entities.
+  #
+  # @example Create a selection set with complex filters
+  #   ss = SelectionSet.new("walls")
+  #   ss.filter do |f|
+  #     f.and(f.layer("WALLS"), f.or(f.type("LINE"), f.type("POLYLINE")))
+  #   end
+  class SelectionSet
+    # @rbs attr_reader name: String -- Unique identifier for the selection set
+    # @rbs attr_reader filter_types: Array[Integer] -- AutoCAD group codes (DXF codes)
+    # @rbs attr_reader filter_values: Array[untyped] -- Filter values matching group codes
+    attr_reader filter_types: untyped
+
+    # @rbs attr_reader name: String -- Unique identifier for the selection set
+    # @rbs attr_reader filter_types: Array[Integer] -- AutoCAD group codes (DXF codes)
+    # @rbs attr_reader filter_values: Array[untyped] -- Filter values matching group codes
+    attr_reader filter_values: untyped
+
+    # @rbs attr_reader name: String -- Unique identifier for the selection set
+    # @rbs attr_reader filter_types: Array[Integer] -- AutoCAD group codes (DXF codes)
+    # @rbs attr_reader filter_values: Array[untyped] -- Filter values matching group codes
+    attr_reader name: untyped
+
+    # Initialize a new selection set with a name
+    # @param name [String] Unique identifier for the selection set
+    # @rbs name: String
+    # @rbs return void
+    def initialize: (String name) -> void
+
+    # Check if set has active filters
+    # @return [Boolean] True if filters are defined
+    # @rbs return bool
+    def has_filter?: () -> bool
+
+    # Filter for text entities with optional content matching
+    # @param str [String, nil] Optional text pattern to match
+    # @return [self] The selection set for chaining
+    # @example Filter all text entities
+    #   ss.filter_text
+    # @example Filter text with specific content
+    #   ss.filter_text("Revision")
+    # @rbs str: String? -- Optional text pattern to match
+    # @rbs return self
+    def filter_text: (?String? str) -> self
+
+    # Configure complex filters through block
+    # @yield [Filter] Block for building filter criteria
+    # @return [self] The selection set for chaining
+    # @example Create a filter for red circles
+    #   ss.filter do |f|
+    #     f.and(f.type("CIRCLE"), f.color(1))
+    #   end
+    # @example Combine multiple conditions
+    #   ss.filter do |f|
+    #     st = f.type('Circle').or(f.type('Arc'))
+    #     st2 = f.layer('0').or(f.layer('1'))
+    #     f.and(st, st2)
+    #   end
+    # @rbs &: (Filter) -> Filter
+    # @rbs return self
+    def filter: () { (Filter) -> Filter } -> self
+
+    # Clear all filter criteria
+    # @return [self] The selection set for chaining
+    # @rbs return self
+    def clear_filter: () -> self
+
+    # Filter by entity types
+    # @param types [Array<String>] Entity type names (e.g., "LINE", "CIRCLE")
+    # @return [self] The selection set for chaining
+    # @example Filter for lines and polylines
+    #   ss.filter_by_type("LINE", "POLYLINE")
+    # @rbs *types: Array[String]
+    # @rbs return self
+    def filter_by_type: (*Array[String] types) -> self
+
+    # Filter by layer names
+    # @param layers [Array<String>] Layer names to filter
+    # @return [self] The selection set for chaining
+    # @example Filter for entities on specific layers
+    #   ss.filter_by_layer("WALLS", "DOORS")
+    # @rbs *layers: Array[String]
+    # @rbs return self
+    def filter_by_layer: (*Array[String] layers) -> self
+
+    # Filter text entities containing specific text
+    # @param text [String] Text pattern to search for (supports wildcards)
+    # @return [self] The selection set for chaining
+    # @example Find text containing "NOTE"
+    #   ss.filter_text_containing("*NOTE*")
+    # @rbs text: String
+    # @rbs return self
+    def filter_text_containing: (String text) -> self
+
+    # Filter for block references with optional name
+    # @param name [String, nil] Optional block name to filter
+    # @return [self] The selection set for chaining
+    # @example Filter for any block reference
+    #   ss.filter_block_references
+    # @example Filter for specific block
+    #   ss.filter_block_references("DOOR")
+    # @rbs name: String?
+    # @rbs return self
+    def filter_block_references: (?String? name) -> self
+  end
+end

data/sig/generated/autocad/selection_set_adapter.rbs

@@ -1,28 +1,235 @@
-# Generated from lib/autocad/selection_set_adapter.rb with RBS::Inline
-
-module Autocad
-  class SelectionSetAdapter
-    def initialize: (untyped drawing, untyped selection_set) -> untyped
-
-    def filter_types: () -> untyped
-
-    def filter_values: () -> untyped
-
-    def select_on_screen: () -> untyped
-
-    # accepts Point3d | [x,y] | (x,y)
-    def select_at_point: (untyped x, untyped y) -> untyped
-
-    # @param points [Array<Point3d>] Array of points defining the polygon
-    # @param mode [:fence, :window, :crossing] Selection mode
-    def select_by_polygon: (?points: untyped, ?mode: untyped) -> untyped
-
-    def filter: () ?{ (?) -> untyped } -> untyped
-
-    private
-
-    def create_selection_set: () -> untyped
-
-    def create_ole_variant: (untyped data) -> untyped
-  end
-end
+# Generated from lib/autocad/selection_set_adapter.rb with RBS::Inline
+
+module Autocad
+  # Manages AutoCAD selection set operations and OLE integration
+  #
+  # Executes selections using stored criteria and provides access to selected entities.
+  # Bridges between Ruby selection criteria and AutoCAD's native selection mechanisms.
+  #
+  # Key Features:
+  # - Multiple selection methods (window, crossing, fence, point)
+  # - Filter-based entity selection
+  # - Enumeration of selected entities
+  # - OLE integration with AutoCAD
+  #
+  # @example Create and use a selection set
+  #   ss = drawing.create_selection_set("walls")
+  #   ss.filter { |f| f.layer("WALLS") }
+  #   ss.select(mode: :all)
+  #   ss.each { |wall| wall.color = 1 }
+  class SelectionSetAdapter
+    # Initialize from OLE object
+    # @param drawing [Drawing] Parent drawing document
+    # @param ole [WIN32OLE] AutoCAD OLE selection set object
+    # @return [SelectionSetAdapter] New adapter instance
+    # @rbs drawing: Drawing
+    # @rbs ole: WIN32OLE
+    # @rbs return SelectionSetAdapter
+    def self.from_ole_obj: (Drawing drawing, WIN32OLE ole) -> SelectionSetAdapter
+
+    # @rbs attr_reader ole_obj: WIN32OLE -- Underlying OLE selection set
+    # @rbs attr_reader drawing: Drawing -- Parent drawing document
+    # @rbs attr_reader selection_set: SelectionSet -- Configured selection criteria
+    attr_reader ole_obj: untyped
+
+    # @rbs attr_reader ole_obj: WIN32OLE -- Underlying OLE selection set
+    # @rbs attr_reader drawing: Drawing -- Parent drawing document
+    # @rbs attr_reader selection_set: SelectionSet -- Configured selection criteria
+    attr_reader drawing: untyped
+
+    # @rbs attr_reader ole_obj: WIN32OLE -- Underlying OLE selection set
+    # @rbs attr_reader drawing: Drawing -- Parent drawing document
+    # @rbs attr_reader selection_set: SelectionSet -- Configured selection criteria
+    attr_reader selection_set: untyped
+
+    # Initialize new adapter
+    # @param drawing [Drawing] Parent drawing document
+    # @param selection_set [SelectionSet] Selection criteria container
+    # @param ole [WIN32OLE, nil] Optional existing OLE selection set
+    # @rbs drawing: Drawing
+    # @rbs selection_set: SelectionSet
+    # @rbs ole: WIN32OLE?
+    # @rbs return void
+    def initialize: (Drawing drawing, SelectionSet selection_set, ?WIN32OLE? ole) -> void
+
+    # Delete the selection set from AutoCAD
+    # @return [void]
+    # @example Remove selection set when no longer needed
+    #   ss.delete if ss.count == 0
+    # @rbs return void
+    def delete: () -> void
+
+    # Checks if the selection set has any items
+    # @return [Boolean] True if selection contains entities
+    # @example Skip processing if selection is empty
+    #   next unless ss.has_items?
+    # @rbs return bool
+    def has_items?: () -> bool
+
+    # Get item count in selection set
+    # @return [Integer] Number of selected entities
+    # @example Report selection count
+    #   puts "Selected #{ss.count} entities"
+    # @rbs return Integer
+    def count: () -> Integer
+
+    # Clear selection set contents
+    # @return [void]
+    # @example Clear before new selection
+    #   ss.clear
+    #   ss.select_on_screen
+    # @rbs return void
+    def clear: () -> void
+
+    # Clear filter criteria
+    # @return [void]
+    # @example Reset filters for new selection
+    #   ss.clear_filter
+    #   ss.filter { |f| f.type("LINE") }
+    # @rbs return void
+    def clear_filter: () -> void
+
+    # Set text content filter
+    # @param str [String] Text pattern to match
+    # @return [void]
+    # @example Filter for text with specific content
+    #   ss.filter_text("Revision")
+    # @rbs str: String -- Text pattern to match
+    # @rbs return void
+    def filter_text: (String str) -> void
+
+    # Filter text containing substring
+    # @param str [String] Substring to match
+    # @return [void]
+    # @example Find text containing "NOTE"
+    #   ss.filter_text_containing("NOTE")
+    # @rbs str: String -- Substring to match
+    # @rbs return void
+    def filter_text_containing: (String str) -> void
+
+    # Get the application instance
+    # @return [Autocad::App] The application instance
+    # @private
+    def app: () -> untyped
+
+    # Iterate through selected entities
+    # @yield [Element] Block to process each entity
+    # @return [Enumerator<Element>] Enumerator of selected entities if no block given
+    # @example Process each selected entity
+    #   ss.each { |entity| entity.color = 1 }
+    # @example Convert to array
+    #   entities = ss.each.to_a
+    # @rbs &: (Element) -> void
+    # @rbs return Enumerator[Element]
+    def each: () { (Element) -> void } -> Enumerator[Element]
+
+    # Get the name of the selection set
+    # @return [String] The selection set name
+    # @example Get selection set identifier
+    #   puts "Working with selection set: #{ss.name}"
+    # @rbs return String
+    def name: () -> String
+
+    # Get filter types from selection set
+    # @return [Array<Integer>] Array of DXF group codes
+    # @example Access raw filter data
+    #   puts "Using filter types: #{ss.filter_types.join(', ')}"
+    # @rbs return Array[Integer]
+    def filter_types: () -> Array[Integer]
+
+    # Get filter values from selection set
+    # @return [Array<Object>] Array of filter values
+    # @example Access raw filter data
+    #   puts "Using filter values: #{ss.filter_values.inspect}"
+    # @rbs return Array[untyped]
+    def filter_values: () -> Array[untyped]
+
+    # Select entities interactively on screen
+    # @param ft [WIN32OLE::Variant, nil] Optional filter types variant
+    # @param fv [WIN32OLE::Variant, nil] Optional filter values variant
+    # @return [void]
+    # @example Select entities with user interaction
+    #   ss.select_on_screen
+    # @example Select with predefined filters
+    #   ss.filter { |f| f.type("CIRCLE") }
+    #   ss.select_on_screen
+    # @rbs ft: WIN32OLE::Variant? -- Filter types variant
+    # @rbs fv: WIN32OLE::Variant? -- Filter values variant
+    # @rbs return void
+    def select_on_screen: (?WIN32OLE::Variant? ft, ?WIN32OLE::Variant? fv) -> void
+
+    # Select entities using various methods
+    # @param mode [Symbol] Selection mode (:all, :window, :crossing, :previous, :last)
+    # @param pt1 [Point3d, nil] First point for window selection
+    # @param pt2 [Point3d, nil] Second point for window selection
+    # @param ft [WIN32OLE::Variant, nil] Optional filter types variant
+    # @param fv [WIN32OLE::Variant, nil] Optional filter values variant
+    # @return [void]
+    # @example Select all entities matching filter
+    #   ss.select(mode: :all)
+    # @example Window selection
+    #   ss.select(mode: :window, pt1: [0,0,0], pt2: [10,10,0])
+    # @rbs mode: Symbol -- Selection mode (:all, :window, :crossing, :previous, :last)
+    # @rbs pt1: Point3d? -- First point for window selection
+    # @rbs pt2: Point3d? -- Second point for window selection
+    # @rbs ft: WIN32OLE::Variant? -- Filter types variant
+    # @rbs fv: WIN32OLE::Variant? -- Filter values variant
+    # @rbs return void
+    def select: (?mode: Symbol, ?pt1: Point3d?, ?pt2: Point3d?, ?ft: WIN32OLE::Variant?, ?fv: WIN32OLE::Variant?) -> void
+
+    # Select entities at specific point
+    # @param x [Numeric, Point3d, Array<Numeric>] X coordinate or point object
+    # @param y [Numeric, nil] Y coordinate (if using separate coordinates)
+    # @return [void]
+    # @example Select at specific point
+    #   ss.select_at_point(10, 20)
+    # @example Select at point object
+    #   ss.select_at_point(Point3d.new(10, 20, 0))
+    # @rbs x: Numeric | Point3d | Array[Numeric] -- X coordinate or point object
+    # @rbs y: Numeric? -- Y coordinate (if using separate coordinates)
+    # @rbs return void
+    def select_at_point: (Numeric | Point3d | Array[Numeric] x, Numeric? y) -> void
+
+    # Select entities using polygonal fence
+    # @param points [Array<Point3d>] Polygon vertices
+    # @param mode [Symbol] Selection mode (:fence, :window, :crossing)
+    # @return [void]
+    # @raise [ArgumentError] For invalid mode
+    # @example Select using fence
+    #   points = [[0,0], [10,0], [10,10], [0,10]]
+    #   ss.select_by_polygon(points: points, mode: :fence)
+    # @rbs points: Array[Point3d] -- Polygon vertices
+    # @rbs mode: Symbol -- Selection mode (:fence, :window, :crossing)
+    # @rbs return void
+    # @raise [ArgumentError] For invalid mode
+    def select_by_polygon: (?points: Array[Point3d], ?mode: Symbol) -> void
+
+    # Configure filter through block
+    # @yield [Filter] Block for building filter criteria
+    # @return [void]
+    # @example Create complex filter
+    #   ss.filter do |f|
+    #     f.and(f.layer("WALLS"), f.or(f.type("LINE"), f.type("POLYLINE")))
+    #   end
+    # @rbs &: (Filter) -> Filter
+    # @rbs return void
+    def filter: () { (Filter) -> Filter } -> void
+
+    private
+
+    # Create new OLE selection set
+    # @return [WIN32OLE] The created OLE selection set
+    # @rbs return WIN32OLE
+    def create_selection_set: () -> WIN32OLE
+
+    # Convert filter types to OLE variant
+    # @return [WIN32OLE::Variant] OLE variant for filter types
+    # @rbs return WIN32OLE::Variant
+    def ole_filter_types: () -> WIN32OLE::Variant
+
+    # Convert filter values to OLE variant
+    # @return [WIN32OLE::Variant] OLE variant for filter values
+    # @rbs return WIN32OLE::Variant
+    def ole_filter_values: () -> WIN32OLE::Variant
+  end
+end

data/sig/generated/autocad/spline.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/autocad/spline.rb with RBS::Inline
+
+module Autocad
+  class Spline < Element
+    # @rbs return float -- The area of the arc
+    def area: () -> float
+
+    # whether the spline is closed
+    def closed?: () -> untyped
+
+    # ole obj Variant (array of doubles)
+    # 3D WCS Control Points for the spline
+    # @rbs return Array(Point3d)
+    def control_points: () -> Array
+
+    # set the control points for the spline
+    # @rbs pts Array(Point3d) | Array(Array[Double,Double,Double?])
+    def control_points=: (Array pts) -> untyped
+
+    def degree: () -> untyped
+  end
+end

data/sig/generated/autocad/text.rbs

@@ -1,19 +1,78 @@
 # Generated from lib/autocad/text.rb with RBS::Inline
 
 module Autocad
+  # Single-line text annotation element in AutoCAD
+  #
+  # Represents a simple text entity with a single line of content.
+  # Provides methods for reading, writing, and manipulating text properties.
+  #
+  # @example Create and modify text
+  #   text = drawing.model.add_text("Label", [10,5,0])
+  #   text.height = 2.5
+  #   text.update("New Label")
   class Text < Element
-    def read_ole: (untyped _ole) -> untyped
+    # Read text content from OLE object
+    #
+    # @param _ole [WIN32OLE] The OLE object to read from (unused parameter)
+    # @return [String] The text content
+    # @rbs (_ole: WIN32OLE) -> String
+    def read_ole: (_ole: WIN32OLE) -> String
 
-    def write_ole: (untyped text) -> untyped
+    # Confirm this is a text element (always true)
+    #
+    # @return [Boolean] Always returns true for Text objects
+    # @rbs return bool
+    def text?: () -> bool
 
-    def to_regexp: () -> untyped
+    # Update text content in AutoCAD
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
+    def write_ole: (String text) -> untyped
 
-    def =~: (untyped reg) -> untyped
+    # Convert text content to regex pattern
+    #
+    # @return [Regexp] A regular expression based on the text content
+    # @rbs return Regexp
+    def to_regexp: () -> Regexp
 
-    def to_s: () -> untyped
+    # Toggle text highlighting in the drawing
+    #
+    # @param flag [Boolean] Whether to highlight (true) or unhighlight (false)
+    # @return [void]
+    # @example Highlight selected text
+    #   selected_text.each { |t| t.highlight }
+    # @rbs flag: bool -> void
+    def highlight: (?bool flag) -> untyped
 
-    def bounds: () -> untyped
+    # 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 =~: (Regexp reg) -> untyped
 
-    def method_missing: (untyped meth, *untyped) ?{ (?) -> untyped } -> untyped
+    # Get text content as string
+    #
+    # @return [String] The text content
+    # @rbs return String
+    def to_s: () -> String
+
+    # Experimental bounding box calculation
+    #
+    # @return [BoundingBox] The text's bounding box
+    # @note Contains debug code - use with caution
+    # @rbs return BoundingBox
+    def bounds: () -> BoundingBox
+
+    # 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: (Symbol, *untyped) -> untyped
   end
 end

data/sig/generated/autocad/text_style.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/autocad/text_style.rb with RBS::Inline
+
+module Autocad
+  class TextStyle < Element
+  end
+end

data/sig/generated/autocad/viewport.rbs

@@ -2,10 +2,27 @@
 
 module Autocad
   class Viewport < Element
-    def width: () -> untyped
+    # Returns the name of the viewport
+    # @rbs return String
+    def name: () -> String
+
+    # Returns the center of the viewport
+    # @rbs return Point3d
+    def center: () -> Point3d
+
+    # Returns the width of the viewport
+    # @rbs return Float
+    def width: () -> Float
+
+    # Splits the viewport
+    #  the split_type is from the AcViewportSplitType enum
+    #  can take the integer or symbol corressponding to the enum
+    def split: (untyped split_type) -> untyped
 
     def height: () -> untyped
 
-    def each: () -> untyped
+    def lower_left: () -> untyped
+
+    def upper_right: () -> untyped
   end
 end