LCOV - code coverage report
Current view: top level - include/framework - undomanagerhelper.hxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 4 4 100.0 %
Date: 2015-06-13 12:38:46 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #ifndef INCLUDED_FRAMEWORK_UNDOMANAGERHELPER_HXX
      21             : #define INCLUDED_FRAMEWORK_UNDOMANAGERHELPER_HXX
      22             : 
      23             : #include <framework/fwedllapi.h>
      24             : #include <framework/imutex.hxx>
      25             : 
      26             : #include <com/sun/star/document/XUndoManager.hpp>
      27             : #include <com/sun/star/util/XModifyListener.hpp>
      28             : 
      29             : #include <memory>
      30             : 
      31             : namespace svl
      32             : {
      33             :     class IUndoManager;
      34             : }
      35             : 
      36             : 
      37             : namespace framework
      38             : {
      39             : 
      40             : 
      41             : 
      42             :     //= IMutexGuard
      43             : 
      44        1942 :     class SAL_NO_VTABLE IMutexGuard
      45             :     {
      46             :     public:
      47             :         /** clears the lock. If the guard does not currently hold the lock, nothing happens.
      48             :         */
      49             :         virtual void clear() = 0;
      50             : 
      51             :         /** returns the mutex guarded by the instance.
      52             : 
      53             :             Even if the guard currently has not a lock on the mutex, this method must succeed.
      54             :         */
      55             :         virtual IMutex& getGuardedMutex() = 0;
      56             : 
      57             :     protected:
      58        1942 :         ~IMutexGuard() {}
      59             :     };
      60             : 
      61             : 
      62             :     //= IUndoManagerImplementation
      63             : 
      64         391 :     class SAL_NO_VTABLE IUndoManagerImplementation
      65             :     {
      66             :     public:
      67             :         /** returns the IUndoManager interface to the actual Undo stack
      68             : 
      69             :             @throws com::sun::star::lang::DisposedException
      70             :                 when the instance is already disposed, and no IUndoManager can be provided
      71             : 
      72             :             @throws com::sun::star::lang::NotInitializedException
      73             :                 when the instance is not initialized, yet, and no IUndoManager can be provided
      74             :         */
      75             :         virtual ::svl::IUndoManager&    getImplUndoManager() = 0;
      76             : 
      77             :         /** provides access to an UNO interface for the XUndoManager implementation. Used when throwing exceptions.
      78             :         */
      79             :         virtual ::com::sun::star::uno::Reference< ::com::sun::star::document::XUndoManager >
      80             :                                         getThis() = 0;
      81             : 
      82             :     protected:
      83          37 :         ~IUndoManagerImplementation() {}
      84             :     };
      85             : 
      86             : 
      87             :     //= UndoManagerHelper
      88             : 
      89             :     class UndoManagerHelper_Impl;
      90             :     /** helper class for implementing an XUndoManager
      91             : 
      92             :         Several of the methods of the class take an IMutexGuard instance. It is assumed that this guard has a lock on
      93             :         its mutext at the moment the method is entered. The lock will be released before any notifications to the
      94             :         registered XUndoManagerListeners happen.
      95             : 
      96             :         The following locking strategy is used for this mutex:
      97             :         <ul><li>Any notifications to the registered XUndoManagerListeners are after the guard has been cleared. i.e.
      98             :                 without the mutex being locked.</p>
      99             :             <li>Any calls into the <code>IUndoManager</code> implementation is made without the mutex being locked.
     100             :                 Note that this implies that the <code>IUndoManager</code> implementation must be thread-safe in itself
     101             :                 (which is true for the default implementation, SfxUndoManager).</li>
     102             :             <li>An exception to the previous item are the <member>IUndoManager::Undo</member> and
     103             :                 <member>IUndoManager::Redo</member> methods: They're called with the given external mutex being
     104             :                 locked.</li>
     105             :         </ul>
     106             : 
     107             :         The reason for the exception for IUndoManager::Undo and IUndoManager::Redo is that those are expected to
     108             :         modify the actual document which the UndoManager works for. And as long as our documents are not thread-safe,
     109             :         and as long as we do not re-fit <strong>all</strong> existing SfxUndoImplementations to <em>not</em> expect
     110             :         the dreaded SolarMutex being locked when they're called, the above behavior is a compromise between "how it should
     111             :         be" and "how it can realistically be".
     112             :     */
     113             :     class FWE_DLLPUBLIC UndoManagerHelper
     114             :     {
     115             :     public:
     116             :         UndoManagerHelper( IUndoManagerImplementation& i_undoManagerImpl );
     117             :         ~UndoManagerHelper();
     118             : 
     119             :         // life time control
     120             :         void disposing();
     121             : 
     122             :         // XUndoManager equivalents
     123             :         void            enterUndoContext( const OUString& i_title, IMutexGuard& i_instanceLock );
     124             :         void            enterHiddenUndoContext( IMutexGuard& i_instanceLock );
     125             :         void            leaveUndoContext( IMutexGuard& i_instanceLock );
     126             :         void            addUndoAction( const ::com::sun::star::uno::Reference< ::com::sun::star::document::XUndoAction >& i_action, IMutexGuard& i_instanceLock );
     127             :         void            undo( IMutexGuard& i_instanceLock );
     128             :         void            redo( IMutexGuard& i_instanceLock );
     129             :         bool            isUndoPossible() const;
     130             :         bool            isRedoPossible() const;
     131             :         OUString getCurrentUndoActionTitle() const;
     132             :         OUString getCurrentRedoActionTitle() const;
     133             :         ::com::sun::star::uno::Sequence< OUString >
     134             :                         getAllUndoActionTitles() const;
     135             :         ::com::sun::star::uno::Sequence< OUString >
     136             :                         getAllRedoActionTitles() const;
     137             :         void            clear( IMutexGuard& i_instanceLock );
     138             :         void            clearRedo( IMutexGuard& i_instanceLock );
     139             :         void            reset( IMutexGuard& i_instanceLock );
     140             :         void            addUndoManagerListener( const ::com::sun::star::uno::Reference< ::com::sun::star::document::XUndoManagerListener >& i_listener );
     141             :         void            removeUndoManagerListener( const ::com::sun::star::uno::Reference< ::com::sun::star::document::XUndoManagerListener >& i_listener );
     142             : 
     143             :         // XLockable, base of XUndoManager, equivalents
     144             :         void            lock();
     145             :         void            unlock();
     146             :         bool            isLocked();
     147             : 
     148             :         // XModifyBroadcaster equivalents
     149             :         void            addModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& i_listener );
     150             :         void            removeModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& i_listener );
     151             : 
     152             :     private:
     153             :         std::unique_ptr< UndoManagerHelper_Impl >   m_xImpl;
     154             :     };
     155             : 
     156             : 
     157             : } // namespace framework
     158             : 
     159             : 
     160             : #endif // INCLUDED_FRAMEWORK_UNDOMANAGERHELPER_HXX
     161             : 
     162             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11