| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_sd.hxx" | |
| #include "UpdateLockManager.hxx" | |
| #include "MutexOwner.hxx" | |
| #include "ViewShellBase.hxx" | |
| #include <com/sun/star/frame/XLayoutManager.hpp> | |
| #include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp> | |
| #include <com/sun/star/frame/LayoutManagerEvents.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <cppuhelper/compbase1.hxx> | |
| #include <vcl/timer.hxx> | |
| #include <sfx2/viewfrm.hxx> | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star; | |
| namespace { | |
| typedef cppu::WeakComponentImplHelper1<frame::XLayoutManagerListener> InterfaceBase; | |
| } | |
| namespace sd { | |
| /** This implementation class not only implements the Lock() and Unlock() | |
| methods but as well listens for the right combination of events to call | |
| Unlock() when all is ready after the PaneManager has switched (some of) | |
| its view shells. | |
| */ | |
| class UpdateLockManager::Implementation | |
| : protected MutexOwner, | |
| public InterfaceBase | |
| { | |
| public: | |
| Implementation (ViewShellBase& rBase); | |
| virtual ~Implementation (void); | |
| void Lock (void); | |
| void Unlock (void); | |
| bool IsLocked (void) const; | |
| /** Unlock regardless of the current lock level. | |
| */ | |
| void ForceUnlock (void); | |
| private: | |
| ViewShellBase& mrBase; | |
| /// A lock level greater than 0 indicates that the ViewShellBase is locked. | |
| sal_Int32 mnLockDepth; | |
| /// The emergency timer to unlock the ViewShellBase when all else fails. | |
| Timer maTimer; | |
| /// Remember when to unlock after a layout event from frame::XLayoutManager | |
| bool mbUnlockOnNextLayout; | |
| /// Remember whether we are listening to the frame::XLayoutManager | |
| bool mbListenerIsRegistered; | |
| /// Remember whether the frame::XLayoutManager is locked. | |
| bool mbLayouterIsLocked; | |
| /** We hold a weak reference to the layout manager in order to have | |
| access to it even when the ViewShellBase object is not valid anymore | |
| and can not be used to obtain the layout manager. | |
| */ | |
| WeakReference<frame::XLayoutManager> mxLayoutManager; | |
| //===== frame::XLayoutEventListener ===================================== | |
| /** The event of the layouter are observed to find the best moment for | |
| unlocking. This is the first layout after the lock level of the | |
| layouter drops to one (we hold a lock to it ourselves which we | |
| release when unlocking). | |
| */ | |
| virtual void SAL_CALL layoutEvent ( | |
| const lang::EventObject& xSource, | |
| sal_Int16 eLayoutEvent, | |
| const Any& rInfo); | |
| //===== lang::XEventListener ============================================ | |
| virtual void SAL_CALL | |
| disposing (const lang::EventObject& rEventObject); | |
| virtual void SAL_CALL disposing (void); | |
| /** This is only a fallback to make the office usable when for some | |
| reason the intended way of unlocking it failed. | |
| */ | |
| DECL_LINK(Timeout, void*); | |
| /** Convenience method that finds the layout manager associated with the | |
| frame that shows the ViewShellBase. | |
| */ | |
| Reference<frame::XLayoutManager> GetLayoutManager (void); | |
| Implementation (const Implementation&); // Not implemented. | |
| Implementation& operator= (const Implementation&); // Not implemented. | |
| }; | |
| //===== UpdateLockManager ===================================================== | |
| UpdateLockManager::UpdateLockManager (ViewShellBase& rBase) | |
| : mpImpl(new Implementation(rBase)) | |
| { | |
| mpImpl->acquire(); | |
| } | |
| UpdateLockManager::~UpdateLockManager (void) | |
| { | |
| if (mpImpl != NULL) | |
| { | |
| mpImpl->ForceUnlock(); | |
| mpImpl->release(); | |
| } | |
| } | |
| void UpdateLockManager::Disable (void) | |
| { | |
| if (mpImpl != NULL) | |
| { | |
| mpImpl->ForceUnlock(); | |
| mpImpl->release(); | |
| mpImpl = NULL; | |
| } | |
| } | |
| void UpdateLockManager::Lock (void) | |
| { | |
| if (mpImpl != NULL) | |
| mpImpl->Lock(); | |
| } | |
| void UpdateLockManager::Unlock (void) | |
| { | |
| if (mpImpl != NULL) | |
| mpImpl->Unlock(); | |
| } | |
| bool UpdateLockManager::IsLocked (void) const | |
| { | |
| if (mpImpl != NULL) | |
| return mpImpl->IsLocked(); | |
| else | |
| return false; | |
| } | |
| //===== UpdateLock::Implementation ============================================ | |
| UpdateLockManager::Implementation::Implementation (ViewShellBase& rBase) | |
| : InterfaceBase(maMutex), | |
| mrBase(rBase), | |
| mnLockDepth(0), | |
| maTimer(), | |
| mbUnlockOnNextLayout(false), | |
| mbListenerIsRegistered(false), | |
| mbLayouterIsLocked(false) | |
| { | |
| } | |
| UpdateLockManager::Implementation::~Implementation (void) | |
| { | |
| OSL_ASSERT(mnLockDepth==0); | |
| ForceUnlock(); | |
| } | |
| void UpdateLockManager::Implementation::Lock (void) | |
| { | |
| ++mnLockDepth; | |
| if (mnLockDepth == 1) | |
| { | |
| Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); | |
| if (xLayouter.is()) | |
| { | |
| // Register as event listener. | |
| Reference<frame::XLayoutManagerEventBroadcaster> xBroadcaster ( | |
| xLayouter, UNO_QUERY); | |
| if (xBroadcaster.is()) | |
| { | |
| mbListenerIsRegistered = true; | |
| xBroadcaster->addLayoutManagerEventListener( | |
| Reference<frame::XLayoutManagerListener> ( | |
| static_cast<XWeak*>(this), UNO_QUERY) ); | |
| } | |
| // Lock the layout manager. | |
| mbLayouterIsLocked = true; | |
| xLayouter->lock(); | |
| } | |
| // As a fallback, when the notification mechanism does not work (or is | |
| // incorrectly used) we use a timer that will unlock us eventually. | |
| maTimer.SetTimeout(5000 /*ms*/); | |
| maTimer.SetTimeoutHdl(LINK(this,UpdateLockManager::Implementation,Timeout)); | |
| maTimer.Start(); | |
| } | |
| } | |
| void UpdateLockManager::Implementation::Unlock (void) | |
| { | |
| --mnLockDepth; | |
| if (mnLockDepth == 0) | |
| { | |
| // Stop the timer. We don't need it anymore. | |
| maTimer.Stop(); | |
| try | |
| { | |
| Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); | |
| if (xLayouter.is()) | |
| { | |
| // Detach from the layouter. | |
| if (mbListenerIsRegistered) | |
| { | |
| Reference<frame::XLayoutManagerEventBroadcaster> xBroadcaster ( | |
| xLayouter, UNO_QUERY); | |
| if (xBroadcaster.is()) | |
| { | |
| mbListenerIsRegistered = false; | |
| xBroadcaster->removeLayoutManagerEventListener( | |
| Reference<frame::XLayoutManagerListener> ( | |
| static_cast<XWeak*>(this), UNO_QUERY) ); | |
| } | |
| } | |
| // Unlock the layouter. | |
| if (mbLayouterIsLocked) | |
| { | |
| mbLayouterIsLocked = false; | |
| xLayouter->unlock(); | |
| } | |
| } | |
| } | |
| catch (RuntimeException) | |
| { } | |
| // Force a rearrangement of the UI elements of the views. | |
| mrBase.Rearrange(); | |
| } | |
| } | |
| bool UpdateLockManager::Implementation::IsLocked (void) const | |
| { | |
| return (mnLockDepth > 0); | |
| } | |
| void UpdateLockManager::Implementation::ForceUnlock (void) | |
| { | |
| while (IsLocked()) | |
| Unlock(); | |
| } | |
| void SAL_CALL UpdateLockManager::Implementation::layoutEvent ( | |
| const lang::EventObject&, | |
| sal_Int16 eLayoutEvent, | |
| const Any& rInfo) | |
| { | |
| switch (eLayoutEvent) | |
| { | |
| case frame::LayoutManagerEvents::LOCK: | |
| { | |
| sal_Int32 nLockCount; | |
| rInfo >>= nLockCount; | |
| } | |
| break; | |
| case frame::LayoutManagerEvents::UNLOCK: | |
| { | |
| sal_Int32 nLockCount = 0; | |
| rInfo >>= nLockCount; | |
| if (nLockCount == 1) | |
| { | |
| // The lock count dropped to one. This means that we are | |
| // the only one that still holds a lock to the layout | |
| // manager. We unlock the layout manager now and the | |
| // ViewShellBase on the next layout of the layout manager. | |
| mbUnlockOnNextLayout = true; | |
| Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); | |
| if (xLayouter.is() && mbLayouterIsLocked) | |
| { | |
| mbLayouterIsLocked = false; | |
| xLayouter->unlock(); | |
| } | |
| } | |
| } | |
| break; | |
| case frame::LayoutManagerEvents::LAYOUT: | |
| // Unlock when the layout manager is not still locked. | |
| if (mbUnlockOnNextLayout) | |
| Unlock(); | |
| break; | |
| } | |
| } | |
| void SAL_CALL UpdateLockManager::Implementation::disposing (const lang::EventObject& ) | |
| { | |
| } | |
| void SAL_CALL UpdateLockManager::Implementation::disposing (void) | |
| { | |
| } | |
| IMPL_LINK(UpdateLockManager::Implementation, Timeout, void*, EMPTYARG) | |
| { | |
| // This method is only called when all else failed. We unlock | |
| // regardless of how deep the lock depth. | |
| while (mnLockDepth > 0) | |
| Unlock(); | |
| return 1; | |
| } | |
| Reference< ::com::sun::star::frame::XLayoutManager> | |
| UpdateLockManager::Implementation::GetLayoutManager (void) | |
| { | |
| Reference<frame::XLayoutManager> xLayoutManager; | |
| if (mxLayoutManager.get() == NULL) | |
| { | |
| if (mrBase.GetViewFrame()!=NULL) | |
| { | |
| Reference<beans::XPropertySet> xFrameProperties ( | |
| mrBase.GetViewFrame()->GetFrame().GetFrameInterface(), | |
| UNO_QUERY); | |
| if (xFrameProperties.is()) | |
| { | |
| try | |
| { | |
| Any aValue (xFrameProperties->getPropertyValue( | |
| ::rtl::OUString::createFromAscii("LayoutManager"))); | |
| aValue >>= xLayoutManager; | |
| } | |
| catch (const beans::UnknownPropertyException& rException) | |
| { | |
| (void)rException; | |
| } | |
| } | |
| mxLayoutManager = xLayoutManager; | |
| } | |
| } | |
| else | |
| xLayoutManager = mxLayoutManager; | |
| return xLayoutManager; | |
| } | |
| } // end of anonymous namespace |