autocad 0.4.6 → 0.5

data/sig/generated/autocad/plot_configuration.rbs

@@ -0,0 +1,176 @@
+# Generated from lib/autocad/plot_configuration.rb with RBS::Inline
+
+module Autocad
+  class PlotConfiguration < Element
+    # Get the name of the plot configuration
+    # @rbs return String
+    def name: () -> String
+
+    # Set the plot device configuration file
+    # @rbs name: String
+    # @rbs return void
+    def device_name=: (String name) -> void
+
+    # Get the current plot device configuration name
+    # @rbs return String
+    def device_name: () -> String
+
+    # Read current configuration properties from OLE object
+    # @rbs return Hash[Symbol, Object]
+    def read_ole: (?untyped ole) -> Hash[Symbol, Object]
+
+    # Write configuration settings to OLE object
+    # @rbs value: Hash[Symbol, Object]
+    # @rbs return void
+    def write_ole: (Hash[Symbol, Object] value) -> void
+
+    # Get plot origin point in millimeters
+    # @rbs return Point3d
+    def plot_origin: () -> Point3d
+
+    # Set plot origin point
+    # @rbs ...: Numeric | Array[Numeric] | Point3d
+    # @rbs return void
+    # @raise [ArgumentError] For invalid coordinate values
+    def plot_origin=: ...
+
+    # Get current plot style mode
+    # @rbs return Symbol
+    def plot_style_mode: () -> Symbol
+
+    def plot_style_mode_variable: () -> untyped
+
+    # Check if using color-dependent plot styles
+    # @rbs return bool
+    def color_style_mode?: () -> bool
+
+    # Check if using named plot styles
+    # @rbs return bool
+    def named_style_mode?: () -> bool
+
+    # Configure multiple plot settings at once
+    # @rbs kwargs: Hash{Symbol => Object} -- See write_ole for valid keys
+    # @rbs return void
+    # @example Configure for PDF output
+    #   setup(
+    #     device_name: "AutoCAD PDF.pc3",
+    #     media_name: "ANSI_D",
+    #     style_sheet: "monochrome.ctb",
+    #     plot_type: :layout
+    #   )
+    def setup: () -> void
+
+    # Update configuration with merged values
+    # @rbs value: Hash{Symbol => Object} -- Partial configuration updates
+    # @rbs return void
+    def update: (Hash value) -> void
+
+    # Print current configuration to console
+    # @rbs return void
+    def display_setup: () -> void
+
+    # Copy settings from another configuration
+    # @rbs pc: PlotConfiguration -- Source configuration
+    # @rbs return void
+    def copy_plot_configuration: (PlotConfiguration pc) -> void
+
+    def plot_style_mode=: (untyped sym) -> untyped
+
+    # ANSI B landscape paper size name
+    # @rbs return String -- Canonical name "ANSI_B_(17.00_x_11.00_Inches)"
+    def ansi_b_landscape: () -> String
+
+    def ansi_d_landscape: () -> untyped
+
+    # Refresh plot device information
+    # @rbs return void
+    # @note Required after changing device configurations
+    def refresh: () -> void
+
+    def style_sheet=: (untyped style) -> untyped
+
+    def style_sheet: () -> untyped
+
+    # The media devices available to for plotting
+    # @rbs return Array[String]
+    def device_names: () -> Array[String]
+
+    # The current device_name for printing as its Canonomical Name
+    # use this name when changing
+    # @rbs return String
+    def canonical_media_name: () -> String
+
+    def canonomical_media_name=: (untyped name) -> untyped
+
+    # The available paper sizes for the configured device. Use this
+    # when setting the media_name:
+    # @rbs return Array[String]
+    # @note Call refresh() first if device was changed
+    def media_names: () -> Array[String]
+
+    def locale_media_name: () -> untyped
+
+    # Returns the different plot tables. Use one of these
+    # when setting style_sheet
+    # @rbs return Array[String] -- CTB/STB file names
+    def plot_style_table_names: () -> Array[String]
+
+    # The different plot bounds or types
+    # @rbs return Array[Symbol]
+    def plot_types: () -> Array[Symbol]
+
+    # @rbs return Array[Float, Float] -- the numerator and denominator for a custom scale
+    def custom_scale: () -> Array[Float, Float]
+
+    # The different paper units
+    # @rbs return Array[Symbol]
+    def paper_units_types: () -> Array[Symbol]
+
+    # Get current paper units
+    # @rbs return Symbol -- :inches, :mm, or :pixels
+    def paper_units: () -> Symbol
+
+    # Conversion factor to millimeters based on paper units
+    # @rbs return Float
+    # @example
+    #   inches: 25.4 (mm per inch)
+    #   pixels: 25.4/96 (mm per pixel at 96 DPI)
+    def paper_units_scale_factor: () -> Float
+
+    private
+
+    # Convert paper units symbol to OLE constant
+    # @rbs unit: Symbol -- Valid values: :inches, :mm, :pixels
+    # @rbs return Integer -- OLE constant (ACAD::Ac*)
+    # @raise [ArgumentError] For invalid paper units
+    def paper_units_to_ole: (Symbol unit) -> Integer
+
+    # Convert OLE paper units constant to symbol
+    # @rbs unit: Integer -- OLE constant (ACAD::Ac*)
+    # @rbs return Symbol -- :inches, :mm, or :pixels
+    def paper_units_from_ole: (Integer unit) -> Symbol
+
+    # Convert rotation degrees to OLE constant
+    # @rbs degree: Integer -- Valid values: 0, 90, 180, 270
+    # @rbs return Integer -- OLE constant (ACAD::Ac*degrees)
+    # @raise [ArgumentError] For invalid rotation values
+    def rotation_degree_to_ole: (Integer degree) -> Integer
+
+    # Convert OLE rotation constant to degrees
+    # @rbs rot: Integer -- OLE constant (ACAD::Ac*degrees)
+    # @rbs return Integer -- 0, 90, 180, or 270
+    def rotation_ole_to_degree: (Integer rot) -> Integer
+
+    # Convert OLE plot type constant to symbol
+    # @rbs typ: Integer -- OLE constant (ACAD::Ac*)
+    # @rbs return Symbol -- :display, :extents, :layout, :limits, :view, or :window
+    def plot_type_ole_to_sym: (Integer typ) -> Symbol
+
+    # Convert plot type symbol to OLE constant
+    # @rbs typ: Symbol -- Valid values: 
+    #   :display, :extents, :layout, :limits, :view, :window
+    # @rbs return Integer -- OLE constant (ACAD::Ac*)
+    # @raise [ArgumentError] For invalid plot types
+    def plot_type_to_ole: (Symbol typ) -> Integer
+  end
+end

