microstation 0.4.1

data/lib/microstation/attributes.rb

@@ -0,0 +1,35 @@
+require 'virtus'
+
+module Microstation
+
+  module Attribute
+
+
+    class Base < Virtus::Attribute::Object
+
+      accept_options :is_hidden, :prompt, :readonly
+
+
+    end
+
+    class String < Base
+
+      primitive ::String
+
+    end
+
+    class Integer < Base
+    end
+
+    class Float < Base
+    end
+
+  end
+
+end
+
+
+
+
+
+

data/lib/microstation/cad_input_queue.rb

@@ -0,0 +1,25 @@
+module Microstation
+
+  
+  class CadInputQueue
+
+    def initialize(ole_obj)
+      @ole_obj = ole_obj
+    end
+
+    def <<(string)
+      send_keyin(string)
+    end
+
+    def send_keyin(string)
+      @ole_obj.SendKeyin(string)
+    end
+
+    def close
+      @ole_ojb = nil
+    end
+
+
+  end
+
+end

data/lib/microstation/configuration.rb

@@ -0,0 +1,57 @@
+module Microstation
+
+  class VariableDefined < ::StandardError
+    end
+
+  class Configuration
+
+    def initialize(app)
+      @app = app
+    end
+
+    def [](variable)
+      return nil unless exists? variable
+     value(variable)
+    end
+
+    def should_update?(key,options={force: false})
+      return true unless exists? key
+      force = options.fetch(:force){ false}
+      return !!force
+    end
+
+    def remove_variable(variable)
+      workspace.RemoveConfigurationVariable variable
+    end
+
+    def set(key,value,options = {})
+      raise Microstation::VariableDefined unless should_update?(key,options)
+      workspace.AddConfigurationVariable(key,value)
+    end
+
+
+    def []=(key,value)
+      set(key,value)
+     end
+
+    def value(variable)
+      workspace.ConfigurationVariableValue(variable)
+    end
+
+    def exists?(value)
+      workspace.IsConfigurationVariableDefined(value)
+    end
+
+    def expand(string)
+      workspace.ExpandConfigurationVariable(string)
+    end
+
+    private
+    def workspace
+      @app.active_workspace
+    end
+
+
+  end
+
+end

data/lib/microstation/dir.rb

@@ -0,0 +1,252 @@
+require_relative 'pdf_support'
+require 'fileutils'
+module Microstation
+
+  class Dir
+
+    include PdfSupport
+    include FileUtils::Verbose
+
+    attr_reader :dir, :relative_pdf_path
+
+    def initialize(dir,pdf_path=nil)
+      @dir = Pathname(dir).expand_path
+      @relative_pdf_path = set_relative_pdf_path(pdf_path)
+    end
+
+    def self.Dir(path)
+      case path
+      when Microstation::Dir
+        path
+      else
+        new(Pathname(path))
+      end
+    end
+
+    def ==(other)
+      self.dir == other.dir && self.relative_pdf_path == other.relative_pdf_path
+    end
+
+    def to_path
+      @dir.to_path
+    end
+
+    def path
+      @dir
+    end
+
+    def directory?
+      path.directory?
+    end
+
+    def exist?
+      path.exist?
+    end
+
+
+    def mkdir
+      @dir.mkdir
+    end
+
+    def mkpath
+      @dir.mkpath
+    end
+
+    def +(other)
+      self.class.new( self.path + other)
+    end
+
+
+    def copy(drawing,dir)
+      cp drawing, dir
+    end
+
+    def select_by_name( re)
+      re = Regexp.new(re)
+      drawing_files.select{|n| n.to_path =~ re}
+    end
+
+
+    def find_by_name(re)
+      re = Regexp.new(re)
+      drawing_files.find{|n| n.to_path =~ re}
+    end
+
+    def drawings
+      Pathname.glob(@dir + "*.d{gn,wg}")
+    end
+
+    def sort_by(&block)
+      @sort_by = block
+    end
+
+    def sort(array_of_files)
+      sort_lambda = @sort_by || lambda{|f| f.path.to_s}
+      array_of_files.sort_by(&sort_lambda)
+    end
+
+    def drawing_files
+      return @drawing_files if @drawing_files
+      set_drawing_files(drawings.map{|dwg| Microstation::Drawing::File.new(dwg)} )
+      @drawing_files
+    end
+
+    def set_drawing_files(dfiles)
+      @drawing_files = sort(dfiles)
+    end
+
+
+    def pdf_generation_complete?
+      drawing_files.all?{|d| not d.needs_pdf?}
+    end
+
+
+    def pdf_files(dir = pdf_dirname)
+      sort(drawing_files).map{|p| p.pdf_name(dir)}
+    end
+
+    def concat_pdfs(files)
+      Pdftk.concat(files)
+    end
+
+    def drawing_files_needing_pdf(dir = pdf_dirname)
+      drawing_files.select{|d| d.needs_pdf?(dir) }
+    end
+
+    def print_pdfs(dir = pdf_dirname)
+      with_drawing_files( drawing_files_needing_pdf) do |drawing|
+        drawing.save_as_pdf(:dir => dir)
+      end
+    end
+
+    def generate_pdfs(dir = pdf_dirname)
+      print_pdfs(dir)
+      concat_pdfs(pdf_files(dir), dir + "dir.combined.drawings.pdf")
+    end
+
+    def find_pdftk(dirs = nil)
+      require 'pdf_forms'
+      @pdftk = PdfForms.new('e:/tools/pdftk-1.44/bin/pdftk.exe')
+    end
+
+    def pdftk
+      @pdftk ||= find_pdftk(dirs= nil)
+    end
+
+
+    def concat_pdfs(files,name)
+      pdftk.cat(files,name.to_s)
+      puts "generated #{name}"
+    end
+
+
+
+    def get_meta_for_drawings
+      @drawing_files = nil
+      files = []
+      with_drawing_files( drawings) do |drawing|
+        files << Microstation::Drawing::File.from_drawing(drawing)
+      end
+      set_drawing_files(files)
+    end
+
+    def with_drawing_files(dwgs = drawing_files, &block)
+      Microstation.with_drawings(dwgs,&block)
+    end
+
+    def pdf_dirname
+      if relative_pdf_path.absolute?
+        relative_pdf_path
+      else
+        dir + relative_pdf_path
+      end
+    end
+
+    def set_relative_pdf_path(path)
+      rel_path = path.nil? ? "." : path
+      Pathname(rel_path)
+    end
+
+
+    def relative_pdf_path=(path)
+      @relative_pdf_path = set_relative_path(path)
+    end
+
+
+
+  end
+end
+
+module Microstation
+
+  class Drawing
+
+    class File
+
+      include PdfSupport
+
+      attr_reader :keywords, :creator, :path
+
+      def self.from_drawing(drawing)
+        file = new(drawing.path)
+        file.get_meta(drawing)
+        file
+      end
+
+      def to_path
+        @path.to_path
+      end
+
+
+      def initialize(path)
+        @path = Pathname(path)
+      end
+
+      def basename
+        @path.basename
+      end
+
+      def dirname
+        @path.dirname
+      end
+
+      def drawing=(drawing)
+        @drawing = drawing
+      end
+
+      def mtime
+        self.path.mtime
+      end
+
+      def title
+        @title ||= get_meta
+      end
+
+      def app_open_drawing(app, &block)
+        draw = app.open_drawing(self.path,&block)
+      end
+
+      def open_drawing(&block)
+        Microstation.open_drawing(self.path,&block)
+      end
+
+      def get_meta(dwg)
+        @title = dwg.title
+        @keywords = dwg.keywords
+        @creator = dwg.creator
+      end
+
+    end
+
+
+  end
+end
+
+
+
+
+
+
+
+
+

data/lib/microstation/drawing.rb

@@ -0,0 +1,189 @@
+require_relative 'properties'
+require 'pry'
+module Microstation
+
+  class Drawing
+
+    include Properties
+
+    attr_reader :app
+
+    def initialize(app, ole)
+      @app = app
+      @ole_obj = ole
+    end
+
+    def active?
+      @ole_obj.IsActive
+    end
+
+    def cad_input_queue(&block)
+      @app.cad_input_queue(&block)
+    end
+
+    def save_as_pdf(name = nil, dir = nil)
+      out_name = pdf_name(name,dir)
+      windows_name = app.windows_path(out_name)
+      cad_input_queue do |q|
+        q << "Print Driver #{pdf_driver}"
+        q << "Print Papername ANSI D"
+        q << "Print BOUNDARY FIT ALL"
+        q << "Print ATTRIBUTES BORDER OUTLINE OFF"
+        q << "Print Attributes Fenceboundary Off"
+        q << "Print Execute #{windows_name}"
+      end
+      puts "saved #{windows_name}"
+    end
+
+    def pdf_name_from_options(options = {})
+      name = options.fetch(:name){ basename.ext('.pdf')}
+      dir = options.fetch(:dir){ dirname}
+      (dir + name).expand_path
+    end
+
+    # alias_method :title, :title=
+
+    def create_scanner(&block)
+      app.create_scanner(&block)
+    end
+
+    def scan(scanner = nil,&block)
+      app.scan(scanner,&block)
+    end
+
+    def scan_graphical(&block)
+      sc = create_scanner
+      sc.ExcludeNonGraphical
+      app.scan(sc,&block)
+    end
+
+    def scan_text(&block)
+      sc = create_scanner do
+        include_textual
+      end
+      app.scan(sc,&block)
+    end
+
+    def scan_tags(&block)
+      sc = create_scanner do
+        include_tags
+      end
+      app.scan(sc,&block)
+    end
+
+    def modified_date
+      @ole_obj.DateLastSaved
+    end
+    #  alias_method :keywords , :keywords=x
+
+    def dimensions
+      eval_cexpression("tcb->ndices")
+    end
+
+    # def fullname
+    #   @ole_obj.FullName
+    # end
+
+    def two_d?
+      dimensions == 2
+    end
+
+    def three_d?
+      dimensions == 3
+    end
+
+    def name
+      @ole_obj.Name
+    end
+
+    def basename
+      Pathname(name)
+    end
+
+    def dirname
+      Pathname(@ole_obj.Path).expand_path
+    end
+
+    def path
+      dirname + basename
+    end
+
+    def revision_count
+      @ole_obj.DesignRevisionCount
+    end
+
+    def eval_cexpression(string)
+      app.eval_cexpression(string)
+    end
+
+    def close
+      @ole_obj.Close
+    end
+
+    def ole_obj
+      @ole_obj
+    end
+
+    def pdf_name(lname = nil,dir=nil)
+      dname = lname ? Pathname(lname) : Pathname(self.basename)
+      pdfname = dname.ext('.pdf')
+      dirname = dir ? Pathname(dir) : Pathname(self.dirname)
+      pdfname = (dirname + pdfname).expand_path
+    end
+
+    def pdf_driver
+      app.windows_path( (Microstation.plot_driver_directory + "pdf-bw.plt").to_s)
+    end
+
+    def tagset_names
+      tagsets.map{|ts| ts.name}
+    end
+
+    def tagsets
+      @tagsets = TagSets.new(ole_obj_tagsets)
+    end
+
+    def create_tagset(name,&block)
+      ts = tagsets.create(name)
+      block.call ts if block
+      ts
+    end
+
+    def create_tagset!(name,&block)
+      remove_tagset(name)
+      create_tagset(name,&block)
+    end
+
+    def remove_tagset(name)
+      tagsets.remove(name)
+    end
+
+    def find_tagset(name)
+      ts = tagsets[name]
+      ts.create_instances(scan_tags)
+    end
+
+    protected
+    def ole_obj_tagsets
+      @ole_obj.TagSets
+    end
+
+    def ensure_tags(tags)
+      tags.map{|t| t.class == WIN32OLE ? app.wrap(t) : t }
+    end
+
+    # def create_tagset_instances(name,groups)
+    #   ts = tagsets[name]
+    #   ts.add_instance(group) if ts
+    # end
+
+    def save
+      @ole_obj.Save
+    end
+
+
+
+
+  end
+
+end