microstation 0.4.1 → 0.8.6

data/lib/microstation/functions.rb

@@ -0,0 +1,60 @@
+require 'dry/monads'
+module Microstation
+
+  class App
+    include Dry::Monads[:result]
+  end
+
+  module Functions
+
+    extend Dry::Monads[:result]
+
+    def get_points_by_rectangle
+      queue = cad_input_queue
+      queue.show_command('Get points by block')
+      start_point = queue.get_point
+      if start_point.failure?
+        return Failure(:point1_reset)
+      end
+      queue.send_command "PLACE BLOCK"
+      queue.send_data_point start_point.value!
+      end_point = queue.get_point
+      if end_point.failure?
+        return Failure(:point2_reset)
+      end
+      Success([start_point.value!, end_point.value!])
+    end
+
+    def get_points_by_line
+      queue = cad_input_queue
+      queue.show_command("Get points by line")
+      start_point = queue.get_point
+      if start_point.failure?
+        return Failure(:point1_reset)
+      end
+      queue.send_command "PLACE LINE"
+      queue.send_data_point start_point.value!
+      end_point = queue.get_point("Enter next vertex")
+      if end_point.failure?
+        return Failure(:point2_reset)
+      end
+      Success([start_point.value!, end_point.value!])
+    end
+
+    def clear_ui
+      cad_input_queue.clear_ui
+    end
+
+    def get_point
+      cad_input_queue.get_point
+    end
+
+
+  end
+
+
+  class App
+    include Functions
+  end
+end
+

data/lib/microstation/graphics.rb

@@ -0,0 +1,35 @@
+module Microstation
+
+  module Graphics
+
+
+    def line(p1,p2,el = WIN32OLE_VARIANT::Nothing)
+      pt1 = app.to_ole_point3d(p1)
+      pt2 = app.to_ole_point3d(p2)
+      begin
+        ole = app.ole_obj.CreateLineElement2(el,pt1,pt2)
+      rescue Exception => ex
+        binding.pry
+        return nil
+      end
+      add_element(ole) if ole
+    end
+
+
+    def line_from_pts(pts, el = WIN32OLE_VARIANT::Nothing)
+      ole_points = pts.map{ |pt| app.to_ole_point3d(pt) }
+      ole = app.ole_obj.CreateLineElement1(el, ole_points)
+      if ole
+        add_element(ole) 
+      else
+        binding.pry
+      end
+    rescue Exception => e
+      binding.pry
+      return nil
+    end
+  end
+
+
+end
+

data/lib/microstation/line.rb

@@ -0,0 +1,19 @@
+require 'microstation/element'
+
+module Microstation
+
+  class Line < Element
+
+    def length
+      ole_obj.Length
+    end
+
+
+    def vertices
+      ole_obj.AsVertexList
+      n = ole_obj.VerticesCount
+      list = ole_obj.GetVertices
+      list
+    end
+  end
+end

data/lib/microstation/model.rb

@@ -0,0 +1,45 @@
+#require_relative 'scan/scan_trait'
+require 'microstation/wrap'
+require_relative 'model_trait'
+
+#require_relative 'ts/tagset_trait'
+#require_relative 'graphics'
+#require_relative 'ts/instance'
+
+
+module Microstation
+
+  class DefaultModel
+
+    include ::Microstation::ModelTrait
+
+    attr_reader :app,:ole_obj
+
+    def initialize(app,ole)
+      @app = app
+      @ole_obj = ole
+    end
+
+    def drawing
+      @drawing ||= ::Microstation::Drawing.from_ole_obj(app,ole_obj)
+    end
+
+
+  end
+
+
+  class Model
+
+    include ::Microstation::ModelTrait
+
+    attr_reader :app,:drawing,:ole_obj
+
+    def initialize(app,drawing,ole)
+      @app = app
+      @drawing = drawing
+      @ole_obj = ole
+    end
+
+  end
+
+end

data/lib/microstation/model_trait.rb

@@ -0,0 +1,189 @@
+require_relative 'graphics'
+require_relative 'scan_trait'
+
+module Microstation
+  module ModelTrait
+
+    include Graphics
+
+    include ScanTrait
+    # include TS::TagSetTrait
+
+    def name
+      ole_obj.name
+    end
+
+    def find_by_id(id)
+      ele = ole_obj.GetElementById64(id) rescue nil
+      return nil unless ele
+      app.ole_to_ruby(ele)
+    end
+
+    def active?
+      ole_obj.IsActive
+    end
+
+    def get_selected_elements
+      Enumerator.new(ole_obj.GetSelectedElements,app)
+    end
+
+    def get_selected_text
+      get_selected_elements.select{|t| t.textual?}
+    end
+
+    def get_matching_text(re)
+      result = []
+      get_selected_text.each do |t|
+        md = re.match( t)
+        if md
+          if block_given?
+            yield t,md
+          else
+            result << t
+          end
+        end
+        result
+      end
+    end
+
+    def change_text_suffix(reg,offset)
+      get_matching_text(reg) do |t,md|
+        pre = md[1]
+        suff = Integer( md[2] ) + offset
+        t.replace "#{pre}#{suff}"
+      end
+    end
+
+    def unselect_element(el)
+      ole_obj.UnselectElement(el.ole_obj)
+    end
+
+    def select_element(el)
+      ole_obj.SelectElement(el.ole_obj)
+    end
+
+    def readonly?
+      ole_obj.IsReadOnly
+    end
+
+    def activate
+      ole_obj.Activate
+    end
+
+    def locked?
+      ole_obj.IsLocked?
+    end
+
+    def to_s
+      "Microstation::Model-#{name}"
+    end
+
+
+    def add_element(el)
+      if el.respond_to? :ole_obj
+        el = el.ole_obj
+        ole_obj.AddElement(el)
+        self
+      end
+    end
+
+    def select_tagset_instances
+
+    end
+
+    def scan_tags_filtered( ts_name: nil, base_element_id: nil,&block)
+      case [ts_name, base_element_id]
+          in [nil, nil]
+          scan_tags(&block)
+          in [String,nil]
+          scan_tags.select{ |t| t.tagset_name == ts_name }
+          in [String, Numeric]
+          scan_tags.select{ |t| t.tagset_name == ts_name && t.base_element_id == base_element_id }
+          in [nil, Numeric]
+          scan_tags.select{ |t| t.base_element_id == base_element_id  }
+
+      end
+    end
+
+    def tags_to_hash(tags)
+      return to_enum(__callee__,tags) unless block_given?
+      tsets = tags.group_by{ |t| t.tagset_name }
+      tsets.each do |tsname, tags|
+        elements = tags.group_by{|t| t.base_element_id}
+        elements.each do |id, tag_elts|
+          result_hash = {
+            name: tsname,
+            model: name,
+            tags: tag_elts,
+            base_element_id: id,
+          }
+          yield result_hash
+        end
+      end
+    end
+
+    def get_tagsets_in_model_hash(ts_name: nil, base_element_id: nil,&block)
+      tags = scan_tags_filtered(ts_name: ts_name, base_element_id: base_element_id)
+      tags_to_hash(tags, &block)
+    end
+
+    def get_tagsets_in_model_hash_old
+      results = []
+      tsets  = scan_tags.group_by{|t| t.tagset_name}
+      tsets.each do |tsname, tags|
+        elements = tags.group_by{|t| t.base_element_id}
+        elements.each do |id, tag_elts|
+          result_hash = {
+            name: tsname,
+            model: name,
+            tags: tag_elts,
+            base_element_id: id,
+          }
+          if block_given?
+            yield result_hash
+          else
+            results << result_hash
+          end
+        end
+        results unless block_given?
+      end 
+
+    end
+
+
+    # Scan the model with
+    # @param [Scan::Criteria] criteria - the criteria to scan
+    # @yield the item
+    def scan_model(criteria=nil)
+      #    binding.pry
+      criteria = criteria || create_scanner(:nullscanner)
+      scan_result = ole_run_scan(criteria)
+      return [] unless scan_result
+      #   binding.pry
+      scan_enum = ::Microstation::Enumerator.new(scan_result, app)
+      result =  []
+      if block_given?
+        scan_enum.each do |item|
+          yield item
+        end
+      else
+        scan_enum.each do |item|
+          result << item
+        end
+      end
+
+      return result unless block_given?
+    end
+
+
+    private
+
+    def ole_run_scan(criteria)
+      criteria.resolve
+      scan_result = self.ole_obj.Scan(criteria.ole_obj) rescue nil
+    end
+
+
+  end
+
+end

data/lib/microstation/ole_cad_input_message.rb

@@ -0,0 +1,101 @@
+module Microstation
+
+
+  module InputType
+
+    Command = 1
+    Reset = 2
+    DataPoint = 3
+    Keyin = 4
+    Any = 5
+    Unassigned = 6
+
+  end
+
+
+  class OLE_CadInputMessage
+
+     include WIN32OLE::VARIANT
+    attr_reader :lastargs,:ole_obj, :app
+
+
+    def initialize(ole,app)
+      @ole_obj = ole
+      @app = app
+    end
+
+    def reset?
+      input_type == InputType::Reset
+    end
+
+    def command?
+      input_type == InputType::Command
+    end
+
+    def data_point?
+      input_type == InputType::DataPoint
+    end
+
+    def key_in?
+      input_type == InputType::Keyin
+    end
+
+    def any?
+      input_type == InputType::Any
+    end
+
+    def unassigned?
+      input_type == InputType::Unassigned
+    end
+
+    def input_type
+      @input_type ||= get_input_type
+    end
+
+    # MsdCadInputType InputType
+    def get_input_type()
+      ole_obj.InputType
+    end
+
+    # BSTR Keyin
+    def get_keyin()
+      ret = ole_obj._getproperty(1610743809, [], [])
+      @lastargs = WIN32OLE::ARGV
+      ret
+    end
+
+    # Point3d Point
+    def get_point()
+      app.to_point3d(ole_obj.Point)
+    end
+
+    # BSTR CommandKeyin
+    def get_command_keyin()
+      ret = ole_obj._getproperty(1610743811, [], [])
+      @lastargs = WIN32OLE::ARGV
+      ret
+    end
+
+    # _View View
+    def get_view()
+      ret = ole_obj._getproperty(1610743812, [], [])
+      @lastargs = WIN32OLE::ARGV
+      ret
+    end
+
+    # Point3d ScreenPoint
+    def get_screen_point()
+      ret = ole_obj._getproperty(1610743813, [], [])
+      @lastargs = WIN32OLE::ARGV
+      ret
+    end
+
+    # I4 CursorButton
+    def get_cursor_button()
+      ret = ole_obj._getproperty(1610743814, [], [])
+      @lastargs = WIN32OLE::ARGV
+      ret
+    end
+  end
+
+end

data/lib/microstation/ole_helper.rb

@@ -0,0 +1,152 @@
+module OleHelper
+
+  def select_ole_type(name)
+    if name.class == String
+      name = Regexp.new(name)
+    end
+    reg = Regexp.new(name.source,Regexp::IGNORECASE)
+    typelib.ole_classes.select do |k|
+      reg =~ k.name
+    end
+  end
+
+  def select_ole_method(name)
+    if name.class == String
+      name = Regexp.new(name)
+    end
+    reg = Regexp.new(name.source,Regexp::IGNORECASE)
+    self.ole_methods.select do |k|
+      reg =~ k.name
+    end
+  end
+
+  def ole_classes
+    typelib.ole_classes
+  end
+
+  def create_ole_type(type)
+    WIN32OLE.new(type.guid)
+  end
+
+  def ole_classes_detail
+    s = String.new
+    ole_classes.sort_by{|k| k.ole_type}.each do |k|
+      s << "#{k.name}\n\n"
+      s << "Type: #{k.ole_type}\n"
+      s << "progid: #{k.progid}\n"
+      s << "quid: #{k.guid}\n"
+      s << "------------\n\n"
+    end
+    s
+  end
+
+
+  def ole_methods_detail
+    s = String.new
+    ole_methods.each do |m|
+      s << "Method #{m.name}\n\n"
+      s << "dispid: #{m.dispid}\n"
+      s << "Event? #{m.event?}\n"
+      s << "Event interface: #{m.event_interface}\n"
+      s << "invoke kind: #{m.invoke_kind}\n"
+      s << "return type: #{m.return_type_detail}\n"
+      s << "visible: #{m.visible?}\n"
+      s << "params...\n"
+      m.params.each do |p|
+        s << "Param Name: #{p.name}\n"
+        s << "Optional: #{p.optional?}\n"
+        s << "Output? #{p.output?}\n"
+        s << "Detail\n"
+        s << "#{p.ole_type_detail}"
+        s << "\n\n"
+      end
+      s << "------------\n\n"
+    end
+    s
+  end
+
+
+  def each_ole_type
+    return enum_for(:each_ole_type) unless block_given?
+    typelib.ole_classes.each do |t|
+      yield t
+    end
+  end
+
+  def get_ole_type(name)
+    if name.class == String
+      return ole_classes.find{|t| t.name == name}
+    end
+    reg = Regexp.new(name.source, Regexp::IGNORECASE)
+    ole_classes.find do |t|
+      t.name =~ name
+    end
+  end
+
+  def typelib
+    self.ole_typelib
+  end
+
+
+end
+
+
+class WIN32OLE
+
+  include OleHelper
+
+end
+
+
+  # def select_ole_type(name)
+    #   if name.class == String
+    #       name = Regexp.new(name)
+    #   end
+    #   reg = Regexp.new(name.source,Regexp::IGNORECASE)
+    #   typelib.ole_classes.select do |k|
+    #     reg =~ k.name
+    #   end
+    # end
+
+    # def select_ole_method(name)
+    #   if name.class == String
+    #     name = Regexp.new(name)
+    #   end
+    #   reg = Regexp.new(name.source,Regexp::IGNORECASE)
+    #   ole_obj.ole_methods.select do |k|
+    #     reg =~ k.name
+    #   end
+    # end
+
+    # def ole_classes
+    #   typelib.ole_classes
+    # end
+
+    # def create_ole_type(type)
+    #   WIN32OLE.new(type.guid)
+    # end
+
+    # def each_ole_type
+    #   return enum_for(:each_ole_type) unless block_given?
+    #   typelib.ole_classes.each do |t|
+    #     yield t
+    #   end
+    # end
+
+    # def get_ole_type(name)
+    #   if name.class == String
+    #     name = Regexp.new name
+    #   end
+    #   reg = Regexp.new(name.source, Regexp::IGNORECASE)
+    #   typelib.ole_classes.find do |t|
+    #     t.name =~ name
+    #   end
+    # end
+
+
+
+#    alias :find_ole_type :get_ole_type
+
+ # def typelib
+    #   ole_obj.ole_typelib
+    # end

data/lib/microstation/pdf_support.rb

@@ -1,40 +1,40 @@
-module Microstation
-
-
-  module PdfSupport
-
-    def pdf_name(output_dir=nil)
-      name = self.basename
-      dir = output_dir || self.dirname
-      pdfname = Pathname(name).ext('pdf')
-      (dir + pdfname).expand_path
-    end
-
-    def pdf_exists?(output_dir = nil)
-      pdf_name(output_dir).file?
-    end
-
-    def file_exists?(file)
-      file.file?
-    end
-
-    def needs_pdf?(output_dir=nil)
-      pdf_path = pdf_name(output_dir)
-      !file_exists?(pdf_path) || pdf_older?(pdf_path)
-    end
-
-    def pdf_older?(pdf)
-      self.mtime > pdf.mtime
-    end
-
-
-    def mtime
-      self.path.mtime
-    end
-
-
-  end
-
-
-end
-
+module Microstation
+
+
+  module PdfSupport
+
+    def pdf_name(output_dir=nil)
+      name = self.basename
+      dir = output_dir || self.dirname
+      pdfname = Pathname(name).ext('pdf')
+      (dir + pdfname).expand_path
+    end
+
+    def pdf_exists?(output_dir = nil)
+      pdf_name(output_dir).file?
+    end
+
+    def file_exists?(file)
+      file.file?
+    end
+
+    def needs_pdf?(output_dir=nil)
+      pdf_path = pdf_name(output_dir)
+      !file_exists?(pdf_path) || pdf_older?(pdf_path)
+    end
+
+    def pdf_older?(pdf)
+      self.mtime > pdf.mtime
+    end
+
+
+    def mtime
+      self.path.mtime
+    end
+
+
+  end
+
+
+end
+