autocad 0.4.6

data/lib/autocad/layer.rb

@@ -0,0 +1,41 @@
+module Autocad
+  class Layer < Element
+    def name
+      ole_obj.name
+    end
+
+    def description
+      ole_obj.description
+    end
+
+    def lock(lk = true)
+      ole_obj.Lock = lk
+    rescue
+      raise Autocad::Error.new("Error locking layer #{name}")
+    end
+
+    def visible?
+      ole_obj.Visible
+    end
+
+    def visible=(vis)
+      ole_obj.Visible = vis
+    end
+
+    def delete
+      ole_obj.Delete
+    rescue => e
+      raise Autocad::Error.new("Error deleting layer #{name} #{e}")
+    end
+
+    def linetype=(ltname)
+      found_lt = app.current_drawing.linetypes.find { |lt| lt.name == ltname }
+
+      app.current_drawing.ole_obj.Linetypes.Load(ltname, ltname) unless found_lt
+
+      ole_obj.Linetype = ltname
+    rescue => e
+      raise Autocad::Error.new("Error setting linetype of layer #{name} : #{e}")
+    end
+  end
+end

data/lib/autocad/line.rb

@@ -0,0 +1,55 @@
+# rbs_inline: enabled
+
+require_relative 'element'
+
+module Autocad
+  class Line < Element
+    def length
+      ole_obj.length
+    end
+
+    def line?
+      true
+    end
+
+    def start_point # : Point3d
+      Point3d(ole_obj.StartPoint)
+    end
+
+    def end_point # : Point3d
+      Point3d(ole_obj.EndPoint)
+    end
+
+    def normal
+      ole_obj.Normal
+    end
+
+    def thickness
+      ole_obj.Thickness
+    end
+
+    def delta
+      ole_obj.Delta
+    end
+  end
+
+  class Circle < Element
+    def center
+      Point3d.new(ole_obj.Center)
+    end
+
+    def radius
+      Point3d.new(ole_obj.Radius)
+    end
+  end
+
+  class Polyline < Element
+    def length
+      @ole_obj.Length
+    end
+
+    def coordinates
+      @ole_obj.coordinates
+    end
+  end
+end

data/lib/autocad/message_box.rb

@@ -0,0 +1,95 @@
+require "fiddle/import"
+require "fiddle/types"
+
+module WinAPI
+  extend Fiddle::Importer
+  dlload "user32.dll"
+  include Fiddle::BasicTypes
+  include Fiddle::Win32Types
+
+  typealias "LPCWSTR", "wchar_t*"
+
+  extern "int MessageBoxA(HWND, LPCSTR, LPCSTR, DWORD)"
+  extern "int MessageBoxW(HWND, LPCWSTR, LPCWSTR, DWORD)"
+  # window handling
+  extern "HWND GetForegroundWindow()"
+  extern "int GetWindowText(HWND, char*, int)"
+  extern "int GetWindowTextLength(HWND)"
+
+  def get_foreground_window
+    GetForegroundWindow()
+  end
+
+  def self.get_text_of_active_window
+    hwnd = GetForegroundWindow()
+    buf_size = GetWindowTextLength(hwnd)
+    str = " " * (buf_size + 1)
+    GetWindowText(hwnd, str, str.length)
+    str.encode(Encoding.default_external)
+  end
+
+  module MB
+    OK = 1
+    CANCEL = 1
+    ABORT = 3
+    RETRY = 4
+    IGNORE = 5
+    YES = 6
+    NO = 7
+
+    module ICON
+      ERROR = 16
+      QUESTION = 32
+      INFORMATION = 64
+      WARNING = 128
+    end
+
+    module BTN
+      OK = 0
+      OKCANCEL = 1
+      ABORTRETRYIGNORE = 2
+      YESNO = 4
+    end
+  end
+end
+
+# msgbox_yesno('Do you want to continue?') do |y|
+#   if y
+#     puts 'proceeding with ...'
+#   else
+#     puts 'cancelled ...'
+#   end
+# end
+#
+# msgbox('We are finished here')
+#
+# loop do
+#   puts WinAPI.get_text_of_active_window
+#   sleep 1
+# end
+module Kernel
+  module_function
+
+  # @rbs str: String
+  # @rbs return String
+  def L(str)
+    str.encode("UTF-16LE")
+  end
+
+  # @example
+  # msg_box_yesno("Do you want to continue") do |y|
+  #  if y
+  #    puts "proceeding"
+  # else
+  #   puts "cancelled"
+  # end
+  # end
+  def msgbox_yesno(content, title: "Alert")
+    result = WinAPI::MessageBoxW(0, L(content), L(title), WinAPI::MB::BTN::YESNO) == WinAPI::MB::YES
+    yield(result)
+  end
+
+  def msgbox(content, title: "Alert")
+    WinAPI::MessageBoxW(0, L(content), L(title), WinAPI::MB::BTN::OK)
+  end
+end

data/lib/autocad/model.rb

