robust_excel_ole 1.11 → 1.12

data/lib/robust_excel_ole/reo_common.rb

@@ -75,13 +75,17 @@ module RobustExcelOle
   end
 
   # @private
-  class WorkbookConnectingNotAliveError < WorkbookREOError        
+  class WorkbookConnectingUnsavedError < WorkbookREOError        
   end
 
   # @private
   class WorkbookConnectingBlockingError < WorkbookREOError       
   end
 
+  # @private
+  class WorkbookConnectingUnknownError < WorkbookREOError       
+  end
+
   # @private
   class FileNotFound < FileREOError                
   end
@@ -169,8 +173,8 @@ module RobustExcelOle
           home = homes.find { |h| !ENV[h].nil? }
           reo_log_dir = ENV[home]
         else
-          reo_log_dir = REO_LOG_DIR
-          #reo_log_dir = "C:/Users/User"
+          #reo_log_dir = REO_LOG_DIR
+          reo_log_dir = "C:/Users/User"
         end
         File.open(reo_log_dir + '/' + REO_LOG_FILE,'a') do |file|
           file.puts text

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.11"
+  VERSION = "1.12"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -14,7 +14,7 @@ module RobustExcelOle
     attr_accessor :excel
     attr_accessor :ole_workbook
     attr_accessor :stored_filename
-    attr_accessor :modified_cells
+    attr_accessor :color_if_modified
     attr_reader :workbook
 
     alias ole_object ole_workbook
@@ -25,9 +25,14 @@ module RobustExcelOle
       :if_unsaved    => :raise,
       :if_obstructed => :raise,
       :if_absent     => :raise,
-      :read_only => false,
+      #:read_only => false,
       :check_compatibility => false,
