basctl/source/basicide/doceventnotifier.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 <doceventnotifier.hxx>
  21 #include <scriptdocument.hxx>
  22
  23 #include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
  24
  25 #include <vcl/svapp.hxx>
  26
  27 #include <comphelper/compbase.hxx>
  28 #include <comphelper/diagnose_ex.hxx>
  29 #include <comphelper/processfactory.hxx>
  30
  31 namespace basctl
  32 {
  33
  34     using ::com::sun::star::document::XDocumentEventBroadcaster;
  35     using ::com::sun::star::document::XDocumentEventListener;
  36     using ::com::sun::star::document::DocumentEvent;
  37     using ::com::sun::star::uno::XComponentContext;
  38     using ::com::sun::star::uno::Reference;
  39     using ::com::sun::star::uno::UNO_QUERY_THROW;
  40     using ::com::sun::star::uno::Exception;
  41     using ::com::sun::star::frame::XModel;
  42     using ::com::sun::star::frame::theGlobalEventBroadcaster;
  43     using ::com::sun::star::uno::UNO_QUERY;
  44
  45     // DocumentEventNotifier::Impl
  46
  47     typedef ::comphelper::WeakComponentImplHelper<   XDocumentEventListener
  48                                            >   DocumentEventNotifier_Impl_Base;
  49
  50     namespace {
  51
  52     enum ListenerAction
  53     {
  54         RegisterListener,
  55         RemoveListener
  56     };
  57
  58     }
  59
  60     /** impl class for DocumentEventNotifier
  61     */
  62     class DocumentEventNotifier::Impl : public DocumentEventNotifier_Impl_Base
  63     {
  64     public:
  65         // noncopyable
  66         Impl(const Impl&) = delete;
  67         Impl& operator=(const Impl&) = delete;
  68
  69         Impl (DocumentEventListener&, Reference<XModel> const& rxDocument);
  70         virtual ~Impl () override;
  71
  72         // XDocumentEventListener
  73         virtual void SAL_CALL documentEventOccured( const DocumentEvent& Event ) override;
  74
  75         // XEventListener
  76         virtual void SAL_CALL disposing( const css::lang::EventObject& Event ) override;
  77
  78         // WeakComponentImplHelper
  79         virtual void disposing(std::unique_lock<std::mutex>&) override;
  80
  81     private:
  82         /// determines whether the instance is already disposed
  83         bool    impl_isDisposed_nothrow(std::unique_lock<std::mutex>& /*rGuard*/) const { return m_pListener == nullptr; }
  84
  85         /// disposes the instance
  86         void    impl_dispose_nothrow(std::unique_lock<std::mutex>& rGuard);
  87
  88         /// registers or revokes the instance as listener at the global event broadcaster
  89         void    impl_listenerAction_nothrow( std::unique_lock<std::mutex>& rGuard, ListenerAction _eAction );
  90
  91     private:
  92         DocumentEventListener*  m_pListener;
  93         Reference< XModel >     m_xModel;
  94     };
  95
  96     DocumentEventNotifier::Impl::Impl (DocumentEventListener& rListener, Reference<XModel> const& rxDocument) :
  97         m_pListener(&rListener),
  98         m_xModel(rxDocument)
  99     {
 100         std::unique_lock aGuard(m_aMutex);
 101         osl_atomic_increment( &m_refCount );
 102         impl_listenerAction_nothrow( aGuard, RegisterListener );
 103         osl_atomic_decrement( &m_refCount );
 104     }
 105
 106     DocumentEventNotifier::Impl::~Impl ()
 107     {
 108         std::unique_lock aGuard(m_aMutex);
 109         if ( !impl_isDisposed_nothrow(aGuard) )
 110         {
 111             acquire();
 112             dispose();
 113         }
 114     }
 115
 116     void SAL_CALL DocumentEventNotifier::Impl::documentEventOccured( const DocumentEvent& _rEvent )
 117     {
 118         std::unique_lock aGuard( m_aMutex );
 119
 120         OSL_PRECOND( !impl_isDisposed_nothrow(aGuard), "DocumentEventNotifier::Impl::notifyEvent: disposed, but still getting events?" );
 121         if ( impl_isDisposed_nothrow(aGuard) )
 122             return;
 123
 124         Reference< XModel > xDocument( _rEvent.Source, UNO_QUERY );
 125         OSL_ENSURE( xDocument.is(), "DocumentEventNotifier::Impl::notifyEvent: illegal source document!" );
 126         if ( !xDocument.is() )
 127             return;
 128
 129         struct EventEntry
 130         {
 131             const char* pEventName;
 132             void (DocumentEventListener::*listenerMethod)( const ScriptDocument& _rDocument );
 133         };
 134         static EventEntry const aEvents[] = {
 135             { "OnNew",          &DocumentEventListener::onDocumentCreated },
 136             { "OnLoad",         &DocumentEventListener::onDocumentOpened },
 137             { "OnSave",         &DocumentEventListener::onDocumentSave },
 138             { "OnSaveDone",     &DocumentEventListener::onDocumentSaveDone },
 139             { "OnSaveAs",       &DocumentEventListener::onDocumentSaveAs },
 140             { "OnSaveAsDone",   &DocumentEventListener::onDocumentSaveAsDone },
 141             { "OnUnload",       &DocumentEventListener::onDocumentClosed },
 142             { "OnTitleChanged", &DocumentEventListener::onDocumentTitleChanged },
 143             { "OnModeChanged",  &DocumentEventListener::onDocumentModeChanged }
 144         };
 145
 146         for (EventEntry const & aEvent : aEvents)
 147         {
 148             if ( !_rEvent.EventName.equalsAscii( aEvent.pEventName ) )
 149                 continue;
 150
 151             // Listener implementations require that we hold the mutex, but to avoid lock ordering issues,
 152             // we need to take the solar mutex before we take our own mutex.
 153             aGuard.unlock();
 154
 155             // Listener implements require that we hold the solar mutex.
 156             SolarMutexGuard aSolarGuard;
 157
 158             // Take the lock again, so we can check our local fields.
 159             aGuard.lock();
 160             if ( impl_isDisposed_nothrow(aGuard) )
 161                 // somebody took the chance to dispose us -> bail out
 162                 return;
 163             DocumentEventListener* pListener = m_pListener;
 164             ScriptDocument aDocument( xDocument );
 165             // We cannot call the listener while holding our mutex because the listener
 166             // call might trigger an event which call back into us.
 167             aGuard.unlock();
 168
 169             (pListener->*aEvent.listenerMethod)( aDocument );
 170
 171             break;
 172         }
 173     }
 174
 175     void SAL_CALL DocumentEventNotifier::Impl::disposing( const css::lang::EventObject& /*Event*/ )
 176     {
 177         SolarMutexGuard aSolarGuard;
 178         std::unique_lock aGuard( m_aMutex );
 179
 180         if ( !impl_isDisposed_nothrow(aGuard) )
 181             impl_dispose_nothrow(aGuard);
 182     }
 183
 184     void DocumentEventNotifier::Impl::disposing(std::unique_lock<std::mutex>& rGuard)
 185     {
 186         impl_listenerAction_nothrow( rGuard, RemoveListener );
 187         impl_dispose_nothrow(rGuard);
 188     }
 189
 190     void DocumentEventNotifier::Impl::impl_dispose_nothrow(std::unique_lock<std::mutex>& /*rGuard*/)
 191     {
 192         m_pListener = nullptr;
 193         m_xModel.clear();
 194     }
 195
 196     void DocumentEventNotifier::Impl::impl_listenerAction_nothrow( std::unique_lock<std::mutex>& rGuard, ListenerAction _eAction )
 197     {
 198         try
 199         {
 200             Reference< XDocumentEventBroadcaster > xBroadcaster;
 201             if ( m_xModel.is() )
 202                 xBroadcaster.set( m_xModel, UNO_QUERY_THROW );
 203             else
 204             {
 205                 Reference< css::uno::XComponentContext > aContext(
 206                     comphelper::getProcessComponentContext() );
 207                 xBroadcaster = theGlobalEventBroadcaster::get(aContext);
 208             }
 209
 210             void ( SAL_CALL XDocumentEventBroadcaster::*listenerAction )( const Reference< XDocumentEventListener >& ) =
 211                 ( _eAction == RegisterListener ) ? &XDocumentEventBroadcaster::addDocumentEventListener : &XDocumentEventBroadcaster::removeDocumentEventListener;
 212
 213             rGuard.unlock();
 214             (xBroadcaster.get()->*listenerAction)( this );
 215             rGuard.lock();
 216         }
 217         catch( const Exception& )
 218         {
 219             DBG_UNHANDLED_EXCEPTION("basctl.basicide");
 220         }
 221     }
 222
 223     // DocumentEventNotifier
 224
 225     DocumentEventNotifier::DocumentEventNotifier (DocumentEventListener& rListener, Reference<XModel> const& rxDocument) :
 226         m_pImpl(new Impl(rListener, rxDocument))
 227     { }
 228
 229     DocumentEventNotifier::DocumentEventNotifier (DocumentEventListener& rListener) :
 230         m_pImpl(new Impl(rListener, Reference<XModel>()))
 231     { }
 232
 233     DocumentEventNotifier::~DocumentEventNotifier()
 234     {
 235     }
 236
 237     void DocumentEventNotifier::dispose()
 238     {
 239         m_pImpl->dispose();
 240     }
 241
 242     // DocumentEventListener
 243
 244     DocumentEventListener::~DocumentEventListener()
 245     {
 246     }
 247
 248 } // namespace basctl
 249
 250 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */