robust_excel_ole 0.3.1 → 0.3.2

data/examples/open_save_close/example_force_excel.rb

@@ -10,7 +10,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  simple_file = dir + 'simple.xls'
+  simple_file = dir + 'workbook.xls'
   book1 = Book.open(simple_file)            # open a book in a new Excel instance since no Excel is open
   book1.excel.visible = true                # make current Excel visible
   sleep 2

data/examples/open_save_close/example_if_obstructed_closeifsaved.rb

@@ -10,12 +10,12 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
-  other_file_name = dir + 'more_data/simple.xls'
+  file_name = dir + 'workbook.xls'
+  other_file_name = dir + 'more_data/workbook.xls'
   book = Book.open(file_name, :visible => true)  # open a book, make Excel visible
   sleep 1
   sheet = book[0]
-  first_cell = sheet[0,0].value                                   # access a sheet
+  first_cell = sheet[0,0].Value                                   # access a sheet
   sheet[0,0] = first_cell == "simple" ? "complex" : "simple"      # change a cell
   sleep 1
   begin
@@ -27,7 +27,7 @@ begin
   new_book = Book.open(file_name, :if_obstructed => :close_if_saved)  # open the new book, close the saved book    
   sleep 1
   new_sheet = new_book[0]
-  new_first_cell = new_sheet[0,0].value
+  new_first_cell = new_sheet[0,0].Value
   puts "the old book was saved" unless new_first_cell == first_cell 
   new_book.close                                 # close the books                  
 ensure

data/examples/open_save_close/example_if_obstructed_forget.rb

@@ -10,8 +10,8 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
-  other_file_name = dir + 'more_data/simple.xls'
+  file_name = dir + 'workbook.xls'
+  other_file_name = dir + 'more_data/workbook.xls'
   book = Book.open(file_name, :visible => true)  # open a book, make Excel application visible
   sleep 3 
   begin

data/examples/open_save_close/example_if_obstructed_save.rb

@@ -10,8 +10,8 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
-  other_file_name = dir + 'more_data/simple.xls'
+  file_name = dir + 'workbook.xls'
+  other_file_name = dir + 'more_data/workbook.xls'
   book = Book.open(file_name, :visible => true)  # open a book, make Excel visible
   sleep 1
   sheet = book[0]

data/examples/open_save_close/example_if_unsaved_accept.rb

@@ -10,7 +10,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls' 
+  file_name = dir + 'workbook.xls' 
   book = Book.open(file_name)                      # open a book 
   sheet = book[0]                                                  # access a sheet
   sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple" # change a cell

data/examples/open_save_close/example_if_unsaved_forget.rb

@@ -10,7 +10,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls' 
+  file_name = dir + 'workbook.xls' 
   book = Book.open(file_name)                      # open a book
   book.excel.visible = true                        # make current Excel visible 
   sleep 1

data/examples/open_save_close/example_if_unsaved_forget_more.rb

@@ -10,7 +10,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls' 
+  file_name = dir + 'workbook.xls' 
   book = Book.open(file_name)                      # open a book
   book.excel.visible = true                        # make current Excel visible 
   sleep

data/examples/open_save_close/example_read_only.rb

@@ -9,8 +9,8 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
-  other_file_name = dir + 'different_simple.xls'
+  file_name = dir + 'workbook.xls'
+  other_file_name = dir + 'different_workbook.xls'
   book = Book.open(file_name, :read_only => true, :visible => true) # open a book with read_only and make Excel visible
   sheet = book[0]                                     			        # access a sheet
   sleep 1     

data/examples/open_save_close/example_rename_cells.rb

@@ -10,7 +10,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
+  file_name = dir + 'workbook.xls'
   book = Book.open(file_name)                                # open a book.  default:  :read_only => false
   book.excel.visible = true                                          # make current Excel visible
   sheet = book[0]

data/examples/open_save_close/example_reuse.rb

@@ -9,9 +9,9 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name1 = dir + 'simple.xls'
-  file_name2 = dir + 'different_simple.xls'
-  file_name3 = dir + 'different_simple.xls'
+  file_name1 = dir + 'workbook.xls'
+  file_name2 = dir + 'different_workbook.xls'
+  file_name3 = dir + 'different_workbook.xls'
   file_name4 = dir + 'book_with_blank.xls'
   book1 = Book.open(file_name1)             # open a book in a new Excel instance since no Excel is open
   book1.excel.visible = true                # make current Excel visible

data/examples/open_save_close/example_simple.rb

@@ -10,8 +10,8 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  file_name = dir + 'simple.xls'
-  other_file_name = dir + 'different_simple.xls'
+  file_name = dir + 'workbook.xls'
+  other_file_name = dir + 'different_workbook.xls'
   book = Book.open(file_name)                                # open a book.  default:  :read_only => false
   book.excel.visible = true                                  # make current Excel visible
   sheet = book[0]                                            # access a sheet

data/examples/open_save_close/example_unobtrusively.rb

@@ -9,7 +9,7 @@ include RobustExcelOle
 Excel.close_all
 begin
   dir = create_tmpdir
-  simple_file = dir + 'simple.xls'
+  simple_file = dir + 'workbook.xls'
   book = Book.open(simple_file, :visible => true)  # open a book, make Excel visible
   old_sheet = book[0]
   p "1st cell: #{old_sheet[0,0].value}"

data/lib/robust_excel_ole/book.rb

@@ -9,6 +9,16 @@ module RobustExcelOle
     attr_accessor :excel
     attr_accessor :workbook
     attr_accessor :stored_filename
+    attr_accessor :options
+
+      DEFAULT_OPEN_OPTS = { 
+        :excel => :reuse,
+        :default_excel => :reuse,
+        :if_locked     => :readonly,       
+        :if_unsaved    => :raise,
+        :if_obstructed => :raise,
+        :read_only => false
+      }
 
     class << self
       
@@ -19,91 +29,63 @@ module RobustExcelOle
       # 
       # options: 
       # :default_excel   if the book was already open in an Excel instance, then open it there.
-      #                  Otherwise, i.e. if the book was not open before or the Excel instance
-      #                   :reuse (default) -> connect to a (the first opened) running Excel instance 
-      #                                       if it exists, open in a new Excel otherwise
+      #                  Otherwise, i.e. if the book was not open before or the Excel instance is not alive
+      #                   :reuse (default) -> connect to a (the first opened) running Excel instance,
+      #                                        excluding the hidden Excel instance, if it exists,
+      #                                       otherwise open in a new Excel instance.
       #                   :new             -> open in a new Excel instance
       #                   <instance>       -> open in the given Excel instance
       # :force_excel     no matter whether the book was already open
       #                   :new (default)   -> open in a new Excel
       #                   <instance>       -> open in the given Excel instance
-      # :if_locked       if the book is open in another Excel instance, then
-      #                   :readonly (default) -> open the book as readonly, if is should be opened in a new Excel,
-      #                                          use the old book otherwise
-      #                   :take_writable      -> use the Excel instance in which the book is writable,
-      #                                          if such an Excel instance exists
-      #                   :force_writability  -> make it writable in the desired Excel
-      #                   (does not work yet)
-      # :if_locked_unsaved  if the book is open in another Excel instance and contains unsaved changes
-      #                  :raise    -> raise an exception
-      #                  :save     -> save the unsaved book 
-      #                  (not implemented yet)
       # :if_unsaved     if an unsaved book with the same name is open, then
-      #                  :raise               -> raise an exception
+      #                  :raise (default)              -> raise an exception
       #                  :forget              -> close the unsaved book, open the new book             
       #                  :accept              -> let the unsaved book open                  
       #                  :alert               -> give control to Excel
-      #                  :new_excel (default) -> open the new book in a new Excel
+      #                  :new_excel           -> open the new book in a new Excel
       # :if_obstructed  if a book with the same name in a different path is open, then
-      #                  :raise               -> raise an exception 
+      #                  :raise (default)     -> raise an exception 
       #                  :forget              -> close the old book, open the new book
       #                  :save                -> save the old book, close it, open the new book
-      #                  :close_if_saved      -> close the old book and open the new book, if the old book is saved
-      #                                          raise an exception otherwise
-      #                  :new_excel (default) -> open the new book in a new Excel                  
+      #                  :close_if_saved      -> close the old book and open the new book, if the old book is saved,
+      #                                          otherwise raise an exception.
+      #                  :new_excel           -> open the new book in a new Excel    
+      # :if_absent       :create              -> creates a new Excel file, if it does not exists  
+      #                  :raise               -> raises an exception     , if the file does not exists
       # :read_only     open in read-only mode         (default: false) 
       # :displayalerts enable DisplayAlerts in Excel  (default: false)
-      # :visible       make visibe in Excel           (default: false)
+      # :visible       make visible in Excel           (default: false)
       # if :default_excel is set, then DisplayAlerts and Visible are set only if these parameters are given
-    
+
       def open(file, opts={ }, &block)
-        @options = {
-          :excel => :reuse,
-          :default_excel => :reuse,
-          :if_locked     => :readonly,       
-          :if_unsaved    => :new_excel,
-          :if_obstructed => :new_excel,
-          :read_only => false
-        }.merge(opts)
-        #self.set_defaults(opts) ???
+        current_options = DEFAULT_OPEN_OPTS.merge(opts)
         book = nil
-        if (not (@options[:force_excel] == :new && (not @options[:if_locked] == :take_writable)))
+        if (not (current_options[:force_excel] == :new && (not current_options[:if_locked] == :take_writable)))
           # if readonly is true, then prefer a book that is given in force_excel if this option is set
-          book = book_store.fetch(file, :prefer_writable => (not @options[:read_only]), :prefer_excel => (@options[:read_only] ? @options[:force_excel] : nil)) rescue nil
+          book = book_store.fetch(file, :prefer_writable => (not current_options[:read_only]), 
+                                        :prefer_excel    => (current_options[:read_only] ? current_options[:force_excel] : nil)) rescue nil
           if book
-            if ((not @options[:force_excel]) || (@options[:force_excel] == book.excel))
-              if (not book.excel.alive?)
-                book.get_excel
-              end
-              if book.excel.alive?
-                # condition: :if_unsaved is not set or :accept or workbook is not unsaved
-                if_unsaved_not_set_or_accept_or_workbook_saved = (@options[:if_unsaved] == :accept || @options[:if_unsaved] == :raise || (not book.workbook) || book.workbook.Saved)
-                if ((not book.alive?) || if_unsaved_not_set_or_accept_or_workbook_saved)
-                  book.set_defaults(opts)
-                  # if the book is opened with a different readonly mode in the same Excel, 
-                  # then save it, close and open the book with the new readonly mode
-                  if (book.alive? && (not book.readonly == @options[:read_only]))
-                    book.Save unless (book.readonly || book.saved)
-                    book.workbook.Close if book.alive?
-                    book.workbook = nil unless book.alive?
-                  end
-                  # reopen the book
-                  book.get_workbook   
-                end
-                return book if book.alive? && if_unsaved_not_set_or_accept_or_workbook_saved
-              end
+            if (((not current_options[:force_excel]) || (current_options[:force_excel] == book.excel)) &&
+                 (not (book.alive? && (not book.saved) && (not current_options[:if_unsaved] == :accept))))
+              book.options = DEFAULT_OPEN_OPTS.merge(opts)
+              book.get_excel unless book.excel.alive?
+              # if the book is opened as readonly and should be opened as writable, then close it and open the book with the new readonly mode
+              book.close if (book.alive? && (not book.writable) && (not current_options[:read_only]))
+              # reopen the book
+              book.get_workbook unless book.alive?
+              return book
             end
           end
         end
-        @options[:excel] = @options[:force_excel] ? @options[:force_excel] : @options[:default_excel]
-        new(file, @options, &block)
+        current_options[:excel] = current_options[:force_excel] ? current_options[:force_excel] : current_options[:default_excel]
+        new(file, current_options, &block)
       end
     end
 
     def initialize(file, opts={ }, &block)
-      raise ExcelErrorOpen, "file #{file} not found" unless File.exist?(file)
-      set_defaults(opts)
-      @file = file
+      @options = DEFAULT_OPEN_OPTS.merge(opts)
+      @file = file      
       get_excel
       get_workbook
       book_store.store(self)
@@ -115,17 +97,6 @@ module RobustExcelOle
         end
       end
     end
-  
-    def set_defaults(opts)
-      @options = {
-        :excel => :reuse,
-        :default_excel => :reuse,
-        :if_locked     => :readonly,       
-        :if_unsaved    => :new_excel,
-        :if_obstructed => :new_excel,
-        :read_only => false
-      }.merge(opts)
-    end
     
     def get_excel
       if @options[:excel] == :reuse
@@ -150,6 +121,7 @@ module RobustExcelOle
     end
 
     def get_workbook
+      raise ExcelErrorOpen, "file #{@file} not found" if ((not File.exist?(@file)) && @options[:if_absent] == :raise) 
       @workbook = @excel.Workbooks.Item(File.basename(@file)) rescue nil
       if @workbook then
         obstructed_by_other_book = (File.basename(@file) == File.basename(@workbook.Fullname)) && 
@@ -162,30 +134,30 @@ module RobustExcelOle
           when :forget
             @workbook.Close
             @workbook = nil
-            open_workbook
+            open_or_create_workbook
           when :save
             save unless @workbook.Saved
             @workbook.Close
             @workbook = nil
-            open_workbook
+            open_or_create_workbook
           when :close_if_saved
             if (not @workbook.Saved) then
               raise ExcelErrorOpen, "book with the same name in a different path is unsaved"
             else 
               @workbook.Close
               @workbook = nil
-              open_workbook
+              open_or_create_workbook
             end
           when :new_excel 
             @excel_options = {:displayalerts => false, :visible => false}.merge(@options)   
             @excel_options[:reuse] = false
             @excel = Excel.new(@excel_options)
-            open_workbook
+            open_or_create_workbook
           else
             raise ExcelErrorOpen, ":if_obstructed: invalid option"
           end
         else
-          # book open, not obstructed by an other book, but not saved
+          # book open, not obstructed by an other book, but not saved and writable
           if (not @workbook.Saved) then
             case @options[:if_unsaved]
             when :raise
@@ -193,18 +165,18 @@ module RobustExcelOle
             when :forget
               @workbook.Close
               @workbook = nil
-              open_workbook
+              open_or_create_workbook
             when :accept
               # do nothing
             when :alert
               @excel.with_displayalerts true do
-                open_workbook
+                open_or_create_workbook
               end 
             when :new_excel
               @excel_options = {:displayalerts => false, :visible => false}.merge(@options)
               @excel_options[:reuse] = false
               @excel = Excel.new(@excel_options)
-              open_workbook
+              open_or_create_workbook
             else
               raise ExcelErrorOpen, ":if_unsaved: invalid option"
             end
@@ -212,37 +184,50 @@ module RobustExcelOle
         end
       else
         # book is not open
-        open_workbook
+        open_or_create_workbook
       end
     end
 
-    def open_workbook
+    def open_or_create_workbook
+      if (not File.exist?(@file))
+        @workbook = self.class.create(@file)
+        #@workbook = Excel.new(:reuse => true).generate_workbook(@file)
+        return
+      end
       if ((not @workbook) || (@options[:if_unsaved] == :alert) || @options[:if_obstructed]) then
         begin
           filename = RobustExcelOle::absolute_path(@file)
           workbooks = @excel.Workbooks
           workbooks.Open(filename,{ 'ReadOnly' => @options[:read_only] })
+        rescue WIN32OLERuntimeError 
+          raise ExcelUserCanceled, "open: canceled by user"
+        end
+        begin
           # workaround for bug in Excel 2010: workbook.Open does not always return 
           # the workbook with given file name
           @workbook = workbooks.Item(File.basename(filename))
-        #rescue BookStoreError => e
-        #  raise ExcelUserCanceled, "open: canceled by user: #{e}"
-        rescue WIN32OLERuntimeError 
-          raise ExcelUserCanceled, "open: canceled by user"
+        rescue WIN32OLERuntimeError
+          raise ExcelErrorOpen, "open: item error"
         end
       end
     end
 
+    # generate, save and close an empty workbook
+    def self.create(file)
+      @workbook = Excel.new(:reuse => true).generate_workbook(file)
+      @workbook
+    end
+
     # closes the book, if it is alive
     #
     # options:
     #  :if_unsaved    if book is unsaved
-    #                      :raise          -> raise an exception       
-    #                      :save (default) -> save the book before it is closed                  
-    #                      :forget         -> close the book 
-    #                      :alert          -> give control to excel
+    #                      :raise (default) -> raise an exception       
+    #                      :save            -> save the book before it is closed                  
+    #                      :forget          -> close the book 
+    #                      :alert           -> give control to excel
     def close(opts = {:if_unsaved => :raise})
-      if ((alive?) && (not @workbook.Saved) && (not @workbook.ReadOnly)) then
+      if (alive? && (not @workbook.Saved) && writable) then
         case opts[:if_unsaved]
         when :raise
           raise ExcelErrorClose, "book is unsaved (#{File.basename(self.stored_filename)})"
@@ -275,38 +260,38 @@ module RobustExcelOle
 
     # modify a book such that its state (open/close, saved/unsaved, readonly/writable) remains unchanged.
     #  options: 
-    #  :visible:   Make the book visible in the Excel (default: false)
-    #  :keep_open: let the book open after modification (default: false)
+    #  :if_closed :  :hidden (default) : open closed books in one separate Excel instance that is not visible and has no displayaslerts
+    #                :reuse            : open closed books in the Excel instance of the book, if it exists, reuse another Excel, otherwise         
     #  :read_only: Open the book unobtrusively for reading only  (default: false)
-    #  :use_this:  if the book is opened only as ReadOnly and shall be modified, then
+    #  :use_readonly_excel:  if the book is opened only as ReadOnly and shall be modified, then
     #              true:  close it and open it as writable in the excel instance where it was open so far
-    #              false(default)    open it as writable in another running excel instance, if it exists
-    #                                in a new excel instance, otherwise
+    #              false (default)   open it as writable in another running excel instance, if it exists,
+    #                                otherwise open in a new excel instance.
+    #  :keep_open: let the book open after unobtrusively opening (default: false)
     def self.unobtrusively(file, opts = { })
       options = {
-        :keep_open => false,
-        :visible => false,
+        :if_closed => :hidden,
         :read_only => false,
-        :use_this => false
+        :use_readonly_excel => false,
+        :keep_open => false,
       }.merge(opts)
       book = book_store.fetch(file, :prefer_writable => (not options[:read_only]))
       was_not_alive_or_nil = book.nil? || (not book.alive?)
       was_saved = was_not_alive_or_nil ? true : book.saved
-      was_readonly = book.readonly unless was_not_alive_or_nil
-      old_book = book if was_readonly
+      was_writable = book.writable unless was_not_alive_or_nil
       old_visible = (book && book.excel.alive?) ? book.excel.visible : false
       begin 
-        book = was_not_alive_or_nil ? open(file) :
-               (((not was_readonly) || options[:read_only]) ? book : 
-                (options[:use_this] ? open(file, :force_excel => book.excel) : open(file, :force_excel => :new)))
-        book.excel.visible = options[:visible]       
+        book = was_not_alive_or_nil ? 
+                 (options[:if_closed] == :hidden ? open(file, :force_excel => book_store.ensure_hidden_excel) : open(file)) :
+               ((was_writable || options[:read_only]) ? book : 
+                (options[:use_readonly_excel] ? open(file, :force_excel => book.excel) : open(file, :force_excel => :new)))
+        book.excel.visible = opts[:visible] unless opts[:visible].nil?
         yield book
       ensure
-        book.save if (was_not_alive_or_nil || was_saved || (was_readonly && (not options[:read_only]))) && (not book.saved)
+        book.save if (was_not_alive_or_nil || was_saved || ((not was_writable) && (not options[:read_only]))) && (not book.saved)
         # book was open, readonly and shoud be modified
-        if (not was_not_alive_or_nil) && (not options[:read_only]) && was_readonly && options[:use_this]
-          book.close
-          open(file, :if_obstructed => :new_excel, :read_only => true)
+        if (not was_not_alive_or_nil) && (not options[:read_only]) && (not was_writable) && options[:use_readonly_excel]
+          open(file, :force_excel => book.excel, :if_obstructed => :new_excel, :read_only => true)
         end
         book.excel.visible = old_visible
         book.close if (was_not_alive_or_nil && (not opts[:keep_open]))
@@ -349,15 +334,15 @@ module RobustExcelOle
       @workbook.Fullname.tr('\\','/') rescue nil
     end
 
-    def readonly
-      @workbook.ReadOnly
+    def writable
+      (not @workbook.ReadOnly) if @workbook
     end
 
     def saved
-      @workbook.Saved
+      @workbook.Saved if @workbook
     end
 
-    # returns true, if the full book names and excel appications are identical, false, otherwise  
+    # returns true, if the full book names and excel appications are identical, false otherwise  
     def == other_book
       other_book.is_a?(Book) &&
       @excel == other_book.excel &&
@@ -530,20 +515,4 @@ public
   class ExcelErrorSheet < ExcelError    # :nodoc: #
   end
 
-
-end
-
-
-__END__
-
-
-          class Object
-            def update_extracted hash, key
-              value = hash[param_name]
-              self.send("#{key}=", value) if value
-            end
-          end
-          @excel.visible = @options[:visible] if @options[:visible] 
-          @excel.displayalerts = @options[:dispayalerts]    
-          @excel.update_extracted(@options, [:visible, :dispayalerts])
-          @excel.options.merge(@options.extract(:visible, :dispayalerts))
+end

data/lib/robust_excel_ole/book_store.rb

@@ -7,14 +7,16 @@ module RobustExcelOle
 
     def initialize
       @filename2books = Hash.new {|hash, key| hash[key] = [] }
+      @hidden_excel_instance = nil
     end
 
     # returns a book with the given filename, if it was open once
     # prefers open books to closed books, and among them, prefers more recently opened books
+    # excludes hidden Excel instance
     # options: :prefer_writable   return the writable book, if it is open (default: true)
-    #                             return the book according to the preference order mentioned above, otherwise
-    #          :prefer_excel      return the book in the given excel instance, if it exists
-    #                             proceed according to prefer_writable otherwise
+    #                             otherwise return the book according to the preference order mentioned above
+    #          :prefer_excel      return the book in the given excel instance, if it exists,
+    #                             otherwise proceed according to prefer_writable 
     def fetch(filename, options = {:prefer_writable => true })
       filename_key = RobustExcelOle::canonize(filename)
       weakref_books = @filename2books[filename_key]
@@ -24,20 +26,22 @@ module RobustExcelOle
         if (not wr_book.weakref_alive?)
           @filename2books[filename_key].delete(wr_book)
         else
-          if options[:prefer_excel] && wr_book.excel == options[:prefer_excel]
-            result = wr_book
+          book = wr_book.__getobj__
+          next if book.excel == try_hidden_excel
+          if options[:prefer_excel] && book.excel == options[:prefer_excel]
+            result = book
             break 
           end
-          if wr_book.alive?
-            open_book = wr_book
-            break if ((not wr_book.readonly) && options[:prefer_writable])
+          if book.alive?
+            open_book = book
+            break if (book.writable && options[:prefer_writable])
           else
-            closed_book = wr_book
+            closed_book = book
           end
         end
       end
       result = result ? result : (open_book ? open_book : closed_book)
-      result.__getobj__ if result
+      result if result
     end
 
     # stores a book
@@ -52,20 +56,16 @@ module RobustExcelOle
       book.stored_filename = book.filename
     end
 
-    # returns all excel instances and the workbooks that are open in them
-    # first: only the stored excel instances are considered
-    def excel_list
-      excel2books = Hash.new {|hash, key| hash[key] = [] }
-      if @filename2books
-        @filename2books.each do |filename,books|
-          if books
-            books.each do |book|
-              excel2books[book.excel] |= [book.workbook]
-            end
-          end
-        end
+    # creates and returns a separate Excel instance with Visible and DisplayAlerts false
+    def ensure_hidden_excel
+      unless (@hidden_excel_instance &&  @hidden_excel_instance.weakref_alive? && @hidden_excel_instance.__getobj__.alive?)       
+        @hidden_excel_instance = WeakRef.new(Excel.create) 
       end
-      excel2books
+      @hidden_excel_instance.__getobj__
+    end
+
+    def try_hidden_excel
+      @hidden_excel_instance.__getobj__ if (@hidden_excel_instance &&  @hidden_excel_instance.weakref_alive? && @hidden_excel_instance.__getobj__.alive?)
     end
 
     # prints the book store