autocad 0.4.6

data/lib/autocad/selection_filter.rb

@@ -0,0 +1,180 @@
+module Autocad
+  class SelectionFilter
+    attr_reader :types, :values
+
+    def initialize
+      @types = []
+      @values = []
+    end
+
+    def has_filters?
+      @types.any?
+    end
+
+    # Logical Operators
+    def and(*conditions)
+      return self if conditions.empty?
+
+      @types << -4
+      @values << "<AND"
+
+      conditions.each do |condition|
+        @types.concat(condition.types)
+        @values.concat(condition.values)
+      end
+
+      @types << -4
+      @values << "AND>"
+
+      self
+    end
+
+    def or(*conditions)
+      return self if conditions.empty?
+
+      @types << -4
+      @values << "<OR"
+
+      conditions.each do |condition|
+        @types.concat(condition.types)
+        @values.concat(condition.values)
+      end
+
+      @types << -4
+      @values << "OR>"
+
+      self
+    end
+
+    def xor(condition1, condition2)
+      @types << -4
+      @values << "<XOR"
+
+      @types.concat(condition1.types)
+      @values.concat(condition1.values)
+
+      @types.concat(condition2.types)
+      @values.concat(condition2.values)
+
+      @types << -4
+      @values << "XOR>"
+
+      self
+    end
+
+    def not(condition)
+      @types << -4
+      @values << "<NOT"
+
+      @types.concat(condition.types)
+      @values.concat(condition.values)
+
+      @types << -4
+      @values << "NOT>"
+
+      self
+    end
+
+    # Relational Operators
+    #  f.type("Circle").greater_than(5)
+    def greater_than(value)
+      @types << -4
+      @values << ">="
+      @types << 40 # floating point
+      @values << value
+      self
+    end
+
+    def less_than(value)
+      @types << -4
+      @values << "<="
+      @types << 40 # floating point
+      @values << value
+      self
+    end
+
+    def equal_to(value)
+      @types << -4
+      @values << "="
+      @types << 40 # floating point
+      @values << value
+      self
+    end
+
+    def not_equal_to(value)
+      @types << -4
+      @values << "<>"
+      @types << 40 # floating point
+      @values << value
+      self
+    end
+
+    def block_reference(name = nil)
+      # return unless name
+
+      @types << 0
+      @values << "INSERT"
+      self
+    end
+
+    def name(value)
+      @types << [0, 2]
+      @values << value
+      self
+    end
+
+    def type(kind)
+      @types << 0
+      @values << kind
+      self
+    end
+
+    def layer(name)
+      @types << 8
+      @values << name
+      self
+    end
+
+    def visible(vis = true)
+      @types << 60
+      @values << (vis ? 0 : 1)
+      self
+    end
+
+    def color(num)
+      @types << 62 # Color number filter
+      @values << num
+      self
+    end
+
+    def paper_space
+      @types << 67  # Paper space filter
+      @values << 1
+      self
+    end
+
+    def model_space
+      @types << 67  # Model space filter
+      @values << 0
+      self
+    end
+
+    def contains(str)
+      @types << -4
+      @values << "<OR"
+
+      # Filter for TEXT
+      @types << 1 # Text string group code for TEXT
+      @values << "*#{str}*"
+
+      # Filter for MTEXT
+      @types << 1 # Text string group code for MTEXT
+      @values << "*#{str}*"
+
+      @types << -4
+      @values << "OR>"
+
+      self
+    end
+  end
+end

data/lib/autocad/selection_set.rb

@@ -0,0 +1,61 @@
+# require_relative "selection_filter"
+require_relative 'filter'
+
+module Autocad
+  class SelectionSet
+    attr_reader :filter_types, :filter_values, :name
+
+    def initialize(name)
+      @name = name
+      @filter_types = []
+      @filter_values = []
+    end
+
+    def has_filter?
+      filter_types && filter_types.any?
+    end
+
+    def filter_text(str = nil)
+      if str
+        filter_text_containing(str)
+      else
+        filter do |f|
+          f.or(f.type('TEXT'), f.type('MTEXT'))
+        end
+      end
+    end
+
+    # 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
+      if block_given?
+        filter = Filter.new
+        result = yield filter
+        @filter_types, @filter_values = result.convert_clauses
+      end
+      self
+    end
+
+    # Helper methods for common operations
+    def filter_by_type(*types)
+      filter { |f| f.or(*types.map { |t| f.type(t) }) }
+    end
+
+    def filter_by_layer(*layers)
+      filter { |f| f.or(*layers.map { |l| f.layer(l) }) }
+    end
+
+    def filter_text_containing(text)
+      filter do |f|
+        f.and(f.has_text(text), f.or(f.type('TEXT'), f.type('MTEXT')))
+      end
+    end
+
+    def filter_block_references(name = nil)
+      filter { |f| f.block_reference(name) }
+    end
+  end
+end

data/lib/autocad/selection_set_adapter.rb

@@ -0,0 +1,146 @@
+module Autocad
+  class SelectionSetAdapter
+    def self.from_ole_obj(drawing, ole)
+      ss = SelectionSet.new(ole.Name)
+      new(drawing, ss, ole)
+    end
+
+    attr_reader :ole_obj, :drawing, :selection_set
+
+    def initialize(drawing, selection_set, ole = nil)
+      @drawing = drawing
+      @selection_set = selection_set
+      @ole_obj = ole || create_selection_set
+    end
+
+    def delete
+      @ole_obj.Delete
+      @selection_set = nil
+    end
+
+    # checks if the selection set has any items
+    # @ rbs return bool
+    def has_items?
+      ole_obj.Count > 0
+    end
+
+    def count
+      ole_obj.Count
+    end
+
+    def clear
+      ole_obj.Clear
+    end
+
+    def filter_text(str)
+      @selection_set.filter_text(str)
+    end
+
+    def filter_text_containing(str)
+      @selection_set.filter_text_containing(str)
+    end
+
+    def app
+      @drawing.app
+    end
+
+    def each
+      return to_enum(__callee__) unless block_given?
+
+      ole_obj.each { |o| yield app.wrap(o) }
+    end
+
+    def name
+      @ole_obj.Name
+    end
+
+    def filter_types
+      @selection_set.filter_types
+    end
+
+    def filter_values
+      @selection_set.filter_values
+    end
+
+    def select_on_screen(ft = ole_filter_types, fv = ole_filter_values)
+      @ole_obj.SelectOnScreen(ft, fv)
+    end
+
+    def select(mode: :all, pt1: nil, pt2: nil, ft: ole_filter_types, fv: ole_filter_values)
+      acad_mode = case mode
+      when :all
+        ACAD::AcSelectionSetAll
+      when :window
+        ACAD::AcSelectionSetWindow
+      when :crossing
+        ACAD::AcSelectionSetCrossing
+      when :previous
+        ACAD::AcSelectionSetPrevious
+      when :last
+        ACAD::AcSelectionSetLast
+      else
+        Acad::AcSelectionSetAll
+      end
+      @ole_obj.Select(acad_mode, nil, nil, ft, fv)
+    end
+
+    # accepts Point3d | [x,y] | (x,y)
+    def select_at_point(x, y)
+      point = if x.respond_to?(:x) && x.respond_to?(:y)
+        # Handle Point3d object
+        [x.x, x.y]
+      elsif x.is_a?(Array)
+        # Handle array input
+        x
+      else
+        # Handle separate x,y coordinates
+        [x, y]
+      end
+
+      @ole_obj.SelectAtPoint(point, filter_types, filter_values)
+    end
+
+    # @param points [Array<Point3d>] Array of points defining the polygon
+    # @param mode [:fence, :window, :crossing] Selection mode
+    def select_by_polygon(points: [], mode: :fence)
+      # Convert points to arrays of coordinates
+      point_coords = points.map { |p| [p.x, p.y] }
+
+      mode_code = case mode
+      when :fence then 5
+      when :window then 3
+      when :crossing then 4
+      else
+        raise ArgumentError, "Invalid selection mode: #{mode}. Must be :fence, :window, or :crossing"
+      end
+
+      @ole_obj.SelectByPolygon(mode_code, point_coords, filter_types, filter_values)
+    end
+
+    def filter(&)
+      @selection_set.filter(&)
+    end
+
+    private
+
+    def create_selection_set
+      @drawing.ole_obj.SelectionSets.Add(@selection_set.name)
+    end
+
+    def ole_filter_types
+      WIN32OLE::Variant.new(filter_types, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_I2)
+    end
+
+    def ole_filter_values
+      WIN32OLE::Variant.new(filter_values, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_VARIANT)
+    end
+  end
+end
+
+# ss = Autocad::SelectionSet.new('test_ss')
+# ss.filter_text_containing('test')
+# ss = drawing.create_selection_set('test_ss') do
+#    filter do |f|
+#      f.or(f.type('Circle'), f.type('Arc'))
+#    end
+# end