-      :update_links => :never
+      :update_links => :never,
+      :if_exists => :raise
+    }.freeze
+
+    CORE_DEFAULT_OPTEN_OPTS = {
+      :default => {:excel => :current}, :force => {}, :update_links => :never
     }.freeze
 
     ABBREVIATIONS = [[:default,:d], [:force, :f], [:excel, :e], [:visible, :v],
@@ -39,8 +44,8 @@ module RobustExcelOle
     # @param [Hash] opts the options
     # @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_unsaved     :raise (default), :forget, :save, :accept, :alert, :excel, or :new_excel
+    # @option opts [Symbol]  :if_blocked     :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
@@ -49,7 +54,7 @@ module RobustExcelOle
     # :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
+    # :default and :force contain: :excel
     #  :excel   :current (or :active or :reuse)
     #                    -> connects to a running (the first opened) Excel instance,
     #                       excluding the hidden Excel instance, if it exists,
@@ -81,14 +86,13 @@ module RobustExcelOle
     def self.open(file, opts = { }, &block)
       raise(FileNameNotGiven, 'filename is nil') if file.nil?
       raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
-      options = process_options(opts)
+      options = process_options(opts, :use_defaults => false)
       book = nil
       if 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 RUBY_PLATFORM !~ /java/ 
+        # if readonly is true, then prefer a book that is given in force_excel if this option is set              
+        forced_excel = 
           (options[:force][:excel].nil? || options[:force][:excel] == :current) ? 
-            excel_class.new(:reuse => true) : excel_of(options[:force][:excel])
-        end
+            (excel_class.new(:reuse => true) if RUBY_PLATFORM !~ /java/) : excel_of(options[:force][:excel])              
         begin
           book = if File.exists?(file)
             bookstore.fetch(file, :prefer_writable => !(options[:read_only]),
@@ -97,22 +101,13 @@ module RobustExcelOle
         rescue
           trace "#{$!.message}"
         end
-        if book          
-          if (!(options[:force][:excel]) || (forced_excel == book.excel)) &&
-             !(book.alive? && !book.saved && (options[:if_unsaved] != :accept))
-            book.ensure_excel(options) # unless book.excel.alive?
-            # if the ReadOnly status shall be changed, save, close and reopen it
-            # removed the feature for the next time
-            if book.alive? && ((!book.writable && !(options[:read_only])) ||
-               (book.writable && options[:read_only]))
-              book.save if book.writable && !book.saved
-              book.close(:if_unsaved => :forget)
-            end
-            # reopens the book if it was closed
-            book.ensure_workbook(file,options) unless book.alive?
-            book.visible = options[:force][:visible] unless options[:force][:visible].nil?
-            book.CheckCompatibility = options[:check_compatibility] unless options[:check_compatibility].nil?
-            book.excel.calculation = options[:calculation] unless options[:calculation].nil?
+        if book      
+          # drop the fetched workbook if it shall be opened in another Excel instance
+          # or the workbook is an unsaved workbook that should not be accepted
+          if (options[:force][:excel].nil? || options[:force][:excel] == :current || forced_excel == book.excel) &&
+            !(book.alive? && !book.saved && (options[:if_unsaved] != :accept))
+            options[:force][:excel] = book.excel if book.excel && book.excel.alive?
+            book.ensure_workbook(file,options)
             return book
           end
         end
@@ -134,11 +129,11 @@ module RobustExcelOle
         # use the Excel instance where the workbook is opened
         ole_excel = WIN32OLE.connect(workbook.Fullname).Application rescue nil
         @excel = excel_class.new(ole_excel)
-        @excel.visible = options[:force][:visible] unless options[:force][:visible].nil?
-        @excel.calculation = options[:calculation] unless options[:calculation].nil?
+        filename = @ole_workbook.Fullname.tr('\\','/')
+        set_options(filename, options)
       else
-        filename = file_or_workbook        
-        ensure_excel(options)
+        filename = file_or_workbook    
+        #ensure_excel(options) #unless RUBY_PLATFORM =~ /java/ && (options[:force][:excel].nil? || options[:force][:excel] == :current)            
         ensure_workbook(filename, options)
       end
       bookstore.store(self)
@@ -175,8 +170,8 @@ module RobustExcelOle
             erg[new_key] = value
           end
         end
-        erg[:default] = {} if erg[:default].nil?
-        erg[:force] = {} if erg[:force].nil?
+        erg[:default] ||= {}
+        erg[:force] ||= {}
         force_list = [:visible, :excel]
         erg.each { |key,value| erg[:force][key] = value if force_list.include?(key) }
         erg[:default][:excel] = erg[:default_excel] unless erg[:default_excel].nil?
@@ -186,8 +181,7 @@ module RobustExcelOle
         erg
       end
       opts = translator.call(options)
-      default_open_opts = proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS :
-        {:default => {:excel => :current}, :force => {}, :update_links => :never }
+      default_open_opts = proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS : CORE_DEFAULT_OPTEN_OPTS        
       default_opts = translator.call(default_open_opts)
       opts = default_opts.merge(opts)
       opts[:default] = default_opts[:default].merge(opts[:default]) unless opts[:default].nil?
@@ -198,21 +192,11 @@ module RobustExcelOle
     # returns an Excel object when given Excel, Workbook or Win32ole object representing a Workbook or an Excel
     # @private
     def self.excel_of(object) 
-      if object.is_a? WIN32OLE
-        case object.ole_obj_help.name
-        when /Workbook/i
-          new(object).excel
-        when /Application/i
-          excel_class.new(object)
-        else
-          object.excel
-        end
-      else
-        begin
-          object.excel
-        rescue
-          raise TypeREOError, 'given object is neither an Excel, a Workbook, nor a Win32ole'
-        end
+      begin
+        object = object.to_reo if object.is_a? WIN32OLE
+        object.excel
+      rescue
+        raise TypeREOError, 'given object is neither an Excel, a Workbook, nor a Win32ole'
       end
     end
 
@@ -221,50 +205,58 @@ module RobustExcelOle
     # @private
     # ensures an excel but not for jruby if current Excel shall be used
     def ensure_excel(options)
+      return if @excel && @excel.alive?
       excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]
       @excel = if excel_option == :new
         excel_class.new(:reuse => false) 
       elsif excel_option.nil? || excel_option == :current
-        excel_class.new(:reuse => true) unless RUBY_PLATFORM =~ /java/
+        excel_class.new(:reuse => true) # unless RUBY_PLATFORM =~ /java/
       else  #elsif excel_options.is_a?(WIN32OLE) || excel_option.is_a?(Excel) #excel_option.respond_to?(:Hwnd)
         self.class.excel_of(excel_option)
       end
-      if @excel && @excel.alive?
-        @excel.visible = options[:force][:visible] unless options[:force][:visible].nil?
-        @excel.calculation = options[:calculation] unless options[:calculation].nil?
-      end
+      raise ExcelREOError, "excel is not alive" unless @excel && @excel.alive?
     end
 
-
     # @private
     # restriction for jruby: does not manage conflicts with blocking or unsaved workbooks
     def ensure_workbook(filename, options)  
-      return if @ole_workook && alive?
-      filename = @stored_filename ? @stored_filename : filename 
-      manage_nonexisting_file(filename,options)
-      if RUBY_PLATFORM =~ /java/ && (options[:force][:excel].nil? || options[:force][:excel] == :current)
-        begin
-          connect(filename,options)  
-        rescue WorkbookConnectingNotAliveError
-          raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(filename).inspect}"
-        rescue WorkbookConnectingBlockingError # can't find moniker
-          raise WorkbookBlocked, "can't open workbook #{filename}"+
-            "\nbecause it is being blocked by a workbook with the same name in a different path."
-        end
-      else
-        workbooks = @excel.Workbooks
-        @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
-        if @ole_workbook
-          manage_blocking_or_unsaved_workbook(filename,options)
-        else
-          if options[:force][:excel].nil? || options[:force][:excel] == :current
+      if options[:if_unsaved]==:accept && options[:read_only]==true
+        raise OptionInvalid, ":if_unsaved:accept and :read_only:true not possible"
+      end
+      unless @ole_workbook && alive?
+        filename = @stored_filename ? @stored_filename : filename 
+        manage_nonexisting_file(filename,options)
+        excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]
+        if RUBY_PLATFORM =~ /java/ && 
+          (excel_option.nil? || excel_option == :current) && filename[0] != '/'
+          begin
             connect(filename,options)
-          else 
-            open_or_create_workbook(filename,options)
+          rescue WorkbookConnectingUnsavedError
+            raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(filename).inspect}"
+          rescue WorkbookConnectingBlockingError
+            raise WorkbookBlocked, "can't open workbook #{filename}"+
+              "\nbecause it is being blocked by a workbook with the same name in a different path."
+          rescue WorkbookConnectingUnknownError
+            raise WorkbookREOError, "can't connect to workbook #{filename}"
           end
-        end       
+          manage_unsaved_workbook(filename,options) unless @ole_workbook.Saved
+        else
+          ensure_excel(options)
+          workbooks = @excel.Workbooks
+          @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
+          if @ole_workbook
+            manage_blocking_or_unsaved_workbook(filename,options)
+          else
+            if excel_option.nil? || excel_option == :current && 
+              (RUBY_PLATFORM !~ /java/ || filename[0] != '/')
+              connect(filename,options)
+            else 
+              open_or_create_workbook(filename,options)
+            end
+          end       
+        end
       end
-      set_options(options)
+      set_options(filename, options)
     end
 
   private
@@ -272,16 +264,24 @@ module RobustExcelOle
     # @private
     # connects to an unknown workbook and returns true, if it exists
     def connect(filename,options)
-      abs_filename = General.absolute_path(filename).tr('/','\\')
+      abs_filename = General.absolute_path(filename)
       @ole_workbook = begin
         WIN32OLE.connect(abs_filename)
       rescue
-        raise WorkbookConnectingBlockingError
+        if $!.message =~ /moniker/
+          raise WorkbookConnectingBlockingError
+        else
+          raise WorkbookConnectingUnknownError
+        end
       end
       ole_excel = begin
-        WIN32OLE.connect(@ole_workbook.Fullname).Application 
+        @ole_workbook.Application     
       rescue 
-        raise WorkbookConnectingNotAliveError
+        if $!.message =~ /dispid/
+          raise WorkbookConnectingUnsavedError
+        else
+          raise WorkbookConnectingUnknownError
+        end
       end
       @excel = excel_class.new(ole_excel)
     end
@@ -289,9 +289,9 @@ module RobustExcelOle
     # @private
     def manage_nonexisting_file(filename,options)      
       return if File.exist?(filename)
-      abs_filename = General.absolute_path(filename).tr('/','\\')
+      abs_filename = General.absolute_path(filename)
       if options[:if_absent] == :create
-        ensure_excel({:force[:excel] => :new}.merge(options)) if RUBY_PLATFORM !~ /java/
+        ensure_excel(options) unless @excel && @excel.alive?
         @excel.Workbooks.Add
         empty_ole_workbook = excel.Workbooks.Item(excel.Workbooks.Count)
         begin
@@ -308,16 +308,7 @@ module RobustExcelOle
     # @private
     def manage_blocking_or_unsaved_workbook(filename,options)
       obstructed_by_other_book = if (File.basename(filename) == File.basename(@ole_workbook.Fullname)) 
-        p1 = General.absolute_path(filename) 
-        p2 = @ole_workbook.Fullname
-        is_same_path = if p1[1..1] == ":" and p2[0..1] == '\\\\' # normal path starting with the drive letter and a path in network notation (starting with 2 backslashes)
-          # this is a Workaround for Excel2010 on WinXP: Network drives won't get translated to drive letters. So we'll do it manually:
-          p1_pure_path = p1[2..-1]
-          p2.end_with?(p1_pure_path)  and p2[0, p2.rindex(p1_pure_path)] =~ /^\\\\[\w\d_]+(\\[\w\d_]+)*$/  # e.g. "\\\\server\\folder\\subfolder"
-        else
-          p1 == p2
-        end
-        not is_same_path
+        General.absolute_path(filename) != @ole_workbook.Fullname
       end      
       if obstructed_by_other_book
         # workbook is being obstructed by a workbook with same name and different path
@@ -340,25 +331,17 @@ module RobustExcelOle
          to allow automatic closing of the old workbook (without or with saving before, respectively),
          before the new workbook is being opened."
       when :forget
-        @excel.with_displayalerts(false) { @ole_workbook.Close }
-        @ole_workbook = nil
-        open_or_create_workbook(filename, options)
+        manage_forgetting_workbook(filename, options)       
       when :save
-        save unless @ole_workbook.Saved
-        @ole_workbook.Close
-        @ole_workbook = nil
-        open_or_create_workbook(filename, options)
+        manage_saving_workbook(filename, options)        
       when :close_if_saved
         if !@ole_workbook.Saved
           raise WorkbookBlocked, "workbook with the same name in a different path is unsaved: #{@ole_workbook.Fullname.tr('\\','/')}"
         else
-          @ole_workbook.Close
-          @ole_workbook = nil
-          open_or_create_workbook(filename, options)
+          manage_forgetting_workbook(filename, options)
         end
       when :new_excel
-        @excel = excel_class.new(:reuse => false)
-        open_or_create_workbook(filename, options)
+        manage_new_excel(filename, options)        
       else
         raise OptionInvalid, ":if_blocked: invalid option: #{options[:if_obstructed].inspect}" +
         "\nHint: Valid values are :raise, :forget, :save, :close_if_saved, :new_excel"
@@ -373,72 +356,88 @@ module RobustExcelOle
         "\nHint: Save the workbook or open the workbook using option :if_unsaved with values :forget and :accept to
          close the unsaved workbook and reopen it, or to let the unsaved workbook open, respectively"
       when :forget
-        @excel.with_displayalerts(false) { @ole_workbook.Close }
-        @ole_workbook = nil
-        open_or_create_workbook(filename, options)
+        manage_forgetting_workbook(filename,options)
       when :accept
         # do nothing
+      when :save
+        manage_saving_workbook(filename, options)
       when :alert, :excel
         @excel.with_displayalerts(true) { open_or_create_workbook(filename,options) }
       when :new_excel
-        @excel = excel_class.new(:reuse => false)
-        open_or_create_workbook(filename, options)
+        manage_new_excel(filename, options)
       else
         raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}" +
-        "\nHint: Valid values are :raise, :forget, :accept, :alert, :excel, :new_excel"
+        "\nHint: Valid values are :raise, :forget, :save, :accept, :alert, :excel, :new_excel"
       end
     end
 
     # @private
-    def open_or_create_workbook(filename, options)  
-      if !@ole_workbook || (options[:if_unsaved] == :alert) || options[:if_obstructed]
+    def manage_forgetting_workbook(filename, options)
+      @excel.with_displayalerts(false) { @ole_workbook.Close }
+      @ole_workbook = nil
+      open_or_create_workbook(filename, options)
+    end
+
+    # @private
+    def manage_saving_workbook(filename, options)
+      save unless @ole_workbook.Saved
+      manage_forgetting_workbook(filename, options)
+    end
+
+    # @private
+    def manage_new_excel(filename, options)
+      @excel = excel_class.new(:reuse => false)
+      @ole_workbook = nil
+      open_or_create_workbook(filename, options)
+    end
+    
+    # @private
+    def open_or_create_workbook(filename, options)       
+      return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel
+      begin
+        abs_filename = General.absolute_path(filename)
         begin
-          abs_filename = General.absolute_path(filename)
-          begin
-            workbooks = @excel.Workbooks
-          rescue WIN32OLERuntimeError => msg
-            raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
-          end
-          begin
-            with_workaround_linked_workbooks_excel2007(options) do
-              # temporary workaround until jruby-win32ole implements named parameters (Java::JavaLang::RuntimeException (createVariant() not implemented for class org.jruby.RubyHash)
-              workbooks.Open(abs_filename, 
-                                        updatelinks_vba(options[:update_links]), 
-                                        options[:read_only] )
-            end
-          rescue WIN32OLERuntimeError => msg
-            # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
-            # if yes: distinguish these events
-            raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
+          workbooks = @excel.Workbooks
+        rescue WIN32OLERuntimeError => msg
+          raise UnexpectedREOError, "cannot access workbooks: #{msg.message} #{msg.backtrace}"
+        end
+        begin
+          with_workaround_linked_workbooks_excel2007(options) do
+            # temporary workaround until jruby-win32ole implements named parameters (Java::JavaLang::RuntimeException (createVariant() not implemented for class org.jruby.RubyHash)
+            workbooks.Open(abs_filename, 
+                                      updatelinks_vba(options[:update_links]), 
+                                      options[:read_only] )
           end
+        rescue WIN32OLERuntimeError => msg
+          # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
+          # if yes: distinguish these events
+          raise UnexpectedREOError, "cannot open workbook: #{msg.message} #{msg.backtrace}"
+        end
+        begin
+          # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
           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 UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
-            end
+            @ole_workbook = workbooks.Item(File.basename(filename))
           rescue WIN32OLERuntimeError => msg
-            raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
+            raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
           end
+        rescue WIN32OLERuntimeError => msg
+          raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
         end
       end
     end
 
     # @private
-    def set_options(options)
-      if options[:force][:visible].nil? && !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?
+    def set_options(filename, options)
+      if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
+        @excel.with_displayalerts(false) { @ole_workbook.Close }
+        @ole_workbook = nil        
+        open_or_create_workbook(filename, options)
+      end
+      retain_saved do
+        self.visible = options[:force][:visible].nil? ? @excel.Visible : options[:force][:visible]
+        @excel.calculation = options[:calculation] unless options[:calculation].nil?
+        @ole_workbook.CheckCompatibility = options[:check_compatibility] unless options[:check_compatibility].nil?
       end      
-      @excel.calculation = options[:calculation] unless options[:calculation].nil?
-      @ole_workbook.CheckCompatibility = options[:check_compatibility]
-      @ole_workbook.Saved = true # unless self.Saved # ToDo: this is too hard
     end
            
     # @private
@@ -571,6 +570,7 @@ module RobustExcelOle
     # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening
     # @return [Workbook] a workbook
     def self.unobtrusively(file, opts = { })
+      opts = process_options(opts, :use_defaults => false)
       opts = {:if_closed => :current,
               :rw_change_excel => :current,
               :keep_open => false}.merge(opts)
@@ -597,12 +597,16 @@ module RobustExcelOle
         book =
           if was_open
             if change_rw_mode
-              open(file, :force => {:excel => opts[:rw_change_excel]}, :read_only => do_not_write)
+              opts = opts.merge({:force => {:excel => opts[:rw_change_excel]}, :read_only => do_not_write})
+              open(file, opts)
+              #open(file, :force => {:excel => opts[:rw_change_excel]}, :read_only => do_not_write)
             else
               book
             end
           else
-            open(file, :force => {:excel => opts[:if_closed]}, :read_only => do_not_write)
+            opts = opts.merge({:force => {:excel => opts[:if_closed]}, :read_only => do_not_write})
+            open(file, opts)
+            #open(file, :force => {:excel => opts[:if_closed]}, :read_only => do_not_write)
           end
         yield book
       ensure
@@ -611,7 +615,8 @@ module RobustExcelOle
           if was_open
             if opts[:rw_change_excel] == book.excel && change_rw_mode
               book.close
-              book = open(file, :force => {:excel => opts[:rw_change_excel]}, :read_only => !was_writable)
+              opts = opts.merge({:force => {:excel => opts[:rw_change_excel]}, :read_only => !was_writable})
+              book = open(file, opts)           
             end
             book.excel.calculation = was_calculation
             book.CheckCompatibility = was_check_compatibility
@@ -632,9 +637,8 @@ module RobustExcelOle
     end
 
     # simple save of a workbook.
-    # @option opts [Boolean] :discoloring  states, whether colored ranges shall be discolored
     # @return [Boolean] true, if successfully saved, nil otherwise
-    def save(opts = {:discoloring => false})
+    def save(opts = { })  # option opts is deprecated #
       raise ObjectNotAlive, 'workbook is not alive' unless alive?
       raise WorkbookReadOnly, 'Not opened for writing (opened with :read_only option)' if @ole_workbook.ReadOnly   
       # if you have open the workbook with :read_only => true,
@@ -642,7 +646,6 @@ module RobustExcelOle
       # otherwise the workbook may already be open writable in an another Excel instance
       # then you could use this workbook or close the workbook there
       begin
-        discoloring if opts[:discoloring]
         @modified_cells = []
         @ole_workbook.Save
       rescue WIN32OLERuntimeError => msg
@@ -666,26 +669,23 @@ module RobustExcelOle
     #               :overwrite -> writes the file, delete the old file
     #               :alert or :excel -> gives control to Excel
     #  :if_obstructed   if a workbook with the same name and different path is already open and blocks the saving, then
-    #                  :raise               -> raises an exception
-    #                  :forget              -> closes the blocking workbook
+    #  or              :raise               -> raises an exception
+    #  :if_blocked     :forget              -> closes the blocking workbook
     #                  :save                -> saves the blocking workbook and closes it
     #                  :close_if_saved      -> closes the blocking workbook, if it is saved,
-    #                                          otherwise raises an exception
-    # :discoloring     states, whether colored ranges shall be discolored
+    #                                          otherwise raises an exception   
     # @return [Workbook], the book itself, if successfully saved, raises an exception otherwise
     def save_as(file, opts = { })
       raise FileNameNotGiven, 'filename is nil' if file.nil?
       raise ObjectNotAlive, 'workbook is not alive' unless alive?
       raise WorkbookReadOnly, 'Not opened for writing (opened with :read_only option)' if @ole_workbook.ReadOnly
-      options = {
-        :if_exists => :raise,
-        :if_obstructed => :raise
-      }.merge(opts)
+      raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
+      options = self.class.process_options(opts)      
       if File.exist?(file)
         case options[:if_exists]
         when :overwrite
           if file == self.filename
-            save({:discoloring => opts[:discoloring]})
+            save
             return self
           else
             begin
@@ -712,7 +712,7 @@ module RobustExcelOle
         case options[:if_obstructed]
         when :raise
           raise WorkbookBlocked, "blocked by another workbook: #{other_workbook.Fullname.tr('\\','/')}" +
-          "\nHint: Use the option :if_obstructed with values :forget or :save to
+          "\nHint: Use the option :if_blocked with values :forget or :save to
            close or save and close the blocking workbook"
         when :forget
           # nothing
@@ -721,25 +721,20 @@ module RobustExcelOle
         when :close_if_saved
           unless other_workbook.Saved
             raise WorkbookBlocked, "blocking workbook is unsaved: #{File.basename(file).inspect}" +
-            "\nHint: Use option :if_obstructed => :save to save the blocking workbooks"
+            "\nHint: Use option :if_blocked => :save to save the blocking workbooks"
           end
         else
-          raise OptionInvalid, ":if_obstructed: invalid option: #{options[:if_obstructed].inspect}" +
+          raise OptionInvalid, ":if_blocked: invalid option: #{options[:if_obstructed].inspect}" +
           "\nHint: Valid values are :raise, :forget, :save, :close_if_saved"
         end
         other_workbook.Close
       end
       save_as_workbook(file, options)
       self
-    end
+    end    
 
   private
 
-    # @private
-    def discoloring
-      @modified_cells.each { |cell| cell.Interior.ColorIndex = XlNone }
-    end
-
     # @private
     def save_as_workbook(file, options)  
       dirname, basename = File.split(file)
@@ -749,7 +744,6 @@ module RobustExcelOle
         when '.xlsx' then RobustExcelOle::XlOpenXMLWorkbook
         when '.xlsm' then RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
         end
-      discoloring if options[:discoloring]
       @modified_cells = []
       @ole_workbook.SaveAs(General.absolute_path(file), file_format)
       bookstore.store(self)
@@ -832,7 +826,7 @@ module RobustExcelOle
       after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet_local]
       begin
         if RUBY_PLATFORM !~ /java/
-          if sheet 
+          if sheet
             sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
           else
             @ole_workbook.Worksheets.Add({ after_or_before.to_s => base_sheet.ole_worksheet })
@@ -862,11 +856,12 @@ module RobustExcelOle
                 ole_workbook.Worksheets.Add(base_sheet.ole_worksheet) 
               end
               base_sheet.Move(ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count-1))
+              ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count).Activate
             end
           end
         end
       rescue #WIN32OLERuntimeError 
-        trace "#{$!.message}"
+        #trace "#{$!.message}"
         raise WorksheetREOError, "could not add given worksheet #{sheet.inspect}"
       end
       #ole_sheet = @excel.Activesheet
@@ -906,7 +901,10 @@ module RobustExcelOle
     # @param [String]  name  the name of the range
     # @param [Variant] value the contents of the range
     def []= (name, value)
-      set_namevalue_glob(name,value, :color => 42)   # 42 - aqua-marin, 4-green
+      old_color_if_modified = @color_if_modified
+      workbook.color_if_modified = 42  # 42 - aqua-marin, 4-green
+      set_namevalue_glob(name,value)   
+      workbook.color_if_modified = old_color_if_modified
     end
 
     # sets options
@@ -981,7 +979,7 @@ module RobustExcelOle
     def visible= visible_value
       return if visible_value.nil?
       @excel.visible = true if visible_value
-      self.window_visible = visible_value
+      self.window_visible = @excel.Visible ? visible_value : true
     end
 
     # returns true, if the window of the workbook is set to visible, false otherwise