sd/source/ui/framework/module/ReadOnlyModeObserver.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ReadOnlyModeObserver.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sd.hxx"
  32
  33 #include "ReadOnlyModeObserver.hxx"
  34
  35 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  36 #include <com/sun/star/lang/DisposedException.hpp>
  37 #include <com/sun/star/util/XURLTransformer.hpp>
  38 #include <comphelper/processfactory.hxx>
  39 #include <cppuhelper/interfacecontainer.hxx>
  40
  41 #include "tools/SlotStateListener.hxx"
  42 #include "framework/FrameworkHelper.hxx"
  43
  44 using namespace ::com::sun::star::uno;
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::drawing::framework;
  47 using ::rtl::OUString;
  48
  49 namespace sd { namespace framework {
  50
  51 class ReadOnlyModeObserver::ModifyBroadcaster
  52     : public ::cppu::OBroadcastHelper
  53 {
  54 public:
  55     explicit ModifyBroadcaster (::osl::Mutex& rOslMutex) : ::cppu::OBroadcastHelper(rOslMutex) {}
  56 };
  57
  58
  59
  60
  61 ReadOnlyModeObserver::ReadOnlyModeObserver (
  62     const Reference<frame::XController>& rxController)
  63     : ReadOnlyModeObserverInterfaceBase(maMutex),
  64       maSlotNameURL(),
  65       mxController(rxController),
  66       mxConfigurationController(NULL),
  67       mxDispatch(NULL),
  68       mpBroadcaster(new ModifyBroadcaster(maMutex))
  69 {
  70     // Create a URL object for the slot name.
  71     maSlotNameURL.Complete = OUString::createFromAscii(".uno:EditDoc");
  72     uno::Reference<lang::XMultiServiceFactory> xServiceManager (
  73         ::comphelper::getProcessServiceFactory());
  74     if (xServiceManager.is())
  75     {
  76         Reference<util::XURLTransformer> xTransformer(xServiceManager->createInstance(
  77             OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.util.URLTransformer"))),
  78             UNO_QUERY);
  79         if (xTransformer.is())
  80             xTransformer->parseStrict(maSlotNameURL);
  81     }
  82
  83     if ( ! ConnectToDispatch())
  84     {
  85         // The controller is not yet connected to a frame.  This means that
  86         // the dispatcher is not yet set up.  We wait for this to happen by
  87         // waiting for configuration updates and try again.
  88         Reference<XControllerManager> xControllerManager (rxController, UNO_QUERY);
  89         if (xControllerManager.is())
  90         {
  91             mxConfigurationController = xControllerManager->getConfigurationController();
  92             if (mxConfigurationController.is())
  93             {
  94                 mxConfigurationController->addConfigurationChangeListener(
  95                     this,
  96                     FrameworkHelper::msConfigurationUpdateStartEvent,
  97                     Any());
  98             }
  99         }
 100     }
 101 }
 102
 103
 104
 105
 106 ReadOnlyModeObserver::~ReadOnlyModeObserver (void)
 107 {
 108 }
 109
 110
 111
 112
 113 void SAL_CALL ReadOnlyModeObserver::disposing (void)
 114 {
 115     if (mxController.is())
 116     {
 117         mxController = NULL;
 118     }
 119     if (mxConfigurationController.is())
 120     {
 121         mxConfigurationController->removeConfigurationChangeListener(this);
 122         mxConfigurationController = NULL;
 123     }
 124     if (mxDispatch.is())
 125     {
 126         mxDispatch->removeStatusListener(this, maSlotNameURL);
 127         mxDispatch = NULL;
 128     }
 129
 130     lang::EventObject aEvent;
 131     aEvent.Source = static_cast<XWeak*>(this);
 132     ::cppu::OInterfaceContainerHelper* pIterator
 133         = mpBroadcaster->getContainer(getCppuType((Reference<frame::XStatusListener>*)NULL));
 134     pIterator->disposeAndClear(aEvent);
 135 }
 136
 137
 138
 139
 140 void ReadOnlyModeObserver::AddStatusListener (
 141     const Reference<frame::XStatusListener>& rxListener)
 142 {
 143     mpBroadcaster->addListener(
 144         getCppuType((Reference<frame::XStatusListener>*)NULL),
 145         rxListener);
 146 }
 147
 148
 149
 150
 151 void ReadOnlyModeObserver::RemoveStatusListener (
 152     const Reference<frame::XStatusListener>& rxListener)
 153 {
 154     mpBroadcaster->removeListener(
 155         getCppuType((Reference<frame::XStatusListener>*)NULL),
 156         rxListener);
 157 }
 158
 159
 160
 161
 162 bool ReadOnlyModeObserver::ConnectToDispatch (void)
 163 {
 164     if ( ! mxDispatch.is())
 165     {
 166         // Get the dispatch object.
 167         Reference<frame::XDispatchProvider> xProvider (mxController->getFrame(), UNO_QUERY);
 168         if (xProvider.is())
 169         {
 170             mxDispatch = xProvider->queryDispatch(maSlotNameURL, OUString(), 0);
 171             if (mxDispatch.is())
 172             {
 173                 mxDispatch->addStatusListener(this, maSlotNameURL);
 174             }
 175         }
 176     }
 177
 178     return mxDispatch.is();
 179 }
 180
 181
 182
 183
 184 void ReadOnlyModeObserver::statusChanged (const frame::FeatureStateEvent& rEvent)
 185     throw (RuntimeException)
 186 {
 187     ::cppu::OInterfaceContainerHelper* pIterator
 188           = mpBroadcaster->getContainer(getCppuType((Reference<frame::XStatusListener>*)NULL));
 189     if (pIterator != NULL)
 190     {
 191         pIterator->notifyEach(&frame::XStatusListener::statusChanged, rEvent);
 192     }
 193 }
 194
 195
 196
 197
 198 //----- XEventListener --------------------------------------------------------
 199
 200 void SAL_CALL ReadOnlyModeObserver::disposing (
 201     const lang::EventObject& rEvent)
 202     throw (RuntimeException)
 203 {
 204     if (rEvent.Source == mxConfigurationController)
 205         mxConfigurationController = NULL;
 206     else if (rEvent.Source == mxDispatch)
 207         mxDispatch = NULL;
 208
 209     dispose();
 210 }
 211
 212
 213
 214
 215 void SAL_CALL ReadOnlyModeObserver::notifyConfigurationChange (
 216     const ConfigurationChangeEvent& rEvent)
 217     throw (RuntimeException)
 218 {
 219     if (rEvent.Type.equals(FrameworkHelper::msConfigurationUpdateStartEvent))
 220     {
 221         if (mxController.is() && mxController->getFrame().is())
 222         {
 223             if (ConnectToDispatch())
 224             {
 225                 // We have connected successfully to the dispatcher and
 226                 // therefore can disconnect from the configuration controller.
 227                 mxConfigurationController->removeConfigurationChangeListener(this);
 228                 mxConfigurationController = NULL;
 229             }
 230         }
 231     }
 232 }
 233
 234 } } // end of namespace sd::framework