autocad 0.4.6

data/lib/autocad/app.rb

@@ -0,0 +1,655 @@
+# rbs_inline: enabled
+
+require_relative "event_handler"
+require_relative "drawing"
+require_relative "paths"
+require_relative "element"
+require_relative "line"
+require_relative "text"
+require_relative "mtext"
+require_relative "pviewport"
+require_relative "block"
+require_relative "block_reference"
+require_relative "selection_set"
+
+require "win32ole"
+module Windows
+  class FileSystem
+    def self.windows_path(path)
+      obj = new
+      obj.windows_path(path)
+    end
+
+    # Convert path to windows path
+    # @rbs path: String, Pathname the path you want to convert
+    def windows_path(path)
+      path = path.to_path if path.respond_to? :to_path
+      fs_object.GetAbsolutePathName(path.to_str)
+    end
+
+    def fs_object
+      @fs_object ||= WIN32OLE.new("Scripting.FileSystemObject")
+    end
+  end
+end
+
+module Autocad
+  class App
+    include Common
+    @default_error_proc = ->(e, f) {
+      puts "Couldn't open drawing #{f}" if f
+      debug_error if $DEBUG
+      raise e
+    }
+
+    class << self
+      attr_accessor :default_error_proc
+
+      def default_app_options
+        {visible: false, error_proc: @default_error_proc, wait_time: 500, wait_interval: 0.5}
+      end
+
+      def debug_error
+        require "debug"
+        binding.break
+      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
+
+      # 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
+      #
+      # [source]
+      # dir = Pathname.new('C:/templates')
+      # drawings = Pathname.glob(dir + '/**/*.dgn')
+      # App.with_drawings(drawings) do |drawing|
+      #   drawing.save_as_pdf(dir: 'c:/output/')
+      # end
+      #
+      # @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(*files, visible: false, error_proc: @default_error_proc,
+        wait_time: 500, wait_interval: 0.5, read_only: false, &block)
+        # drawing_options = default_drawing_options.merge(options)
+        # app_options = default_app_options
+        files = files[0] if files[0].is_a? Array
+        begin
+          the_app = new(visible:, error_proc:, wait_time:, wait_interval:)
+          files_enum = files.each
+          loop do
+            file = files_enum.next
+            puts "opening #{file}.."
+            begin
+              the_app.open_drawing(file, read_only:, wait_time:, wait_interval:, error_proc:, &block)
+              the_app.ole_obj.ole_methods # check if server still open
+            rescue => e
+              raise e unless error_proc
+
+              error_proc.call(e, file)
+              the_app = new(visible: opt_visible)
+            end
+          end
+        ensure
+          the_app&.quit
+          the_app = nil
+        end
+      end
+
+      # gets all dwg and dgn files in the directory given by
+      # dir_or_file or gets the file given by dir_or_file
+      # and saves them as pdf files in the outdir
+      # @rbs dir_or_file: String the directory of drawing [dgn,dwg] to convert
+      # @rbs outdir: String the output dir for converted pdf files
+      # @rbs return void
+      def dwg2pdf(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, read_only: true) 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
+
+      # Initialize an instance of app with the options
+      # @rbs : Hash] options the options to create the app with
+      # @option options bool :visible Is the app visible
+      #
+      # [source]
+      # ----
+      # App.run do |app|
+      #   drawing = app.open_drawing('test.dgn')
+      #   drawing.scan_all_text do |model,text|
+      #   puts "#{model} #{text}"
+      #   end
+      # end
+      # @rbs options: Hash[Symbol,Object]
+      # @rbs &: (App) -> void -- the_app yields the instanciated app
+      def run(options = {}) #: void
+        opts = default_app_options.merge(options)
+        err_fn = opts.fetch(:error_proc, default_error_proc)
+        begin
+          the_app = new(**opts)
+          # binding.break if the_app.nil?
+          yield the_app
+        rescue => e
+          if e.respond_to? :drawing
+            err_fn.call(e, e.drawing)
+          else
+            err_fn.call(e, nil)
+          end
+        ensure
+          the_app&.quit
+          GC.start
+        end
+      end
+
+      # Calls #run to get an app instance then call open drawing with
+      # that app
+      # (see #open_drawing)
+      # @rbs &block: { (Drawing) -> void }
+      def open_drawing(drawing, **options, &block) #: void
+        run(**options) do |app|
+          app.open_drawing(drawing, **options, &block)
+        end
+      end
+    end
+
+    # @rbs return bool -- true if there is an active drawing
+    def active_drawing?
+      ole_obj.Documents.count > 0
+    end
+
+    # @rbs return Drawing | nil -- returns drawing if active_drawing
+    def active_drawing
+      return unless active_drawing?
+      ole = ole_obj.ActiveDocument
+      drawing_from_ole(ole)
+    end
+
+    def drawing_from_ole(ole) #: Drawing
+      Drawing.new(self, ole)
+    end
+
+    attr_reader :error_proc, :visible, :logger
+
+    # Constructor for app
+    # @rbs visible: bool -- do you want the app to be visible
+    # @rbs event_handler: EventHandler
+    def initialize(visible: true, error_proc: self.class.default_error_proc, event_handler: default_event_handler, wait_interval: nil, wait_time: nil)
+      @visible = visible
+      @logger = Logger.new("autocad.log")
+      @event_handler = event_handler
+      @error_proc = error_proc
+      @ole_obj, @app_event = init_ole_and_app_event(visible: @visible, event_handler: @event_handler, tries: 5,
+        sleep_duration: 0.5)
+      @run_loop = true
+      @windows = Windows::FileSystem.new
+      #  make_visible(visible)
+      @scanners = {}
+    rescue => e
+      @error_proc.call(e, nil)
+    end
+
+    def windows_path(path)
+      @windows.windows_path(path)
+    end
+
+    def wrap(item, cell = nil)
+      Element.convert_item(item, self, cell)
+    end
+
+    # the default EventHandler
+    #
+    # @rbs return EventHandler -- returns the default EventHandler
+    def default_event_handler
+      event_handler = EventHandler.new
+      # event_handler.add_handler("BeginOpen") do |*args|
+      #   puts "begining opening drawing #{args}"
+      # end
+      event_handler.add_handler("EndOpen") do |*args|
+        puts "drawing #{args} opened"
+        @drawing_opened = true
+      end
+      event_handler.add_handler("BeginDocClose") do |*args|
+        @drawing_opened = false
+        puts "drawing #{args} closed"
+      end
+
+      event_handler.add_handler("NewDrawing") do |*args|
+        @drawing_opened = true
+        puts "drawing #{args} created"
+      end
+      event_handler
+    end
+
+    def default_app_options
+      self.class.default_app_options
+    end
+
+    # register an handler
+    #
+    # @rbs event: String -- event to registor for
+    def register_handler(event, &)
+      @event_handler.add_handler(event, &) unless event == "OnQuit"
+    end
+
+    #
+    # return a Handler
+    #
+    # @rbs : String,Symbol] event the event key
+    #
+    # @rbs return Proc returns the Proc given by event name
+    #
+    def get_handler(event)
+      @event_handler.get_handler(event)
+    end
+
+    def load_constants(ole)
+      WIN32OLE.const_load(ole, ACAD) unless ACAD.constants.size > 0
+    end
+
+    def run_loop
+      WIN32OLE_EVENT.message_loop if @run_loop
+    end
+
+    def stop_loop
+      @run_loop = false
+    end
+
+    def exit_message_loop
+      puts "Autocad exiting..."
+      @run_loop = false
+    end
+
+    def visible?
+      @visible
+    end
+
+    def visible=(value)
+      make_visible !!value
+    end
+
+    def make_visible(visible)
+      @visible = visible
+      begin
+        @ole_obj.Visible = visible
+        true
+      rescue
+        false
+      end
+    end
+
+    # Zooms the current viewport to display the entire drawing
+    def zoom_all
+      ole_obj.ZoomAll
+    end
+
+    def zoom_center(center, magnify: 1.0)
+      pt = Point3d(center)
+      ole_obj.ZoomCenter(pt.to_ole, magnify.to_f)
+    end
+
+    def zoom_window(pt1, pt2)
+      pt1 = Point3d(pt1)
+      pt2 = Point3d(pt2)
+      ole_obj.ZoomWindow(pt1.to_ole, pt2.to_ole)
+    end
+
+    def zoom_pick_window
+      ole_obj.ZoomPickWindowo
+    end
+
+    def zoom_extents
+      ole_obj.ZoomExtents
+    end
+
+    def zoom_previous
+      ole_obj.ZoomPrevious
+    end
+
+    def zoom_scaled(magnify: 1.0, scale_type: :paper_space)
+      scale_type = case scale_type
+      when :paper_space
+        ACAD::AcZoomScaledRelativePSpace
+      when :absolute
+        ACAD::AcZoomScaledAbsolute
+      when :relative
+        ACAD::AcZoomScaledRelative
+      else
+        ACAD::AcZoomScaledRelative
+      end
+      ole_obj.ZoomScaled(magnify.to_f, scale_type)
+    end
+
+    # Zooms the current viewport to a specific center point and magnify factor
+    # @rbs center: Point3d | [Float, Float, Float| nil] -- center of zoom
+    # @rbs magnify: Float
+    def zoom_center(center, magnify: 1.0)
+      pt = Point3d(center)
+      ole_obj.ZoomCenter(pt.to_ole, magnify.to_f)
+    end
+
+    def ole_obj
+      is_ok = true
+      begin
+        @ole_obj.Visible
+      rescue
+        is_ok = false
+      end
+
+      @ole_obj, @app_event = init_ole_and_app_event(visible: @visible, event_handler: @event_handler, tries: 3) unless is_ok
+
+      @ole_obj
+    end
+
+    def quit
+      close_all_drawings
+      @ole_obj&.Quit
+    rescue
+      nil
+    end
+
+    def close_all_drawings(save: false)
+      return unless @ole_obj
+      until @ole_obj.Documents.Count == 0
+        begin
+          @ole_obj.ActiveDocument.Close(save)
+        rescue
+          break
+        end
+      end
+    end
+
+    def close_active_drawing
+      drawing = active_drawing
+      drawing&.close
+    end
+
+    # create a new drawing
+    #
+    # @rbs filename: String | Pathname -- The name of the drawing.
+    # @rbs seedfile: String -- The name of the seed file.
+    #  should not include a path. The default ggextension is ".dgn".
+    #  Typical values are "seed2d" or "seed3d".
+    # @rbs open: bool -- If the open argument is True,
+    #   CreateDesignFile returns the newly-opened DesignFile object;
+    #   this is the same value as ActiveDesignFile. If the Open argument is False,
+    #   CreateDesignFile returns Nothing.
+    # @rbs return Drawing, void -- returns the new drawing
+    def new_drawing(filename, open: true, options: {}, &block)
+      opts = default_app_options.merge(options)
+      err_fn = opts.fetch(:error_proc, error_proc)
+      file_path = Pathname.new(filename).expand_path
+      raise ExistingFile, file_path if file_path.exist?
+
+      # drawing_name = normalize_name(filename)
+      # seedfile = determine_seed(seedfile)
+      # binding.break unless seedfile
+      windows_name = windows_path(filename)
+      ole = new_ole_drawing(windows_name, open: open, wait_time: opts[:wait_time], wait_interval: opts[:wait_interval])
+      drawing = drawing_from_ole(ole)
+      return drawing unless block
+
+      begin
+        yield drawing
+      rescue DrawingError => e
+        err_fn.call(e, e.drawing)
+      rescue => e
+        err_fn.call(e, file_path)
+      ensure
+        drawing.close
+      end
+    end
+
+    # open the drawing
+    # @rbs filename: String the name of the file to open
+    # @rbs : bool :read_only  (false)
+    # @rbs wait_time: Integer -- the total amount of time to wait to open file (500)
+    # @rbs wait_interval: Float -- the amount of time in seconds to wait before retry (0.5)
+    # @rbs error_proc: Proc -- a proc to run
+    # @rbs &: (Drawing) -> (void)
+    # @rbs return Drawing | void
+    def open_drawing(filename, read_only: false, wait_time: nil,
+      wait_interval: nil, error_proc: nil, &block)
+      file_path = Pathname.new(filename).expand_path
+      raise FileNotFound.new(file_path) unless file_path.file?
+
+      begin
+        ole = ole_open_drawing(windows_path(filename), read_only:, wait_time:, wait_interval:)
+      rescue DrawingError => e
+        raise e unless err_fn
+
+        err_fn.call(e, e.drawing)
+      end
+      drawing = drawing_from_ole(ole)
+      return drawing unless block_given?
+
+      begin
+        yield drawing
+      rescue => e
+        raise e unless err_fn
+        err_fn.call(e, filename)
+      ensure
+        drawing.close
+      end
+    end
+
+    alias_method :doc, :active_drawing
+
+    alias_method :current_drawing, :active_drawing
+
+    def model_space
+      ModelSpace.new(doc_ole.ModelSpace)
+    end
+
+    def paper_space
+      PaperSpace.new(doc_ole.PaperSpace)
+    end
+
+    alias_method :model, :model_space
+
+    # @rbs message: String -- the String to put in Autocad prompt
+    def prompt(message)
+      doc.prompt(message)
+    end
+
+    # @rbs prompt: string -- the string to prompt the user for string
+    # @rbs has_spaces: bool -- whether the string returned can contain spaces
+    def get_input_string(...)
+      doc.get_input_string(...)
+    end
+
+    # @rbs prompt: string -- the string to prompt the user for integer
+    def get_input_integer(...)
+      doc.get_input_integer(...)
+    end
+
+    # In a running Autocad instance, prompts the user for a point.
+    # Uses the prompt argument as the prompt string.
+    # If base_point is provided, it is used as the base point and a
+    # stretched line is drawn from the base point to the returned point.
+    # @rbs prompt: String
+    # @rbs base_point: Array, Point3d, nil
+    # @rbs return [Point3d]
+    def get_point(...)
+      doc.get_point(...)
+    end
+
+    # In autocad prompts the user for a selection.
+    # @rbs prompt: String the prompt that displays in Autocad
+    # @rbs name: String the name of the selection
+    # @rbs return [SelectionSet]
+    def get_selection(prompt: "Select objects", name: "_SS1")
+      prompt(prompt)
+      begin
+        doc_ole.SelectionSets.Item(name).Delete
+      rescue
+        logger.debug("Delete selection failed")
+      end
+
+      selection = doc_ole.SelectionSets.Add(name)
+      selection.SelectOnScreen
+      selection
+    end
+
+    def has_documents?
+      ole_obj.Documents.Count > 0
+    end
+
+    alias_method :has_drawings?, :has_documents?
+
+    # @rbs return Enumerator[Drawing] | void
+    # @rbs &: (Drawing) -> void
+    def documents
+      return to_enum(__callee__) unless block_given?
+      ole_obj.Documents.each { |o| yield Drawing.new(self, o) }
+    end
+
+    alias_method :drawings, :documents
+
+    # @rbs return [bool] true
+    def drawing_opened?
+      @drawing_opened
+    end
+
+    # @rbs return [Pathname] Autocad Files.TemplateDwgPath
+    def templates_path
+      Pathname.new(ole_preferences_files.TemplateDwgPath)
+    end
+
+    def templates
+      return enum_for(:templates) unless block_given?
+
+      templates_path.children.each do |template|
+        yield template if template.file?
+      end
+    end
+
+    # Set Autocad Files.TemplateDwgPath
+    # @rbs path: Pathname, String the location on disk for Autocad templates
+    def template_path=(path)
+      ole_preferences_files.TemplateDwgPath = path.to_s
+    end
+
+    # @rbs return [Array<Pathname>] all paths in Files.SupportPath
+    def support_paths
+      ole_preferences_files.SupportPath.split(";").map { |f| Pathname.new(f) }
+    end
+
+    # @rbs return [Array<Pathname>] all paths in Files.PrinterConfigPath
+    def printer_config_paths
+      ole_preferences_files.PrinterConfigPath.split(";").map { |f| Pathname.new(f) }
+    end
+
+    # from the printer_config_paths, return all plotcfg files
+    # @rbs return [Enumerator[String]]
+    def plot_configs
+      return enum_for(:plot_configs) unless block_given?
+      printer_config_paths.each do |path|
+        path.children.each do |plot|
+          yield plot.to_s if plot.file?
+        end
+      end
+    end
+
+    private
+
+    def ole_preferences_files
+      @ole_preferences_files ||= ole_obj.Preferences.Files
+    end
+
+    def send_command(command)
+      ole_obj.SendCommand command
+    end
+
+    def init_ole_and_app_event(visible: @visible, event_handler: @event_handler, tries: 5, sleep_duration: 1)
+      ole = nil
+      begin
+        ole = WIN32OLE.connect("Autocad.Application")
+      rescue WIN32OLERuntimeError
+        ole = WIN32OLE.new("Autocad.Application")
+      end
+
+      sleep(sleep_duration)
+      # ole.Visible = visible
+      # ole.IsProcessLocked = true
+      load_constants(ole)
+      app_event = WIN32OLE_EVENT.new(ole)
+      app_event.handler = event_handler
+      [ole, app_event]
+    rescue => e
+      tries -= 1
+      sleep_duration += 1.5
+      puts "Error: #{e}. #{tries} tries left."
+      retry if tries.positive?
+      raise e, "unable to init ole app"
+    end
+
+    def doc_ole
+      ole_obj.ActiveDocument
+    end
+
+    def new_ole_drawing(filename, open: true, wait_time: 500, wait_interval: 0.5)
+      ole = ole_obj.Documents.add(filename)
+      wait_drawing_opened(wait_time, wait_interval)
+      return ole if drawing_opened?
+      raise DrawingError.new("New drawing not opened in #{wait_time} seconds", filename)
+    end
+
+    def ole_open_drawing(filename, read_only: false, wait_time: 500, wait_interval: 0.5)
+      ole = ole_obj.Documents.Open(filename, read_only)
+      wait_drawing_opened(wait_time: wait_time, wait_interval: wait_interval)
+      return ole if drawing_opened?
+      raise DrawingError.new("drewing not opened in #{wait_time}", path) unless drawing_opened?
+    end
+
+    def wait_drawing_opened(secs, interval = 1)
+      elapsed = 0
+      while !drawing_opened? && elapsed <= secs
+        elapsed += interval
+        sleep(interval)
+        run_loop
+      end
+    end
+  end
+end

data/lib/autocad/arc.rb

@@ -0,0 +1,29 @@
+require_relative "element"
+
+module Autocad
+  class Arc < Element
+    def length
+      @ole_obj.ArcLength
+    end
+
+    def start_point
+      Point3d(ole_obj.StartPoint)
+    end
+
+    def end_point
+      Point3d(ole_obj.EndPoint)
+    end
+
+    def start_angle
+      @ole_obj.StartAngle
+    end
+
+    def end_angle
+      @ole_obj.EndAngle
+    end
+
+    def total_angle
+      @ole_obj.TotalAngle
+    end
+  end
+end