robust_excel_ole 1.0 → 1.0.1

data/examples/edit_sheets/example_saving.rb

@@ -28,7 +28,7 @@ begin
       end
       book.close(:if_unsaved => :save)
       # alternative: delete all other sheets
-      #book = Book.open(file_sheet_name, :force_excel => :new, :visible => true)
+      #book = Book.open(file_sheet_name, :force => {:excel => :new}, :visible => true)
       #book.each do |sheet|
       #  book.sheet(sheet.Name).Delete() unless sheet.Name == sheet_orig.Name
       #end

data/examples/open_save_close/example_default_excel.rb

@@ -23,18 +23,18 @@ begin
   p "book1 == book2" if book2 == book1      # the books are identical
   sleep 2   
   new_excel = Excel.new(:reuse => false)    # create a new Excel    
-  book3 = Book.open(file_name2, :default_excel => :current, :visible => true) # open another book
-  if book3.excel == book2.excel then     # since this book cannot be reopened, the option :default_excel applies:
-    p "book3 opened in the first Excel"  # according to :default_excel => :current the book is opened
+  book3 = Book.open(file_name2, :default => {:excel => :current}, :visible => true) # open another book
+  if book3.excel == book2.excel then     # since this book cannot be reopened, the option :default => {:excel} applies:
+    p "book3 opened in the first Excel"  # according to :default => {:excel => :current} the book is opened
   end                                    # in the Excel instance the was created first
   sleep 2                                          
   new_excel = Excel.new(:reuse => false)         
-  book4 = Book.open(file_name3, :default_excel => new_excel, :visible => true)  # open another book
+  book4 = Book.open(file_name3, :default => {:excel => new_excel}, :visible => true)  # open another book
   if book4.excel == new_excel then       # since this book cannot be reopened, the option :default_excel applies: 
     p "book4 opened in the second Excel" # according to :default_excel => new_excel the book is opened
   end                                    # in the given Excel, namely the second Excel instance new_excel 
   sleep 2   
-  book5 = Book.open(file_name4, :default_excel => :new, :visible => true)  # open another book
+  book5 = Book.open(file_name4, :default => {:excel => :new}, :visible => true)  # open another book
   if ((not book5.excel == book1.excel) && (not book5.excel == new_excel)) then  # since this book cannot be reopened, 
     p "book5 opened in a third Excel" # the option :default_excel applies. according to :default_excel => :new 
   end                                 # the book is opened in a new Excel

data/examples/open_save_close/example_force_excel.rb

@@ -17,11 +17,11 @@ begin
   book2 = Book.open(simple_file)             # open a new book in the same Excel instance                            
   p "book1 == book2" if book2 == book1      # the books are identical
   sleep 2       
-  book3 = Book.open(simple_file, :force_excel => :new, :visible => true) # open another book in a new Excel instance,   
+  book3 = Book.open(simple_file, :force => {:excel => :new, :visible => true}) # open another book in a new Excel instance,   
   p "book3 != book1" if (not (book3 == book1))   # the books are not identical 
   sleep 2   
   new_excel = Excel.new(:reuse => false)        # create a third Excel instance
-  book4 = Book.open(simple_file, :force_excel => new_excel, :visible => true)  # open another book in the new Excel instance
+  book4 = Book.open(simple_file, :force => {:excel => new_excel, :visible => true})  # open another book in the new Excel instance
   p "book4 != book3 && book4 != book1" if (not (book4 == book3) && (not (book4 == book1)))
   sleep 2                                     # (Excel chooses the first Excel application)        
   book4.close                                 # close the books

data/lib/robust_excel_ole/book.rb

@@ -9,47 +9,54 @@ module RobustExcelOle
     attr_accessor :excel
     attr_accessor :ole_workbook
     attr_accessor :stored_filename
-    attr_accessor :options
-    attr_accessor :can_be_closed
+    attr_accessor :options    
 
     alias ole_object ole_workbook
 
-      DEFAULT_OPEN_OPTS = { 
-        :default_excel => :current,      
-        :if_unsaved    => :raise,
-        :if_obstructed => :raise,
-        :if_absent     => :raise,
-        :read_only => false,
-        :check_compatibility => false,
-        :update_links => :never
-      }
+    DEFAULT_OPEN_OPTS = { 
+      :default => {:excel => :current},
+      :force => {},      
+      :if_unsaved    => :raise,
+      :if_obstructed => :raise,
+      :if_absent     => :raise,
+      :read_only => false,
+      :check_compatibility => false,       
+      :update_links => :never
+    }
+
+    SYNONYMS_OPTS = [[[:default],[:d]], [[:force], [:f]], 
+                     [[:default,:excel],[:default_excel]],[[:force,:excel],[:force_excel]],                    
+                     [[:default,:excel],[:default,:e]], [[:force,:excel],[:force,:e]],
+                     [[:default,:visible],[:default,:v]], [[:force,:visible],[:force,:v]],
+                     [[:force,:visible],[:visible]], [[:force,:visible],[:v]]
+    ]
 
     class << self
       
       # opens a workbook.
       # @param [String] file the file name
       # @param [Hash] opts the options
-      # @option opts [Variant] :default_excel  :current (or :active, or :reuse) (default), :new, or <excel-instance>     
-      # @option opts [Variant] :force_excel    :current, :new, or <excel-instance>
+      # @option opts [Hash] :default or :d
+      # @option opts [Hash] :force or :f
       # @option opts [Symbol]  :if_unsaved     :raise (default), :forget, :accept, :alert, :excel, or :new_excel
       # @option opts [Symbol]  :if_obstructed  :raise (default), :forget, :save, :close_if_saved, or _new_excel
       # @option opts [Symbol]  :if_absent      :raise (default) or :create
       # @option opts [Boolean] :read_only      true (default) or false
       # @option opts [Boolean] :update_links   :never (default), :always, :alert
-      # @option opts [Boolean] :visible        true or false (default) 
+      # @option opts [Boolean] :calculation    :manual, :automatic, or nil (default) 
       # options: 
-      # :default_excel   if the workbook was already open in an Excel instance, then open it in that Excel instance,
-      #                  where it was opened most recently
-      #                  Otherwise, i.e. if the workbook was not open before or the Excel instance is not alive
-      #                   :current            -> connects to a running (the first opened) Excel instance,
-      #                    (or :active, :reuse)  excluding the hidden Excel instance, if it exists,
-      #                                          otherwise opens in a new Excel instance.
-      #                   :new                -> opens in a new Excel instance
-      #                   <excel-instance>    -> opens in the given Excel instance
-      # :force_excel     no matter whether the workbook was already open
-      #                   :new                          -> opens in a new Exceö instance 
-      #                   :current (or :active, :reuse) -> opens in the current Excel instance
-      #                   <excel-instance> -> opens in the given Excel instance
+      # :default : if the workbook was already open before, then use (unchange) its properties,
+      #            otherwise, i.e. if the workbook cannot be reopened, use the properties stated in :default
+      # :force   : no matter whether the workbook was already open before, use the properties stated in :force 
+      # :default and :force contain: :excel, :visible
+      #  :excel   :current (or :active or :reuse) 
+      #                    -> connects to a running (the first opened) Excel instance,
+      #                       excluding the hidden Excel instance, if it exists,
+      #                       otherwise opens in a new Excel instance.
+      #           :new     -> opens in a new Excel instance 
+      #           <excel-instance> -> opens in the given Excel instance
+      #  :visible true, false, or nil (default)
+      #  alternatives: :default_excel, :force_excel, :visible, :d, :f, :e, :v
       # :if_unsaved     if an unsaved workbook with the same name is open, then
       #                  :raise               -> raises an exception
       #                  :forget              -> close the unsaved workbook, open the new workbook             
@@ -65,35 +72,33 @@ module RobustExcelOle
       #                  :new_excel           -> opens the new workbook in a new Excel instance   
       # :if_absent       :raise               -> raises an exception     , if the file does not exists
       #                  :create              -> creates a new Excel file, if it does not exists  
-      # :read_only            true -> opens in read-only mode         
-      # :update_links         true -> user is being asked how to update links, false -> links are never updated
-      # :visible              true -> makes the window of the workbook visible
+      # :read_only            true -> opens in read-only mode               
+      # :visible              true -> makes the workbook visible
       # :check_compatibility  true -> check compatibility when saving
+      # :update_links         true -> user is being asked how to update links, false -> links are never updated
       # @return [Book] a workbook
       def open(file, opts={ }, &block)
-        options = DEFAULT_OPEN_OPTS.merge(opts)
-        options[:default_excel] = :current if (options[:default_excel] == :reuse || options[:default_excel] == :active)
-        options[:force_excel] = :current if (options[:force_excel] == :reuse || options[:force_excel] == :active)
+        options = process_options(opts)
         book = nil
-        if (not (options[:force_excel] == :new))
+        if (not (options[:force][:excel] == :new))
           # if readonly is true, then prefer a book that is given in force_excel if this option is set
-          forced_excel = if options[:force_excel]
-            options[:force_excel] == :current ? excel_class.new(:reuse => true) : excel_of(options[:force_excel])
+          forced_excel = if options[:force][:excel]
+            options[:force][:excel] == :current ? excel_class.new(:reuse => true) : excel_of(options[:force][:excel])
           end
           book = bookstore.fetch(file, 
                   :prefer_writable => (not options[:read_only]), 
                   :prefer_excel    => (options[:read_only] ? forced_excel : nil)) rescue nil
           if book