data/lib/autocad/text.rb

@@ -0,0 +1,74 @@
+require_relative "element"
+
+module Autocad
+  class Text < Element
+    def read_ole(_ole)
+      ole_obj.TextString
+    end
+
+    def write_ole(text)
+      ole_obj.TextString = text
+    end
+
+    def to_regexp
+      Regexp.new(read_ole.to_s)
+    end
+
+    def =~(reg)
+      @original =~ reg
+    end
+
+    # de_relativef tocad_id
+    #   @ole_obj.Id || @ole_obj.ID64
+    # end
+    # def text?
+    #   true
+    # end
+
+    # def text_node?
+    #   false
+    # end
+
+    def to_s
+      original.to_s
+    end
+
+    def bounds
+      binding.break
+      rotation = ole_obj.Rotation
+      begin
+        app_ole_obj.Matrix3dInverse(rotation)
+      rescue
+        binding.irb
+      end
+      transform = app_ole_obj.Transform3dFromMatrix3dandFixedPoint3d(app_ole_obj.Matrix3dInverse(rotation),
+        ole_obj.origin)
+      ole_obj.transform transform
+
+      0.upto(4) do |i|
+        points[i] = ole_obj.Boundary.Low
+      end
+      points[2] = self.Boundary.High
+      points[1].X = points[2].x
+      points[3].y = points[2].Y
+    end
+
+    def method_missing(meth, *, &)
+      if /^[A-Z]/.match?(meth)
+        ole_obj.send(meth, *)
+      else
+        dup = @original.dup
+        result = dup.send(meth, *, &)
+        update(result)
+        result
+      end
+    end
+
+    # def method_missing(meth,*args,&block)
+    #   dup = @original_text.dup
+    #     result = dup.send(meth,*args, &block)
+    #     _update(dup) unless dup == @original_text
+    #   result
+    # end
+  end
+end

data/lib/autocad/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Autocad
+  VERSION = '0.4.6'
+end

data/lib/autocad.rb

