microstation 0.4.1

data/lib/microstation/scan/subtype.rb

@@ -0,0 +1,40 @@
+module Microstation
+
+  module Scan
+
+    module Subtype
+
+      def subtype_inclusions
+        @subtype_inclusions ||= []
+      end
+
+      def include_subtype(subtype)
+        subtype_inclusions << subtype
+      end
+
+      def reset_subtypes
+        reset_ole_subtypes
+        @subtype_inclusions = []
+      end
+
+      def reset_ole_subtypes
+        ole_obj.ExcludeAllSubtypes
+      end
+
+      def resolve_subtype_scans
+        return unless subtype_inclusions.size > 0
+        reset_ole_subtypes
+        subtype_inclusions.each do |subtype|
+          ole_obj.IncludeSubtype(subtype)
+        end
+      end
+
+    end
+
+  end
+
+end
+
+
+      
+      

data/lib/microstation/scan/type.rb

@@ -0,0 +1,109 @@
+module Microstation
+
+  module Scan
+
+    module Type
+
+      # MsdElementTypeCellLibraryHeader
+      # MsdElementTypeCellHeader
+      # MsdElementTypeLine
+      # MsdElementTypeLineString
+      # MsdElementTypeGroupData
+      # MsdElementTypeShape
+      # MsdElementTypeTextNode
+      # MsdElementTypeDigSetData
+      # MsdElementTypeDesignFileHeader
+      # MsdElementTypeLevelSymbology
+      # MsdElementTypeCurve
+      # MsdElementTypeComplexString
+      # MsdElementTypeConic
+      # MsdElementTypeComplexShape
+      # MsdElementTypeEllipse
+      # MsdElementTypeArc
+      # MsdElementTypeText
+      # MsdElementTypeSurface
+      # MsdElementTypeSolid
+      # MsdElementTypeBsplinePole
+      # MsdElementTypePointString
+      # MsdElementTypeCone
+      # MsdElementTypeBsplineSurface
+      # MsdElementTypeBsplineBoundary
+      # MsdElementTypeBsplineKnot
+      # MsdElementTypeBsplineCurve
+      # MsdElementTypeBsplineWeight
+      # MsdElementTypeDimension
+      # MsdElementTypeSharedCellDefinition
+      # MsdElementTypeSharedCell
+      # MsdElementTypeMultiLine
+      # MsdElementTypeTag
+      # MsdElementTypeDgnStoreComponent
+      # MsdElementTypeDgnStoreHeader
+      # MsdElementType44
+      # MsdElementTypeMicroStation
+      # MsdElementTypeRasterHeader
+      # MsdElementTypeRasterComponent
+      # MsdElementTypeRasterReference
+      # MsdElementTypeRasterReferenceComponent
+      # MsdElementTypeRasterFrame
+      # MsdElementTypeTableEntry
+      # MsdElementTypeTable
+      # MsdElementTypeViewGroup
+      # MsdElementTypeView
+      # MsdElementTypeLevelMask
+      # MsdElementTypeReferenceAttachment
+      # MsdElementTypeMatrixHeader
+      # MsdElementTypeMatrixIntegerData
+      # MsdElementTypeMatrixDoubleData
+      # MsdElementTypeMeshHeader
+      # MsdElementTypeReferenceOverride
+      # MsdElementTypeNamedGroupHeader
+      # MsdElementTypeNamedGroupComponent
+
+      def type_inclusions
+        @type_inclusions ||= []
+      end
+
+      def reset_types
+        reset_ole_types
+        @type_inclusions = []
+      end
+
+      def reset_ole_types
+        ole_obj.ExcludeAllTypes
+      end
+
+      def include_type(type)
+        type_inclusions << type
+      end
+
+      def resolve_type_scans
+        return unless type_inclusions.size > 0
+        reset_ole_types
+        type_inclusions.each do |type|
+          ole_obj.IncludeType(type)
+        end
+      end
+
+      def include_text
+        self.include_type(Microstation::MSD::MsdElementTypeText)
+      end
+
+      def include_tags
+        self.include_type Microstation::MSD::MsdElementTypeTag
+      end
+
+      def include_text_nodes
+        self.include_type Microstation::MSD::MsdElementTypeTextNode
+      end
+
+      def include_textual
+        include_text
+        include_text_nodes
+      end
+
+
+    end
+
+  end
+
+end

data/lib/microstation/scanner.rb

@@ -0,0 +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

data/lib/microstation/tag.rb

@@ -0,0 +1,58 @@
+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
+

data/lib/microstation/tag_set.rb

@@ -0,0 +1,280 @@
+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