-            if (((not options[:force_excel]) || (forced_excel == book.excel)) &&
+            if (((not options[:force][:excel]) || (forced_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?
+              book.options = options
+              book.ensure_excel(options) # 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 options[:read_only]))
               # reopens the book
               book.ensure_workbook(file,options) unless book.alive?
-              book.visible = options[:visible].nil? ? book.excel.visible : options[:visible]
-              #book.visible = options[:visible] unless options[:visible].nil?
+              book.visible = options[:force][:visible] unless options[:force][:visible].nil?
+              book.excel.calculation = options[:calculation] unless options[:calculation].nil?
               return book
             end
           end
@@ -108,14 +113,16 @@ module RobustExcelOle
     # @param [Hash] opts the options
     # @option opts [Symbol] see above
     # @return [Book] a workbook
-    def self.new(workbook, opts={ }, &block)      
+    def self.new(workbook, opts={ }, &block)
       if workbook && (workbook.is_a? WIN32OLE)
+        opts = process_options(opts)
         filename = workbook.Fullname.tr('\\','/') rescue nil
         if filename
           book = bookstore.fetch(filename)
           if book && book.alive?
-            #book.visible = opts[:visible] unless opts[:visible].nil?
-            book.visible = opts[:visible].nil? ? book.excel.visible : opts[:visible]
+            book.visible = opts[:force][:visible] unless opts[:force][:visible].nil?
+            #book.excel.calculation = opts[:calculation].nil? ? book.excel.calculation : opts[:calculation]
+            book.excel.calculation = opts[:calculation] unless opts[:calculation].nil?
             return book 
           end
         end
@@ -130,21 +137,20 @@ module RobustExcelOle
     # @option opts [Symbol] see above
     # @return [Book] a workbook
     def initialize(file_or_workbook, opts={ }, &block)
-      options = DEFAULT_OPEN_OPTS.merge(opts)      
-      if file_or_workbook.is_a? WIN32OLE
+      options = self.class.process_options(opts)
+      if file_or_workbook.is_a? WIN32OLE        
         workbook = file_or_workbook
         @ole_workbook = workbook        
         # use the Excel instance where the workbook is opened
         win32ole_excel = WIN32OLE.connect(workbook.Fullname).Application rescue nil   
         @excel = excel_class.new(win32ole_excel)     
-        @excel.visible = options[:visible] unless options[:visible].nil?     
-        # if the Excel could not be promoted, then create it         
+        @excel.visible = options[force][:visible] unless options[:force][:visible].nil? 
+        @excel.calculation = options[:calculation] unless options[:calculation].nil?
         ensure_excel(options)
       else
         file = file_or_workbook
         ensure_excel(options)
         ensure_workbook(file, options)        
-        @can_be_closed = false if @can_be_closed.nil?
       end
       bookstore.store(self)
       if block
@@ -158,6 +164,32 @@ module RobustExcelOle
 
   private
 
+    # merges options with defaults and translates abbreviations and synonyms
+    def self.process_options(options) # :nodoc: #
+      translator = proc do |opts|
+        SYNONYMS_OPTS.each do |a|
+          synonym = a[1][1].nil? ? opts[a[1][0]] : opts[a[1][0]][a[1][1]] unless opts[a[1][0]].nil?
+          unless synonym.nil?
+            if a[0][1].nil?
+              opts[a[0][0]] = synonym if opts[a[0][0]].nil?
+            else
+              opts[a[0][0]] = {} if opts[a[0][0]].nil?
+              opts[a[0][0]][a[0][1]] = synonym if opts[a[0][0]][a[0][1]].nil?
+            end
+          end          
+        end
+        opts[:default][:excel] = :current if (not opts[:default].nil?) && (opts[:default][:excel] == :reuse || opts[:default][:excel] == :active)
+        opts[:force][:excel] = :current if (not opts[:force].nil?) && (opts[:force][:excel] == :reuse || opts[:force][:excel] == :active)        
+        opts
+      end
+      default_opts = translator.call(DEFAULT_OPEN_OPTS)
+      given_opts = translator.call(options)
+      opts = default_opts.merge(given_opts)
+      opts[:default] = default_opts[:default].merge(opts[:default]) unless opts[:default].nil?
+      opts[:force] = default_opts[:force].merge(opts[:force]) unless opts[:force].nil?
+      opts
+    end
+
     # returns an Excel object when given Excel, Book or Win32ole object representing a Workbook or an Excel
     def self.excel_of(object)  # :nodoc: #
       if object.is_a? WIN32OLE
@@ -186,8 +218,7 @@ module RobustExcelOle
       filename = General::absolute_path(file)
       ole_workbook = WIN32OLE.connect(filename)
       workbook = Book.new(ole_workbook)
-      #workbook.visible = options[:visible] unless options[:visible].nil?
-      workbook.visible = options[:visible].nil? ? workbook.excel.visible : options[:visible]
+      workbook.visible = options[:force][:visible] unless options[:force][:visible].nil?
       update_links_opt =
             case options[:update_links]
             when :alert; RobustExcelOle::XlUpdateLinksUserSetting
@@ -200,13 +231,19 @@ module RobustExcelOle
       workbook
     end
 
-
     def ensure_excel(options)   # :nodoc: #
-      return if @excel && @excel.alive?
-      options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
-      options[:excel] = :current if (options[:excel] == :reuse || options[:excel] == :active)
-      @excel = self.class.excel_of(options[:excel]) unless (options[:excel] == :current || options[:excel] == :new)
-      @excel = excel_class.new(:reuse => (options[:excel] == :current)) unless (@excel && @excel.alive?)     
+      if @excel && @excel.alive?
+        @excel.created = false
+        return
+      end
+      excel_option = (options[:force].nil? or options[:force][:excel].nil?) ? options[:default][:excel] : options[:force][:excel]
+      @excel = self.class.excel_of(excel_option) unless (excel_option == :current || excel_option == :new)
+      @excel = excel_class.new(:reuse => (excel_option == :current)) unless (@excel && @excel.alive?)
+
+      #options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
+      #options[:excel] = :current if (options[:excel] == :reuse || options[:excel] == :active)
+      #@excel = self.class.excel_of(options[:excel]) unless (options[:excel] == :current || options[:excel] == :new)
+      #@excel = excel_class.new(:reuse => (options[:excel] == :current)) unless (@excel && @excel.alive?)
     end    
 
     def ensure_workbook(file, options)     # :nodoc: #
@@ -246,9 +283,7 @@ module RobustExcelOle
               open_or_create_workbook(file, options)
             end
           when :new_excel 
-            excel_options = {:visible => false}.merge(options)   
-            excel_options[:reuse] = false
-            @excel = excel_class.new(excel_options)
+            @excel = excel_class.new(:reuse => false)
             open_or_create_workbook(file, options)
           else
             raise OptionInvalid, ":if_obstructed: invalid option: #{options[:if_obstructed].inspect}"
@@ -268,7 +303,6 @@ module RobustExcelOle
             when :alert, :excel
               @excel.with_displayalerts(true) { open_or_create_workbook(file,options) }
             when :new_excel
-              excel_options = {:visible => false}.merge(options)
               excel_options[:reuse] = false
               @excel = excel_class.new(excel_options)
               open_or_create_workbook(file, options)
@@ -278,7 +312,7 @@ module RobustExcelOle
           end
         end
       else
-        # book is not open
+        # open a new workbook
         open_or_create_workbook(file, options)
       end
     end
@@ -292,58 +326,80 @@ module RobustExcelOle
           begin
             workbooks = @excel.Workbooks
           rescue RuntimeError => msg
-            trace "RuntimeError: #{msg.message}" 
             if msg.message =~ /method missing: Excel not alive/
               raise ExcelDamaged, "Excel instance not alive or damaged" 
             else
-              raise UnexpectedError, "unknown RuntimeError"
+              raise UnexpectedError, "unknown RuntimeError: #{msg.message}"
             end
-          rescue WeakRef::RefError => msg
-            raise WeakRef::RefError, "#{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
-          if @excel.Version.split(".").first.to_i >= 12 && count == 0
-            workbooks.Add 
-            #@excel.set_calculation(:automatic)
-          end
-          update_links_opt =
-            case options[:update_links]
-            when :alert; RobustExcelOle::XlUpdateLinksUserSetting
-            when :never; RobustExcelOle::XlUpdateLinksNever
-            when :always; RobustExcelOle::XlUpdateLinksAlways
-            else RobustExcelOle::XlUpdateLinksNever
-          end
-          # probably bug in Excel: setting UpadateLinks seems to be dependent on calculation mode:
-          # update happens, if calcultion mode is automatic, does not, if calculation mode is manual
-          # parameter 'UpdateLinks' has no effect
-          @excel.with_displayalerts(update_links_opt == :alert ? true : @excel.displayalerts) do
-            workbooks.Open(filename, { 'ReadOnly' => options[:read_only] , 'UpdateLinks' => update_links_opt } )
           end
-          workbooks.Item(1).Close if @excel.Version.split(".").first.to_i >= 12 && count == 0                
-        rescue WIN32OLERuntimeError => msg
-          # trace "WIN32OLERuntimeError: #{msg.message}" 
-          if msg.message =~ /800A03EC/
-            raise ExcelError, "user canceled or runtime error"
-          else 
-            raise UnexpectedError, "unknown WIN32OLERuntimeError"
+          begin
+            with_workaround_linked_workbooks_excel2007(options) do            
+              workbooks.Open(filename, { 'ReadOnly' => options[:read_only] ,
+                                         'UpdateLinks' => updatelinks_vba(options[:update_links]) })
+            end
+          rescue WIN32OLERuntimeError => msg
+            if msg.message =~ /800A03EC/
+              raise ExcelError, "user canceled or runtime error #{msg.message}"
+            else 
+              raise UnexpectedError, "unexpected WIN32OLERuntimeError: #{msg.message}"
+            end 
           end
-        end   
-        begin
-          # workaround for bug in Excel 2010: workbook.Open does not always return the workbook with given file name
-          @ole_workbook = workbooks.Item(File.basename(filename))       
-          self.visible = options[:visible].nil? ? @excel.visible : options[:visible]
-          #self.visible = options[:visible] unless options[:visible].nil?
-          #@ole_workbook.UpdateLinks = update_links_opt
-          @ole_workbook.CheckCompatibility = options[:check_compatibility]
-        rescue WIN32OLERuntimeError
-          raise FileNotFound, "cannot find the file #{File.basename(filename).inspect}"
-        end       
+          begin
+            # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
+            begin
+              @ole_workbook = workbooks.Item(File.basename(filename))
+            rescue WIN32OLERuntimeError => msg
+              raise UnexpectedError, "unexpected WIN32OLERuntimeError: #{msg.message}"
+            end
+            if options[:force][:visible].nil? && (not options[:default][:visible].nil?)
+              if @excel.created   
+                self.visible = options[:default][:visible] 
+              else
+                self.window_visible = options[:default][:visible]
+              end
+            else
+              self.visible = options[:force][:visible] unless options[:force][:visible].nil?
+            end
+            @ole_workbook.CheckCompatibility = options[:check_compatibility]
+            @excel.calculation = options[:calculation] unless options[:calculation].nil?
+            self.Saved = true # unless self.Saved # ToDo: this is too hard
+          rescue WIN32OLERuntimeError => msg
+            raise UnexpectedError, "unexpected WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
+          end       
+        end
+      end
+    end
+
+    # translating the option UpdateLinks from REO to VBA 
+    # setting UpdateLinks works only if calculation mode is automatic,
+    # parameter 'UpdateLinks' has no effect
+    def updatelinks_vba(updatelinks_reo)
+      case updatelinks_reo
+      when :alert; RobustExcelOle::XlUpdateLinksUserSetting
+      when :never; RobustExcelOle::XlUpdateLinksNever
+      when :always; RobustExcelOle::XlUpdateLinksAlways
+      else RobustExcelOle::XlUpdateLinksNever
       end
     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
+    def with_workaround_linked_workbooks_excel2007(options)
+      workbooks = @excel.Workbooks
+      workaround_condition = @excel.Version.split(".").first.to_i >= 12 && workbooks.Count == 0
+      if workaround_condition
+        workbooks.Add 
+        @excel.calculation = options[:calculation].nil? ? @excel.calculation : options[:calculation] 
+      end
+      begin
+        #@excel.with_displayalerts(update_links_opt == :alert ? true : @excel.displayalerts) do
+        yield self
+      ensure
+        @excel.with_displayalerts(false){workbooks.Item(1).Close} if workaround_condition           
+      end
+    end
+       
   public
 
     # closes the workbook, if it is alive
@@ -391,6 +447,16 @@ module RobustExcelOle
 
   public
 
+    # keeps the saved-status unchanged
+    def retain_saved
+      saved = self.Saved
+      begin
+         yield self
+      ensure
+        self.Saved = saved
+      end
+    end
+
     def self.for_reading(*args, &block)
       args = args.dup
       opts = args.last.is_a?(Hash) ? args.pop : {}
@@ -407,7 +473,7 @@ module RobustExcelOle
       unobtrusively(*args, &block)
     end
 
-    # modifies a workbook such that its state (open/close, saved/unsaved, readonly/writable) remains unchanged
+    # allows to modify a workbook such that its state (open/close, saved/unsaved, readonly/writable) remains unchanged
     # @param [String] file        the file name
     # @param [Hash]   if_closed   an option
     # @param [Hash]   opts        the options
@@ -420,13 +486,13 @@ module RobustExcelOle
     #   :if_closed :   if the workbook is closed, then open it in
     #                    :current (or :active, :reuse) -> the Excel instance of the workbook, if it exists, 
     #                                                     reuse another Excel, otherwise          
-    #                    :hidden -> a separate Excel instance that is not visible and has no displayaslerts
+    #                    :hidden -> a separate Excel instance that is not visible and has no displayalerts
     #                    <excel-instance> -> the given Excel instance
     #  :readonly_excel:  if the workbook is opened only as ReadOnly and shall be modified, then
     #                    true:  closes it and open it as writable in the Excel instance where it was open so far
     #                    false (default)   opens it as writable in another running excel instance, if it exists,
     #                                      otherwise open in a new Excel instance.
-    #  :visible, :readl_only, :update_links, :check_compatibility : see options in #open
+    #  :visible, :read_only, :update_links, :check_compatibility : see options in #open
     # @return [Book] a workbook
     def self.unobtrusively(file, if_closed = nil, opts = { }, &block) 
       if if_closed.is_a? Hash
@@ -435,58 +501,60 @@ module RobustExcelOle
       end
       if_closed = :current if (if_closed == :reuse || if_closed == :active)
       if_closed = :current unless if_closed
-      options = {
-        :read_only => false,
-        :readonly_excel => false,
-        :keep_open => false,
-        :check_compatibility => false
-      }.merge(opts)
+      options = process_options(opts)
+      opts = {:readonly_excel => false,:keep_open => false}.merge(opts)
       book = bookstore.fetch(file, :prefer_writable => (not options[:read_only]))
       was_not_alive_or_nil = book.nil? || (not book.alive?)
       workbook = book.excel.Workbooks.Item(File.basename(file)) rescue nil
-      now_alive = 
-        begin 
-          workbook.Name
-          true
-        rescue 
-          false
-        end
       was_saved = was_not_alive_or_nil ? true : book.saved
-      was_writable = book.writable unless was_not_alive_or_nil      
+      was_writable = book.writable unless was_not_alive_or_nil
+      was_check_compatibility = book.CheckCompatibility unless was_not_alive_or_nil     
       begin 
         book = 
           if was_not_alive_or_nil 
             case if_closed
             when :current
-              open(file, :default_excel => :current, :read_only => options[:read_only])
+              open(file, :default => {:excel => :current}, :read_only => options[:read_only])
             when :hidden 
-              open(file, :force_excel => bookstore.hidden_excel, :read_only => options[:read_only])
+              open(file, :force => {:excel => bookstore.hidden_excel}, :read_only => options[:read_only])
             else 
-              open(file, :force_excel => if_closed, :read_only => options[:read_only])
+              open(file, :force => {:excel => if_closed}, :read_only => options[:read_only])
             end
           else
             if was_writable || options[:read_only]
               book
             else
-              options[:readonly_excel] ? open(file, :force_excel => book.excel, :read_only => options[:read_only]) : 
-                                         open(file, :force_excel => :new, :read_only => options[:read_only])
+              options[:readonly_excel] ? open(file, :force => {:excel => book.excel}, :read_only => options[:read_only]) : 
+                                         open(file, :force => {:excel => :new}, :read_only => options[:read_only])
             end
           end
-        #book.excel.visible = options[:visible] unless options[:visible].nil?
-        book.visible = options[:visible].nil? ? book.excel.visible : options[:visible]
-        old_check_compatibility = book.CheckCompatibility
-        book.CheckCompatibility = options[:check_compatibility]
+        #book.excel.visible = options[:force][:visible] unless options[:force].nil? or options[:force][:visible].nil?
+        options = process_options(options)
+        if options[:force][:visible].nil? && (not options[:default][:visible].nil?)
+          if book.excel.created   
+            book.visible = options[:default][:visible] 
+          else
+            book.window_visible = options[:default][:visible]
+          end
+        else
+          book.visible = options[:force][:visible] unless options[:force][:visible].nil?
+        end
+        book.CheckCompatibility = options[:check_compatibility] unless options[:check_compatibility].nil?
         yield book
       ensure
-        was_saved_or_appeared = was_saved || was_not_alive_or_nil || (not was_writable)
-        book.save if book && (not book.saved) && (not options[:read_only]) && was_saved_or_appeared
-        # book was open, readonly and shoud be modified
-        if (not was_not_alive_or_nil) && (not options[:read_only]) && (not was_writable) && options[:readonly_excel]
-          open(file, :force_excel => book.excel, :if_obstructed => :new_excel, :read_only => true)
+        if book && book.alive?          
+          unless book.saved
+            book.save unless options[:read_only]
+            book.Saved = true if was_saved && options[:read_only]
+            book.Saved = false unless was_saved || options[:read_only]
+          end
+          # book was open, readonly and should be modified
+          unless was_not_alive_or_nil || options[:read_only] || was_writable || (not options[:readonly_excel])
+            open(file, :force => {:excel => book.excel}, :if_obstructed => :new_excel, :read_only => true)
+          end
+          book.CheckCompatibility = was_check_compatibility unless was_check_compatibility.nil?
+          book.close if was_not_alive_or_nil && (not options[:keep_open])
         end
-        @can_be_closed = true if options[:keep_open] && book
-        book.close if (was_not_alive_or_nil && (not now_alive) && (not options[:keep_open]) && book)
-        book.CheckCompatibility = old_check_compatibility if book && book.alive?
       end
     end
 
@@ -561,26 +629,21 @@ module RobustExcelOle
           raise OptionInvalid, ":if_exists: invalid option: #{options[:if_exists].inspect}"
         end
       end
-      blocking_workbook = 
-        begin
-          @excel.Workbooks.Item(File.basename(file))
-        rescue WIN32OLERuntimeError => msg
-          nil
-        end
-      if blocking_workbook then
+      other_workbook = @excel.Workbooks.Item(File.basename(file)) rescue nil
+      if other_workbook && (not(self.filename == other_workbook.Fullname.tr('\\','/'))) then
         case options[:if_obstructed]
         when :raise
-          raise WorkbookBlocked, "blocked by another workbook: #{blocking_workbook.Fullname.tr('\\','/')}"
+          raise WorkbookBlocked, "blocked by another workbook: #{other_workbook.Fullname.tr('\\','/')}"
         when :forget
           # nothing
         when :save
-          blocking_workbook.Save
+          other_workbook.Save
         when :close_if_saved
-          raise WorkbookBlocked, "blocking workbook is unsaved: #{File.basename(file).inspect}" unless blocking_workbook.Saved
+          raise WorkbookBlocked, "blocking workbook is unsaved: #{File.basename(file).inspect}" unless other_workbook.Saved
         else
           raise OptionInvalid, ":if_obstructed: invalid option: #{options[:if_obstructed].inspect}"
         end
-        blocking_workbook.Close
+        other_workbook.Close
       end
       save_as_workbook(file, options)
       self
@@ -619,7 +682,6 @@ module RobustExcelOle
         sheet_class.new(@ole_workbook.Worksheets.Item(name))
       rescue WIN32OLERuntimeError => msg
         raise NameNotFound, "could not return a sheet with name #{name.inspect}"
-        # trace "#{msg.message}"
       end
     end    
 
@@ -742,7 +804,7 @@ module RobustExcelOle
           raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
         end
       end
-      if value == RobustExcelOle::XlErrName  # -2146826259
+      if value.is_a?(Bignum)  #RobustExcelOle::XlErrName  
         return default_val if default_val
         raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
       end 
@@ -794,19 +856,35 @@ module RobustExcelOle
       @excel.visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
     end
 
-    # makes the window of the workbook visible or invisible
-    # @param [Boolean] visible_value value that determines whether the workbook shall be visible
+    # makes both the Excel instance and the window of the workbook visible, or the window invisible
+    # @param [Boolean] visible_value determines whether the workbook shall be visible
     def visible= visible_value
-      saved = @ole_workbook.Saved
       @excel.visible = true if visible_value
-      if @excel.Visible
-        if @ole_workbook.Windows.Count > 0
-          @ole_workbook.Windows(@ole_workbook.Name).Visible = visible_value
-        end
+      self.window_visible = visible_value
+    end
+
+    # returns true, if the window of the workbook is set to visible, false otherwise
+    def window_visible
+      return @ole_workbook.Windows(@ole_workbook.Name).Visible
+    end
+
+    # makes the window of the workbook visible or invisible
+    # @param [Boolean] visible_value determines whether the window of the workbook shall be visible
+    def window_visible= visible_value
+      retain_saved do
+        @ole_workbook.Windows(@ole_workbook.Name).Visible = visible_value if @ole_workbook.Windows.Count > 0
       end
-      @ole_workbook.Saved = saved
     end
 
+#    def visible= visible_value
+#      retain_saved do
+#        @excel.visible = true if visible_value
+#        if @ole_workbook.Windows.Count > 0
+#          @ole_workbook.Windows(@ole_workbook.Name).Visible = visible_value 
+#        end
+#      end
+#    end
+
     # returns true, if the workbook reacts to methods, false otherwise
     def alive?
       begin 
@@ -920,6 +998,4 @@ public
 
   Workbook = Book
 
-
-
 end