data/sig/generated/autocad/point.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/autocad/point.rb with RBS::Inline
+
+module Autocad
+  class Point < Element
+    def coordinates: () -> untyped
+  end
+end

data/sig/generated/autocad/point3d.rbs

@@ -1,66 +1,70 @@
-# Generated from lib/autocad/point3d.rb with RBS::Inline
-
-module Autocad
-  class Point3d
-    def self.cartesian_to_polar: (untyped x, untyped y) -> untyped
-
-    def self.from_polar_degrees: (untyped r, untyped a) -> untyped
-
-    def self.from_ole: (untyped ole) -> untyped
-
-    def self.polar_to_cartesian: (untyped r, untyped a) -> untyped
-
-    # convert array of points to array of x,y coordinates
-    # array can be [ Point3d, Point3d, ..]
-    # array can be [  [x,y,z], [x,y,z], [x,y,z] ..]
-    # array can be [x,y, x1, y1, x2,y2, x3,y3]
-    # array can be [[x,y], [x2,y2], [x3,y3]]
-    # all coordinates are converted to float
-    # z coordinates are ignored
-    # @rbs return Array[Float]
-    def self.pts_to_array: (untyped pts) -> Array[Float]
-
-    def self.array_to_ole: (untyped ar) -> untyped
-
-    attr_reader x: untyped
-
-    attr_reader y: untyped
-
-    attr_reader z: untyped
-
-    def initialize: (?untyped _x, ?untyped _y, ?untyped _z, ?x: untyped, ?y: untyped, ?z: untyped) -> untyped
-
-    # @rbs other: Point3d | [Float,Float,Float]
-    def +: (Point3d | [ Float, Float, Float ] other) -> untyped
-
-    def distance_to: (untyped other) -> untyped
-
-    # @rbs return [Float,Float, Float]
-    def deconstruct: () -> [ Float, Float, Float ]
-
-    # @rbs return { x: Float, y: Float, z: Float}
-    def deconstruct_keys: () -> { x: Float, y: Float, z: Float }
-
-    # @rbs return [Float,Float, Float]
-    def to_ary: () -> [ Float, Float, Float ]
-
-    # @rbs other: Point3d | [Float,Float,Float]
-    def -: (Point3d | [ Float, Float, Float ] other) -> untyped
-
-    def to_xy: () -> untyped
-
-    def xy_bounds: (untyped other) -> untyped
-
-    def to_s: () -> untyped
-
-    # @rbs return [Float,Float, Float]
-    def to_a: () -> [ Float, Float, Float ]
-
-    # @rbs return Point3d -- return a Point3d at [0,0,0]
-    def zero: () -> Point3d
-
-    def to_cartesian: () -> untyped
-
-    def to_ole: () -> untyped
-  end
-end
+# Generated from lib/autocad/point3d.rb with RBS::Inline
+
+module Autocad
+  class Point3d
+    # @rbs return Point3d -- return a Point3d at [0,0,0]
+    def self.zero: () -> Point3d
+
+    def self.cartesian_to_polar: (untyped x, untyped y) -> untyped
+
+    def self.from_polar_degrees: (untyped r, untyped a) -> untyped
+
+    def self.from_ole: (untyped ole) -> untyped
+
+    def self.polar_to_cartesian: (untyped r, untyped a) -> untyped
+
+    # convert array of points to array of x,y coordinates
+    # array can be [ Point3d, Point3d, ..]
+    # array can be [  [x,y,z], [x,y,z], [x,y,z] ..]
+    # array can be [x,y, x1, y1, x2,y2, x3,y3]
+    # array can be [[x,y], [x2,y2], [x3,y3]]
+    # all coordinates are converted to float
+    # z coordinates are ignored
+    # @rbs return Array[Float]
+    def self.pts_to_array: (untyped pts) -> Array[Float]
+
+    def self.array_to_ole: (untyped ar) -> untyped
+
+    attr_reader x: untyped
+
+    attr_reader y: untyped
+
+    attr_reader z: untyped
+
+    def initialize: (?untyped _x, ?untyped _y, ?untyped _z, ?x: untyped, ?y: untyped, ?z: untyped) -> untyped
+
+    # @rbs other: Point3d | [Float,Float,Float]
+    def +: (Point3d | [ Float, Float, Float ] other) -> untyped
+
+    def distance_to: (untyped other) -> untyped
+
+    # @rbs return [Float,Float, Float]
+    def deconstruct: () -> [ Float, Float, Float ]
+
+    # @rbs return { x: Float, y: Float, z: Float}
+    def deconstruct_keys: () -> { x: Float, y: Float, z: Float }
+
+    # @rbs return [
+    def to_ary: () -> untyped
+
+    # @rbs other: Point3d | [Float,Float,Float]
+    def -: (Point3d | [ Float, Float, Float ] other) -> untyped
+
+    def to_xy: () -> untyped
+
+    # @rbs model_space: bool
+    # @return Autocad::Point
+    def to_acad_point: (?bool model_space) -> untyped
+
+    def xy_bounds: (untyped other) -> untyped
+
+    def to_s: () -> untyped
+
+    # @rbs return [Float,Float, Float]
+    def to_a: () -> [ Float, Float, Float ]
+
+    def to_cartesian: () -> untyped
+
+    def to_ole: () -> untyped
+  end
+end

data/sig/generated/autocad/pviewport.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/autocad/pviewport.rb with RBS::Inline
+
+module Autocad
+  class PViewport < Element
+    # the viewport width
+    # @rbs return Float
+    def width: () -> Float
+
+    def width_inches: () -> untyped
+
+    def height_inches: () -> untyped
+
+    def pviewport?: () -> untyped
+
+    # change the viewport to front_view direction
+    def front_view: () -> untyped
+
+    def top_view: () -> untyped
+
+    def right_view: () -> untyped
+
+    def isometric_view: () -> untyped
+
+    # the viewport height
+    # @rbs return Float
+    def height: () -> Float
+
+    # @rbs return bool
+    def on?: () -> bool
+
+    # turn on the view
+    # @rbs return void
+    def on: () -> void
+
+    # turn of the display of viewport
+    # @rbs return void
+    def off: () -> void
+
+    # the standard scale from Autocad AcViewportScale enum converted to symbol
+    # @rbs return Symbol
+    def standard_scale: () -> Symbol
+
+    def standard_scale=: (untyped scale) -> untyped
+
+    def standard_scale_ole_to_symbol: (untyped scale) -> untyped
+
+    def standard_scale_symbol_to_ole: (untyped scale) -> untyped
+
+    # set a custom scale for model objects
+    # @rbs scale: Float
+    def custom_scale=: (Float scale) -> untyped
+
+    def lock_display: () -> untyped
+
+    # specifies the lock stat fo the viewports display. When locked, cant
+    # change view
+    # @rbs return bool
+    def display_locked?: () -> bool
+
+    def unlock_display: () -> untyped
+
+    def each: () -> untyped
+  end
+end

data/sig/generated/autocad/selection_filter.rbs

@@ -1,50 +1,226 @@
-# Generated from lib/autocad/selection_filter.rb with RBS::Inline
-
-module Autocad
-  class SelectionFilter
-    attr_reader types: untyped
-
-    attr_reader values: untyped
-
-    def initialize: () -> untyped
-
-    def has_filters?: () -> untyped
-
-    # Logical Operators
-    def and: (*untyped conditions) -> untyped
-
-    def or: (*untyped conditions) -> untyped
-
-    def xor: (untyped condition1, untyped condition2) -> untyped
-
-    def not: (untyped condition) -> untyped
-
-    # Relational Operators
-    #  f.type("Circle").greater_than(5)
-    def greater_than: (untyped value) -> untyped
-
-    def less_than: (untyped value) -> untyped
-
-    def equal_to: (untyped value) -> untyped
-
-    def not_equal_to: (untyped value) -> untyped
-
-    def block_reference: (?untyped name) -> untyped
-
-    def name: (untyped value) -> untyped
-
-    def type: (untyped kind) -> untyped
-
-    def layer: (untyped name) -> untyped
-
-    def visible: (?untyped vis) -> untyped
-
-    def color: (untyped num) -> untyped
-
-    def paper_space: () -> untyped
-
-    def model_space: () -> untyped
-
-    def contains: (untyped str) -> untyped
-  end
-end
+# Generated from lib/autocad/selection_filter.rb with RBS::Inline
+
+module Autocad
+  # Builds AutoCAD selection filter criteria using group codes
+  #
+  # Provides a fluent interface for creating complex entity filters
+  # based on AutoCAD DXF group codes and logical operations.
+  #
+  # Key Features:
+  # - Logical operators (AND, OR, NOT, XOR)
+  # - Comparison operators (>, <, =, !=)
+  # - Entity property filters (type, layer, color)
+  # - Text content matching
+  # - Space-specific filtering (model/paper)
+  #
+  # @example Create a filter for red circles
+  #   filter = SelectionFilter.new
+  #     .and(
+  #       SelectionFilter.new.type("CIRCLE"),
+  #       SelectionFilter.new.color(1)
+  #     )
+  #
+  # @example Complex filter with nested conditions
+  #   filter = SelectionFilter.new
+  #     .and(
+  #       SelectionFilter.new.layer("WALLS"),
+  #       SelectionFilter.new.or(
+  #         SelectionFilter.new.type("LINE"),
+  #         SelectionFilter.new.type("POLYLINE")
+  #       )
+  #     )
+  class SelectionFilter
+    # @rbs attr_reader types: Array[Integer] -- AutoCAD group codes (e.g., 0=Entity type)
+    # @rbs attr_reader values: Array[untyped] -- Filter values matching group codes
+    attr_reader types: untyped
+
+    # @rbs attr_reader types: Array[Integer] -- AutoCAD group codes (e.g., 0=Entity type)
+    # @rbs attr_reader values: Array[untyped] -- Filter values matching group codes
+    attr_reader values: untyped
+
+    # Initialize empty filter
+    # @return [void]
+    # @rbs return void
+    def initialize: () -> void
+
+    # Check if filter has any conditions
+    # @return [Boolean] True if filter has conditions
+    # @example Skip empty filter
+    #   next unless filter.has_filters?
+    # @rbs return bool
+    def has_filters?: () -> bool
+
+    # Logical AND combination of filters
+    # @param conditions [Array<SelectionFilter>] Filters to combine
+    # @return [self] The filter for chaining
+    # @example Combine multiple conditions with AND
+    #   filter.and(
+    #     SelectionFilter.new.type("LINE"),
+    #     SelectionFilter.new.layer("WALLS")
+    #   )
+    # @rbs *conditions: Array[SelectionFilter] -- Filters to combine
+    # @rbs return SelectionFilter
+    def and: (*Array[SelectionFilter] conditions) -> SelectionFilter
+
+    # Logical OR combination of filters
+    # @param conditions [Array<SelectionFilter>] Filters to combine
+    # @return [self] The filter for chaining
+    # @example Match entities on multiple layers
+    #   filter.or(
+    #     SelectionFilter.new.layer("WALLS"),
+    #     SelectionFilter.new.layer("DOORS")
+    #   )
+    # @rbs *conditions: Array[SelectionFilter]
+    # @rbs return SelectionFilter
+    def or: (*Array[SelectionFilter] conditions) -> SelectionFilter
+
+    # Logical XOR combination of two filters
+    # @param condition1 [SelectionFilter] First filter
+    # @param condition2 [SelectionFilter] Second filter
+    # @return [self] The filter for chaining
+    # @example Select entities that match exactly one condition
+    #   filter.xor(
+    #     SelectionFilter.new.type("CIRCLE"),
+    #     SelectionFilter.new.layer("SPECIAL")
+    #   )
+    # @rbs condition1: SelectionFilter
+    # @rbs condition2: SelectionFilter
+    # @rbs return SelectionFilter
+    def xor: (SelectionFilter condition1, SelectionFilter condition2) -> SelectionFilter
+
+    # Logical NOT for a filter condition
+    # @param condition [SelectionFilter] Filter to negate
+    # @return [self] The filter for chaining
+    # @example Select everything except circles
+    #   filter.not(SelectionFilter.new.type("CIRCLE"))
+    # @rbs condition: SelectionFilter
+    # @rbs return SelectionFilter
+    def not: (SelectionFilter condition) -> SelectionFilter
+
+    # Greater than comparison
+    # @param value [Numeric] Comparison value
+    # @return [self] The filter for chaining
+    # @example Find circles with radius > 5
+    #   filter.type("CIRCLE").greater_than(5)
+    # @rbs value: Numeric -- Comparison value
+    # @rbs return SelectionFilter
+    def greater_than: (Numeric value) -> SelectionFilter
+
+    # Less than comparison
+    # @param value [Numeric] Comparison value
+    # @return [self] The filter for chaining
+    # @example Find circles with radius < 10
+    #   filter.type("CIRCLE").less_than(10)
+    # @rbs value: Numeric -- Comparison value
+    # @rbs return SelectionFilter
+    def less_than: (Numeric value) -> SelectionFilter
+
+    # Equal to comparison
+    # @param value [Numeric] Comparison value
+    # @return [self] The filter for chaining
+    # @example Find circles with radius = 7.5
+    #   filter.type("CIRCLE").equal_to(7.5)
+    # @rbs value: Numeric -- Comparison value
+    # @rbs return SelectionFilter
+    def equal_to: (Numeric value) -> SelectionFilter
+
+    # Not equal to comparison
+    # @param value [Numeric] Comparison value
+    # @return [self] The filter for chaining
+    # @example Find circles with radius != 5
+    #   filter.type("CIRCLE").not_equal_to(5)
+    # @rbs value: Numeric -- Comparison value
+    # @rbs return SelectionFilter
+    def not_equal_to: (Numeric value) -> SelectionFilter
+
+    # Filter by block references
+    # @param name [String, nil] Optional block name pattern
+    # @return [self] The filter for chaining
+    # @example Find any block reference
+    #   filter.block_reference
+    # @example Find specific block
+    #   filter.block_reference("DOOR")
+    # @rbs name: String? -- Optional block name pattern
+    # @rbs return SelectionFilter
+    def block_reference: (?String? name) -> SelectionFilter
+
+    # Filter by entity name/type
+    # @param value [String] Entity type name (e.g., "CIRCLE")
+    # @return [self] The filter for chaining
+    # @example Filter by entity name
+    #   filter.name("CIRCLE")
+    # @rbs value: String -- Entity type name (e.g., "CIRCLE")
+    # @rbs return SelectionFilter
+    def name: (String value) -> SelectionFilter
+
+    # Filter by entity type
+    # @param kind [String] Entity type name (e.g., "CIRCLE")
+    # @return [self] The filter for chaining
+    # @example Filter for lines
+    #   filter.type("LINE")
+    # @rbs kind: String -- Entity type name (e.g., "CIRCLE")
+    # @rbs return SelectionFilter
+    def type: (String kind) -> SelectionFilter
+
+    # Filter by layer name
+    # @param name [String] Layer name
+    # @return [self] The filter for chaining
+    # @example Filter for entities on a specific layer
+    #   filter.layer("WALLS")
+    # @rbs name: String -- Layer name
+    # @rbs return SelectionFilter
+    def layer: (String name) -> SelectionFilter
+
+    # Filter by visibility state
+    # @param vis [Boolean] True for visible entities
+    # @return [self] The filter for chaining
+    # @example Filter for visible entities
+    #   filter.visible(true)
+    # @example Filter for hidden entities
+    #   filter.visible(false)
+    # @rbs vis: bool -- True for visible entities
+    # @rbs return SelectionFilter
+    def visible: (?bool vis) -> SelectionFilter
+
+    # Filter by color index
+    # @param num [Integer] AutoCAD color number (0-256)
+    # @return [self] The filter for chaining
+    # @example Filter for red entities (color 1)
+    #   filter.color(1)
+    # @rbs num: Integer -- AutoCAD color number (0-256)
+    # @rbs return SelectionFilter
+    def color: (Integer num) -> SelectionFilter
+
+    # Filter for paper space entities
+    # @return [self] The filter for chaining
+    # @example Filter for paper space entities
+    #   filter.paper_space
+    # @rbs return SelectionFilter
+    def paper_space: () -> SelectionFilter
+
+    # Filter for model space entities
+    # @return [self] The filter for chaining
+    # @example Filter for model space entities
+    #   filter.model_space
+    # @rbs return SelectionFilter
+    def model_space: () -> SelectionFilter
+
+    # Filter text content using wildcards
+    # @param str [String] Search pattern (e.g., "*REV*")
+    # @return [self] The filter for chaining
+    # @example Find text containing "REVISION"
+    #   filter.contains("*REVISION*")
+    # @rbs str: String -- Search pattern (e.g., "*REV*")
+    # @rbs return SelectionFilter
+    def contains: (String str) -> SelectionFilter
+
+    # Helper method for text content matching
+    # @param str [String] Text to search for
+    # @return [self] The filter for chaining
+    # @example Find text containing specific content
+    #   filter.has_text("Revision")
+    # @rbs str: String -- Text to search for
+    # @rbs return SelectionFilter
+    def has_text: (String str) -> SelectionFilter
+  end
+end