microstation 0.4.1 → 0.8.3

data/lib/microstation.rb

@@ -1,88 +1,252 @@
-require 'win32ole'
-require 'microstation/app'
-require 'microstation/drawing'
-require 'microstation/configuration'
-require 'microstation/ext/pathname'
-require 'microstation/cad_input_queue'
-require 'microstation/scan/criteria'
-require 'microstation/enumerator'
-require 'microstation/text'
-require 'microstation/text_node'
-require 'microstation/template'
-require 'microstation/tag_set'
-require 'microstation/tag'
-require 'microstation/dir'
-
-require 'erb'
-
-module Microstation
-  VERSION = '0.4.1'
-
-  def self.root
-    Pathname.new( File.dirname(__FILE__)).parent
-  end
-
-
-  def self.app
-    Microstation::App.new
-  end
-
-
-  def self.plot_driver_directory
-    root + "plot"
-  end
-
-  def self.use_template(template,context)
-    def context.binding
-      binding
-    end
-    opts = {:read_only => true}
-    Microstation::App.run do |app|
-      tmpfile = Tempfile.new('drawing')
-      app.new_drawing(tmpfile,template) do |drawing|
-        drawing.scan_text do |text|
-          compiled_template = ERB.new(text)
-          new_text = compiled_template.result(context.binding)
-          text = new_text
-        end
-      end
-    end
-    tempfile.read
-  end
-
-  def self.drawings_in_dir(dir)
-    dirpath = Pathname.new(dir).expand_path
-    drawings = Pathname.glob("#{dirpath}/*.d{gn,wg}")
-  end
-
-  def self.dgn2pdf(dir,output = dir)
-    drawings = drawings_in_dir(dir)
-    self.with_drawings(drawings) do |drawing|
-      drawing.save_as_pdf(drawing.name,output)
-    end
-  end
-
-  def self.open_drawing(drawing,options = {}, &block)
-    Microstation::App.open_drawing(drawing,options,&block)
-  end
-
-  def self.with_drawings_in_dir(dir,&block)
-    drawings = self.drawings_in_dir(dir)
-    self.with_drawings(drawings,&block)
-  end
-
-  def self.with_drawings(*files, &block)
-    Microstation::App.with_drawings(*files,&block)
-  end
-
-  def self.run(options={}, &block)
-    options = {:visible => false}.merge(options)
-    begin
-      app = Microstation::App.new(options)
-      block.arity < 1 ? app.instance_eval(&block) : block.call(app)
-    ensure
-      app.quit
-    end
-  end
-
-end
+require 'microstation/version'
+require 'win32ole'
+require 'microstation/file_tests'
+require 'microstation/app'
+require 'microstation/drawing'
+require 'microstation/configuration'
+require 'microstation/ext/pathname'
+require 'microstation/cad_input_queue'
+require 'microstation/scan/criteria'
+require 'microstation/enumerator'
+require 'microstation/line'
+require 'microstation/text'
+require 'microstation/text_node'
+require 'microstation/template'
+require 'microstation/tag_set'
+require 'microstation/cell'
+require 'microstation/tag'
+require 'microstation/dir'
+require 'microstation/ext/win32ole'
+require 'microstation/template_info'
+require 'microstation/template_runner'
+require 'erb'
+
+module Microstation
+
+  ROOT = Pathname(__dir__).parent
+
+  TEMPLATES_PATH = ROOT + 'templates'
+  
+  class << self
+
+    def save_as_pdf(d)
+      run do |app|
+        drawing = app.current_drawing
+        drawing.save_as_pdf(dir: d)
+        drawing.close
+      end
+    end
+
+    def default_error_proc
+      @default_error_proc ||= ->(e,f){ puts "Couldn't open drawing #{f}" }
+    end
+
+    def default_drawing_options
+      {read_only: true, error_proc: default_error_proc}
+    end
+
+    def default_error_proc=(p)
+      @default_error_proc = p
+    end
+
+    def default_app_options
+      @default_app_options
+    end
+
+    def default_app_options=(opts)
+      @default_app_options = opts 
+    end
+
+    default_app_options = {visible: false}
+
+    def root
+      ROOT 
+    end
+
+    def plot_driver_directory
+      root + "plot"
+    end
+
+    def use_template(template,context, options ={} )
+      def context.binding
+        binding
+      end
+      options = {readonly: true}
+      App.run do |app|
+        tmpfile = Tempfile.new('drawing')
+        app.new_drawing(tmpfile,template) do |drawing|
+          drawing.scan_text do |text|
+            compiled_template = ERB.new(text)
+            new_text = compiled_template.result(context.binding)
+            text = new_text
+          end
+        end
+      end
+      tempfile.read
+    end
+
+    # starts an app with drawing, opens a temp
+    # copy of the drawing and yields it
+    # saves the drawing with with name or output_dir
+    # same name
+    #
+    # @param dgn
+    # @yield [Drawing]
+    def change_drawing(...)
+      App.change_drawing(...)
+    end
+
+    # gets all dwg and dgn dfiles in a directory
+    # @param dir 
+    def drawings_in_dir(dir)
+      dirpath = Pathname.new(dir).expand_path
+      drawings = Pathname.glob("#{dirpath}/*.d{gn,wg,xf}")
+    end
+
+    def dump_template_info_for_dir(dir, options={})
+      drawings = drawings_in_dir(dir)
+      raise "no drawings in dir #{dir}" if drawings.empty?
+      with_drawings(drawings) do |drawing|
+        template = TemplateInfo.new(drawing,options)
+        template.dump(dir)
+      end
+    end
+
+    def dump_template_info(dgn, dir: nil,  tagset_filter: nil, visible: false)
+      drawing = Pathname(dgn).expand_path
+      output_dir = dir || drawing.parent
+      template = TemplateInfo.new(drawing,tagset_filter: tagset_filter, visible: visible)
+      template.dump(output_dir)
+    end
+
+    # @param dir [String] the directory of drawing [dgn,dwg] to convert
+    # @param outdir [String] the output dir for converted pdf files
+    def dgn2pdf(dir,outdir = dir)
+      drawings = drawings_in_dir(dir)
+      with_drawings(drawings) do |drawing|
+        drawing.save_as_pdf(name: drawing.name,dir: outdir)
+      end
+    end
+
+    def run_templates_in_dir(...)
+      App.run_templates_in_dir(...)
+    end
+
+    # starts app, opens drawing, and yields
+    # the drawing before closing drawing and
+    # quitting the app
+    def open_drawing(...)
+      App.open_drawing(...)
+    end
+
+    # opens all the drawings in a drawing
+    # by calling open drawing
+    def with_drawings_in_dir(dir,...)
+      drawings = drawings_in_dir(dir)
+      with_drawings(drawings,...)
+    end
+
+    
+    def with_drawings(...)
+      App.with_drawings(...) 
+    end
+
+    def scan_text(file,&block)
+      App.open_drawing(file) do |d|
+        d.scan_text(&block)
+      end
+    end
+
+    def get_text(file, &block)
+      App.open_drawing(file) do |d|
+        d.get_text(&block)
+      end
+    end
+
+    def get_all_text(file)
+      App.open_drawing(file) do |d|
+        d.get_all_text
+      end
+    end
+
+    def save_current_drawing(dir, exit: true)
+      if exit
+        run do |app|
+          drawing = app.current_drawing
+          drawing.copy(dir: dir)
+          drawing.save_as_pdf(dir: dir)
+          drawing.close
+        end
+      else
+        app = App.new
+        drawing = app.current_drawing
+        drawing.copy(dir: dir)
+        drawing.save_as_pdf(dir: dir)
+        app
+      end
+    end
+
+    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
+
+    def run(...)
+      App.run(...)
+    end
+
+  end
+
+end
+
+if $0 == __FILE__
+
+  require 'pry'
+
+  app = Microstation::App.new
+  require 'microstation/ole_helper'
+
+  File.open('app_methods.txt','w') do |f|
+    f.write app.ole_obj.ole_methods_detail
+  end
+
+  tlib = app.ole_obj.ole_typelib
+  File.open('microstation_classes.txt','w') do |f|
+    f.write app.ole_obj.ole_classes_detail
+  end
+
+  ole_obj = app.ole_obj
+
+  event_classes = ole_obj.select_ole_type('event')
+  puts event_classes
+
+
+  # drawing = app.new_drawing('mynew.dgn')
+
+  # le =tlib.ole_classes.find{|c| c.name == 'LineElement'}
+  # #puts drawing.model_names
+
+  # VT = WIN32OLE::VARIANT
+  # # Type.Missing equivalent
+
+  # e1 = WIN32OLE_VARIANT::NoParam
+  # e2 = WIN32OLE_VARIANT.new(nil, VT::VT_VARIANT|VT::VT_BYREF)
+
+
+  # drawing.change_model('Default')
+  # line = drawing.create_line [1,0.5],[1,1,0],e1
+  # drawing.add_line line if line
+
+
+
+  binding.pry
+
+
+  app.quit
+
+
+
+end

