dbaccess/source/ui/misc/dbaundomanager.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 <dbaccess/dbaundomanager.hxx>
  21
  22 #include <com/sun/star/lang/DisposedException.hpp>
  23 #include <com/sun/star/lang/NoSupportException.hpp>
  24
  25 #include <svl/undo.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <framework/undomanagerhelper.hxx>
  28 #include <framework/imutex.hxx>
  29
  30 namespace dbaui
  31 {
  32
  33     using ::com::sun::star::uno::Reference;
  34     using ::com::sun::star::uno::XInterface;
  35     using ::com::sun::star::uno::Sequence;
  36     using ::com::sun::star::document::XUndoManager;
  37     using ::com::sun::star::lang::DisposedException;
  38     using ::com::sun::star::document::XUndoAction;
  39     using ::com::sun::star::document::XUndoManagerListener;
  40     using ::com::sun::star::lang::NoSupportException;
  41
  42     // UndoManager_Impl
  43     struct UndoManager_Impl : public ::framework::IUndoManagerImplementation
  44     {
  45         UndoManager_Impl( UndoManager& i_antiImpl, ::cppu::OWeakObject& i_parent, ::osl::Mutex& i_mutex )
  46             :rAntiImpl( i_antiImpl )
  47             ,rParent( i_parent )
  48             ,rMutex( i_mutex )
  49             ,bDisposed( false )
  50             ,aUndoManager()
  51             ,aUndoHelper( *this )
  52         {
  53         }
  54
  55         virtual ~UndoManager_Impl()
  56         {
  57         }
  58
  59         UndoManager&                    rAntiImpl;
  60         ::cppu::OWeakObject&            rParent;
  61         ::osl::Mutex&                   rMutex;
  62         bool                            bDisposed;
  63         SfxUndoManager                  aUndoManager;
  64         ::framework::UndoManagerHelper  aUndoHelper;
  65
  66         // IUndoManagerImplementation
  67         virtual SfxUndoManager&             getImplUndoManager() override;
  68         virtual Reference< XUndoManager >   getThis() override;
  69     };
  70
  71     SfxUndoManager& UndoManager_Impl::getImplUndoManager()
  72     {
  73         return aUndoManager;
  74     }
  75
  76     Reference< XUndoManager > UndoManager_Impl::getThis()
  77     {
  78         return static_cast< XUndoManager* >( &rAntiImpl );
  79     }
  80
  81     namespace {
  82
  83     // OslMutexFacade
  84     class OslMutexFacade : public ::framework::IMutex
  85     {
  86     public:
  87         explicit OslMutexFacade( ::osl::Mutex& i_mutex )
  88             :m_rMutex( i_mutex )
  89         {
  90         }
  91
  92         virtual ~OslMutexFacade() {}
  93
  94         virtual void acquire() override;
  95         virtual void release() override;
  96
  97     private:
  98         ::osl::Mutex&   m_rMutex;
  99     };
 100
 101     }
 102
 103     void OslMutexFacade::acquire()
 104     {
 105         m_rMutex.acquire();
 106     }
 107
 108     void OslMutexFacade::release()
 109     {
 110         m_rMutex.release();
 111     }
 112
 113     namespace {
 114
 115     // UndoManagerMethodGuard
 116     /** guard for public UNO methods of the UndoManager
 117     */
 118     class UndoManagerMethodGuard : public ::framework::IMutexGuard
 119     {
 120     public:
 121         explicit UndoManagerMethodGuard( UndoManager_Impl& i_impl )
 122             :m_aGuard( i_impl.rMutex )
 123             ,m_aMutexFacade( i_impl.rMutex )
 124         {
 125             // throw if the instance is already disposed
 126             if ( i_impl.bDisposed )
 127                 throw DisposedException( OUString(), i_impl.getThis() );
 128         }
 129         virtual ~UndoManagerMethodGuard()
 130         {
 131         }
 132
 133         // IMutexGuard
 134         virtual void clear() override;
 135         virtual ::framework::IMutex& getGuardedMutex() override;
 136
 137     private:
 138         osl::ClearableMutexGuard m_aGuard;
 139         OslMutexFacade              m_aMutexFacade;
 140     };
 141
 142     }
 143
 144     ::framework::IMutex& UndoManagerMethodGuard::getGuardedMutex()
 145     {
 146         return m_aMutexFacade;
 147     }
 148
 149     void UndoManagerMethodGuard::clear()
 150     {
 151         m_aGuard.clear();
 152     }
 153
 154     // UndoManager
 155     UndoManager::UndoManager( ::cppu::OWeakObject& i_parent, ::osl::Mutex& i_mutex )
 156         :m_xImpl( new UndoManager_Impl( *this, i_parent, i_mutex ) )
 157     {
 158     }
 159
 160     UndoManager::~UndoManager()
 161     {
 162     }
 163
 164     SfxUndoManager& UndoManager::GetSfxUndoManager() const
 165     {
 166         return m_xImpl->aUndoManager;
 167     }
 168
 169     void SAL_CALL UndoManager::acquire(  ) throw ()
 170     {
 171         m_xImpl->rParent.acquire();
 172     }
 173
 174     void SAL_CALL UndoManager::release(  ) throw ()
 175     {
 176         m_xImpl->rParent.release();
 177     }
 178
 179     void UndoManager::disposing()
 180     {
 181         {
 182             ::osl::MutexGuard aGuard( m_xImpl->rMutex );
 183             m_xImpl->bDisposed = true;
 184         }
 185         m_xImpl->aUndoHelper.disposing();
 186     }
 187
 188     void SAL_CALL UndoManager::enterUndoContext( const OUString& i_title )
 189     {
 190         UndoManagerMethodGuard aGuard( *m_xImpl );
 191         m_xImpl->aUndoHelper.enterUndoContext( i_title, aGuard );
 192     }
 193
 194     void SAL_CALL UndoManager::enterHiddenUndoContext(  )
 195     {
 196         UndoManagerMethodGuard aGuard( *m_xImpl );
 197         m_xImpl->aUndoHelper.enterHiddenUndoContext( aGuard );
 198     }
 199
 200     void SAL_CALL UndoManager::leaveUndoContext(  )
 201     {
 202         UndoManagerMethodGuard aGuard( *m_xImpl );
 203         m_xImpl->aUndoHelper.leaveUndoContext( aGuard );
 204     }
 205
 206     void SAL_CALL UndoManager::addUndoAction( const Reference< XUndoAction >& i_action )
 207     {
 208         UndoManagerMethodGuard aGuard( *m_xImpl );
 209         m_xImpl->aUndoHelper.addUndoAction( i_action, aGuard );
 210     }
 211
 212     void SAL_CALL UndoManager::undo(  )
 213     {
 214         SolarMutexGuard aSolarGuard;
 215             // (all our UndoActions work directly on VCL code, usually, so ...)
 216         UndoManagerMethodGuard aGuard( *m_xImpl );
 217         m_xImpl->aUndoHelper.undo( aGuard );
 218     }
 219
 220     void SAL_CALL UndoManager::redo(  )
 221     {
 222         SolarMutexGuard aSolarGuard;
 223             // (all our UndoActions work directly on VCL code, usually, so ...)
 224         UndoManagerMethodGuard aGuard( *m_xImpl );
 225         m_xImpl->aUndoHelper.redo( aGuard );
 226     }
 227
 228     sal_Bool SAL_CALL UndoManager::isUndoPossible(  )
 229     {
 230         UndoManagerMethodGuard aGuard( *m_xImpl );
 231         return m_xImpl->aUndoHelper.isUndoPossible();
 232     }
 233
 234     sal_Bool SAL_CALL UndoManager::isRedoPossible(  )
 235     {
 236         UndoManagerMethodGuard aGuard( *m_xImpl );
 237         return m_xImpl->aUndoHelper.isRedoPossible();
 238     }
 239
 240     OUString SAL_CALL UndoManager::getCurrentUndoActionTitle(  )
 241     {
 242         UndoManagerMethodGuard aGuard( *m_xImpl );
 243         return m_xImpl->aUndoHelper.getCurrentUndoActionTitle();
 244     }
 245
 246     OUString SAL_CALL UndoManager::getCurrentRedoActionTitle(  )
 247     {
 248         UndoManagerMethodGuard aGuard( *m_xImpl );
 249         return m_xImpl->aUndoHelper.getCurrentRedoActionTitle();
 250     }
 251
 252     Sequence< OUString > SAL_CALL UndoManager::getAllUndoActionTitles(  )
 253     {
 254         UndoManagerMethodGuard aGuard( *m_xImpl );
 255         return m_xImpl->aUndoHelper.getAllUndoActionTitles();
 256     }
 257
 258     Sequence< OUString > SAL_CALL UndoManager::getAllRedoActionTitles(  )
 259     {
 260         UndoManagerMethodGuard aGuard( *m_xImpl );
 261         return m_xImpl->aUndoHelper.getAllRedoActionTitles();
 262     }
 263
 264     void SAL_CALL UndoManager::clear(  )
 265     {
 266         UndoManagerMethodGuard aGuard( *m_xImpl );
 267         m_xImpl->aUndoHelper.clear( aGuard );
 268     }
 269
 270     void SAL_CALL UndoManager::clearRedo(  )
 271     {
 272         UndoManagerMethodGuard aGuard( *m_xImpl );
 273         m_xImpl->aUndoHelper.clearRedo( aGuard );
 274     }
 275
 276     void SAL_CALL UndoManager::reset(  )
 277     {
 278         UndoManagerMethodGuard aGuard( *m_xImpl );
 279         m_xImpl->aUndoHelper.reset( aGuard );
 280     }
 281
 282     void SAL_CALL UndoManager::addUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 283     {
 284         UndoManagerMethodGuard aGuard( *m_xImpl );
 285         m_xImpl->aUndoHelper.addUndoManagerListener( i_listener );
 286     }
 287
 288     void SAL_CALL UndoManager::removeUndoManagerListener( const Reference< XUndoManagerListener >& i_listener )
 289     {
 290         UndoManagerMethodGuard aGuard( *m_xImpl );
 291         m_xImpl->aUndoHelper.removeUndoManagerListener( i_listener );
 292     }
 293
 294     void SAL_CALL UndoManager::lock(  )
 295     {
 296         UndoManagerMethodGuard aGuard( *m_xImpl );
 297         m_xImpl->aUndoHelper.lock();
 298     }
 299
 300     void SAL_CALL UndoManager::unlock(  )
 301     {
 302         UndoManagerMethodGuard aGuard( *m_xImpl );
 303         m_xImpl->aUndoHelper.unlock();
 304     }
 305
 306     sal_Bool SAL_CALL UndoManager::isLocked(  )
 307     {
 308         UndoManagerMethodGuard aGuard( *m_xImpl );
 309         return m_xImpl->aUndoHelper.isLocked();
 310     }
 311
 312     Reference< XInterface > SAL_CALL UndoManager::getParent(  )
 313     {
 314         UndoManagerMethodGuard aGuard( *m_xImpl );
 315         return m_xImpl->rParent;
 316     }
 317
 318     void SAL_CALL UndoManager::setParent( const Reference< XInterface >& )
 319     {
 320         throw NoSupportException( OUString(), m_xImpl->getThis() );
 321     }
 322
 323 } // namespace dbaui
 324
 325 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */