robust_excel_ole 0.3.6 → 0.3.7

data/Changelog

@@ -1,7 +1,7 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [0.3.6] - 2015-10-25
+## [0.3.6] - 2015-10-27
 
 ### Added
 - Excel#recreate: reopening a closed Excel
@@ -15,7 +15,6 @@ All notable changes to this project will be documented in this file.
 - Method missing: error messages for dead objects
 - trace to stdout or file
 
-
 ### Changed
 
 ## [0.3.5] - 2015-08-13

data/README.rdoc

@@ -43,6 +43,8 @@ Options are
   +:default_excel+, +:force_excel+, +:if_absent+, +:if_unsaved+, +:if_obstructed+, 
   +:read_only+, +:visible+, +:displayalerts+. 
 
+Values for +:default_excel+ are +:reuse+, +:new+ or some Excel instance. Values for +:force_excel+ are +:new+ or some Excel instance. Values for +:if_unsaved+ are +:raise+, +:accept+, +:forget+, +:alert+ and +:new_excel+. Values for +:if_obstructed+ are +:raise+, +:save+, +:close_if_saved+, +:forget+, +:alert+ and +:new_excel+. Values for +:if_absent+ are +:raise+ and +:create+.
+
 Here are a few examples:
 
 Opening a workbook in the Excel instance where it was opened before, or opening the workbook in a new Excel instance if it was not opened before.
@@ -62,11 +64,13 @@ If a workbook is open and a workbook with the same name but in different path sh
 
   book = Book.open('path/workbook.xls', :if_obstructed => :forget)
 
+Opening linked workbooks for EXCEL 2007 is supported
+
 === Closing a workbook.
 
   book.close
 
-There is one option: : +:if_unsaved+. Example:
+There is one option: : +:if_unsaved+. Values for this option are +:raise+, +:save+, +:forget+, +:alert+ and +:keep_open+. Example:
 
 Closing the workbook and saving it before if it has unsaved changes.
 
@@ -89,7 +93,7 @@ An Excel file (or workbook) is represented by a Book object. A Book object is de
 Identity transparence means that the same Book objects refer to the same Excel files, and vice versa.
 In other words, a Book objects is a proxy of an Excel file.
 
-=== Uplifting a workbook to a Book object
+=== Lifting a workbook to a Book object
 
 A Book object can be created when giving an Excel workbook.
 
@@ -324,7 +328,7 @@ Reusing a running Excel instance, making it visible and turning on displayalerts
 
   excel2 = Excel.new(:reuse => true, :visible => true, :displayalerts => true).
 
-Uplifting an Excel instance represented as WIN32OLE object to an Excel object
+Lifting an Excel instance represented as WIN32OLE object to an Excel object
 
   excel = Excel.new(:reuse => win32ole_object)
 
@@ -362,17 +366,21 @@ Turning on and off in a block.
   excel = Excel.current
   excel.close
 
-Closing the Excel instance and terminating the Excel process
+The options are +:if_unsaved+ and +:hard+ . Example:
 
-  excel.close(:hard => true)
+Closing the Excel instance, saving unsaved wrkbooks and terminating the Excel process
+
+  excel.close(:if_unsaved => :save, :hard => true)
 
 === Closing all Excel instances.
 
   Excel.close_all
 
- Closing the Excel instances and terminating the Excel processes
+The options are +:if_unsaved+ and +:hard+ . Values for :if_unsaved+ are +raise+, +save+, +forget+. Example:
+
+Closing all Excel instances, not saving unsaved workbooks and terminating the Excel processes
 
-  Excel.close_all(:hard => true) 
+  Excel.close_all(:if_unsaved => :forget, :hard => :true) 
 
 === Terminating all Excel processes
 
@@ -385,9 +393,9 @@ Reopening the closed Excel instance. This includes reopening all workbooks that
   excel.close
   excel.recreate
 
-Options are :visible and :displayalerts
+The options are :reopen_workbooks, :visible and :displayalerts.
 
-  excel.recreate(:visible => true, :displayalerts => true)
+  excel.recreate(:reopen_workbooks => true, :visible => true, :displayalerts => true)
 
 === Providing Excel instances
 

data/lib/robust_excel_ole.rb

@@ -28,7 +28,7 @@ module RobustExcelOle
     else
       if REO_LOG_DIR.empty?
         homes = ["HOME", "HOMEPATH"]
-        home = homes.detect {|h| ENV[h] != nil}
+        home = homes.find {|h| ENV[h] != nil}
         reo_log_dir = ENV[home]
       else
         reo_log_dir = REO_LOG_DIR
@@ -69,7 +69,9 @@ class Object      # :nodoc: #
   def excel
     raise ExcelError, "receiver instance is neither an Excel nor a Book"
   end
+end
 
+class WIN32OLE
 end
 
 class ::String    # :nodoc: #

data/lib/robust_excel_ole/book.rb

@@ -5,6 +5,7 @@ require 'weakref'
 module RobustExcelOle
 
   class Book
+
     attr_accessor :excel
     attr_accessor :workbook
     attr_accessor :stored_filename
@@ -67,9 +68,9 @@ module RobustExcelOle
           # if readonly is true, then prefer a book that is given in force_excel if this option is set
           book = bookstore.fetch(file, 
                   :prefer_writable => (not options[:read_only]), 
-                  :prefer_excel    => (options[:read_only] ? options[:force_excel].excel : nil)) rescue nil
+                  :prefer_excel    => (options[:read_only] ? excel_of(options[:force_excel]) : nil)) rescue nil
           if book
-            if (((not options[:force_excel]) || (options[:force_excel].excel == book.excel)) &&
+            if (((not options[:force_excel]) || (excel_of(options[:force_excel]) == book.excel)) &&
                  (not (book.alive? && (not book.saved) && (not options[:if_unsaved] == :accept))))
               book.options = DEFAULT_OPEN_OPTS.merge(opts)
               book.ensure_excel(options) unless book.excel.alive?
@@ -81,18 +82,23 @@ module RobustExcelOle
             end
           end
         end
-        #options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
         new(file, options, &block)
       end
     end    
 
     # creates a Book object for a given workbook or file name
+    # @param [WIN32OLE] workbook a workbook
+    # @options opts [Symbol] see above
+    # @return [Book] a Book object
     def self.new(workbook, opts={ }, &block)      
-      if workbook && workbook.class == WIN32OLE
+      if workbook && (workbook.is_a? WIN32OLE)
         filename = workbook.Fullname.tr('\\','/') rescue nil
         if filename
           book = bookstore.fetch(filename)
-          return book if book && book.alive?
+          if book && book.alive?
+            book.apply_options(opts)
+            return book 
+          end
         end
       end
       super
@@ -103,16 +109,15 @@ module RobustExcelOle
     def initialize(file_or_workbook, opts={ }, &block)
       options = DEFAULT_OPEN_OPTS.merge(opts)
       options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
-      if file_or_workbook.class == WIN32OLE
+      if file_or_workbook.is_a? WIN32OLE
         workbook = file_or_workbook
         @workbook = workbook        
         # use the Excel instance where the workbook is opened
         win32ole_excel = WIN32OLE.connect(workbook.Fullname).Application rescue nil   
-        options = {:reuse => win32ole_excel}.merge(options)
-        @excel = Excel.new(options)     
+        @excel = excel_class.new(win32ole_excel)     
+        self.apply_options(options)       
         # if the Excel could not be lifted up, then create it         
-        ensure_excel(options) unless (@excel && @excel.alive?)
-        t "@excel: #{@excel}"
+        ensure_excel(options)
       else
         file = file_or_workbook
         ensure_excel(options)
@@ -128,7 +133,35 @@ module RobustExcelOle
       end
     end
 
+    def apply_options(options) # :nodoc: #
+      @excel.visible = options[:visible] unless options[:visible].nil?
+      @excel.displayalerts = options[:displayalerts] unless options[:displayalerts].nil? 
+    end
+
+  private
+
+    # returns an Excel object when given Excel, Book or Win32ole object representing a Workbook or an Excel
+    def self.excel_of(object)
+      if object.is_a? WIN32OLE
+        case object.ole_obj_help.name
+        when /Workbook/i 
+          new(object).excel 
+        when /Application/i
+          excel_class.new(object)
+        else
+          object.excel
+        end
+      else
+        object.excel
+      end
+      #rescue
+        # t "no Excel, Book, or WIN32OLE object representing a Workbook or an Excel instance"
+    end
+
+  public
+
     def ensure_excel(options)
+      return if @excel && @excel.alive?
       if options[:excel] == :reuse
         @excel = excel_class.new(:reuse => true)
       end
@@ -146,7 +179,7 @@ module RobustExcelOle
           excel_options[:reuse] = false
           @excel = excel_class.new(excel_options)
         else 
-          @excel = options[:excel].excel
+          @excel = self.class.excel_of(options[:excel])
         end
       end
       # if :excel => :new or (:excel => :reuse but could not reuse)
@@ -251,7 +284,13 @@ module RobustExcelOle
             t "WeakRefError: #{msg.message}"
             raise ExcelErrorOpen, "#{msg.message}"
           end
+          # workaround for linked workbooks for Excel 2007: 
+          # opening and closing a dummy workbook if Excel has no workbooks.
+          # delay: with visible: 0.2 sec, without visible almost none
+          count = workbooks.Count
+          workbooks.Add if @excel.Version == "12.0" && count == 0
           workbooks.Open(filename,{ 'ReadOnly' => options[:read_only] })
+          workbooks.Item(1).Close if @excel.Version == "12.0" && count == 0
         rescue WIN32OLERuntimeError => msg
           t "WIN32OLERuntimeError: #{msg.message}" 
           if msg.message =~ /800A03EC/
@@ -279,6 +318,7 @@ module RobustExcelOle
     #                      :raise (default) -> raises an exception       
     #                      :save            -> saves the workbook before it is closed                  
     #                      :forget          -> closes the workbook 
+    #                      :keep_open       -> keep the workbook open
     #                      :alert           -> gives control to excel
     def close(opts = {:if_unsaved => :raise})
       if (alive? && (not @workbook.Saved) && writable) then
@@ -290,6 +330,8 @@ module RobustExcelOle
           close_workbook
         when :forget
           close_workbook
+        when :keep_open
+          # nothing
         when :alert
           @excel.with_displayalerts true do
             close_workbook
@@ -440,7 +482,9 @@ module RobustExcelOle
       value      
     end
 
-    # set the contents of a range with given name
+    # sets the contents of a range with given name
+    # @param [String] name the range name
+    # @param [Variant] value the contents of the range
     def set_nvalue(name, value) 
       begin
         item = self.Names.Item(name)
@@ -514,7 +558,7 @@ module RobustExcelOle
     end
 
     # simple save of a workbook.
-    # returns true, if successfully saved, nil or error otherwise
+    # @return [Boolean] true, if successfully saved, nil or error otherwise
     def save      
       raise ExcelErrorSave, "Workbook is not alive" if (not alive?)
       raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @workbook.ReadOnly
@@ -531,6 +575,8 @@ module RobustExcelOle
     end
 
     # saves a workbook with a given file name.
+    # @param [String] file the file name
+    # @option opts [Symbol] :if_exists if a file with the same name exists, then  
     #
     # options:
     #  :if_exists   if a file with the same name exists, then  
@@ -630,7 +676,7 @@ module RobustExcelOle
 
   public
 
-    # returns a sheet, if a name of a sheet or a number is given
+    # returns a sheet, if a sheet name or a number is given
     # returns the value of the range, if a global name of a range in the book is given 
     def [] name
       name += 1 if name.is_a? Numeric
@@ -646,6 +692,8 @@ module RobustExcelOle
     end
 
     # sets the value of a range given its name
+    # @param [String] name the name of the range
+    # @param [Variant] value the contents of the range
     def []= (name, value)
       set_nvalue(name,value)
     end
@@ -656,6 +704,11 @@ module RobustExcelOle
       end
     end
 
+    # adds a sheet to the workbook
+    # @param [Sheet] sheet a sheet
+    # @option opts [Symbol] :as new name of the copyed sheet
+    # @option opts [Symbol] :before a sheet before which the sheet shall be inserted
+    # @option opts [Symbol] :after a sheet after which the sheet shall be inserted
     def add_sheet(sheet = nil, opts = { })
       if sheet.is_a? Hash
         opts = sheet
@@ -700,6 +753,10 @@ module RobustExcelOle
       "<#Book: " + "#{"not alive " unless alive?}" + "#{File.basename(self.filename) if alive?}" + " #{@workbook} #{@excel}"  + ">"
     end
 
+    def self.in_context(klass)
+      
+    end
+
     def self.excel_class
       @excel_class ||= begin
         module_name = self.parent_name
@@ -749,6 +806,8 @@ module RobustExcelOle
   
 public
 
+  Workbook = Book
+
   class ExcelError < RuntimeError    # :nodoc: #
   end
 

data/lib/robust_excel_ole/excel.rb

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+require 'timeout'
+
 module RobustExcelOle
 
   class Excel
@@ -18,18 +20,20 @@ module RobustExcelOle
     end
 
     # returns an Excel instance  
-    # options:
-    #  :reuse          uses an already running Excel instance (true) or 
-    #                  uses the Excel instance represented as WIN32OLE object (default: true)
+    # given: a WIN32OLE object representing an Excel instance, or a Hash representing options:
+    #  :reuse          connects to an already running Excel instance (true) or
+    #                  creates a new Excel instance (false)   (default: true)
     #  :displayalerts  allows display alerts in Excel         (default: false)
     #  :visible        makes the Excel visible                (default: false)
     #  if :reuse => true, then DisplayAlerts and Visible are set only if they are given
-    def self.new(options= {})
-      options = {:reuse => true}.merge(options)
-      if options[:reuse] == true then
-        excel = current_excel
-      elsif options[:reuse].class == WIN32OLE then
-        excel = options[:reuse]
+    def self.new(options = {})
+      if options.is_a? WIN32OLE
+        excel = options
+      else
+        options = {:reuse => true}.merge(options)
+        if options[:reuse] == true then
+          excel = current_excel
+        end
       end
       if not (excel)
         excel = WIN32OLE.new('Excel.Application')
@@ -38,8 +42,10 @@ module RobustExcelOle
           :visible => false,
         }.merge(options)
       end
-      excel.DisplayAlerts = options[:displayalerts] unless options[:displayalerts].nil?
-      excel.Visible = options[:visible] unless options[:visible].nil?
+      unless options.is_a? WIN32OLE
+        excel.DisplayAlerts = options[:displayalerts] unless options[:displayalerts].nil?
+        excel.Visible = options[:visible] unless options[:visible].nil?
+      end
 
       hwnd = excel.HWnd
       stored = hwnd2excel(hwnd)
@@ -51,7 +57,6 @@ module RobustExcelOle
         result.instance_variable_set(:@ole_excel, excel)
         WIN32OLE.const_load(excel, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
         @@hwnd2excel[hwnd] = WeakRef.new(result)
-
       end
       result
     end
@@ -61,21 +66,24 @@ module RobustExcelOle
     end
 
     # reopens a closed Excel instance
-    # options: :visible (default: false), :displayalerts (default: false)
+    # options: reopen_workbooks (default: false): reopen the workbooks in the Excel instances
+    #          :visible (default: false), :displayalerts (default: false)
     def recreate(opts = {})      
       unless self.alive?
         opts = {
-          :displayalerts => false,
-          :visible => false,
+          :displayalerts => @displayalerts ? @displayalerts : false,
+          :visible => @visible ? @visible : false
         }.merge(opts)
         new_excel = WIN32OLE.new('Excel.Application')
         new_excel.DisplayAlerts = opts[:displayalerts]
         new_excel.Visible = opts[:visible]
         @ole_excel = new_excel 
-        books = Book.books
-        books.each do |book|
-          book.reopen if ((not book.alive?) && book.excel.alive?)
-        end        
+        if opts[:reopen_workbooks]
+          books = book_class.books
+          books.each do |book|
+            book.reopen if ((not book.alive?) && book.excel.alive? && book.excel == self)
+          end        
+        end
       end
       self 
     end
@@ -84,7 +92,9 @@ module RobustExcelOle
     
     # returns an Excel instance to which one 'connect' was possible
     def self.current_excel   # :nodoc: #
+      #p "current_excel:"
       result = WIN32OLE.connect('Excel.Application') rescue nil
+      #p "result: #{result}"
       if result
         begin
           result.Visible    # send any method, just to see if it responds
@@ -93,6 +103,7 @@ module RobustExcelOle
           return nil
         end
       end
+      #p "result: #{result}"
       result
     end
 
@@ -104,24 +115,36 @@ module RobustExcelOle
     #                      :raise (default) -> raises an exception       
     #                      :save            -> saves the workbooks before closing
     #                      :forget          -> closes the excel instance without saving the workbooks 
-    #                      :alert           -> gives control to Excel
-    #  :hard          kills the Excel instances hard (default: false) 
+    #                      :alert           -> give control to Excel
+    #  :hard          closes Excel instances soft (default: false), or, additionally kills the Excel processes hard (true)
+    #  :kill_if_timeout:  kills Excel instances hard if the closing process exceeds a certain time limit (default: true)
     def self.close_all(options={})
       options = {
         :if_unsaved => :raise,
-        :hard => false
+        :hard => false,
+        :kill_if_timeout => false
       }.merge(options)      
       excels_number = excel_processes.size
-      # kill hard if the number of Excel instqnces does not decrease
-      while current_excel do
-        close_one_excel(options)
-        GC.start
-        sleep 0.3
-        current_excels_number = excel_processes.size
-        (current_excels_number < excels_number) ? (excels_number = current_excels_number) : kill_all
+      timeout = false
+      begin
+        status = Timeout::timeout(5) {
+          while current_excel do
+            close_one_excel(options)
+            GC.start
+            sleep 0.3
+            current_excels_number = excel_processes.size
+            if current_excels_number == excels_number && excels_number > 0
+              raise ExcelError, "some Excel instance cannot be closed"
+            end
+            excels_number = current_excels_number
+          end   
+        }
+      rescue Timeout::Error
+        raise ExcelError, "close_all: timeout" unless options[:kill_if_timeout]
+        timeout = true
       end
+      kill_all if options[:hard] || (timeout && options[:kill_if_timeout])
       init
-      kill_all if options[:hard]
     end
 
     def self.init
@@ -131,7 +154,6 @@ module RobustExcelOle
   private
 
     def self.manage_unsaved_workbooks(excel, options)
-      #this_excel = excel == 0 ? self : excel
       unsaved_workbooks = []
       begin
         excel.Workbooks.each {|w| unsaved_workbooks << w unless (w.Saved || w.ReadOnly)}
@@ -149,22 +171,32 @@ module RobustExcelOle
           end
         when :forget
           # nothing
+        when :keep_open
+          return
         when :alert
-          excel.DisplayAlerts = true
+          begin
+            excel.DisplayAlerts = true
+            yield
+          ensure
+            excel.DisplayAlerts = false
+          end
+          return
         else
           raise ExcelErrorClose, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
         end
       end
+      yield
     end
 
     # closes one Excel instance to which one was connected
     def self.close_one_excel(options={})
       excel = current_excel
       return unless excel
-      manage_unsaved_workbooks(excel, options)
-      weak_ole_excel = WeakRef.new(excel)
-      excel = nil
-      close_excel_ole_instance(weak_ole_excel.__getobj__)
+      manage_unsaved_workbooks(excel, options) do
+        weak_ole_excel = WeakRef.new(excel)
+        excel = nil
+        close_excel_ole_instance(weak_ole_excel.__getobj__)
+      end
     end
 
     def self.close_excel_ole_instance(ole_excel)
@@ -180,7 +212,6 @@ module RobustExcelOle
         GC.start
         sleep 0.2
         if weak_excel_ref.weakref_alive? then
-          #if WIN32OLE.ole_reference_count(weak_xlapp) > 0
           begin
             weak_excel_ref.ole_free
             t "successfully ole_freed #{weak_excel_ref}"
@@ -188,7 +219,6 @@ module RobustExcelOle
             t "could not do ole_free on #{weak_excel_ref}"
           end
         end
-        hwnd2excel(excel_hwnd).die rescue nil
         @@hwnd2excel.delete(excel_hwnd)
       rescue => e
         t "Error when closing Excel: #{e.message}"
@@ -217,11 +247,6 @@ module RobustExcelOle
       t "went through #{anz_objekte} OLE objects"
     end   
 
-    # sets this Excel instance to nil
-    def die 
-      @ole_excel = nil
-    end
-
   public
 
     # closes the Excel
@@ -229,15 +254,16 @@ module RobustExcelOle
     #                      :raise (default) -> raises an exception       
     #                      :save            -> saves the workbooks before closing
     #                      :forget          -> closes the Excel instance without saving the workbooks 
-    #                      :alert           -> gives control to Excel
+    #                      :keep_open       -> keeps the Excel instance open 
     #  :hard          kill the Excel instance hard (default: false) 
     def close(options = {})
       options = {
         :if_unsaved => :raise,
         :hard => false
       }.merge(options)
-      self.class.manage_unsaved_workbooks(@ole_excel, options)
-      close_excel(options)
+      self.class.manage_unsaved_workbooks(@ole_excel, options) do 
+        close_excel(options)
+      end
     end
 
   private
@@ -257,7 +283,6 @@ module RobustExcelOle
       GC.start
       sleep 0.2
       if weak_excel_ref.weakref_alive? then
-        #if WIN32OLE.ole_reference_count(weak_xlapp) > 0
         begin
           weak_excel_ref.ole_free
           t "successfully ole_freed #{weak_excel_ref}"
@@ -266,7 +291,6 @@ module RobustExcelOle
           t "could not do ole_free on #{weak_excel_ref}"
         end
       end
-      hwnd2excel(excel_hwnd).die rescue nil
       @@hwnd2excel.delete(excel_hwnd)      
       if options[:hard] then
         Excel.free_all_ole_objects
@@ -288,6 +312,7 @@ module RobustExcelOle
       procs.InstancesOf("win32_process").each do |p|
         Process.kill('KILL', p.processid) if p.name == "EXCEL.EXE"        
       end
+      init
       number
     end
 
@@ -297,11 +322,12 @@ module RobustExcelOle
     def self.excel_processes
       pid2excel = {}
       @@hwnd2excel.each do |hwnd,wr_excel|
+        excel = wr_excel.__getobj__
         process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
         pid_puffer = " " * 32
         process_id.call(hwnd, pid_puffer)
         pid = pid_puffer.unpack("L")[0]
-        pid2excel[pid] = wr_excel
+        pid2excel[pid] = excel
       end
       procs = WIN32OLE.connect("winmgmts:\\\\.")
       processes = procs.InstancesOf("win32_process")     
@@ -309,11 +335,11 @@ module RobustExcelOle
       processes.each do |p|
         if p.name == "EXCEL.EXE"
           if pid2excel.include?(p.processid)
-            excel = pid2excel[p.processid].__getobj__ 
+            excel = pid2excel[p.processid]
             result << excel
           end
-          # how to connect with an Excel instance that is not in hwnd2excel (uplifting Excel)?
-          #excel = Excel.uplift unless (excel && excel.alive?)
+          # how to connect to an (interactively opened) Excel instance and get a WIN32OLE object?
+          # after that, lift it to an Excel object
         end
       end
       result
@@ -353,7 +379,7 @@ module RobustExcelOle
 
     # returns true, if the Excel instances are alive and identical, false otherwise
     def == other_excel
-      self.Hwnd == other_excel.Hwnd    if other_excel.is_a?(Excel) && self.alive? && other_excel.alive?
+      self.Hwnd == other_excel.Hwnd  if other_excel.is_a?(Excel) && self.alive? && other_excel.alive?
     end
 
     # returns true, if the Excel instances responds to VBA methods, false otherwise
@@ -365,11 +391,18 @@ module RobustExcelOle
       false
     end
 
-    def print_workbooks
-      self.Workbooks.each {|w| t "#{w.Name} #{w}"}
+    
+    # returns all unsaved workbooks in Excel instances
+    def self.unsaved_workbooks_all
+      result = []
+      @@hwnd2excel.each do |hwnd,wr_excel| 
+        excel = wr_excel.__getobj__
+        result << excel.unsaved_workbooks
+      end
+      result
     end
 
-    # returns all unsaved workbooks
+    # returns unsaved workbooks
     def unsaved_workbooks
       result = []
       begin
@@ -383,6 +416,11 @@ module RobustExcelOle
     # yields different WIN32OLE objects than book.workbook
     #self.class.map {|w| (not w.Saved)}
 
+    def print_workbooks
+      self.Workbooks.each {|w| t "#{w.Name} #{w}"}
+    end
+
+
     # empty workbook is generated, saved and closed 
     def generate_workbook file_name                  
       self.Workbooks.Add                           
@@ -416,22 +454,22 @@ module RobustExcelOle
 
     # enables DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
-      @ole_excel.DisplayAlerts = displayalerts_value
+      @displayalerts = @ole_excel.DisplayAlerts = displayalerts_value
     end
 
     # return if in the current Excel instance DisplayAlerts is enabled
     def displayalerts 
-      @ole_excel.DisplayAlerts
+      @displayalerts = @ole_excel.DisplayAlerts
     end
 
     # makes the current Excel instance visible or invisible
     def visible= visible_value
-      @ole_excel.Visible = visible_value
+      @visible = @ole_excel.Visible = visible_value
     end
 
     # returns whether the current Excel instance is visible
     def visible 
-      @ole_excel.Visible
+      @visible = @ole_excel.Visible
     end    
 
     def to_s
@@ -442,6 +480,19 @@ module RobustExcelOle
       self.to_s
     end
 
+    def self.book_class
+      @book_class ||= begin
+        module_name = self.parent_name
+        "#{module_name}::Book".constantize
+      rescue NameError => e
+        book
+      end
+    end
+
+    def book_class
+      self.class.book_class
+    end
+
   private
 
     def method_missing(name, *args)