@@ -0,0 +1,161 @@
+# rbs_inline: enabled
+
+module Autocad
+  module Common
+    def method_missing(method, ...)
+      if /^[A-Z]/.match?(method.to_s)
+        ole_obj.send(method, ...)
+      else
+        super
+      end
+    end
+  end
+end
+
+module ACAD
+end
+
+require "logger"
+require "autocad/version"
+require "win32ole"
+require "pathname"
+require "autocad/app"
+require "autocad/errors"
+require "autocad/point3d"
+require "autocad/layer"
+require "autocad/message_box"
+
+def Point3d(...)
+  Autocad::Point3d.new(...)
+end
+
+module Autocad
+  ROOT = Pathname.new(__dir__).parent
+
+  class << self
+    # @yield [Autocad::App]
+    def run(...) #: void
+      App.run(...)
+    end
+
+    # @return [Pathname]
+    def root #:Pathname
+      ROOT
+    end
+
+    # @rbs dir: String -- the directory of drawing dgn|dwg -- to convert
+    # @rbs outdir: String -- the output dir for converted pdf files
+    def dgn2pdf(dir_or_file, outdir: dir_or_file, mode: :dir)
+      raise "Mode on of :dir or :file" unless [:dir, :file].include? mode
+      if mode == :dir
+        drawings = drawings_in_dir(dir_or_file)
+        with_drawings(drawings) do |drawing|
+          drawing.save_as_pdf(name: drawing.name, dir: outdir)
+        end
+      else
+        open_drawing(dir_or_file) do |drawing|
+          drawing.save_as_pdf(name: drawing.name, dir: outdir)
+        end
+      end
+    end
+
+    # save the current drawing
+    # @rbs dir: String|Pathname -- the dir to save drawing to
+    # @rbs exit: bool -- whether to exit afterwards or start irb
+    # @rbs model: bool -- prints model space instead of paperspace in pdf document
+    # @rbs return void
+    def save_open_drawings(dir: Pathname.getwd, exit: true, model: false)
+      if exit
+        run do |app|
+          return unless app.has_drawings?
+          drawings = app.drawings
+          drawings.each do |d|
+            d.copy(dir:)
+            d.save_as_pdf(dir:, model:)
+            d.close(false)
+          end
+        end
+      else
+        app = App.new
+        return unless app.has_drawings?
+        drawings = app.drawings
+        drawings.each do |d|
+          d.copy(dir:)
+          d.save_as_pdf(dir:, model:)
+          # d.close(false)
+        end
+        app
+      end
+    end
+
+    # save the current drawing
+    # @rbs dir: String|Dir -- the dir to save drawing to
+    # @rbs exit: bool -- whether to exit afterwards or start irb
+    # @rbs model: bool -- prints model space in pdf document
+    # @rbs return void
+    def save_current_drawing(dir, exit: true, model: false)
+      if exit
+        run do |app|
+          drawing = app.current_drawing
+          return unless drawing
+          drawing.copy(dir: dir)
+          drawing.save_as_pdf(dir:, model:)
+          drawing.close(false)
+        end
+      else
+        app = App.new
+        drawing = app.current_drawing
+        return unless drawing
+        drawing.copy(dir: dir)
+        drawing.save_as_pdf(dir: dir)
+        app
+      end
+    end
+
+    # save the current drawing as pdf
+    # @rbs dir: String|Dir -- the dir to save drawing to
+    # @rbs return void
+    def save_current_drawing_as_pdf(dir)
+      App.run do |app|
+        drawing = app.current_drawing
+        drawing.save_as_pdf(dir: dir)
+        drawing.close
+      end
+    end
+
+    # gets all dwg and dgn dfiles in a directory
+    # @rbs dir: String|Pathname
+    def drawings_in_dir(dir)
+      dirpath = Pathname.new(dir).expand_path
+      dirpath.glob("*.d{gn,wg,xf}").sort_by { _1.basename(".*").to_s.downcase }
+    end
+
+    def open_drawing(drawing, ...)
+      App.open_drawing(drawing, ...)
+    end
+
+    # Runs the app, opening the filenames
+    # and yielding each open drawing to the
+    # supplied block
+    # it automatically closes the drawing and
+    # the app when done
+    #
+    # @rbs *files: Array[String|Pathname]
+    # @rbs visible: bool -- show the app window
+    # @rbs error_proc: (Exception, Drawing) -> void
+    # @rbs wait_time: Integer -- the total amount of time to wait to open file (500)
+    # @rbs wait_interval: Float -- the amount of time to wait between attempts (0.5)
+    # @rbs read_only: bool
+    # @rbs &: (Drawing) -> void
+    def with_drawings(...)
+      App.with_drawings(...)
+    end
+
+    # Finds the drawing in dir and calls with_drawing forwarding all params
+    # @rbs dir: String|Pathname -- directory to search for drawings
+    def with_drawings_in_dir(dir, ...)
+      drawings = drawings_in_dir(dir)
+      with_drawings(drawings, ...)
+    end
+  end
+end