autocad 0.4.6

data/lib/autocad/element.rb

@@ -0,0 +1,454 @@
+# rbs_inline: enabled
+
+# require "autocad/property_handler"
+
+class WIN32OLE
+  def to_ole
+    self
+  end
+end
+
+module Autocad
+end
+
+module Autocad
+  module AcadEntity
+    def layer
+      ole_obj.Layer
+    end
+
+    def layer=(name)
+      ole_obj.Layer = name
+    end
+
+    def line_type
+      ole_obj.LineType
+    end
+
+    def line_type=(name)
+      ole_obj.LineType = name
+    end
+
+    def visible?
+      ole_obj.Visible
+    end
+
+    def copy
+    end
+
+    def intersects_with(obj)
+    end
+
+    def mirror
+    end
+
+    def move_to
+    end
+
+    def update
+    end
+
+    def transform_by(matrix)
+    end
+  end
+
+  module ElementTrait
+    def block_reference?
+      false
+    end
+
+    #
+    #
+    #
+    # @rbs return bool -- true if ole type is Text
+    #
+    def text?
+      ole_obj.ole_type == "IAcadText"
+    end
+
+    # @rbs return bool -- true if ole type is TextNode
+    def mtext?
+      ole_obj.ole_type == "IAcadMText"
+    end
+
+    def has_tags?
+      ole_obj.HasAnyTags
+    end
+
+    def to_ole
+      ole_obj
+    end
+
+    # @rbs return bool -- true if object is of type cell
+    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?
+    end
+
+    def autocad_id
+      @ole_obj.ObjectId
+    end
+
+    def visible?
+      @ole_obj.Visible
+    end
+
+    # @rbs return bool -- true if ole type is TypeLine
+    def line?
+      ole_obj.ObjectName == "AcdbLine"
+    end
+
+    def graphical?
+      ole_obj.IsGraphical
+    end
+
+    def inspect
+      "<#{self.class}: #{autocad_id}>"
+    end
+
+    def parent
+      parent_id = ole_obj.ParentID
+      return nil unless parent_id
+
+      id = id_from_record(parent_id)
+      app.active_design_file.find_by_id(id)
+    end
+
+    def id_from_record(id)
+      return unless id.instance_of?(WIN32OLE_RECORD)
+      return id.Low if id.Low > id.High
+
+      id.High
+    end
+
+    def select
+      app.active_model_reference.select_element(self)
+    end
+
+    # def Type
+    #   ole_obj.Type
+    # end
+
+    def autocad_type
+      ole_obj.ObjectName
+    end
+
+    def model
+      Model.new(app, app.current_drawing, ole_obj.ModelReference)
+    end
+  end
+
+  class Element
+    include ElementTrait
+
+    def self.convert_item(ole, app, cell = nil)
+      return Point3d.from_ole(ole) if ole.instance_of?(WIN32OLE_RECORD) && ole.typename == "Point3d"
+      return ole unless ole.instance_of?(WIN32OLE)
+
+      if ole.respond_to? :ObjectName
+        typ = case ole.ObjectName
+        when "AcDbModelSpace"
+          ::Autocad::ModelSpace.new(ole, app, typ)
+        when "AcDbPaperSpace"
+          ::Autocad::PaperSpace.new(ole, app, typ)
+        when "AcDbBlockTableRecord"
+          ::Autocad::Block.new(ole, app, typ, cell)
+        when "AcDbPolyline"
+          ::Autocad::Polyline.new(ole, app, typ, cell)
+        when "AcDbText"
+          ::Autocad::Text.new(ole, app, typ, cell)
+        when "AcDbMText"
+          ::Autocad::TextNode.new(ole, app, typ, cell)
+        when "AcDbArc"
+          ::Autocad::Arc.new(ole, app, typ, cell)
+        when "AcDbViewport"
+          ::Autocad::Viewport.new(ole, app, typ)
+        when "AcDbBlock"
+          ::Autocad::Block.new(ole, app, typ)
+        when "AcDbLayerTableRecord"
+          ::Autocad::Layer.new(ole, app, typ)
+        when AcDbLayerTableRecord
+        end
+
+        return typ if typ
+        binding.irb
+
+      else
+        typ = ole.ole_type
+        result = case typ.name
+        when "IAcadSelectionSet"
+          drawing = app.current_drawing
+          ::Autocad::SelectionSetAdapter.from_ole_obj(drawing, ole)
+        when "IAcadLayer"
+          ::Autocad::Layer.new(ole, app, typ)
+        when "IAcadLine"
+          ::Autocad::Line.new(ole, app, typ)
+        when "IAcadCircle"
+          ::Autocad::Circle.new(ole, app, typ)
+        when "IAcadLWPolyline"
+          ::Autocad::Polyline.new(ole, app, typ)
+        when "IAcadLineType"
+          ::Autocad::Linetype.new(ole, app, typ)
+        when "IAcadText"
+          ::Autocad::Text.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 "IAcadExternalReference"
+          ::Autocad::ExternalReference.new(ole, app, typ)
+        when "IAcadAttributeReference"
+          ::Autocad::AttributeReference.new(ole, app, typ)
+
+        else
+          Element.new(ole, app, typ)
+        end
+
+        return result if result
+        binding.irb
+      end
+    end
+
+    def self.ole_object?
+      ole.instance_of?(WIN32OLE)
+    end
+
+    attr_reader :ole_obj, :app, :acad_type, :original
+
+    def initialize(ole, app, typ, cell = nil)
+      @ole_obj = ole
+      @original = read_ole(ole)
+      @app = app
+      @cell = cell
+      @acad_type = typ
+    end
+
+    def in_cell?
+      !!@cell
+    end
+
+    def read_ole(ole)
+    end
+
+    def write_ole(value)
+    end
+
+    def method_missing(meth, *, &)
+      if /^[A-Z]/.match?(meth.to_s)
+        result = ole_obj.send(meth, *, &)
+        Element.convert_item(result, app)
+      else
+        super
+      end
+    end
+
+    def get_property_handler
+      ph_ole = app_ole_obj.CreatePropertyHandler(ole_obj)
+      PropertyHandler.new(ph_ole)
+    end
+
+    def property_handler
+      @property_handler ||= get_property_handler
+    end
+
+    def [](name)
+      property_handler[name]
+    end
+
+    def do_update(value)
+      return false if value == original
+
+      saved_original = original
+      begin
+        write_ole(value)
+        @original = read_ole(ole_obj)
+        true
+      rescue
+        @original = saved_original
+        false
+      end
+    end
+
+    def update(value)
+      redraw_el = ole_obj
+      if do_update(value)
+        if in_cell?
+          @cell.ReplaceCurrentElement @ole_obj
+          redraw_el = @cell
+        end
+        redraw(redraw_el)
+        @updated = true
+        true
+      else
+        @updated = false
+        false
+      end
+    rescue => e
+      app.error_proc.call(e, nil)
+    end
+
+    def updated?
+      @updated
+    end
+
+    def redraw(el = ole_obj)
+      # el.Redraw ::Autocad::MSD::MsdDrawingModeNormal if el.IsGraphical
+      el.Update
+    rescue => e
+      app.error_proc.call(e, nil)
+    end
+
+    def app_ole_obj
+      app.ole_obj
+    end
+
+    def delete
+      ole_obj.Delete
+    rescue => ex
+      raise Autocad::Error.new("Error deleting object #{self} #{ex}")
+    end
+
+    def clone(new_insertion_point)
+      pt = Point3d.new(new_insertion_point)
+      ole = ole_obj.Copy(pt.to_ole)
+      app.wrap(ole)
+    rescue => ex
+      raise Autocad::Error.new("Error cloning object #{ex}")
+    end
+
+    def move_x(amt)
+      pt1 = Point3d(0, 0, 0)
+      pt2 = Point3d(amt, 0, 0)
+      move_ole(pt1.to_ole, pt2.to_ole)
+    end
+
+    def move_y(amt)
+      pt1 = Point3d(0, 0, 0)
+      pt2 = Point3d(0, 1, 0)
+      move_ole(pt1.to_ole, pt2.to_ole)
+    end
+
+    def move(x, y)
+      pt1 = Point3d(0, 0, 0)
+      pt2 = Point3d(x, y, 0)
+      move_ole(pt1.to_ole, pt2.to_ole)
+    end
+
+    def move_ole(pt1, pt2)
+      ole_obj.Move(pt1, pt2)
+      app.wrap(ole_obj)
+    rescue => ex
+      raise Autocad::Error.new("Error moving object #{ex}")
+    end
+
+    def ole_cell(ole)
+      ole.IsCellElement || ole.IsSharedCellElement
+    end
+
+    # def each_cell(ole, &)
+    #   cell = ole if ole_cell(ole)
+    #   begin
+    #     ole.ResetElementEnumeration
+    #   rescue
+    #     binding.break
+    #   end
+    #   while ole.MoveToNextElement
+    #     component = ole.CopyCurrentElement
+    #     if component.IsTextNodeElement
+    #       yield Autocad::Wrap.wrap(component.AsTextNodeElement, app, cell)
+    #     elsif component.IsTextElement
+    #       yield Autocad::Wrap.wrap(component.AsTextElement, app, cell)
+    #     elsif component.IsComplexElement
+    #       each(component, &)
+    #     else
+    #       yield Autocad::Wrap.wrap(component, app, cell)
+    #     end
+    #   end
+    # end
+
+    # def each(ole = ole_obj, &block)
+    #   return unless ole.IsComplexElement
+    #   return to_enum(:each) unless block
+
+    #   if ole.IsCellElement
+    #     each_cell(ole, &block)
+    #   else
+    #     each_complex(ole, &block)
+    #   end
+    # end
+
+    def each_complex(ole, &)
+      cell = nil
+      components = ole.GetSubElements
+      while components.MoveNext
+        component = components.Current
+        if component.IsTextNodeElement
+          yield Autocad::Wrap.wrap(component.AsTextNodeElement, app, cell)
+        elsif component.IsTextElement
+          yield Autocad::Wrap.wrap(component.AsTextElement, app, cell)
+        elsif component.IsComplexElement
+          each(component, &)
+        else
+          yield Autocad::Wrap.wrap(component, app, cell)
+        end
+      end
+    end
+  end
+
+  class App
+    def ole_to_ruby(ole)
+      Element.convert_item(ole, self)
+    end
+  end
+end
+
+module Autocad
+  class Arc < Element
+  end
+end
+
+module Autocad
+  class Ellipse < Element
+  end
+end
+
+module Autocad
+  class BSplineSurface < Element
+  end
+end
+
+module Autocad
+  class Linetype < Element
+    CONTINUOUS = "Continuous"
+    DASHED = "Dashed"
+    CENTER = "Center"
+    HIDDEN = "Hidden"
+    PHANTOM = "Phantom"
+    BREAK = "Break"
+    BORDER = "Border"
+    DOT2 = "Dot2"
+    DOTX2 = "DotX2"
+    DIVIDE = "Divide"
+    TRACKING = "Tracking"
+    DASHDOT = "Daskdot"
+
+    def name
+      ole_obj.Name
+    end
+  end
+end
+
+module Autocad
+  class BSplineCurve < Element
+  end
+end

data/lib/autocad/enumerator.rb

@@ -0,0 +1,24 @@
+module Autocad
+  class Enumerator
+    include Enumerable
+
+    attr_reader :app
+
+    def initialize(ole, app)
+      @ole_obj = ole
+      @app = app
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @ole_obj.each do |ole|
+        yield app.wrap(ole)
+      end
+    end
+
+    def reset
+      @ole_obj.reset
+    end
+  end
+end

data/lib/autocad/errors.rb

@@ -0,0 +1,37 @@
+# rbs_enabled: true
+
+module Autocad
+  Error = Class.new(::RuntimeError)
+  NonDGNFile = Class.new(Error)
+
+  class FileNotFound < Error
+    def initialize(path)
+      super("File at path #{path} not found")
+    end
+  end
+  MultipleUpdateError = Class.new(Error)
+
+  # class RetryableError < Error
+  #   attr_reader :num_tries
+  #   def initialize(message, num_tries)
+  #     @num_tries = num_tries
+  #     super("#{message} (##{num_tries})")
+  #   end
+  # end
+
+  class DrawingError < Error
+    attr_reader :drawing
+
+    def initialize(message, drawing)
+      @drawing = drawing
+      super("#{message} for #{drawing.path}")
+    end
+  end
+
+  class ExistingFile < Error
+    def initialize(path)
+      msg = "File at path #{path} already exists"
+      super(msg)
+    end
+  end
+end

data/lib/autocad/event_handler.rb

@@ -0,0 +1,30 @@
+# rbs_inline: enabled
+
+module Autocad
+  class EventHandler
+    def initialize
+      @handlers = {}
+      @file = File.open("event_handler.log", "w")
+    end
+
+    # @rbs event: String -- the event name to handle
+    def add_handler(event, &block)
+      @handlers[event] = block if block
+    end
+
+    def get_handler(event)
+      @handlers[event]
+    end
+
+    def method_missing(event, *args)
+      if @handlers[event.to_s]
+        @handlers[event.to_s].call(*args)
+      else
+        @file.puts "Unhandled event: #{event} args: #{args}"
+        @file.puts "Event class is: #{event.class}, args are: #{args}"
+        # event = event.to_sym if event.is_a? String
+        # super
+      end
+    end
+  end
+end

data/lib/autocad/filter.rb

@@ -0,0 +1,168 @@
+module Autocad
+  class Filter
+    attr_reader :types, :values, :clauses
+
+    def initialize(clauses: {})
+      @clauses = clauses
+      @types = []
+      @values = []
+    end
+
+    def new_filter(clause, value)
+      new_clauses = clauses.dup
+      new_clauses[clause] = value
+      Filter.new(clauses: new_clauses)
+    end
+
+    def has_filters?
+      true
+    end
+
+    # convert the clauses to the values and types needed for autocad filter
+    # rbs return Array[Array,Array] -- the types and values array
+    def convert_clauses
+      types = []
+      values = []
+
+      case clauses.keys.first
+      when :type
+        types << 0
+        values << clauses[:type]
+      when :layer
+        types << 8
+        values << clauses[:layer]
+      when :color
+        types << 62
+        values << clauses[:color]
+      when :block_reference
+        types << 0
+        values << 'INSERT'
+        if clauses[:block_reference]
+          types << 1
+          values << clauses[:block_reference]
+        end
+      when :paper_space
+        types << 67
+        values << 1
+      when :model_space
+        types << 67
+        values << 0
+      when :text_content
+        types << 1 # DXF type code 1 for text content
+        values << clauses[:text_content]
+      when :and, :or, :xor
+        operator = clauses.keys.first.to_s.upcase
+        types << -4
+        values << "<#{operator}"
+
+        clauses[clauses.keys.first].each do |condition|
+          sub_types, sub_values = condition.convert_clauses
+          types.concat(sub_types)
+          values.concat(sub_values)
+        end
+
+        types << -4
+        values << "#{operator}>"
+      when :not
+        types << -4
+        values << '<NOT'
+
+        sub_types, sub_values = clauses[:not].convert_clauses
+        types.concat(sub_types)
+        values.concat(sub_values)
+
+        types << -4
+        values << 'NOT>'
+      when :gt
+        types.concat([-4, 40])
+        values.concat(['>=', clauses[:gt]])
+      when :lt
+        types.concat([-4, 40])
+        values.concat(['<=', clauses[:lt]])
+      when :eq
+        types.concat([-4, 40])
+        values.concat(['=', clauses[:eq]])
+      when :neq
+        types.concat([-4, 40])
+        values.concat(['<>', clauses[:neq]])
+      end
+
+      [types, values]
+    end
+
+    # Logical Operators
+    def and(*conditions)
+      new_filter(:and, conditions)
+    end
+
+    def merge_conditions(existing, new_condition)
+    end
+
+    def or(*conditions)
+      new_filter(:or, conditions)
+    end
+
+    def xor(condition1, condition2)
+      new_filter(:xor, [condition1, condition2])
+    end
+
+    def not(condition)
+      new_filter(:not, condition)
+    end
+
+    # Relational Operators
+    #  f.type("Circle").greater_than(5)
+    def greater_than(value)
+      new_filter(:gt, value)
+    end
+
+    def less_than(value)
+      new_filter(:lt, value)
+    end
+
+    def equal_to(value)
+      new_filter(:eq, value)
+    end
+
+    def not_equal_to(value)
+      new_filter(:neq, value)
+    end
+
+    def block_reference(name = nil)
+      new_filter(:block_reference, name)
+    end
+
+    def name(value)
+      new_filter(:name, value)
+    end
+
+    def type(kind)
+      new_filter(:type, kind)
+    end
+
+    def layer(name)
+      new_filter(:layer, name)
+    end
+
+    def visible(vis = true)
+      new_filter(:visible, vis)
+    end
+
+    def color(num)
+      new_filter(:color, num)
+    end
+
+    def paper_space
+      new_filter(:paper_space, nil)
+    end
+
+    def model_space
+      new_filter(:model_space, nil)
+    end
+
+    def has_text(str)
+      new_filter(:text_content, str)
+    end
+
+  end
+end