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