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 #include <sfx2/sfxsids.hrc>
  28 #include <com/sun/star/lang/NoSupportException.hpp>
  29 #include <com/sun/star/lang/NotInitializedException.hpp>
  30 #include <svl/undo.hxx>
  31 #include <tools/diagnose_ex.h>
  32 #include <framework/undomanagerhelper.hxx>
  33 #include <framework/imutex.hxx>
  34
  35
  36 namespace sfx2
  37 {
  38
  39
  40     using ::com::sun::star::uno::Reference;
  41     using ::com::sun::star::uno::XInterface;
  42     using ::com::sun::star::uno::RuntimeException;
  43     using ::com::sun::star::uno::Sequence;
  44     using ::com::sun::star::document::XUndoAction;
  45     using ::com::sun::star::lang::NotInitializedException;
  46     using ::com::sun::star::document::XUndoManagerListener;
  47     using ::com::sun::star::document::XUndoManager;
  48     using ::com::sun::star::lang::NoSupportException;
  49     using ::com::sun::star::frame::XModel;
  50
  51     //= DocumentUndoManager_Impl
  52
  53     struct DocumentUndoManager_Impl : public ::framework::IUndoManagerImplementation
  54     {
  55         DocumentUndoManager&                rAntiImpl;
  56         SfxUndoManager*                     pUndoManager;
  57         ::framework::UndoManagerHelper      aUndoHelper;
  58
  59         explicit DocumentUndoManager_Impl( DocumentUndoManager& i_antiImpl )
  60             :rAntiImpl( i_antiImpl )
  61             ,pUndoManager( impl_retrieveUndoManager( i_antiImpl.getBaseModel() ) )
  62                 // do this *before* the construction of aUndoHelper (which actually means: put pUndoManager before
  63                 // aUndoHelper in the member list)!
  64             ,aUndoHelper( *this )
  65         {
  66         }
  67
  68         virtual ~DocumentUndoManager_Impl()
  69         {
  70         };
  71
  72         // IUndoManagerImplementation
  73         virtual SfxUndoManager&        getImplUndoManager() override;
  74         virtual Reference< XUndoManager >   getThis() override;
  75
  76         void disposing()
  77         {
  78             aUndoHelper.disposing();
  79             ENSURE_OR_RETURN_VOID( pUndoManager, "DocumentUndoManager_Impl::disposing: already disposed!" );
  80             pUndoManager = nullptr;
  81         }
  82
  83         void invalidateXDo_nolck();
  84
  85     private:
  86         static SfxUndoManager* impl_retrieveUndoManager( SfxBaseModel& i_baseModel )
  87         {
  88             SfxUndoManager* pUndoManager( nullptr );
  89             SfxObjectShell* pObjectShell = i_baseModel.GetObjectShell();
  90             if ( pObjectShell != nullptr )
  91                 pUndoManager = pObjectShell->GetUndoManager();
  92             if ( !pUndoManager )
  93                 throw NotInitializedException( OUString(), i_baseModel );
  94             return pUndoManager;
  95         }
  96     };
  97
  98
  99     SfxUndoManager& DocumentUndoManager_Impl::getImplUndoManager()
 100     {
 101         ENSURE_OR_THROW( pUndoManager != nullptr, "DocumentUndoManager_Impl::getImplUndoManager: no access to the doc's UndoManager implementation!" );
 102
 103 #if OSL_DEBUG_LEVEL > 0
 104         // in a non-product build, assert if the current UndoManager at the shell is not the same we obtained
 105         // (and cached) at construction time
 106         SfxObjectShell* pObjectShell = rAntiImpl.getBaseModel().GetObjectShell();
 107         OSL_ENSURE( ( pObjectShell != nullptr ) && ( pUndoManager == pObjectShell->GetUndoManager() ),
 108             "DocumentUndoManager_Impl::getImplUndoManager: the UndoManager changed meanwhile - what about our listener?" );
 109 #endif
 110
 111         return *pUndoManager;
 112     }
 113
 114
 115     Reference< XUndoManager > DocumentUndoManager_Impl::getThis()
 116     {
 117         return static_cast< XUndoManager* >( &rAntiImpl );
 118     }
 119
 120
 121     void DocumentUndoManager_Impl::invalidateXDo_nolck()
 122     {
 123         SfxModelGuard aGuard( rAntiImpl );
 124
 125         const SfxObjectShell* pDocShell = rAntiImpl.getBaseModel().GetObjectShell();
 126         ENSURE_OR_THROW( pDocShell != nullptr, "lcl_invalidateUndo: no access to the doc shell!" );
 127         SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( pDocShell );
 128         while ( pViewFrame )
 129         {
 130             pViewFrame->GetBindings().Invalidate( SID_UNDO );
 131             pViewFrame->GetBindings().Invalidate( SID_REDO );
 132             pViewFrame = SfxViewFrame::GetNext( *pViewFrame, pDocShell );
 133         }
 134     }
 135
 136
 137     //= SolarMutexFacade
 138
 139     namespace {
 140
 141     /** a facade for the SolarMutex, implementing ::framework::IMutex
 142     */
 143     class SolarMutexFacade : public ::framework::IMutex
 144     {
 145     public:
 146         SolarMutexFacade()
 147         {
 148         }
 149
 150         virtual ~SolarMutexFacade() {}
 151
 152         virtual void acquire() override
 153         {
 154             Application::GetSolarMutex().acquire();
 155         }
 156
 157         virtual void release() override
 158         {
 159             Application::GetSolarMutex().release();
 160         }
 161     };
 162
 163
 164     //= UndoManagerGuard
 165
 166     class UndoManagerGuard  :public ::framework::IMutexGuard
 167     {
 168     public:
 169         explicit UndoManagerGuard( DocumentUndoManager& i_undoManager )
 170             :m_guard( i_undoManager )
 171             ,m_solarMutexFacade()
 172         {
 173         }
 174
 175         virtual ~UndoManagerGuard()
 176         {
 177         }
 178
 179         UndoManagerGuard(const UndoManagerGuard&) = delete;
 180         UndoManagerGuard& operator=(const UndoManagerGuard&) = delete;
 181
 182         virtual void clear() override
 183         {
 184             m_guard.clear();
 185         }
 186
 187         virtual ::framework::IMutex& getGuardedMutex() override
 188         {
 189             // note that this means that we *know* that SfxModelGuard also locks the SolarMutex (nothing more, nothing less).
 190             // If this ever changes, we need to adjust this code here, too.
 191             return m_solarMutexFacade;
 192         }
 193
 194     private:
 195         SfxModelGuard       m_guard;
 196         SolarMutexFacade    m_solarMutexFacade;
 197     };
 198
 199     }
 200
 201     //= DocumentUndoManager
 202
 203
 204     DocumentUndoManager::DocumentUndoManager( SfxBaseModel& i_document )
 205         :SfxModelSubComponent( i_document )
 206         ,m_pImpl( new DocumentUndoManager_Impl( *this ) )
 207     {
 208     }
 209
 210     DocumentUndoManager::~DocumentUndoManager()
 211     {
 212     }
 213
 214     void DocumentUndoManager::disposing()
 215     {
 216         m_pImpl->disposing();
 217     }
 218
 219
 220     bool DocumentUndoManager::isInContext() const
 221     {
 222         // No mutex locking within this method, no disposal check - this is the responsibility of the owner.
 223         return m_pImpl->getImplUndoManager().IsInListAction();
 224     }
 225
 226
 227     void SAL_CALL DocumentUndoManager::acquire() throw()
 228     {
 229         OWeakObject::acquire();
 230         SfxModelSubComponent::acquireModel();
 231     }
 232
 233
 234     void SAL_CALL DocumentUndoManager::release() throw()
 235     {
 236         SfxModelSubComponent::releaseModel();
 237         OWeakObject::release();
 238     }
 239
 240
 241     void SAL_CALL DocumentUndoManager::enterUndoContext( const OUString& i_title )
 242     {
 243         // SYNCHRONIZED --->
 244         UndoManagerGuard aGuard( *this );
 245         m_pImpl->aUndoHelper.enterUndoContext( i_title, aGuard );
 246         // <--- SYNCHRONIZED
 247         m_pImpl->invalidateXDo_nolck();
 248     }
 249
 250
 251     void SAL_CALL DocumentUndoManager::enterHiddenUndoContext(  )
 252     {
 253         // SYNCHRONIZED --->
 254         UndoManagerGuard aGuard( *this );
 255         m_pImpl->aUndoHelper.enterHiddenUndoContext( aGuard );
 256         // <--- SYNCHRONIZED
 257         m_pImpl->invalidateXDo_nolck();
 258     }
 259
 260
 261     void SAL_CALL DocumentUndoManager::leaveUndoContext(  )
 262     {
 263         // SYNCHRONIZED --->
 264         UndoManagerGuard aGuard( *this );
 265         m_pImpl->aUndoHelper.leaveUndoContext( aGuard );
 266         // <--- SYNCHRONIZED
 267         m_pImpl->invalidateXDo_nolck();
 268     }
 269
 270
 271     void SAL_CALL DocumentUndoManager::addUndoAction( const Reference< XUndoAction >& i_action )
 272     {
 273         // SYNCHRONIZED --->
 274         UndoManagerGuard aGuard( *this );
 275         m_pImpl->aUndoHelper.addUndoAction( i_action, aGuard );
 276         // <--- SYNCHRONIZED
 277         m_pImpl->invalidateXDo_nolck();
 278     }
 279
 280
 281     void SAL_CALL DocumentUndoManager::undo(  )
 282     {
 283         // SYNCHRONIZED --->
 284         UndoManagerGuard aGuard( *this );
 285         m_pImpl->aUndoHelper.undo( aGuard );
 286         // <--- SYNCHRONIZED
 287         m_pImpl->invalidateXDo_nolck();
 288     }
 289
 290
 291     void SAL_CALL DocumentUndoManager::redo(  )
 292     {
 293         // SYNCHRONIZED --->
 294         UndoManagerGuard aGuard( *this );
 295         m_pImpl->aUndoHelper.redo( aGuard );
 296         // <--- SYNCHRONIZED
 297         m_pImpl->invalidateXDo_nolck();
 298     }
 299
 300
 301     sal_Bool SAL_CALL DocumentUndoManager::isUndoPossible(  )
 302     {
 303         UndoManagerGuard aGuard( *this );
 304         return m_pImpl->aUndoHelper.isUndoPossible();
 305     }
 306
 307
 308     sal_Bool SAL_CALL DocumentUndoManager::isRedoPossible(  )
 309     {
 310         UndoManagerGuard aGuard( *this );
 311         return m_pImpl->aUndoHelper.isRedoPossible();
 312     }
 313
 314
 315     OUString SAL_CALL DocumentUndoManager::getCurrentUndoActionTitle(  )
 316     {
 317         UndoManagerGuard aGuard( *this );
 318         return m_pImpl->aUndoHelper.getCurrentUndoActionTitle();
 319     }
 320
 321
 322     OUString SAL_CALL DocumentUndoManager::getCurrentRedoActionTitle(  )
 323     {
 324         UndoManagerGuard aGuard( *this );
 325         return m_pImpl->aUndoHelper.getCurrentRedoActionTitle();
 326     }
 327
 328
 329     Sequence< OUString > SAL_CALL DocumentUndoManager::getAllUndoActionTitles(  )
 330     {
 331         UndoManagerGuard aGuard( *this );
 332         return m_pImpl->aUndoHelper.getAllUndoActionTitles();
 333     }
 334
 335
 336     Sequence< OUString > SAL_CALL DocumentUndoManager::getAllRedoActionTitles(  )
 337     {
 338         UndoManagerGuard aGuard( *this );
 339         return m_pImpl->aUndoHelper.getAllRedoActionTitles();
 340     }
 341
 342
 343     void SAL_CALL DocumentUndoManager::clear(  )
 344     {
 345         // SYNCHRONIZED --->
 346         UndoManagerGuard aGuard( *this );
 347         m_pImpl->aUndoHelper.clear( aGuard );
 348         // <--- SYNCHRONIZED
 349         m_pImpl->invalidateXDo_nolck();
 350     }
 351
 352
 353     void SAL_CALL DocumentUndoManager::clearRedo(  )
 354     {
 355         // SYNCHRONIZED --->
 356         UndoManagerGuard aGuard( *this );
 357         m_pImpl->aUndoHelper.clearRedo( aGuard );
 358         // <--- SYNCHRONIZED
 359         m_pImpl->invalidateXDo_nolck();
 360     }
 361
 362
 363     void SAL_CALL DocumentUndoManager::reset()
 364     {
 365         // SYNCHRONIZED --->
 366         UndoManagerGuard aGuard( *this );
 367         m_pImpl->aUndoHelper.reset( aGuard );
 368         // <--- SYNCHRONIZED
 369         m_pImpl->invalidateXDo_nolck();
 370     }
 371
 372
 373     void SAL_CALL DocumentUndoManager::lock(  )
 374     {
 375         UndoManagerGuard aGuard( *this );
 376         m_pImpl->aUndoHelper.lock();
 377     }
 378
 379
 380     void SAL_CALL DocumentUndoManager::unlock(  )
 381     {
 382         UndoManagerGuard aGuard( *this );
 383         m_pImpl->aUndoHelper.unlock();
 384     }
 385
 386
 387     sal_Bool SAL_CALL DocumentUndoManager::isLocked(  )
 388     {
 389         UndoManagerGuard aGuard( *this );
 390         return m_pImpl->aUndoHelper.isLocked();
 391     }
 392
 393
 394     void SAL_CALL DocumentUndoManager::addUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 395     {
 396         UndoManagerGuard aGuard( *this );
 397         return m_pImpl->aUndoHelper.addUndoManagerListener( i_listener );
 398     }
 399
 400
 401     void SAL_CALL DocumentUndoManager::removeUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 402     {
 403         UndoManagerGuard aGuard( *this );
 404         return m_pImpl->aUndoHelper.removeUndoManagerListener( i_listener );
 405     }
 406
 407
 408     Reference< XInterface > SAL_CALL DocumentUndoManager::getParent(  )
 409     {
 410         UndoManagerGuard aGuard( *this );
 411         return static_cast< XModel* >( &getBaseModel() );
 412     }
 413
 414
 415     void SAL_CALL DocumentUndoManager::setParent( const Reference< XInterface >& )
 416     {
 417         throw NoSupportException( OUString(), m_pImpl->getThis() );
 418     }
 419
 420
 421 } // namespace sfx2
 422
 423
 424 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */