microstation 0.4.1 → 0.8.3

data/lib/microstation/scan_trait.rb

@@ -0,0 +1,62 @@
+require_relative 'criteria_creation_t'
+module Microstation
+
+  module ScanTrait
+
+     def create_scanner(name,&block)
+      app.create_scanner(name, &block)
+    end
+
+    def text_criteria
+      app.scanners[:textual] || app.create_scanner(:textual){ include_textual}
+    end
+
+    def graphics_criteria
+      app.scanners[:graphical] || app.create_scanner(:graphical){ ExcludeNonGraphical}
+    end
+
+    def tags_criteria
+      app.scanners[:tags] || app.create_scanner(:tags){ include_tags}
+    end
+
+    def cells_criteria
+      app.scanners[:cells] || app.create_scanner(:cells){ include_cells}
+    end
+
+    def lines_criteria
+      app.scanners[:lines] || app.create_scanner(:lines){ include_lines}
+    end
+
+    def scan_graphical(&block)
+      self.scan_model(graphic_criteria, &block)
+    end
+
+    def scan_text(&block)
+      self.scan_model(text_criteria,&block)
+    end
+
+    def scan_tags(&block)
+      self.scan_model(tags_criteria,&block)
+    end
+
+    def scan_cells(&block)
+      self.scan_model(cells_criteria,&block)
+    end
+
+    def scan_lines(&block)
+      self.scan_model(lines_criteria, &block)
+    end
+
+
+    def scan_cell_with_name(name, &block)
+      sc = create_scanner
+      sc.IncludeOnlyCell(name)
+      sc.include_cell
+      self.scan_model(sc,&block)
+    end
+
+
+
+  end
+
+end

data/lib/microstation/scanner.rb

@@ -1,24 +1,24 @@
-module Microstation
-
-
-  class Scanner
-
-    attr_reader :app
-
-    def initialize(app)
-      @app = app
-      @ole_obj = @app.create_ole_scanner
-    end
-
-    private
-
-    def ole_obj
-      @ole_obj
-    end
-    
-    
-
-  end
-
-
-end
+module Microstation
+
+
+  class Scanner
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+      @ole_obj = @app.create_ole_scanner
+    end
+
+    private
+
+    def ole_obj
+      @ole_obj
+    end
+    
+    
+
+  end
+
+
+end

data/lib/microstation/tag.rb

@@ -1,58 +1,87 @@
-module Microstation
-
-  class Tag < Element
-
-    def initialize(ole)
-      @ole_obj = ole
-      @original = @ole_obj.Value
-    end
-
-    def ole_value
-      @ole_obj.Value
-    end
-
-    def name
-      @ole_obj.TagDefinitionName
-    end
-
-    def to_s
-      "#{name}: #{value} ts ->#{tagset_name}"
-    end
-
-    def value
-      @original
-    end
-
-    def tagset
-      @ole_obj.TagSetName
-    end
-
-    def tagset_name
-      @ole_obj.TagSetName
-    end
-
-    def update_ole(value)
-      value = value.nil? ? "" : value
-      @ole_obj.Value = value
-    end
-
-    def base_element=(ele)
-      @base_element = ele
-    end
-
-    def ole_base_element
-      @ole_obj.BaseElement
-    end
-
-    def base_element_id
-      ole_base_element.ID64
-    end
-
-    def base_element
-      @base_element ||= TaggedElement.new(ole_base_element)
-    end
-
-  end
-
-end
-
+require_relative 'tagged_element'
+
+
+
+module Microstation
+
+  class Tag < Element
+
+    # def initialize(ole)
+    #   @ole_obj = ole
+    #   @original = @ole_obj.Value
+    # end
+
+    def read_ole(ole)
+      ole.Value
+    end
+
+    def write_ole(value)
+      value = value.nil? ? "" : value
+      ole_obj.Value = value
+    end
+
+
+    def ole_value
+      @ole_obj.Value
+    end
+
+    def name
+      @ole_obj.TagDefinitionName
+    end
+
+    
+    def inspect
+      "#{name}: #{value} ts ->#{tagset_name}"
+    end
+
+    def to_s
+      "#{value}"
+    end
+
+    def value
+      @original
+    end
+
+    def tagset
+      @ole_obj.TagSetName
+    end
+
+    def tagset_name
+      @ole_obj.TagSetName
+    end
+
+    def update_ole(value)
+      value = value.nil? ? "" : value
+      @ole_obj.Value = value
+    end
+
+    def base_element=(ele)
+      @base_element = ele
+    end
+
+    def ole_base_element
+      @ole_obj.BaseElement
+    end
+
+    def base_element_id
+      base = ole_base_element
+      id = base.Id || base.ID64 rescue nil
+      if id.class == WIN32OLE_RECORD
+        if id.Low > id.High
+          return id.Low
+        else
+          return id.High
+        end
+      end
+      id
+    end
+
+    def base_element
+      @base_element ||= TaggedElement.new(ole_base_element)
+    end
+
+  end
+
+
+
+end

data/lib/microstation/tag_set.rb

@@ -1,280 +1,385 @@
-require File.join(File.dirname(__FILE__) , 'attributes')
-require File.join(File.dirname(__FILE__), 'ts/instance')
-require File.join(File.dirname(__FILE__), 'ts/attribute')
-module Microstation
-
-  class TagSets
-    include Enumerable
-
-    def initialize(ole)
-      @ole_obj = ole
-    end
-
-    def init_ts
-      result = []
-      @ole_obj.each do |ts|
-        result << TagSet.new(ts)
-      end
-      result
-    end
-
-    def to_s
-      "Tagsets: #{tagsets.to_s}"
-    end
-
-    def reset
-      @tagsets = nil
-    end
-
-    def tagsets
-      @tagsets ||= init_ts
-    end
-
-    def each
-      tagsets.each do |obj|
-        yield obj
-      end
-    end
-
-    def find(name)
-      return nil if empty?
-      tagsets.find{|ts| ts.name == name}
-    end
-
-    def last
-      tagsets[-1]
-    end
-
-    def [](name)
-      find(name)
-    end
-
-    def remove(name)
-      ts = find(name)
-      if ts
-        @ole_obj.Remove(name) rescue nil
-        ts.close
-        ts = nil
-      end
-      @tagsets = init_ts
-    end
-
-    def empty?
-      tagsets.empty?
-    end
-
-    def create(name)
-      raise if self[name]
-      ole = @ole_obj.add(name)
-      definer = Definer.new(ole)
-      yield definer if block_given?
-      @tagsets = init_ts
-      ts = self[name]
-      raise if ts.nil?
-      definer = nil
-      ts
-    end
-
-    def size
-      tagsets.size
-    end
-
-  end
-
-  class Definer
-
-    attr_reader :tagset
-
-    def initialize(tagset)
-      @tagset = tagset
-    end
-
-
-    def add_attribute(name,type,options = {})
-      ole_td = create_ole_definition(name, type)
-      td = TS::Attribute.new(ole_td)
-      td.prompt = options[:prompt] || name
-      td.hidden = options[:is_hidden]
-      td.constant = options[:is_constant] || false
-      td.default = options[:default] if options[:default]
-      #td.hidden = td.fetch(:is_hidden)
-      yield td if block_given?
-      td
-    end
-
-    private
-
-    def tag_definitions
-      tagset.ole_tag_definitions
-    end
-
-    def close
-
-    end
-
-    def ole_type(type)
-      TS::Attribute.tag_type(type)
-    end
-
-    def create_ole_definition(name,type)
-      tag_definitions.Add(name,ole_type(type))
-    end
-
-  end
-
-  class Definition
-
-    attr_reader :tagset
-
-    def initialize(tagset)
-      @tagset = tagset
-    end
-
-    def add_attribute(name,type,options={})
-      td = definer.add_attribute(name,type,options)
-      reset
-      td
-    end
-
-    def definer
-      @definer ||= Definer.new(tagset)
-    end
-
-    def ole_tag_definitions
-      tagset.ole_tag_definitions
-    end
-
-    def init_definitions
-      results = []
-      ole_tag_definitions.each do |ole|
-        results << TS::Attribute.new(ole, {definer: self})
-      end
-      results
-    end
-
-    def attributes
-      @attributes ||= init_definitions
-    end
-
-    def attribute_names
-      attributes.map{|a| a.name}
-    end
-
-    def reset
-      @attributes = nil
-    end
-
-    def close
-      attributes.each{| a| a.close}
-    end
-
-    def [](name)
-      attributes.find{|d| d.name == name}
-    end
-
-  end
-
-  class TagSet
-
-    attr_reader :ole_obj
-
-    def initialize(ole)
-      @ole_obj = ole
-      @instances = []
-    end
-
-    def instances
-      Microstation.app.current_drawing.find_tagset_instances(self.name)
-    end
-
-
-    def add_attribute(name,type,options={})
-      definition.add_attribute(name,type,options)
-    end
-
-    def definer
-      @definer ||= Definer.new(self)
-    end
-
-    def ole_tag_definitions
-      @ole_obj.TagDefinitions
-    end
-
-
-
-    # def ole_tag_definitions
-    #   @tag_definitions = @ole_obj.TagDefinitions
-    # end
-
-    def reset
-      @tag_definitions = nil
-    end
-
-    def add_instance(array)
-      @instances << TS::Instance.new(self,array)
-    end
-
-    def create_instance(group)
-      TS::Instance.new(self,group)
-    end
-
-    def instances(drawing = Microstation.app.current_drawing)
-      @instances = create_instances(drawing.scan_tags)
-    end
-
-    def create_instances(tags)
-      mytags = tags_for_self(tags)
-      grouped = grouped_tags_to_host(mytags)
-      grouped.map{|group| create_instance(group)}
-    end
-
-    def tags_for_self(tags)
-      tags.select{|t| t.tagset_name == name}
-    end
-
-    def grouped_tags_to_host(tags)
-      tags.group_by{|t| t.base_element_id}.values
-    end
-
-
-    def all_tags_in_drawing
-      Microstation.app.current_drawing.scan_tags
-    end
-
-
-    def definition
-      @definition ||= Definition.new(self)
-    end
-
-    def close
-      @ole_obj = nil
-    end
-
-
-    def name
-      @ole_obj.name
-    end
-
-    def to_s
-      "TagSet: #{name}"
-    end
-
-    def ==(other)
-      @ole_obj == other.ole_obj
-    end
-
-    def attribute_names
-      definition.attribute_names
-    end
-
-    def attributes
-      definition.attributes
-    end
-
-    def [](name)
-      definition[name]
-    end
-
-  end
-
-end
+#require File.join(File.dirname(__FILE__) , 'attributes')
+require File.join(File.dirname(__FILE__), 'ts/instance')
+require File.join(File.dirname(__FILE__), 'ts/attribute')
+
+module Microstation
+
+  module OleCollection
+
+    def initialize(ole_col)
+      @ole_obj = ole
+    end
+
+    def [](name)
+      ole_obj(name) rescue nil
+    end
+
+    def each
+      @ole_obj.each do |ts|
+        yield wrap(ts)
+      end
+    end
+
+    def wrap(ts)
+      ts
+    end
+
+  end
+
+
+  class TagSets
+    include Enumerable
+
+    attr_reader :drawing, :ole_obj
+
+    def initialize(drawing,ole)
+      raise if ole == nil
+      @drawing = drawing
+      @ole_obj = ole
+    end
+
+    def init_ts
+      result = []
+      @ole_obj.each do |ts|
+        result << TagSet.new(drawing,ts)
+      end
+      result
+    end
+
+    def to_s
+      "Tagsets: #{tagsets.to_s}"
+    end
+
+    def reset
+      @tagsets = nil
+      @drawing.reset_tagset_instances
+    end
+
+    def names
+      self.map{|ts| ts.name}
+    end
+
+
+    def tagsets
+      @tagsets ||= init_ts
+    end
+
+    def each
+      tagsets.each do |obj|
+        yield obj
+      end
+    end
+
+    def find(name)
+      return nil if empty?
+      tagsets.detect{|ts| ts.name == name}
+    end
+
+    def last
+      tagsets[-1]
+    end
+
+    def [](name)
+      find(name)
+    end
+
+    def remove(name)
+      ts = find(name)
+      if ts
+        @ole_obj.Remove(name) rescue nil
+        ts.close
+        ts = nil
+      end
+      reset
+    end
+
+    def empty?
+      tagsets.empty?
+    end
+
+    def create(name)
+      raise if self[name]
+     
+      ole = @ole_obj.add(name) rescue binding.pry
+     # ts = Tagset.new(ole)
+      # yield definer if block_given?
+      reset
+      ts = self[name]
+      raise if ts.nil?
+      yield ts if block_given?
+      ts
+    end
+
+    def size
+      tagsets.size
+    end
+
+  end
+
+  # class Definer
+
+  #   attr_reader :tagset
+
+  #   def initialize(tagset)
+  #     @tagset = tagset
+  #   end
+
+
+  #   def add_attribute(name,type,prompt: name, is_hidden: false, is_constant: false, default: nil)
+  #     ole_td = create_ole_definition(name, type)
+  #     td = TS::Attribute.new(ole_td)
+  #     td.prompt = prompt
+  #     td.hidden = is_hidden
+  #     td.constant = is_constant
+  #     td.default = default
+  #     #td.hidden = td.fetch(:is_hidden)
+  #     yield td if block_given?
+  #     td
+  #   end
+
+  #   private
+
+  #   def tag_definitions
+  #     tagset.ole_tag_definitions
+  #   end
+
+  #   def close
+
+  #   end
+
+  #   def ole_type(type)
+  #     TS::Attribute.tag_type(type)
+  #   end
+
+  #   def create_ole_definition(name,type)
+  #     tag_definitions.Add(name,ole_type(type))
+  #   end
+
+  # end
+
+
+
+  class Definition
+
+    attr_reader :tagset
+
+    def initialize(tagset)
+      @tagset = tagset
+    end
+
+    def add_attribute(*args, **kwargs)
+      td = create_attribute(*args, **kwargs)
+      yield td if block_given?
+      reset
+      td
+    end
+
+    # def definer
+    #   @definer ||= Definer.new(tagset)
+    # end
+
+
+    def attributes
+      @attributes ||= init_definitions
+    end
+
+    def attribute_names
+      attributes.map{|a| a.name}
+    end
+
+    def reset
+      @attributes = nil
+    end
+
+    def close
+      attributes.each{| a| a.close}
+    end
+
+    def [](name)
+      attributes.find{|d| d.name == name}
+    end
+
+    protected
+
+    # def ole_tag_definitions
+    #   tagset.ole_tag_definitions
+    # end
+
+    def ole_tag_definitions
+      @tagset.ole_obj.TagDefinitions
+    end
+
+    def create_ole_definition(name,type)
+      ole_tag_definitions.Add(name,ole_type(type))
+    end
+
+    def init_definitions
+      results = []
+      ole_tag_definitions.each do |ole|
+        results << TS::Attribute.new(ole, {definer: self})
+      end
+      results
+    end
+
+    def create_attribute(name,type,prompt: name, is_hidden: false, is_constant: false, default: nil)
+      ole_td = create_ole_definition(name, type)
+      td = TS::Attribute.new(ole_td)
+      td.prompt = prompt
+      td.hidden = is_hidden
+      td.constant = is_constant
+      td.default = default
+      yield td if block_given?
+      td
+    end
+
+    def ole_type(type)
+      TS::Attribute.tag_type(type)
+    end
+
+  end
+
+  class TagSet
+
+    attr_reader :ole_obj
+
+    attr_reader :instances, :drawing
+
+    def initialize(drawing,ole)
+      @drawing = drawing
+      @ole_obj = ole
+      @instances = nil
+    end
+
+    def add_attribute(name,type,**options, &block)
+      ts = definition.add_attribute(name,type,**options, &block)
+    end
+
+    # def definer
+    #   @definer ||= Definer.new(self)
+    # end
+
+
+  
+    def add_instance(array)
+      @instances << TS::Instance.new(self,array)
+    end
+
+    def create_instance(base_element_id , tags , model )
+      if @instaces.nil?
+        @instance = []
+        ti = TS::Instances.new(self, base_element_id, tags, model)
+        @instances << ti
+        ti
+     end 
+    end
+
+    def create_instance(id, elements, model)
+      if @instances.nil?
+        @instances = []
+      end
+      ti = TS::Instance.new(self,id,elements,model)
+      @instances << ti
+      ti
+    end
+
+    # def instances(drawing = Microstation.app.current_drawing)
+    #   @instances = create_instances(drawing.scan_tags)
+    # end
+
+    # def find_instances_in_model(model)
+    #   result = create_instances(model.scan_tags)
+    #   instances[model.name] = result
+    #   result
+    # end
+
+    def instances
+      if @instances.nil? && find_tagset_instances_not_called?
+        @instances = @drawing.create_tagset_instances( ts_name: name).to_a
+      end
+      raise if find_tagset_instances_not_called?
+      @instances.nil? ? [] : @instances
+    end
+
+
+
+
+    # def create_instances_from_drawing(drawing)
+    #   mytags = tags_for_self(tags)
+    #   grouped = grouped_tags_to_host(mytags)
+    #   grouped.map{|group| create_instance(group)}
+    # end
+
+    # def all_tags_in_drawing
+    #   Microstation.app.current_drawing.scan_tags
+    # end
+
+
+    def close
+      @ole_obj = nil
+    end
+
+    def name
+      @ole_obj.name
+    end
+
+    def to_s
+      "TagSet: #{name}"
+    end
+
+    def ==(other)
+      @ole_obj == other.ole_obj
+    end
+
+    def attribute_names
+      definition.attribute_names
+    end
+
+    def attributes
+      definition.attributes
+    end
+
+    def [](name)
+      definition[name]
+    end
+
+    protected
+
+    def definition
+      @definition ||= Definition.new(self)
+    end
+
+    def reset
+      @tag_definitions = nil
+    end
+
+
+    def find_tagset_instances_not_called?
+      !drawing.find_tagset_instances_called?
+    end
+
+
+    # def create_ole_definition(name,type)
+    #   ole_tag_definitions.Add(name, ole_type(type))
+    # end
+
+    private
+
+    # protected
+
+    # def tags_for_self(tags)
+    #   tags.select{|t| t.tagset_name == name}
+    # end
+
+    # def grouped_tags_to_host(tags)
+    #   tags.group_by{|t| t.base_element_id}
+    # end
+
+    # def ole_tag_definitions
+    #   @ole_obj.TagDefinitions
+    # end
+    
+
+
+  end
+
+end