@@ -0,0 +1,89 @@
+# require_relative 'scan/scan_trait'
+# require_relative "model_trait"
+
+# require_relative 'ts/tagset_trait'
+# require_relative 'graphics'
+# require_relative 'ts/instance'
+
+module Autocad
+  module ModelTrait
+    def each
+      return enum_for(:each) unless block_given?
+
+      @ole_obj.each do |ole|
+        yield app.wrap(ole)
+      end
+    end
+
+    # @rbs pt1: Autocad::Point3d
+    # @rbs return Autocad::Line
+    def add_line(pt1, pt2, layer: nil)
+      pt1 = Point3d.new(pt1)
+      pt2 = Point3d.new(pt2)
+      ole_line = ole_obj.AddLine(pt1.to_ole, pt2.to_ole)
+      if layer
+        layer = app.create_layer(layer)
+        ole_line.layer = layer.ole_obj
+      end
+      app.wrap(ole_line)
+    rescue ex
+      puts ex.message
+    end
+
+    # @rbs center: [] | Point3d -- center of circle
+    # @rbs radius:
+    def add_circle(center, radius)
+      pt = Point3d(center)
+      ole_circle = ole_obj.AddCircle(pt.to_ole, radius)
+      app.wrap(ole_circle)
+    rescue
+      raise Autocad::Error.new('Error adding circle #{ex}')
+    end
+
+    def add_rectangle(upper_left, lower_right)
+      x1, y1, _z = Point3d(upper_left).to_a
+      x2, y2, _z2 = Point3d(lower_right)
+      pts = [x1, y1, x2, y1, x2, y1, x2, y2]
+      pts_variant = WIN32OLE::Variant.new(pts, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
+      ole = ole_obj.AddLightweightPolyline(pts_variant)
+      app.wrap(ole)
+    rescue => e
+      raise Autocad::Error.new("Error adding rectangle #{e}")
+    end
+
+    def add_spline(points)
+      pts = Point3d.pts_to_array(points)
+      pts_variant = Point3d.array_to_ole(pts)
+      ole = ole_obj.AddSpline(pts_variant)
+      puts "pts #{pts}"
+      puts "pts_variant #{pts_variant.class} #{pts_variant}"
+      app.wrap(ole)
+    rescue => e
+      raise Autocad::Error.new("Error adding spline #{e}")
+    end
+
+    def drawing
+      @drawing ||= ::Autocad::Drawing.from_ole_obj(app, ole_obj.Document)
+    end
+  end
+
+  class PaperSpace
+    include ModelTrait
+    attr_reader :app, :ole_obj
+
+    def initialize(ole, app)
+      @ole_obj = ole
+      @app = app
+    end
+  end
+
+  class ModelSpace
+    include ModelTrait
+    attr_reader :app, :ole_obj
+
+    def initialize(ole, app)
+      @ole_obj = ole
+      @app = app
+    end
+  end
+end

data/lib/autocad/mtext.rb

@@ -0,0 +1,110 @@
+module Autocad
+  class MText < Element
+    attr_reader :original, :ole_obj
+
+    def to_regexp
+      Regexp.new(original.to_s)
+    end
+
+    def empty?
+      ole_obj.TextLinesCount == 0
+    end
+
+    def mtext?
+      true
+    end
+
+    def text?
+      false
+    end
+
+    def size
+      ole_obj.TextLinesCount
+    end
+
+    def read_ole(ole)
+      ole.TextString
+    end
+
+    # def _update(text)
+    #   update_ole!(text)
+    #   @original = text
+    # end
+
+    def write_ole(text)
+      if in_cell?
+        write_ole_in_cell(text)
+      else
+        write_ole_regular(text)
+      end
+    end
+
+    def write_ole_regular(text)
+      ole_obj.TextString = text
+    end
+
+    def write_ole_in_cell(text)
+      orig_ole = ole_obj
+      new_text_ole = ole_obj.Clone
+      new_text_ole.DeleteAllTextLines
+      text.each_line do |line|
+        new_text_ole.AddTextLine(line)
+      end
+      @ole_obj = new_text_ole
+    rescue
+      @ole_obj = orig_ole
+    end
+
+    def update_ole!(text)
+      ole_obj.DeleteAllTextLines
+      text.each_line do |line|
+        ole_obj.AddTextLine(line)
+      end
+      ole_obj.Redraw Autocad::MSD::MsdDrawingModeNormal
+      ole_obj.Rewrite
+    end
+
+    def to_s
+      @original.to_s
+    end
+
+    def =~(reg)
+      @original =~ reg
+    end
+
+    def template?
+      !!(@original =~ /{{.+}}/)
+    end
+
+    def render(h = {})
+      return self unless template?
+
+      template = Liquid::Template.parse(to_s)
+      result = template.render(h)
+      update(result) unless result == @original
+      self
+    end
+
+    def method_missing(meth, *, &)
+      if /^[A-Z]/.match?(meth)
+        ole_obj.send(meth, *)
+      else
+        copy = @original.dup
+        result = copy.send(meth, *, &)
+        update(result) unless copy == @original
+        result
+      end
+    end
+
+    # def method_missing2(meth,*args,&block)
+    #   if meth.to_s =~ /^[A-Z]/
+    #     ole_obj.send(meth,*args)
+    #   else
+    #     dup = @original.dup
+    #     result = dup.send(meth,*args,&block)
+    #     _update(dup) unless dup == @original
+    #     result
+    #   end
+    # end
+  end
+end

data/lib/autocad/paths.rb

@@ -0,0 +1,29 @@
+module Autocad
+  class Paths
+    include Enumerable
+
+    def initialize(path)
+      @paths = path.split(";").map { |p| Pathname(p) }
+    end
+
+    def <<(path)
+      @paths << Path(path)
+    end
+
+    def append(path)
+      @paths.append Path(path)
+    end
+
+    def prepend(path)
+      paths.prepend Path(path)
+    end
+
+    def each(...)
+      paths.each(...)
+    end
+
+    def to_s
+      parhs.join(";")
+    end
+  end
+end

data/lib/autocad/point3d.rb

@@ -0,0 +1,143 @@
+# rbs_inline: enabled
+
+module Autocad
+  class Point3d
+    class << self
+      def cartesian_to_polar(x, y)
+        r = Math.sqrt(x * x + y * y)
+        angle = Angle.radians(Math.atan2(y, x))
+        [r, angle]
+      end
+
+      def from_polar_degrees(r, a)
+      end
+
+      def from_ole(ole)
+        new(ole.X, ole.Y, ole.Z)
+      end
+
+      def polar_to_cartesian(r, a)
+      end
+
+      # 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 pts_to_array(pts)
+        case pts.first
+        when Point3d
+          pts.flat_map(&:to_xy)
+        when Array
+          pts.flat_map { |pt| [pt[0].to_f, pt[1].to_f] }
+        when Numeric
+          pts.each_slice(2).flat_map { |x, y| [x.to_f, y.to_f] }
+        end
+      end
+
+      def array_to_ole(ar)
+        WIN32OLE::Variant.new(ar, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
+      end
+    end
+
+    attr_reader :x, :y, :z
+
+    def initialize(_x = nil, _y = nil, _z = nil, x: _x, y: _y, z: _z)
+      case [x, y, z]
+      in [Point3d, y, z]
+        @x = x.x
+        @y = x.y
+        @z = x.z
+      in [Array, nil, nil]
+        @x = x[0].to_f
+        @y = x[1].to_f
+        @z = x[2].to_f
+      in [Float, Float, Float]
+        @x = x
+        @y = y
+        @z = z
+      else
+        @x = x.to_f || 0.0
+        @y = y.to_f || 0.0
+        @z = z.to_f || 0.0
+      end
+    end
+
+    # @rbs other: Point3d | [Float,Float,Float]
+    def +(other) # : Point3d
+      case other
+      when Point3d
+        self.class.new(x + other.x, y + other.y, z + other.z)
+      when Array
+        self.class.new(x + other[0], y + other[1])
+      end
+    end
+
+    def distance_to(other)
+      pt2 = Point3d.new(other)
+      Math.sqrt((x - pt2.x)**2 + (y - pt2.y)**2 + (z - pt2.z)**2)
+    end
+
+    # @rbs return [Float,Float, Float]
+    def deconstruct
+      [@x, @y, @z]
+    end
+
+    # @rbs return { x: Float, y: Float, z: Float}
+    def deconstruct_keys
+      {x: @x, y: @y, z: @z}
+    end
+
+    # @rbs return [Float,Float, Float]
+    def to_ary
+      [x, y, z]
+    end
+
+    # @rbs other: Point3d | [Float,Float,Float]
+    def -(other) # : Point3d
+      case other
+      when Point3d
+        self.class.new(x - other.x, y - other.y, z - other.z)
+      when Array
+        self.class.new(x - other[0], y - other[1])
+      end
+    end
+
+    def to_xy
+      [x, y]
+    end
+
+    def xy_bounds(other)
+      x2, y2 = Points3d.new(other).to_xy
+      [x, y, x2, y, x2, y2, x, y2, x, y]
+    end
+
+    def to_s
+      "Point3d(#{x}, #{y}, #{z})"
+    end
+
+    # @rbs return [Float,Float, Float]
+    def to_a
+      [x, y, z]
+    end
+
+    # @rbs return Point3d -- return a Point3d at [0,0,0]
+    def zero
+      new(0.0, 0.0, 0, 0)
+    end
+
+    def to_cartesian
+    end
+
+    def to_ole
+      ole = WIN32OLE::Variant.array([3], WIN32OLE::VARIANT::VT_R8)
+      ole[0] = x
+      ole[1] = y
+      ole[z] = z
+      ole
+    end
+  end
+end

data/lib/autocad/pviewport.rb

@@ -0,0 +1,21 @@
+require_relative "element"
+
+module Autocad
+  class PViewport < Element
+    def width
+      @ole_obj.Width
+    end
+
+    def height
+      @ole_obj.Height
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @ole_obj.each do |ole|
+        yield app.wrap(ole)
+      end
+    end
+  end
+end