chart2/source/model/main/UndoManager.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 #include "UndoManager.hxx"
  21 #include <ChartViewHelper.hxx>
  22
  23 #include <com/sun/star/frame/XModel.hpp>
  24 #include <com/sun/star/lang/DisposedException.hpp>
  25 #include <com/sun/star/lang/NoSupportException.hpp>
  26
  27 #include <framework/undomanagerhelper.hxx>
  28 #include <framework/imutex.hxx>
  29 #include <officecfg/Office/Common.hxx>
  30 #include <svl/undo.hxx>
  31
  32 namespace chart
  33 {
  34
  35     using ::com::sun::star::uno::Reference;
  36     using ::com::sun::star::uno::XInterface;
  37     using ::com::sun::star::uno::UNO_QUERY;
  38     using ::com::sun::star::uno::Sequence;
  39     using ::com::sun::star::lang::DisposedException;
  40     using ::com::sun::star::document::XUndoManager;
  41     using ::com::sun::star::document::XUndoAction;
  42     using ::com::sun::star::document::XUndoManagerListener;
  43     using ::com::sun::star::lang::NoSupportException;
  44     using ::com::sun::star::util::XModifyListener;
  45     using ::com::sun::star::frame::XModel;
  46
  47     namespace impl
  48     {
  49         class UndoManager_Impl : public ::framework::IUndoManagerImplementation
  50         {
  51         public:
  52             UndoManager_Impl( UndoManager& i_antiImpl, ::cppu::OWeakObject& i_parent, ::osl::Mutex& i_mutex )
  53                 :m_rAntiImpl( i_antiImpl )
  54                 ,m_rParent( i_parent )
  55                 ,m_rMutex( i_mutex )
  56                 ,m_bDisposed( false )
  57                 ,m_aUndoManager()
  58                 ,m_aUndoHelper( *this )
  59             {
  60                 m_aUndoManager.SetMaxUndoActionCount(
  61                     officecfg::Office::Common::Undo::Steps::get());
  62             }
  63
  64             virtual ~UndoManager_Impl()
  65             {
  66             }
  67
  68             ::osl::Mutex&                       getMutex();
  69             // IUndoManagerImplementation
  70             virtual SfxUndoManager&             getImplUndoManager() override;
  71             virtual Reference< XUndoManager >   getThis() override;
  72
  73             // attribute access
  74             ::cppu::OWeakObject&                getParent() { return m_rParent; }
  75             ::framework::UndoManagerHelper&     getUndoHelper() { return m_aUndoHelper; }
  76
  77             // public interface
  78
  79             /// is called when the owner of the UndoManager is being disposed
  80             void    disposing();
  81
  82             /// checks whether we're already disposed, throws a DisposedException if so
  83             void    checkDisposed_lck();
  84
  85         private:
  86             UndoManager&                        m_rAntiImpl;
  87             ::cppu::OWeakObject&                m_rParent;
  88             ::osl::Mutex&                       m_rMutex;
  89             bool                                m_bDisposed;
  90
  91             SfxUndoManager                      m_aUndoManager;
  92             ::framework::UndoManagerHelper      m_aUndoHelper;
  93         };
  94
  95         ::osl::Mutex& UndoManager_Impl::getMutex()
  96         {
  97             return m_rMutex;
  98         }
  99
 100         SfxUndoManager& UndoManager_Impl::getImplUndoManager()
 101         {
 102             return m_aUndoManager;
 103         }
 104
 105         Reference< XUndoManager > UndoManager_Impl::getThis()
 106         {
 107             return &m_rAntiImpl;
 108         }
 109
 110         void UndoManager_Impl::disposing()
 111         {
 112             {
 113                 ::osl::MutexGuard aGuard( m_rMutex );
 114                 m_bDisposed = true;
 115             }
 116             m_aUndoHelper.disposing();
 117         }
 118
 119         void UndoManager_Impl::checkDisposed_lck()
 120         {
 121             if ( m_bDisposed )
 122                 throw DisposedException( OUString(), getThis() );
 123         }
 124
 125         namespace {
 126
 127         /** guard for public UNO methods of the UndoManager
 128
 129             The only purpose of this guard is to check for the instance being disposed already. Everything else,
 130             in particular the IMutexGuard functionality required by the UndoManagerHelper class, is a dummy only,
 131             as all involved classes (means we ourselves, the UndoManagerHelper, the SfxUndoManager, and the Undo actions
 132             we create) are inherently thread-safe, thus need no external lock (in particular no SolarMutex!).
 133         */
 134         class UndoManagerMethodGuard : public ::framework::IMutexGuard
 135         {
 136         public:
 137             explicit UndoManagerMethodGuard( UndoManager_Impl& i_impl )
 138             {
 139                 ::osl::MutexGuard aGuard( i_impl.getMutex() );
 140                 // throw if the instance is already disposed
 141                 i_impl.checkDisposed_lck();
 142             }
 143             virtual ~UndoManagerMethodGuard()
 144             {
 145             }
 146
 147             // IMutexGuard
 148             virtual void clear() override;
 149             virtual ::framework::IMutex& getGuardedMutex() override;
 150         };
 151
 152         class DummyMutex : public ::framework::IMutex
 153         {
 154         public:
 155             virtual ~DummyMutex() {}
 156             virtual void acquire() override { }
 157             virtual void release() override { }
 158         };
 159
 160         }
 161
 162         ::framework::IMutex& UndoManagerMethodGuard::getGuardedMutex()
 163         {
 164             static DummyMutex s_aDummyMutex;
 165             return s_aDummyMutex;
 166         }
 167
 168         void UndoManagerMethodGuard::clear()
 169         {
 170             // nothing to do. This interface implementation is a dummy.
 171         }
 172     }
 173
 174     using impl::UndoManagerMethodGuard;
 175
 176     UndoManager::UndoManager( ::cppu::OWeakObject& i_parent, ::osl::Mutex& i_mutex )
 177         :m_pImpl( new impl::UndoManager_Impl( *this, i_parent, i_mutex ) )
 178     {
 179     }
 180
 181     UndoManager::~UndoManager()
 182     {
 183     }
 184
 185     void SAL_CALL UndoManager::acquire() throw ()
 186     {
 187         m_pImpl->getParent().acquire();
 188     }
 189
 190     void SAL_CALL UndoManager::release() throw ()
 191     {
 192         m_pImpl->getParent().release();
 193     }
 194
 195     void UndoManager::disposing()
 196     {
 197         m_pImpl->disposing();
 198     }
 199
 200     void SAL_CALL UndoManager::enterUndoContext( const OUString& i_title )
 201     {
 202         UndoManagerMethodGuard aGuard( *m_pImpl );
 203         m_pImpl->getUndoHelper().enterUndoContext( i_title, aGuard );
 204     }
 205
 206     void SAL_CALL UndoManager::enterHiddenUndoContext(  )
 207     {
 208         UndoManagerMethodGuard aGuard( *m_pImpl );
 209         m_pImpl->getUndoHelper().enterHiddenUndoContext( aGuard );
 210     }
 211
 212     void SAL_CALL UndoManager::leaveUndoContext(  )
 213     {
 214         UndoManagerMethodGuard aGuard( *m_pImpl );
 215         m_pImpl->getUndoHelper().leaveUndoContext( aGuard );
 216     }
 217
 218     void SAL_CALL UndoManager::addUndoAction( const Reference< XUndoAction >& i_action )
 219     {
 220         UndoManagerMethodGuard aGuard( *m_pImpl );
 221         m_pImpl->getUndoHelper().addUndoAction( i_action, aGuard );
 222     }
 223
 224     void SAL_CALL UndoManager::undo(  )
 225     {
 226         UndoManagerMethodGuard aGuard( *m_pImpl );
 227         m_pImpl->getUndoHelper().undo( aGuard );
 228
 229         ChartViewHelper::setViewToDirtyState( Reference< XModel >( getParent(), UNO_QUERY ) );
 230     }
 231
 232     void SAL_CALL UndoManager::redo(  )
 233     {
 234         UndoManagerMethodGuard aGuard( *m_pImpl );
 235         m_pImpl->getUndoHelper().redo( aGuard );
 236
 237         ChartViewHelper::setViewToDirtyState( Reference< XModel >( getParent(), UNO_QUERY ) );
 238     }
 239
 240     sal_Bool SAL_CALL UndoManager::isUndoPossible(  )
 241     {
 242         UndoManagerMethodGuard aGuard( *m_pImpl );
 243         return m_pImpl->getUndoHelper().isUndoPossible();
 244     }
 245
 246     sal_Bool SAL_CALL UndoManager::isRedoPossible(  )
 247     {
 248         UndoManagerMethodGuard aGuard( *m_pImpl );
 249         return m_pImpl->getUndoHelper().isRedoPossible();
 250     }
 251
 252     OUString SAL_CALL UndoManager::getCurrentUndoActionTitle(  )
 253     {
 254         UndoManagerMethodGuard aGuard( *m_pImpl );
 255         return m_pImpl->getUndoHelper().getCurrentUndoActionTitle();
 256     }
 257
 258     OUString SAL_CALL UndoManager::getCurrentRedoActionTitle(  )
 259     {
 260         UndoManagerMethodGuard aGuard( *m_pImpl );
 261         return m_pImpl->getUndoHelper().getCurrentRedoActionTitle();
 262     }
 263
 264     Sequence< OUString > SAL_CALL UndoManager::getAllUndoActionTitles(  )
 265     {
 266         UndoManagerMethodGuard aGuard( *m_pImpl );
 267         return m_pImpl->getUndoHelper().getAllUndoActionTitles();
 268     }
 269
 270     Sequence< OUString > SAL_CALL UndoManager::getAllRedoActionTitles(  )
 271     {
 272         UndoManagerMethodGuard aGuard( *m_pImpl );
 273         return m_pImpl->getUndoHelper().getAllRedoActionTitles();
 274     }
 275
 276     void SAL_CALL UndoManager::clear(  )
 277     {
 278         UndoManagerMethodGuard aGuard( *m_pImpl );
 279         m_pImpl->getUndoHelper().clear( aGuard );
 280     }
 281
 282     void SAL_CALL UndoManager::clearRedo(  )
 283     {
 284         UndoManagerMethodGuard aGuard( *m_pImpl );
 285         m_pImpl->getUndoHelper().clearRedo( aGuard );
 286     }
 287
 288     void SAL_CALL UndoManager::reset(  )
 289     {
 290         UndoManagerMethodGuard aGuard( *m_pImpl );
 291         m_pImpl->getUndoHelper().reset( aGuard );
 292     }
 293
 294     void SAL_CALL UndoManager::addUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 295     {
 296         UndoManagerMethodGuard aGuard( *m_pImpl );
 297         m_pImpl->getUndoHelper().addUndoManagerListener( i_listener );
 298     }
 299
 300     void SAL_CALL UndoManager::removeUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 301     {
 302         UndoManagerMethodGuard aGuard( *m_pImpl );
 303         m_pImpl->getUndoHelper().removeUndoManagerListener( i_listener );
 304     }
 305
 306     void SAL_CALL UndoManager::lock(  )
 307     {
 308         UndoManagerMethodGuard aGuard( *m_pImpl );
 309         m_pImpl->getUndoHelper().lock();
 310     }
 311
 312     void SAL_CALL UndoManager::unlock(  )
 313     {
 314         UndoManagerMethodGuard aGuard( *m_pImpl );
 315         m_pImpl->getUndoHelper().unlock();
 316     }
 317
 318     sal_Bool SAL_CALL UndoManager::isLocked(  )
 319     {
 320         UndoManagerMethodGuard aGuard( *m_pImpl );
 321         return m_pImpl->getUndoHelper().isLocked();
 322     }
 323
 324     Reference< XInterface > SAL_CALL UndoManager::getParent(  )
 325     {
 326         UndoManagerMethodGuard aGuard( *m_pImpl );
 327         return m_pImpl->getParent();
 328     }
 329
 330     void SAL_CALL UndoManager::setParent( const Reference< XInterface >& )
 331     {
 332         UndoManagerMethodGuard aGuard( *m_pImpl );
 333         throw NoSupportException( OUString(), m_pImpl->getThis() );
 334     }
 335
 336     void SAL_CALL UndoManager::addModifyListener( const Reference< XModifyListener >& i_listener )
 337     {
 338         UndoManagerMethodGuard aGuard( *m_pImpl );
 339         m_pImpl->getUndoHelper().addModifyListener( i_listener );
 340     }
 341
 342     void SAL_CALL UndoManager::removeModifyListener( const Reference< XModifyListener >& i_listener )
 343     {
 344         UndoManagerMethodGuard aGuard( *m_pImpl );
 345         m_pImpl->getUndoHelper().removeModifyListener( i_listener );
 346     }
 347
 348 } // namespace chart
 349
 350 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */