robust_excel_ole 0.5.1 → 0.6

data/examples/edit_sheets/example_saving.rb

@@ -1,9 +1,8 @@
 # example_saving.rb: 
 # save the sheets of a book as separate workbooks
 
-require 'rubygems'
-#require 'general'
-require File.join(File.dirname(__FILE__), '../../lib/general')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_control_to_excel.rb

@@ -1,8 +1,8 @@
 # example_give_control_to_excel.rb: 
 # open, close, save  with giving control to Excel 
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle
@@ -23,7 +23,7 @@ begin
   	puts "#{msg.message}"                                  #   an exeptions is raised
   end
   puts "new book has opened" if new_book
-  Excel.current.Visible = true
+  Excel.current.visible = true
   begin
   	book.close(:if_unsaved => :alert)                      # close the unsaved book. 
   rescue ExcelUserCanceled => msg                          # user is asked whether the unsaved book shall be saved

data/examples/open_save_close/example_default_excel.rb

@@ -1,8 +1,8 @@
 # example_default_excel.rb: 
 # reopening books using :default_excel
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle
@@ -23,9 +23,9 @@ 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 => :reuse, :visible => true) # open another book
+  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 => :reuse the book is opened
+    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)         

data/examples/open_save_close/example_force_excel.rb

@@ -1,8 +1,8 @@
 # example_force_excel.rb: 
 # opening books in new or given Excel instances using :force_excel
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_obstructed_closeifsaved.rb

@@ -1,8 +1,8 @@
 # example_if_obstructed_close_if_saved.rb:
 # open with :if_obstructed: :close_if_saved
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_obstructed_forget.rb

@@ -1,8 +1,8 @@
 # example_if_obstructed_forget.rb: 
 # open with :if_obstructed: :forget, :new_excel
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_obstructed_save.rb

@@ -1,8 +1,8 @@
 # example_if_obstructed_save.rb:
 # open with :if_obstructed: :save
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_unsaved_accept.rb

@@ -1,8 +1,8 @@
 # example_ifunsaved_accept.rb: 
 # open with :if_unsaved => :accept, close with :if_unsaved => :save 
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_unsaved_forget.rb

@@ -1,8 +1,8 @@
 # example_ifunsaved_forget.rb:
 # open with :if_unsaved => :forget, :new_excel, close with :if_unsaved => :save 
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_if_unsaved_forget_more.rb

@@ -1,19 +1,18 @@
 # example_ifunsaved_forget_more.rb:
 # open with :if_unsaved => :forget, :new_excel, close with :if_unsaved => :save 
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle
 
-Excel.close_all
+Excel.kill_all
 begin
   dir = create_tmpdir
   file_name = dir + 'workbook.xls' 
   book = Book.open(file_name)                      # open a book
   book.excel.visible = true                        # make current Excel visible 
-  sleep
   sheet = book.sheet(1)                                            # access a sheet
   first_cell = sheet[1,1].value
   sheet[1,1] = first_cell == "simple" ? "complex" : "simple" # change a cell
@@ -33,6 +32,6 @@ begin
   another_book.close(:if_unsaved => :forget )           # close the last book without saving it.                      
   book.close(:if_unsaved => :save)                      # close the first book and save it before
 ensure
-	  Excel.close_all                                    # close all workbooks, quit Excel application
+	  Excel.kill_all                                    # close all workbooks, quit Excel application
     rm_tmp(dir)
 end

data/examples/open_save_close/example_read_only.rb

@@ -1,7 +1,7 @@
 # example_read_only: open with read_only mode. save, close 
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_rename_cells.rb

@@ -1,8 +1,8 @@
 # example_simple.rb: 
 # open a book, simple save, save_as, close
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle
@@ -17,7 +17,7 @@ begin
   workbook = book.ole_workbook
   fullname = workbook.Fullname
   puts "fullname: #{fullname}"  
-  sheet.add_name(1,1,"a_name")   # rename cell A1 to "a_name"
+  sheet.set_name("a_name",1,1)   # rename cell A1 to "a_name"
   number = workbook.Names.Count
   puts "number of name objects :#{number}"
   name_object = workbook.Names("a_name")

data/examples/open_save_close/example_reuse.rb

@@ -1,7 +1,7 @@
 # example_reuse.rb: open a book in a new Excel and a running Excel instance. make visible
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/examples/open_save_close/example_simple.rb

@@ -5,15 +5,14 @@ LOG_TO_STDOUT = false
 REO_LOG_FILE = "reo2.log"
 REO_LOG_DIR = "C:/"
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle
 
 Excel.kill_all
 begin
-  trace "hello"
   dir = create_tmpdir
   file_name = dir + 'workbook.xls'
   other_file_name = dir + 'different_workbook.xls'
@@ -34,6 +33,6 @@ begin
   book.close                                                 # close the book
 ensure
 	  Excel.close_all                                         # close workbooks, quit Excel application
-    rm_tmp(dir)
+    #rm_tmp(dir)
 end		
 

data/examples/open_save_close/example_unobtrusively.rb

@@ -1,7 +1,7 @@
 # example_unobtrusively.rb:
 
-require File.join(File.dirname(__FILE__), '../../lib/general')
-require File.join(File.dirname(__FILE__), '../../spec/helpers/create_temporary_dir')
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
 require "fileutils"
 
 include RobustExcelOle

data/lib/robust_excel_ole/book.rb

@@ -15,13 +15,13 @@ module RobustExcelOle
     alias ole_object ole_workbook
 
       DEFAULT_OPEN_OPTS = { 
-        :excel => :active,
-        :default_excel => :active,      
+        :default_excel => :current,      
         :if_unsaved    => :raise,
         :if_obstructed => :raise,
         :if_absent     => :raise,
         :read_only => false,
-        :check_compatibility => true
+        :check_compatibility => true,
+        :update_links => :never
       }
 
     class << self
@@ -29,26 +29,26 @@ module RobustExcelOle
       # opens a workbook.
       # @param [String] file the file name
       # @param [Hash] opts the options
-      # @option opts [Variant] :default_excel  :active (default), :new, or <excel-instance>     
-      # @option opts [Variant] :force_excel    :active, :new, or <excel-instance>
+      # @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 [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] :displayalerts  true, or false (default)
-      # @option opts [Boolean] :visible        true, or false (default) 
+      # @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) 
       # 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
-      #                   :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
+      #                   :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             -> connects to a running (the first opened) Excel instance
-      #                   :active or :reuse   -> opens in the active Excel instance
+      #                   :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
       # :if_unsaved     if an unsaved workbook with the same name is open, then
       #                  :raise               -> raises an exception
@@ -65,22 +65,20 @@ 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     opens in read-only mode         
-      # :displayalerts enables DisplayAlerts in Excel  
-      # :visible       makes visible in Excel        
-      # :check_compatibility  check compatibility when saving
-      # if :default_excel is set, then DisplayAlerts and Visible are set only if these parameters are given
+      # :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
+      # :check_compatibility  true -> check compatibility when saving
       # @return [Book] a workbook
       def open(file, opts={ }, &block)
         options = DEFAULT_OPEN_OPTS.merge(opts)
-        options[:default_excel] = :active if options[:default_excel] == :reuse
-        options[:force_excel] = :active if options[:force_excel] == :reuse
+        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)
         book = nil
         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] == :active ? excel_class.new(:reuse => true) : excel_of(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]), 
@@ -94,6 +92,7 @@ module RobustExcelOle
               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] unless options[:visible].nil?
               return book
             end
           end
@@ -102,7 +101,8 @@ module RobustExcelOle
       end
     end    
 
-    # creates a Book object for a given workbook or file name
+    # creates a Book object by opening an Excel file given its filename workbook or 
+    # by lifting a Win32OLE object representing an Excel file
     # @param [WIN32OLE] workbook a workbook
     # @param [Hash] opts the options
     # @option opts [Symbol] see above
@@ -113,7 +113,7 @@ module RobustExcelOle
         if filename
           book = bookstore.fetch(filename)
           if book && book.alive?
-            book.apply_options(opts)
+            book.visible = opts[:visible] unless opts[:visible].nil?
             return book 
           end
         end
@@ -135,13 +135,15 @@ module RobustExcelOle
         # use the Excel instance where the workbook is opened
         win32ole_excel = WIN32OLE.connect(workbook.Fullname).Application rescue nil   
         @excel = excel_class.new(win32ole_excel)     
-        self.apply_options(options)       
+        @excel.visible = options[:visible] unless options[:visible].nil?     
         # if the Excel could not be promoted, then create it         
         ensure_excel(options)
       else
         file = file_or_workbook
         ensure_excel(options)
         ensure_workbook(file, options)
+        @ole_workbook.CheckCompatibility = options[:check_compatibility]
+        @can_be_closed = false if @can_be_closed.nil?
       end
       bookstore.store(self)
       if block
@@ -153,11 +155,6 @@ 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
@@ -187,16 +184,14 @@ module RobustExcelOle
     def ensure_excel(options)   # :nodoc: #
       return if @excel && @excel.alive?
       options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
-      options[:excel] = :active if options[:excel == :reuse]
-      excel_options = {:displayalerts => false, :visible => false}.merge(options)
-      excel_options[:reuse] = (options[:excel] == :active) 
-      @excel = self.class.excel_of(options[:excel]) unless (options[:excel] == :active || options[:excel] == :new)
-      @excel = excel_class.new(excel_options) unless (@excel && @excel.alive?)
-      apply_options unless excel_options
-    end
+      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: #
       file = @stored_filename ? @stored_filename : file
+      raise(ExcelErrorOpen, "filename is nil") if file.nil?
       unless File.exist?(file)
         if options[:if_absent] == :create
           @ole_workbook = excel_class.current.generate_workbook(file)
@@ -231,7 +226,7 @@ module RobustExcelOle
               open_or_create_workbook(file, options)
             end
           when :new_excel 
-            excel_options = {:displayalerts => false, :visible => false}.merge(options)   
+            excel_options = {:visible => false}.merge(options)   
             excel_options[:reuse] = false
             @excel = excel_class.new(excel_options)
             open_or_create_workbook(file, options)
@@ -255,7 +250,7 @@ module RobustExcelOle
                 open_or_create_workbook(file,options)
               end 
             when :new_excel
-              excel_options = {:displayalerts => false, :visible => false}.merge(options)
+              excel_options = {:visible => false}.merge(options)
               excel_options[:reuse] = false
               @excel = excel_class.new(excel_options)
               open_or_create_workbook(file, options)
@@ -294,10 +289,19 @@ module RobustExcelOle
           # 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
-          workbooks.Item(1).CheckCompatibility = options[:check_compatibility]
-          @can_be_closed = false if @can_be_closed.nil?
+          update_links_opt =
+            case options[:update_links]
+            when :alert; RobustExcelOle::XlUpdateLinksUserSetting
+            when :never; RobustExcelOle::XlUpdateLinksNever
+            when :always; RobustExcelOle::XlUpdateLinksAlways
+            else RobustExcelOle::XlUpdateLinksNever
+          end
+          @excel.with_displayalerts(update_links_opt == :alert ? true : @excel.displayalerts) do
+            # ??? determining update_links_opt here does not work, it is always XlUpdateLinksNever afterwords
+            workbooks.Open(filename, { 'ReadOnly' => options[:read_only] , 'UpdateLinks' => update_links_opt } )
+          end
+          workbooks.Open(filename, { 'ReadOnly' => options[:read_only] } )
+          workbooks.Item(1).Close if @excel.Version == "12.0" && count == 0                   
         rescue WIN32OLERuntimeError => msg
           trace "WIN32OLERuntimeError: #{msg.message}" 
           if msg.message =~ /800A03EC/
@@ -307,12 +311,13 @@ module RobustExcelOle
           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))
+          # 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] unless options[:visible].nil?
+          @ole_workbook.UpdateLinks = update_links_opt
         rescue WIN32OLERuntimeError
           raise ExcelErrorOpen, "cannot find the file #{File.basename(filename).inspect}"
-        end
+        end       
       end
     end
 
@@ -385,34 +390,30 @@ module RobustExcelOle
     # @param [String] file        the file name
     # @param [Hash]   if_closed   an option
     # @param [Hash]   opts        the options
-    # @option opts [Variant] :if_closed  :active or :reuse (default), :hidden or a Excel instance
+    # @option opts [Variant] :if_closed  :current (or :reuse, :active) (default), :hidden or a Excel instance
     # @option opts [Boolean] :read_only whether the file is opened for read-only
     # @option opts [Boolean] :readonly_excel behaviour when workbook is opened read-only and shall be modified
     # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening
-    # @option opts [Boolean] :displayalerts  true, or false (default)
     # @option opts [Boolean] :visible        true, or false (default) 
     #  options: 
     #   :if_closed :   if the workbook is closed, then open it in
-    #                    :active or :reuse -> the Excel instance of the workbook, if it exists, 
-    #                                         reuse another Excel, otherwise          
+    #                    :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
     #                    <excel-instance> -> the given Excel instance
-    #  :read_only        : opens the workbook unobtrusively for reading only  (default: false)
     #  :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.
-    # :displayalerts      enables DisplayAlerts in Excel  
-    # :visible            makes visible in Excel 
-    # :check_compatibility checks compatibility when saving
+    #  :visible, :readl_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
         opts = if_closed
         if_closed = nil
       end
-      if_closed = :active if if_closed == :reuse
-      if_closed = :active unless if_closed
+      if_closed = :current if (if_closed == :reuse || if_closed == :active)
+      if_closed = :current unless if_closed
       options = {
         :read_only => false,
         :readonly_excel => false,
@@ -435,8 +436,8 @@ module RobustExcelOle
         book = 
           if was_not_alive_or_nil 
             case if_closed
-            when :active
-              open(file, :read_only => options[:read_only])
+            when :current
+              open(file, :default_excel => :current, :read_only => options[:read_only])
             when :hidden 
               open(file, :force_excel => bookstore.hidden_excel, :read_only => options[:read_only])
             else 
@@ -450,7 +451,6 @@ module RobustExcelOle
                                          open(file, :force_excel => :new, :read_only => options[:read_only])
             end
           end
-        book.excel.displayalerts = options[:displayalerts] unless options[:displayalerts].nil?
         book.excel.visible = options[:visible] unless options[:visible].nil?
         old_check_compatibility = book.CheckCompatibility
         book.CheckCompatibility = options[:check_compatibility]
@@ -477,7 +477,7 @@ module RobustExcelOle
     # @raise ExcelErrorSave if workbook is not alive or opened for read-only, or another error occurs
     # @return [Boolean] true, if successfully saved, nil otherwise
     def save      
-      raise ExcelErrorSave, "Workbook is not alive" if (not alive?)
+      raise ExcelErrorSave, "workbook is not alive" if (not alive?)
       raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @ole_workbook.ReadOnly
       begin
         @ole_workbook.Save 
@@ -511,8 +511,9 @@ module RobustExcelOle
     #                          the file already exists (with option :if_exists :raise),
     #                          the workbook is blocked by another one (with option :if_obstructed :raise)
     # @return [Book], the book itself, if successfully saved, raises an exception otherwise
-    def save_as(file = nil, opts = { } )
-      raise ExcelErrorSave, "Workbook is not alive" if (not alive?)
+    def save_as(file, opts = { } )
+      raise(ExcelErrorSave, "filename is nil") if file.nil?
+      raise ExcelErrorSave, "workbook is not alive" if (not alive?)
       raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @ole_workbook.ReadOnly
       options = {
         :if_exists => :raise,
@@ -704,16 +705,20 @@ module RobustExcelOle
     # returns the contents of a range with given name
     # evaluates formula contents of the range is a formula
     # if no contents could be returned, then return default value, if provided, raise error otherwise
+    # Excel Bug: if a local name without a qualifier is given, then by default Excel takes the first worksheet,
+    #            even if a different worksheet is active
     # @param  [String]      name      the name of the range
     # @param  [Hash]        opts      the options
     # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
     # @raise  ExcelError if range name is not in the workbook or if range value could not be evaluated
     # @return [Variant] the contents of a range with given name
+  
     def nameval(name, opts = {:default => nil})
+      default_val = opts[:default]
       begin
         name_obj = self.Names.Item(name)
       rescue WIN32OLERuntimeError
-        return opts[:default] if opts[:default]
+        return default_val if default_val
         raise ExcelError, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
       end
       begin
@@ -722,15 +727,15 @@ module RobustExcelOle
         begin
           value = self.sheet(1).Evaluate(name_obj.Name)
         rescue WIN32OLERuntimeError
-          return opts[:default] if opts[:default]
-          raise SheetError, "cannot evaluate name #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
+          return default_val if default_val
+          raise ExcelError, "cannot evaluate name #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
         end
       end
-      if value == -2146826259
-        return opts[:default] if opts[:default]
-        raise SheetError, "cannot evaluate name #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
+      if value == RobustExcelOle::XlErrName  # -2146826259
+        return default_val if default_val
+        raise ExcelError, "cannot evaluate name #{name.inspect} in #{File.basename(self.stored_filename).inspect}"
       end 
-      return opts[:default] if (value.nil? && opts[:default])
+      return default_val if default_val && value.nil?
       value      
     end
 
@@ -782,15 +787,16 @@ module RobustExcelOle
 
     # returns true, if the workbook is visible, false otherwise 
     def visible
-      @excel.Windows(@ole_workbook.Name).Visible
+      @excel.visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
     end
 
-    # makes a workbook visible or invisible
+    # makes the window of the workbook visible or invisible
     # @param [Boolean] visible_value value that determines whether the workbook shall be visible
     def visible= visible_value
       saved = @ole_workbook.Saved
-      @excel.Windows(@ole_workbook.Name).Visible = visible_value
-      save if saved 
+      @excel.visible = true if visible_value
+      @ole_workbook.Windows(@ole_workbook.Name).Visible = visible_value if @excel.Visible
+      save if saved && (not self.ReadOnly)
     end
 
     # returns true, if the workbook reacts to methods, false otherwise
@@ -837,7 +843,7 @@ module RobustExcelOle
       self.class.bookstore
     end   
 
-    def self.show_books   # :nodoc: #
+    def self.all_books   # :nodoc: #
       bookstore.books
     end