data/lib/microstation/app.rb

@@ -1,286 +1,781 @@
-require_relative 'wrap'
-
-module Windows
-
-  class FileSystem
-
-    def self.windows_path(path)
-      obj = new
-      obj.windows_path(path)
-    end
-
-    def fs_object
-      @fs_object ||= WIN32OLE.new('Scripting.FileSystemObject')
-    end
-
-    def windows_path(path)
-      path = path.to_path if path.respond_to? :to_path
-      fs_object.GetAbsolutePathName(path.to_str)
-    end
-
-  end
-end
-
-module Microstation
-
-  module MSD
-  end
-
-  def self.win_fs
-    @windows_fs ||= Windows::FileSystem.new
-  end
-
-  class App
-
-    include Wrap
-
-    def self.run(options={})
-      begin
-        the_app = new(options)
-
-        yield the_app
-      ensure
-        the_app.quit
-      end
-    end
-
-    def self.open_drawing(drawing,options={},&block)
-      self.run(options) do |app|
-        app.open_drawing(drawing,options,&block)
-      end
-    end
-
-    def self.with_drawings(*files,&block)
-      files = files[0] if files[0].kind_of?  Array
-      opts = {:read_only => true}
-      self.run do |app|
-        files.each do |file|
-          puts "opening #{file}.."
-          app.open_drawing(file,opts) do |draw|
-            block.call draw
-          end
-
-        end
-      end
-    end
-
-    def load_constants
-      WIN32OLE.const_load(@ole_obj, MSD) unless MSD.constants.size > 0
-    end
-
-    attr_reader :scanners
-
-    def initialize(options = {})
-      visible = options.fetch(:visible){ true }
-
-      @ole_obj = WIN32OLE.new('MicrostationDGN.Application')
-      @windows = Windows::FileSystem.new
-      make_visible(visible)
-      @scanners = []
-    end
-
-    def visible?
-      @visible
-    end
-
-    def project_dir
-      @project_dir
-    end
-
-    def project_dir=(dir)
-      @project_dir = dir ? Pathname.new(dir) : dir
-    end
-
-    def base_dir
-      project_dir ? project_dir : Pathname.getwd
-    end
-
-    def normalize_name(name)
-      name = Pathname.new(name) unless name.kind_of? Pathname
-      name = name.ext('.dgn')  unless name.extname.to_s == /\.(dgn|dwg)$/
-      return (base_dir + name).expand_path
-    end
-
-    def make_visible(visible)
-      @visible = visible
-      @ole_obj.Visible = @visible
-    end
-
-    attr_reader :ole_obj
-
-    # def method_missing(name,*args,&block)
-    #   @ole_obj.send(name,*args,&block)
-    # end
-
-    def with_drawing(drawing)
-      begin
-        yield drawing
-      ensure
-        drawing.close
-      end
-    end
-
-    def with_template(template)
-      template = Template.new(template,self)
-      yield template
-      template = nil
-    end
-
-    def open_drawing(filename,options = {})
-      filename = Pathname(filename)
-      raise FileNotFound unless filename.file?
-      readonly = options.fetch(:read_only){ false}
-      ole = @ole_obj.OpenDesignFile(windows_path(filename), "ReadOnly" => readonly)
-      drawing = drawing_from_ole(ole)
-      return drawing unless block_given?
-      begin
-        yield drawing
-      rescue
-        puts "got error"
-      ensure
-        drawing.close
-      end
-
-    end
-
-    def windows_path(path)
-      @windows.windows_path(path)
-    end
-
-    def active_workspace
-      @ole_obj.ActiveWorkspace
-    end
-
-    def configuration
-      @config ||= Microstation::Configuration.new(self)
-    end
-
-    def username
-      configuration["USERNAME"]
-    end
-
-    # seedfile A String expression. The name of the seed file. Should not include a path. The default extension is ".dgn".
-    # Typical values are "seed2d" or "seed3d".
-    # open
-    # 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.
-    def new_drawing(filename, seedfile=nil     ,open = true,&block)
-      #drawing_name = normalize_name(filename)
-      seedfile = determine_seed(seedfile)
-      windows_name = windows_path(filename)
-      ole = @ole_obj.CreateDesignFile(seedfile, windows_name, open)
-      drawing = drawing_from_ole(ole)
-      return drawing unless block_given?
-      begin
-        yield drawing
-      rescue
-      ensure
-        drawing.close
-      end
-
-    end
-
-    def drawing_from_ole(ole)
-      Drawing.new(self,ole)
-    end
-
-    def determine_seed(seedfile)
-      return "seed2d" unless seedfile
-      return windows_path( File.expand_path(seedfile))
-    end
-
-    def eval_cexpression(string)
-      @ole_obj.GetCExpressionValue(string)
-    end
-
-    def quit
-      active_design_file.close if active_file?
-      @scanners.each{|sc| sc.close}
-      @ole_obj.quit
-    end
-
-    def active_design_file
-      ole = @ole_obj.ActiveDesignFile rescue nil
-      drawing_from_ole(ole) if ole
-    end
-
-    def current_drawing
-      active_design_file
-    end
-
- #   alias :current_drawing :active_design_file
-
-    def close_active_drawing
-      active_design_file.close if active_design_file
-    end
-
-    def active_file?
-      !!active_design_file
-    end
-
-    def file_exists?(file)
-      File.file?( File.expand_path(file) )
-    end
-
-    def create_scanner(&block)
-      Microstation::Scan::Criteria.create_scanner(self,&block)
-    end
-
-    def find_by_id(id)
-      model = active_model_reference.GetElementById64(id)
-      wrap(model)
-    end
-
-    def scan(criteria = nil)
-      result = []
-      raise 'NoActiveModel' unless active_model_reference
-      if criteria
-        criteria.resolve
-        ee = active_model_reference.Scan(criteria.ole_obj)
-      else
-        ee = active_model_reference.Scan(nil)
-      end
-      scan_result = Microstation::Enumerator.new ee
-      return scan_result.to_enum unless block_given?
-      scan_result.each do |item|
-        yield item
-      end
-      nil
-    end
-
-    def cad_input_queue
-      queue = init_cad_input_queue
-      return queue unless block_given?
-      begin
-        yield queue
-      rescue
-
-      ensure
-        queue.close
-        queue = nil
-      end
-    end
-
-    def can_open?(filename)
-      ext = File.extname(filename)
-      (ext == ".dwg") || (ext == ".dgn")
-    end
-
-    def active_model_reference
-      @ole_obj.ActiveModelReference rescue nil
-    end
-
-    private
-
-
-
-
-    def init_cad_input_queue
-      Microstation::CadInputQueue.new(@ole_obj.CadInputQueue)
-    end
-
-
-  end
-
-end
-
+# frozen_string_literal: true
+
+require_relative 'wrap'
+require_relative 'point3d'
+require_relative 'event_handler'
+require_relative 'functions'
+require 'pry'
+
+class WIN32OLE
+  def ole_obj
+    self
+  end
+end
+
+module Windows
+  class FileSystem
+    def self.windows_path(path)
+      obj = new
+      obj.windows_path(path)
+    end
+
+    def fs_object
+      @fs_object ||= WIN32OLE.new('Scripting.FileSystemObject')
+    end
+
+    def windows_path(path)
+      path = path.to_path if path.respond_to? :to_path
+      fs_object.GetAbsolutePathName(path.to_str)
+    end
+  end
+end
+
+module Microstation
+  module MSD
+  end
+
+  def self.win_fs
+    @windows_fs ||= Windows::FileSystem.new
+  end
+
+  class App
+    include Functions
+
+
+    @default_app_options = { visible: false }
+
+    class << self
+
+      attr_accessor :default_app_options
+
+      #  include Wrap
+
+      # Initialize an instance of app with the options
+      # @param [Hash] options the options to create the app with
+      # @option options [Boolean] :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
+      #
+      # @yield [App] the_app yields the instanciated app
+      # @return [void]
+      def run(options = {})
+        opts = self.default_app_options.merge(options)
+        begin
+          the_app = new(**opts)
+          binding.pry if the_app.nil?
+          yield the_app
+        rescue StandardError
+          binding.pry
+        ensure
+          the_app.quit if the_app.respond_to? :quit
+          the_app = nil
+          GC.start
+          nil
+        end
+      end
+
+      # Calls #run to get an app instance then call open drawing with
+      # that app
+      # (see #open_drawing)
+      # @yield Drawing
+      # @return [void]
+      def open_drawing(drawing, app_options: {}, options:  {}, &block)
+        run(**app_options) do |app|
+          app.open_drawing(drawing, **options, &block)
+        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('C:/templates')
+      # drawings = Pathname.glob(dir + '/**/*.dgn')
+      # App.with_drawings(drawings) do |drawing|
+      #   drawing.save_as_pdf(dir: 'c:/output/')
+      # end
+      #
+      # @param files [Array<String,Pathname>]
+      # @param visible [Boolean]
+      # @param readonly [Boolean]
+      # @param error_proc [Proc]
+      # @yield [Drawing]
+      # @return [void]
+      def with_drawings(*files, visible: true, readonly: false, error_proc: ::Microstation.default_error_proc, &block)
+        # drawing_options = default_drawing_options.merge(options)
+        # app_options = default_app_options
+        errors = []
+        files = files[0] if files[0].is_a? Array
+        begin
+          the_app = new(visible: visible)
+          files_enum = files.each
+          loop do
+            file = files_enum.next
+            puts "opening #{file}.."
+            begin
+              the_app.open_drawing(file, readonly: readonly, error_proc: error_proc, &block)
+              the_app.ole_obj.ole_methods # check if server still open
+            rescue StandardError => e
+              error_proc.call(e, file)
+              the_app = new(app_options)
+            end
+          end
+        ensure
+          the_app&.quit
+          the_app = nil
+        end
+      end
+  end
+
+    attr_reader :scanners, :visible, :app_event, :project_dir
+
+    # Constructor for app
+    # @param [Boolean] visible
+    # @param event_handler [EventHandler]
+    def initialize(visible: false, event_handler: default_event_handler)
+      @visible = visible
+      @event_handler = event_handler
+      @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 StandardError => e
+      binding.pry
+    end
+
+    def run_templates_in_dir(dir, options = {})
+      yaml_files = Pathname.glob("#{Pathname(dir).expand_path}*.yaml")
+      yaml_files.each do |f|
+        TemplateRunner.new(f).run_with_app(self, options)
+      end
+    end
+
+    def change_drawing(dgn, output_dir: nil, name: nil, options: {}, &block)
+      changer = Changer.new(dgn, name: name, output_dir: output_dir, app: self)
+      changer.run(&block)
+    end
+
+    def render_template(drawing, output_dir: nil, locals: {}, name: nil)
+      temp = Template.new(drawing, output_dir: output_dir, app: self, name: name)
+      temp.render(output_dir: output_dir, locals: locals)
+    end
+
+    #
+    # the default EventHandler
+    #
+    # @return [EventHandler] returns the default EventHandler
+    #
+    def default_event_handler
+      event_handler = EventHandler.new
+      event_handler.add_handler('OnDesignFileOpened') do |*_args|
+        puts 'drawing opened'
+        @drawing_opened = true
+      end
+      event_handler.add_handler('OnDesignFileClosed') do |*_args|
+        @drawing_opened = false
+        puts 'drawing closed'
+      end
+      event_handler
+    end
+
+    #
+    # register an handler
+    #
+    # @param [String] event key for handler
+    # @param [<Type>] &block <description>
+    #
+    # @return [<Type>] <description>
+    #
+    def register_handler(event, &block)
+      @event_handler.add_handler(event, &block) unless event == 'OnQuit'
+    end
+
+    #
+    # return a Handler
+    #
+    # @param [String,Symbol] event the event key
+    #
+    # @return [Proc] returns the Proc given by event name
+    #
+    def get_handler(event)
+      @event_handler.get_handler(event)
+    end
+
+    def exit_message_looop
+      puts 'Microstation exiting...'
+      @run_loop = false
+    end
+
+    def wait_drawing_opened(secs, interval = 1)
+      elapsed = 0
+      while !drawing_opened? && elapsed <= secs
+        elapsed += interval
+        sleep(interval)
+        WIN32OLE_EVENT.message_loop
+      end
+    end
+
+    def init_ole_and_app_event(visible: @visible, event_handler: @event_handler, tries: 5, sleep_duration: 1)
+      ole = WIN32OLE.new('MicrostationDGN.Application')
+      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 StandardError => 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
+
+    # @return [Boolean] whether the app is visible
+    def visible?
+      @visible
+    end
+
+    #
+    # Change the visible attribute
+    #
+    # @param [Boolean] bool true or false to make it visible
+    #
+    # @return [void]
+    #
+    def visible=(bool)
+      ole_obj.Visible = bool
+    end
+
+    def project_dir=(dir)
+      @project_dir = dir ? Pathname.new(dir) : dir
+    end
+
+    def base_dir
+      project_dir || Pathname.getwd
+    end
+
+    def wrap(item, cell = nil)
+      Element.convert_item(item, self, cell)
+    end
+
+    def normalize_name(name)
+      name = Pathname.new(name) unless name.is_a? Pathname
+      name = name.ext('.dgn') unless name.extname.to_s == /\.(dgn|dwg)$/
+      (base_dir + name).expand_path
+    end
+
+    def make_visible(visible)
+      @visible = visible
+      begin
+        ole_obj.Visible = @visible
+        true
+      rescue Exception => e
+        false
+      end
+    end
+
+    def ole_obj
+      is_ok = true
+      begin
+        @ole_obj.Visible
+      rescue StandardError => e
+        is_ok = false
+      end
+
+      @ole_obj, @app_event = init_ole_and_app_event(tries: 3) unless is_ok
+
+      @ole_obj
+    end
+
+    def with_drawing(drawing)
+      yield drawing
+    ensure
+      drawing.close
+    end
+
+    def with_template(template)
+      template = Template.new(template, self)
+      yield template
+      template = nil
+    end
+
+    # open the drawing
+    # @param filename [String] the name of the file to open
+    # @param  [Boolean] :readonly  (false)
+    # @param  [Proc] :error_proc (raise) a proc to run
+    # @param wait_time [Integer] the total amount of time to wait to open file (500)
+    # @param wait_interval [Float] the amount of time in seconds to wait before retry (0.5)
+    # @yield [Drawing] drawing
+    # @return [void]
+    def open_drawing(filename, readonly: false, error_proc: nil, wait_time: 500, wait_interval: 0.5)
+      filename = Pathname(filename)
+      raise FileNotFound unless filename.file?
+
+      begin
+        ole = ole_open_drawing(windows_path(filename), readonly: readonly, wait_time: wait_time,
+                                                       wait_interval: wait_interval)
+      rescue StandardError => e
+        if error_proc
+          error_proc.call(filename)
+          return
+        else
+          raise e
+        end
+      end
+      drawing = drawing_from_ole(ole)
+      return drawing unless block_given?
+
+      begin
+        yield drawing
+      ensure
+        drawing.close
+      end
+    end
+
+    def drawing_opened?
+      @drawing_opened
+    end
+
+    def windows_path(path)
+      @windows.windows_path(path)
+    end
+
+    def active_workspace
+      ole_obj.ActiveWorkspace
+    end
+
+    # @return the [Configuration]
+    def configuration
+      @config ||= ::Microstation::Configuration.new(self)
+    end
+
+    # @return [String] the configuration variable USERNAME
+    def username
+      configuration['USERNAME']
+    end
+
+    # create a new drawing
+    # @param filename [String,Pathname] the name of the file
+    # @param seedfile [String] The name of the seed file.
+    #  should not include a path. The default extension is ".dgn".
+    #  Typical values are "seed2d" or "seed3d".
+    # @param open [Boolean] .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.
+    # @return [Drawing]
+    def new_drawing(filename, seedfile: nil, open: true, wait_time: 500, wait_interval: 1, &block)
+      file_path = Pathname(filename).expand_path
+      raise ExistingFile, file_path if file_path.exist?
+
+      # drawing_name = normalize_name(filename)
+      seedfile = determine_seed(seedfile)
+      binding.pry unless seedfile
+      windows_name = windows_path(filename)
+      ole = new_ole_drawing(seedfile, windows_name, open: open, wait_time: wait_time, wait_interval: wait_interval)
+      drawing = drawing_from_ole(ole)
+      return drawing unless block_given?
+
+      begin
+        yield drawing
+      rescue StandardError => e
+        'puts error in new drawing'
+        raise e
+      ensure
+        drawing.close
+      end
+    end
+
+    def new_ole_drawing(seedfile, new_design_file_name, open: true, wait_time: 500, wait_interval: 0.5)
+      ole = ole_obj.CreateDesignFile(seedfile, new_design_file_name, open)
+      wait_drawing_opened(wait_time, wait_interval)
+      raise "drawing not opened in #{wait_time}" unless drawing_opened?
+
+      ole
+    rescue StandardError => e
+      raise e
+    end
+
+    def has_current_drawing?
+      ole_obj.HasActiveDesignFile
+    end
+
+    # prepend a dir to the MS_SEEDFILES configuration
+    # @param dir [String,Pathname]
+    def prepend_seed_path(dir)
+      configuration.prepend('MS_SEEDFILES', windows_path(dir))
+    end
+
+    def drawing_from_ole(ole)
+      Drawing.new(self, ole)
+    end
+
+    def determine_seed(seedfile)
+      return configuration['MS_DESIGNSEED'] unless seedfile
+
+      seed = find_seed(seedfile)
+      return seed.to_s if seed
+
+      raise "Seedfile #{seedfile} not found in #{configured_seed_paths}"
+    end
+
+    # @return [String] the configuration variable MS_SEEDFILES
+    def configured_seed_paths
+      configuration['MS_SEEDFILES']
+    end
+
+    # find the seedfile
+    # @param [String,Pathname] seedfile
+    #
+    # * If the seed file is absolute and found the return the
+    # seedfile.
+    # * If the seed file is not found search MS_SEEDFILES
+    # @return [Pathname] seedfile the found seedfile
+    def find_seed(seedfile)
+      seed = Pathname(seedfile).expand_path.sub_ext('.dgn')
+      return seed if seed.file?
+
+      find_seed_in_seed_dirs(seed.basename)
+    end
+
+    def find_seed_in_seed_dirs(seedfile)
+      seed_dir = seed_paths.find { |p| (p + seedfile).file? }
+      return (seed_dir + seedfile) if seed_dir
+    end
+
+    # @return [Array] returns the MS_SEEDFILES as Pathnames Array
+    def seed_paths
+      configured_seed_paths.split(';').map { |d| Pathname(d) }
+    end
+
+    def eval_cexpression(string)
+      ole_obj.GetCExpressionValue(string)
+    end
+
+    #
+    # quit the app
+    #
+    # @return [void]
+    #
+    def quit
+      close_active_drawing
+      @scanners.each { |_name, sc| sc.close }
+      begin
+        ole_obj.Quit
+      rescue StandardError
+        nil
+      end
+    end
+
+    # the active design file
+    # @return [Drawing]
+    def active_design_file
+      if active_design_file?
+        ole = ole_obj.ActiveDesignFile
+        drawing_from_ole(ole)
+      end
+    end
+
+    alias active_drawing active_design_file
+    alias current_drawing active_design_file
+
+    #
+    # close the active_design_file
+    #
+    # @return [void]
+    #
+    def close_active_drawing
+      active_design_file.close if active_design_file?
+    end
+
+    alias close_current_drawing close_active_drawing
+
+    #
+    #
+    #
+    # @return [Boolean] true if app has an active design file open
+    #
+    def active_design_file?
+      ole_obj.HasActiveDesignFile
+    end
+
+    alias current_design_file? active_design_file?
+
+    #
+    # <Description>
+    #
+    # @param [String,Pathname] file name of file to search for
+    #
+    # @return [Boolean] true if file exists
+    #
+    def file_exists?(file)
+      Pathname(file).expand_path.file?
+    end
+
+    def create_scanner(name = nil, &block)
+      ::Microstation::Scan::Criteria.create_scanner(name, self, &block)
+    end
+
+    def text_criteria
+      scanners[:textual] || create_scanner(:textual) { include_textual }
+    end
+
+    def tags_criteria
+      sc = scanners[:tags] || create_scanner(:tags) { include_tags }
+    end
+
+    def create_scan_criteria(name = nil, &block)
+      ::Microstation::Scan::Criteria.create_scanner(name, self, &block)
+    end
+
+    # def find_by_id(id)
+    #   active_design_file.find_by_id(id)
+    #   wrap(model) if el
+    # end
+
+    def scan_model(criteria = nil, model = nil)
+      model ||= active_model_reference
+      model.scan(criteria)
+    end
+
+    def get_ole_element_enumerator(model:, criteria: nil)
+      criteria ||= create_scan_criteria
+      criteria.resolve
+      model.scan(criteria.ole_obj)
+    rescue Exception
+      # binding.pry
+    end
+
+    # lets you interact with the cad_input_queue
+    # @yield [CadInputQueue]
+    # @return [void]
+    def cad_input_queue
+      queue = init_cad_input_queue
+      return queue unless block_given?
+
+      begin
+        yield queue
+      rescue StandardError
+      ensure
+        queue.close
+        queue = nil
+        @cad_input_queue = nil
+      end
+    end
+
+    def show_command(text)
+      ole_obj.ShowCommand(text)
+    end
+
+    def show_prompt(text)
+      ole_obj.ShowPrompt(text)
+    end
+
+    def show_message(text)
+      ole_obj.ShowMessage(text)
+    end
+
+    #
+    #
+    # @param [String] text text to show
+    # @param [Symbol] location (one of :left, :middle)
+    #
+    # @return [void]
+    #
+    def show_temp_message(text, location: nil)
+      loc = case location
+            when :left
+              MSD::MsdStatusBarAreaLeft
+            when :middle
+              MSD::MsdStatusBarAreaMiddle
+            else
+              MSD::MsdStatusBarAreaLeft
+            end
+      ole_obj.ShowTempMessage(loc, text)
+    end
+
+    def can_open?(filename)
+      ext = File.extname(filename)
+      (ext == '.dwg') || (ext == '.dgn')
+    end
+
+    def active_model_reference
+      DefaultModel.new(self, ole_obj.ActiveModelReference)
+    rescue StandardError
+      nil
+    end
+
+    def default_model
+      DefaultModel.new(self, ole_obj.DefaultModelReference)
+    rescue StandardError
+      nil
+    end
+
+    def ole_point
+      ::WIN32OLE_RECORD.new('Point3d', ole_obj)
+    end
+
+    def ole_rotation
+      ::WIN32OLE_RECORD.new('Rotation', ole_obj)
+    end
+
+    def ole_matrix
+      ::WIN32OLE_RECORD.new('Matrix', ole_obj)
+    end
+
+    #
+    # Create an WIN32OLE_RECORD of type Point3d
+    #
+    # @param [Numeric] x coordinate in x axis
+    # @param [Numeric] y coordinate in y axis
+    # @param [Numeric] z coordinate in z direction (0.0)
+    #
+    # @return [WIN32OLE_RECORD] record of type Point3d
+    #
+    def create_ole_point(x, y, z = 0)
+      ole = ole_point
+      ole.X = x
+      ole.Y = y
+      ole.Z = z
+      ole
+    end
+
+    def to_ole_matrix3d(vec)
+      if vec.instance_of?(WIN32OLE_RECORD) && vec.typename == 'Matrix3d'
+        vec
+      else
+        binding.pry
+      end
+    end
+
+    #
+    # Conversion to WIN32OLE_RECORD of type Point3d
+    #
+    # @param [WIN32OLE_RECORD, Point3d, Array<Numeric>] pt Point to normalize to ole point
+    # @return [WIN32OLE_RECORD] 'Point3d' WIN32OLE_RECORD
+    #
+    def to_ole_point3d(pt)
+      case pt
+      when ole_point3d?(pt)
+        pt
+      when Point3d
+        create_ole_point(pt.x, pt.y, pt.z)
+      when Array
+        pt1 = pt.map(&:to_f)
+        x, y, z = pt1
+        z ||= 0.0
+        create_ole_point(x, y, z)
+      end
+    end
+
+    #
+    # <Description>
+    #
+    # @param [Object] pt pt object to test if it is a WIN32OLE_RECORD of 'Point3d'
+    #
+    # @return [Boolean] true if pt is WIN32OLE_RECORD of 'Point3d'
+    #
+    def ole_point3d?(pt)
+      pt.instance_of?(WIN32OLE_RECORD) && pt.typename == 'Point3d'
+    end
+
+    def create_text_node(origin, rotation, temp = nil)
+      ole_origin = to_ole_point3d(origin)
+      ole_rotation = to_ole_matrix3d(rotation)
+      temp ||= WIN32OLE_VARIANT::Nothing
+      ole = ole_obj.CreateTextNodeElement1(temp, ole_origin, ole_rotation)
+    rescue Exception => e
+      puts e.message
+      nil
+    end
+
+    #
+    # convert pt to Point3d
+    #
+    # @param [Array<Numeric,Numeric,Numeric>, Point3d, WIN32OLE_RECORD] pt Point to convert
+    #
+    # @return [Point3d]
+    #
+    def to_point3d(pt)
+      case pt
+      when Array
+        pt_a = pt.map(&:to_f)
+        x, y, z = pt_a
+        z ||= 0.0
+        Point3d.new(x, y, z)
+      when Point3d
+        pt
+      when WIN32OLE_RECORD
+        Point3d.from_ole(pt) if pt.typename == 'Point3d'
+      end
+    end
+
+    def to_point(pt)
+      to_point3d(pt)
+    end
+
+    def start_primitive(klass)
+      ole_obj.CommandState.StartPrimitive klass.new(self)
+    end
+
+    def my_place_line
+      require_relative 'primitive_command_interface'
+      start_primitive LineCreation
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^[A-Z]/
+        require 'pry'; binding.pry
+        result = ole_obj.send(meth, *args, &block)
+      else
+        super(meth, *args, &block)
+      end
+    rescue StandardError => e
+      binding.pry
+    end
+
+    protected
+
+    def ole_open_drawing(path, readonly: false, wait_time: 500, wait_interval: 0.5)
+      ole = ole_obj.OpenDesignFile(windows_path(path), 'ReadOnly' => readonly)
+      wait_drawing_opened(wait_time, wait_interval)
+      raise "drawing not opened in #{wait_time}" unless drawing_opened?
+
+      ole
+    rescue StandardError => e
+      raise e
+    end
+
+    def load_constants(ole_obj)
+      WIN32OLE.const_load(ole_obj, MSD) unless MSD.constants.size.positive?
+    end
+
+    def run_loop
+      WIN32OLE_EVENT.message_loop while @run_loop
+    end
+
+    def stop_loop
+      @run_loop = false
+    end
+
+    private
+
+    def init_cad_input_queue
+      ::Microstation::CadInputQueue.new(ole_obj.CadInputQueue, self)
+    end
+  end
+end