sfx2/source/doc/docundomanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "docundomanager.hxx"
  22 #include "sfx2/sfxbasemodel.hxx"
  23 #include "sfx2/objsh.hxx"
  24 #include "sfx2/viewfrm.hxx"
  25 #include "sfx2/viewsh.hxx"
  26 #include "sfx2/bindings.hxx"
  27
  28 #include <com/sun/star/lang/XComponent.hpp>
  29
  30 #include <comphelper/anytostring.hxx>
  31 #include <comphelper/flagguard.hxx>
  32 #include <svl/undo.hxx>
  33 #include <tools/diagnose_ex.h>
  34 #include <framework/undomanagerhelper.hxx>
  35
  36 #include <boost/noncopyable.hpp>
  37 #include <stack>
  38
  39 //......................................................................................................................
  40 namespace sfx2
  41 {
  42 //......................................................................................................................
  43
  44     using ::com::sun::star::uno::Reference;
  45     using ::com::sun::star::uno::XInterface;
  46     using ::com::sun::star::uno::UNO_QUERY;
  47     using ::com::sun::star::uno::UNO_QUERY_THROW;
  48     using ::com::sun::star::uno::UNO_SET_THROW;
  49     using ::com::sun::star::uno::Exception;
  50     using ::com::sun::star::uno::RuntimeException;
  51     using ::com::sun::star::uno::Any;
  52     using ::com::sun::star::uno::makeAny;
  53     using ::com::sun::star::uno::Sequence;
  54     using ::com::sun::star::uno::Type;
  55     using ::com::sun::star::util::InvalidStateException;
  56     using ::com::sun::star::document::EmptyUndoStackException;
  57     using ::com::sun::star::util::NotLockedException;
  58     using ::com::sun::star::document::UndoContextNotClosedException;
  59     using ::com::sun::star::document::XUndoAction;
  60     using ::com::sun::star::document::XUndoManagerSupplier;
  61     using ::com::sun::star::lang::XComponent;
  62     using ::com::sun::star::lang::IllegalArgumentException;
  63     using ::com::sun::star::lang::NotInitializedException;
  64     using ::com::sun::star::lang::EventObject;
  65     using ::com::sun::star::document::UndoManagerEvent;
  66     using ::com::sun::star::document::XUndoManagerListener;
  67     using ::com::sun::star::document::UndoFailedException;
  68     using ::com::sun::star::document::XUndoManager;
  69     using ::com::sun::star::lang::NoSupportException;
  70     using ::com::sun::star::frame::XModel;
  71
  72     using ::svl::IUndoManager;
  73
  74     //==================================================================================================================
  75     //= DocumentUndoManager_Impl
  76     //==================================================================================================================
  77     struct DocumentUndoManager_Impl : public ::framework::IUndoManagerImplementation
  78     {
  79         DocumentUndoManager&                rAntiImpl;
  80         IUndoManager*                       pUndoManager;
  81         ::framework::UndoManagerHelper      aUndoHelper;
  82
  83         DocumentUndoManager_Impl( DocumentUndoManager& i_antiImpl )
  84             :rAntiImpl( i_antiImpl )
  85             ,pUndoManager( impl_retrieveUndoManager( i_antiImpl.getBaseModel() ) )
  86                 // do this *before* the construction of aUndoHelper (which actually means: put pUndoManager before
  87                 // aUndoHelper in the member list)!
  88             ,aUndoHelper( *this )
  89         {
  90         }
  91
  92         virtual ~DocumentUndoManager_Impl()
  93         {
  94         };
  95
  96         const SfxObjectShell* getObjectShell() const { return rAntiImpl.getBaseModel().GetObjectShell(); }
  97               SfxObjectShell* getObjectShell()       { return rAntiImpl.getBaseModel().GetObjectShell(); }
  98
  99         // IUndoManagerImplementation
 100         virtual ::svl::IUndoManager&        getImplUndoManager();
 101         virtual Reference< XUndoManager >   getThis();
 102
 103         void disposing()
 104         {
 105             aUndoHelper.disposing();
 106             ENSURE_OR_RETURN_VOID( pUndoManager, "DocumentUndoManager_Impl::disposing: already disposed!" );
 107             pUndoManager = NULL;
 108         }
 109
 110         void invalidateXDo_nolck();
 111
 112     private:
 113         static IUndoManager* impl_retrieveUndoManager( SfxBaseModel& i_baseModel )
 114         {
 115             IUndoManager* pUndoManager( NULL );
 116             SfxObjectShell* pObjectShell = i_baseModel.GetObjectShell();
 117             if ( pObjectShell != NULL )
 118                 pUndoManager = pObjectShell->GetUndoManager();
 119             if ( !pUndoManager )
 120                 throw NotInitializedException( OUString(), *&i_baseModel );
 121             return pUndoManager;
 122         }
 123     };
 124
 125     //------------------------------------------------------------------------------------------------------------------
 126     ::svl::IUndoManager& DocumentUndoManager_Impl::getImplUndoManager()
 127     {
 128         ENSURE_OR_THROW( pUndoManager != NULL, "DocumentUndoManager_Impl::getImplUndoManager: no access to the doc's UndoManager implementation!" );
 129
 130 #if OSL_DEBUG_LEVEL > 0
 131         // in a non-product build, assert if the current UndoManager at the shell is not the same we obtained
 132         // (and cached) at construction time
 133         SfxObjectShell* pObjectShell = rAntiImpl.getBaseModel().GetObjectShell();
 134         OSL_ENSURE( ( pObjectShell != NULL ) && ( pUndoManager == pObjectShell->GetUndoManager() ),
 135             "DocumentUndoManager_Impl::getImplUndoManager: the UndoManager changed meanwhile - what about our listener?" );
 136 #endif
 137
 138         return *pUndoManager;
 139     }
 140
 141     //------------------------------------------------------------------------------------------------------------------
 142     Reference< XUndoManager > DocumentUndoManager_Impl::getThis()
 143     {
 144         return static_cast< XUndoManager* >( &rAntiImpl );
 145     }
 146
 147     //------------------------------------------------------------------------------------------------------------------
 148     void DocumentUndoManager_Impl::invalidateXDo_nolck()
 149     {
 150         SfxModelGuard aGuard( rAntiImpl );
 151
 152         const SfxObjectShell* pDocShell = getObjectShell();
 153         ENSURE_OR_THROW( pDocShell != NULL, "lcl_invalidateUndo: no access to the doc shell!" );
 154         SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( pDocShell );
 155         while ( pViewFrame )
 156         {
 157             pViewFrame->GetBindings().Invalidate( SID_UNDO );
 158             pViewFrame->GetBindings().Invalidate( SID_REDO );
 159             pViewFrame = SfxViewFrame::GetNext( *pViewFrame, pDocShell );
 160         }
 161     }
 162
 163     //==================================================================================================================
 164     //= SolarMutexFacade
 165     //==================================================================================================================
 166     /** a facade for the SolarMutex, implementing ::framework::IMutex (as opposed to ::vos::IMutex)
 167     */
 168     class SolarMutexFacade : public ::framework::IMutex
 169     {
 170     public:
 171         SolarMutexFacade()
 172         {
 173         }
 174
 175         virtual ~SolarMutexFacade() {}
 176
 177         virtual void acquire()
 178         {
 179             Application::GetSolarMutex().acquire();
 180         }
 181
 182         virtual void release()
 183         {
 184             Application::GetSolarMutex().release();
 185         }
 186     };
 187
 188     //==================================================================================================================
 189     //= UndoManagerGuard
 190     //==================================================================================================================
 191     class UndoManagerGuard  :public ::framework::IMutexGuard
 192                             ,public ::boost::noncopyable
 193     {
 194     public:
 195         UndoManagerGuard( DocumentUndoManager& i_undoManager )
 196             :m_guard( i_undoManager )
 197             ,m_solarMutexFacade()
 198         {
 199         }
 200
 201         virtual ~UndoManagerGuard()
 202         {
 203         }
 204
 205         virtual void reset()
 206         {
 207             m_guard.reset();
 208         }
 209
 210         virtual void clear()
 211         {
 212             m_guard.clear();
 213         }
 214
 215         virtual ::framework::IMutex& getGuardedMutex()
 216         {
 217             // note that this means that we *know* that SfxModelGuard also locks the SolarMutex (nothing more, nothing less).
 218             // If this ever changes, we need to adjust this code here, too.
 219             return m_solarMutexFacade;
 220         }
 221
 222     private:
 223         SfxModelGuard       m_guard;
 224         SolarMutexFacade    m_solarMutexFacade;
 225     };
 226
 227     //==================================================================================================================
 228     //= DocumentUndoManager
 229     //==================================================================================================================
 230     //------------------------------------------------------------------------------------------------------------------
 231     DocumentUndoManager::DocumentUndoManager( SfxBaseModel& i_document )
 232         :SfxModelSubComponent( i_document )
 233         ,m_pImpl( new DocumentUndoManager_Impl( *this ) )
 234     {
 235     }
 236
 237     //------------------------------------------------------------------------------------------------------------------
 238     DocumentUndoManager::~DocumentUndoManager()
 239     {
 240     }
 241
 242     //------------------------------------------------------------------------------------------------------------------
 243     void DocumentUndoManager::disposing()
 244     {
 245         m_pImpl->disposing();
 246     }
 247
 248     //------------------------------------------------------------------------------------------------------------------
 249     bool DocumentUndoManager::isInContext() const
 250     {
 251         // No mutex locking within this method, no disposal check - this is the responsibility of the owner.
 252         return m_pImpl->getImplUndoManager().IsInListAction();
 253     }
 254
 255     //------------------------------------------------------------------------------------------------------------------
 256     void SAL_CALL DocumentUndoManager::acquire(  ) throw ()
 257     {
 258         SfxModelSubComponent::acquire();
 259     }
 260
 261     //------------------------------------------------------------------------------------------------------------------
 262     void SAL_CALL DocumentUndoManager::release(  ) throw ()
 263     {
 264         SfxModelSubComponent::release();
 265     }
 266
 267     //------------------------------------------------------------------------------------------------------------------
 268     void SAL_CALL DocumentUndoManager::enterUndoContext( const OUString& i_title ) throw (RuntimeException)
 269     {
 270         // SYNCHRONIZED --->
 271         UndoManagerGuard aGuard( *this );
 272         m_pImpl->aUndoHelper.enterUndoContext( i_title, aGuard );
 273         // <--- SYNCHRONIZED
 274         m_pImpl->invalidateXDo_nolck();
 275     }
 276
 277     //------------------------------------------------------------------------------------------------------------------
 278     void SAL_CALL DocumentUndoManager::enterHiddenUndoContext(  ) throw (EmptyUndoStackException, RuntimeException)
 279     {
 280         // SYNCHRONIZED --->
 281         UndoManagerGuard aGuard( *this );
 282         m_pImpl->aUndoHelper.enterHiddenUndoContext( aGuard );
 283         // <--- SYNCHRONIZED
 284         m_pImpl->invalidateXDo_nolck();
 285     }
 286
 287     //------------------------------------------------------------------------------------------------------------------
 288     void SAL_CALL DocumentUndoManager::leaveUndoContext(  ) throw (InvalidStateException, RuntimeException)
 289     {
 290         // SYNCHRONIZED --->
 291         UndoManagerGuard aGuard( *this );
 292         m_pImpl->aUndoHelper.leaveUndoContext( aGuard );
 293         // <--- SYNCHRONIZED
 294         m_pImpl->invalidateXDo_nolck();
 295     }
 296
 297     //------------------------------------------------------------------------------------------------------------------
 298     void SAL_CALL DocumentUndoManager::addUndoAction( const Reference< XUndoAction >& i_action ) throw (RuntimeException, IllegalArgumentException)
 299     {
 300         // SYNCHRONIZED --->
 301         UndoManagerGuard aGuard( *this );
 302         m_pImpl->aUndoHelper.addUndoAction( i_action, aGuard );
 303         // <--- SYNCHRONIZED
 304         m_pImpl->invalidateXDo_nolck();
 305     }
 306
 307     //------------------------------------------------------------------------------------------------------------------
 308     void SAL_CALL DocumentUndoManager::undo(  ) throw (EmptyUndoStackException, UndoContextNotClosedException, UndoFailedException, RuntimeException)
 309     {
 310         // SYNCHRONIZED --->
 311         UndoManagerGuard aGuard( *this );
 312         m_pImpl->aUndoHelper.undo( aGuard );
 313         // <--- SYNCHRONIZED
 314         m_pImpl->invalidateXDo_nolck();
 315     }
 316
 317     //------------------------------------------------------------------------------------------------------------------
 318     void SAL_CALL DocumentUndoManager::redo(  ) throw (EmptyUndoStackException, UndoContextNotClosedException, UndoFailedException, RuntimeException)
 319     {
 320         // SYNCHRONIZED --->
 321         UndoManagerGuard aGuard( *this );
 322         m_pImpl->aUndoHelper.redo( aGuard );
 323         // <--- SYNCHRONIZED
 324         m_pImpl->invalidateXDo_nolck();
 325     }
 326
 327     //------------------------------------------------------------------------------------------------------------------
 328     ::sal_Bool SAL_CALL DocumentUndoManager::isUndoPossible(  ) throw (RuntimeException)
 329     {
 330         UndoManagerGuard aGuard( *this );
 331         return m_pImpl->aUndoHelper.isUndoPossible();
 332     }
 333
 334     //------------------------------------------------------------------------------------------------------------------
 335     ::sal_Bool SAL_CALL DocumentUndoManager::isRedoPossible(  ) throw (RuntimeException)
 336     {
 337         UndoManagerGuard aGuard( *this );
 338         return m_pImpl->aUndoHelper.isRedoPossible();
 339     }
 340
 341     //------------------------------------------------------------------------------------------------------------------
 342     OUString SAL_CALL DocumentUndoManager::getCurrentUndoActionTitle(  ) throw (EmptyUndoStackException, RuntimeException)
 343     {
 344         UndoManagerGuard aGuard( *this );
 345         return m_pImpl->aUndoHelper.getCurrentUndoActionTitle();
 346     }
 347
 348     //------------------------------------------------------------------------------------------------------------------
 349     OUString SAL_CALL DocumentUndoManager::getCurrentRedoActionTitle(  ) throw (EmptyUndoStackException, RuntimeException)
 350     {
 351         UndoManagerGuard aGuard( *this );
 352         return m_pImpl->aUndoHelper.getCurrentRedoActionTitle();
 353     }
 354
 355     //------------------------------------------------------------------------------------------------------------------
 356     Sequence< OUString > SAL_CALL DocumentUndoManager::getAllUndoActionTitles(  ) throw (RuntimeException)
 357     {
 358         UndoManagerGuard aGuard( *this );
 359         return m_pImpl->aUndoHelper.getAllUndoActionTitles();
 360     }
 361
 362     //------------------------------------------------------------------------------------------------------------------
 363     Sequence< OUString > SAL_CALL DocumentUndoManager::getAllRedoActionTitles(  ) throw (RuntimeException)
 364     {
 365         UndoManagerGuard aGuard( *this );
 366         return m_pImpl->aUndoHelper.getAllRedoActionTitles();
 367     }
 368
 369     //------------------------------------------------------------------------------------------------------------------
 370     void SAL_CALL DocumentUndoManager::clear(  ) throw (UndoContextNotClosedException, RuntimeException)
 371     {
 372         // SYNCHRONIZED --->
 373         UndoManagerGuard aGuard( *this );
 374         m_pImpl->aUndoHelper.clear( aGuard );
 375         // <--- SYNCHRONIZED
 376         m_pImpl->invalidateXDo_nolck();
 377     }
 378
 379     //------------------------------------------------------------------------------------------------------------------
 380     void SAL_CALL DocumentUndoManager::clearRedo(  ) throw (UndoContextNotClosedException, RuntimeException)
 381     {
 382         // SYNCHRONIZED --->
 383         UndoManagerGuard aGuard( *this );
 384         m_pImpl->aUndoHelper.clearRedo( aGuard );
 385         // <--- SYNCHRONIZED
 386         m_pImpl->invalidateXDo_nolck();
 387     }
 388
 389     //------------------------------------------------------------------------------------------------------------------
 390     void SAL_CALL DocumentUndoManager::reset() throw (RuntimeException)
 391     {
 392         // SYNCHRONIZED --->
 393         UndoManagerGuard aGuard( *this );
 394         m_pImpl->aUndoHelper.reset( aGuard );
 395         // <--- SYNCHRONIZED
 396         m_pImpl->invalidateXDo_nolck();
 397     }
 398
 399     //------------------------------------------------------------------------------------------------------------------
 400     void SAL_CALL DocumentUndoManager::lock(  ) throw (RuntimeException)
 401     {
 402         UndoManagerGuard aGuard( *this );
 403         m_pImpl->aUndoHelper.lock();
 404     }
 405
 406     //------------------------------------------------------------------------------------------------------------------
 407     void SAL_CALL DocumentUndoManager::unlock(  ) throw (RuntimeException, NotLockedException)
 408     {
 409         UndoManagerGuard aGuard( *this );
 410         m_pImpl->aUndoHelper.unlock();
 411     }
 412
 413     //------------------------------------------------------------------------------------------------------------------
 414     ::sal_Bool SAL_CALL DocumentUndoManager::isLocked(  ) throw (RuntimeException)
 415     {
 416         UndoManagerGuard aGuard( *this );
 417         return m_pImpl->aUndoHelper.isLocked();
 418     }
 419
 420     //------------------------------------------------------------------------------------------------------------------
 421     void SAL_CALL DocumentUndoManager::addUndoManagerListener( const Reference< XUndoManagerListener >& i_listener ) throw (RuntimeException)
 422     {
 423         UndoManagerGuard aGuard( *this );
 424         return m_pImpl->aUndoHelper.addUndoManagerListener( i_listener );
 425     }
 426
 427     //------------------------------------------------------------------------------------------------------------------
 428     void SAL_CALL DocumentUndoManager::removeUndoManagerListener( const Reference< XUndoManagerListener >& i_listener ) throw (RuntimeException)
 429     {
 430         UndoManagerGuard aGuard( *this );
 431         return m_pImpl->aUndoHelper.removeUndoManagerListener( i_listener );
 432     }
 433
 434     //------------------------------------------------------------------------------------------------------------------
 435     Reference< XInterface > SAL_CALL DocumentUndoManager::getParent(  ) throw (RuntimeException)
 436     {
 437         UndoManagerGuard aGuard( *this );
 438         return static_cast< XModel* >( &getBaseModel() );
 439     }
 440
 441     //------------------------------------------------------------------------------------------------------------------
 442     void SAL_CALL DocumentUndoManager::setParent( const Reference< XInterface >& i_parent ) throw (NoSupportException, RuntimeException)
 443     {
 444         (void)i_parent;
 445         throw NoSupportException( OUString(), m_pImpl->getThis() );
 446     }
 447
 448 //......................................................................................................................
 449 } // namespace sfx2
 450 //......................................................................................................................
 451
 452 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */