framework/source/services/ContextChangeEventMultiplexer.cxx

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 #include "services/ContextChangeEventMultiplexer.hxx"
  19 #include "services.h"
  20
  21 using ::rtl::OUString;
  22
  23 #define A2S(s) ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))
  24
  25 using namespace css;
  26 using namespace cssu;
  27
  28 namespace framework {
  29
  30 #define IMPLEMENTATION_NAME "org.apache.openoffice.comp.framework.ContextChangeEventMultiplexer"
  31 #define SERVICE_NAME "com.sun.star.ui.ContextChangeEventMultiplexer"
  32 #define SINGLETON_NAME "org.apache.openoffice.comp.framework.ContextChangeEventMultiplexerSigleton"
  33
  34
  35 ContextChangeEventMultiplexer::ContextChangeEventMultiplexer (
  36     const cssu::Reference<cssu::XComponentContext>& rxContext)
  37     : ContextChangeEventMultiplexerInterfaceBase(m_aMutex),
  38       maListeners()
  39 {
  40     (void)rxContext;
  41 }
  42
  43
  44
  45
  46 ContextChangeEventMultiplexer::~ContextChangeEventMultiplexer (void)
  47 {
  48 }
  49
  50
  51
  52
  53 void SAL_CALL ContextChangeEventMultiplexer::disposing (void)
  54 {
  55     ListenerMap aListeners;
  56     aListeners.swap(maListeners);
  57
  58     cssu::Reference<cssu::XInterface> xThis (static_cast<XWeak*>(this));
  59     css::lang::EventObject aEvent (xThis);
  60     for (ListenerMap::const_iterator iContainer(aListeners.begin()), iEnd(aListeners.end());
  61          iContainer!=iEnd;
  62          ++iContainer)
  63     {
  64         // Unregister from the focus object.
  65         Reference<lang::XComponent> xComponent (iContainer->first, UNO_QUERY);
  66         if (xComponent.is())
  67             xComponent->removeEventListener(this);
  68
  69         // Tell all listeners that we are being disposed.
  70         const FocusDescriptor& rFocusDescriptor (iContainer->second);
  71         for (ListenerContainer::const_iterator
  72                  iListener(rFocusDescriptor.maListeners.begin()),
  73                  iContainerEnd(rFocusDescriptor.maListeners.end());
  74              iListener!=iContainerEnd;
  75              ++iListener)
  76         {
  77             (*iListener)->disposing(aEvent);
  78         }
  79     }
  80 }
  81
  82
  83
  84
  85 // XContextChangeEventMultiplexer
  86
  87 void SAL_CALL ContextChangeEventMultiplexer::addContextChangeEventListener (
  88     const cssu::Reference<css::ui::XContextChangeEventListener>& rxListener,
  89     const cssu::Reference<cssu::XInterface>& rxEventFocus)
  90     throw(cssu::RuntimeException,cssl::IllegalArgumentException)
  91 {
  92     if ( ! rxListener.is())
  93         throw css::lang::IllegalArgumentException(
  94             A2S("can not add an empty reference"),
  95             static_cast<XWeak*>(this),
  96             0);
  97
  98     FocusDescriptor* pFocusDescriptor = GetFocusDescriptor(rxEventFocus, true);
  99     if (pFocusDescriptor != NULL)
 100     {
 101         ListenerContainer& rContainer (pFocusDescriptor->maListeners);
 102         if (::std::find(rContainer.begin(), rContainer.end(), rxListener) == rContainer.end())
 103             rContainer.push_back(rxListener);
 104         else
 105         {
 106             // The listener was added for the same event focus
 107             // previously.  That is an error.
 108             throw cssl::IllegalArgumentException(A2S("listener added twice"), static_cast<XWeak*>(this), 0);
 109         }
 110     }
 111
 112     // Send out an initial event that informs the new listener about
 113     // the current context.
 114     if (rxEventFocus.is() && pFocusDescriptor!=NULL)
 115     {
 116         css::ui::ContextChangeEventObject aEvent (
 117             NULL,
 118             pFocusDescriptor->msCurrentApplicationName,
 119             pFocusDescriptor->msCurrentContextName);
 120         rxListener->notifyContextChangeEvent(aEvent);
 121     }
 122 }
 123
 124
 125
 126
 127 void SAL_CALL ContextChangeEventMultiplexer::removeContextChangeEventListener (
 128     const cssu::Reference<css::ui::XContextChangeEventListener>& rxListener,
 129     const cssu::Reference<cssu::XInterface>& rxEventFocus)
 130     throw(cssu::RuntimeException,cssl::IllegalArgumentException)
 131 {
 132     if ( ! rxListener.is())
 133         throw cssl::IllegalArgumentException(
 134             A2S("can not remove an empty reference"),
 135             static_cast<XWeak*>(this), 0);
 136
 137     FocusDescriptor* pFocusDescriptor = GetFocusDescriptor(rxEventFocus, false);
 138     if (pFocusDescriptor != NULL)
 139     {
 140         ListenerContainer& rContainer (pFocusDescriptor->maListeners);
 141         const ListenerContainer::iterator iListener (
 142             ::std::find(rContainer.begin(), rContainer.end(), rxListener));
 143         if (iListener != rContainer.end())
 144         {
 145             rContainer.erase(iListener);
 146
 147             // We hold on to the focus descriptor even when the last listener has been removed.
 148             // This allows us to keep track of the current context and send it to new listeners.
 149         }
 150     }
 151
 152 }
 153
 154
 155
 156
 157 void SAL_CALL ContextChangeEventMultiplexer::removeAllContextChangeEventListeners (
 158     const cssu::Reference<css::ui::XContextChangeEventListener>& rxListener)
 159     throw(cssu::RuntimeException,cssl::IllegalArgumentException)
 160 {
 161     if ( ! rxListener.is())
 162         throw cssl::IllegalArgumentException(
 163             A2S("can not remove an empty reference"),
 164             static_cast<XWeak*>(this), 0);
 165
 166     for (ListenerMap::iterator
 167              iContainer(maListeners.begin()),
 168              iEnd(maListeners.end());
 169          iContainer!=iEnd;
 170          ++iContainer)
 171     {
 172         const ListenerContainer::iterator iListener (
 173             ::std::find(iContainer->second.maListeners.begin(), iContainer->second.maListeners.end(), rxListener));
 174         if (iListener != iContainer->second.maListeners.end())
 175         {
 176             iContainer->second.maListeners.erase(iListener);
 177
 178             // We hold on to the focus descriptor even when the last listener has been removed.
 179             // This allows us to keep track of the current context and send it to new listeners.
 180         }
 181     }
 182 }
 183
 184
 185
 186
 187 void SAL_CALL ContextChangeEventMultiplexer::broadcastContextChangeEvent (
 188     const css::ui::ContextChangeEventObject& rEventObject,
 189     const cssu::Reference<cssu::XInterface>& rxEventFocus)
 190     throw(cssu::RuntimeException)
 191 {
 192     // Remember the current context.
 193     if (rxEventFocus.is())
 194     {
 195         FocusDescriptor* pFocusDescriptor = GetFocusDescriptor(rxEventFocus, true);
 196         if (pFocusDescriptor != NULL)
 197         {
 198             pFocusDescriptor->msCurrentApplicationName = rEventObject.ApplicationName;
 199             pFocusDescriptor->msCurrentContextName = rEventObject.ContextName;
 200         }
 201     }
 202
 203     BroadcastEventToSingleContainer(rEventObject, rxEventFocus);
 204     if (rxEventFocus.is())
 205         BroadcastEventToSingleContainer(rEventObject, NULL);
 206 }
 207
 208
 209
 210
 211 void ContextChangeEventMultiplexer::BroadcastEventToSingleContainer (
 212     const css::ui::ContextChangeEventObject& rEventObject,
 213     const cssu::Reference<cssu::XInterface>& rxEventFocus)
 214 {
 215     FocusDescriptor* pFocusDescriptor = GetFocusDescriptor(rxEventFocus, false);
 216     if (pFocusDescriptor != NULL)
 217     {
 218         // Create a copy of the listener container to avoid problems
 219         // when one of the called listeners calls add... or remove...
 220         ListenerContainer aContainer (pFocusDescriptor->maListeners);
 221         for (ListenerContainer::const_iterator
 222                  iListener(aContainer.begin()),
 223                  iEnd(aContainer.end());
 224              iListener!=iEnd;
 225              ++iListener)
 226         {
 227             (*iListener)->notifyContextChangeEvent(rEventObject);
 228         }
 229     }
 230 }
 231
 232
 233
 234
 235 ContextChangeEventMultiplexer::FocusDescriptor* ContextChangeEventMultiplexer::GetFocusDescriptor (
 236     const cssu::Reference<cssu::XInterface>& rxEventFocus,
 237     const bool bCreateWhenMissing)
 238 {
 239     ListenerMap::iterator iDescriptor (maListeners.find(rxEventFocus));
 240     if (iDescriptor == maListeners.end() && bCreateWhenMissing)
 241     {
 242         // Listen for the focus being disposed.
 243         Reference<lang::XComponent> xComponent (rxEventFocus, UNO_QUERY);
 244         if (xComponent.is())
 245             xComponent->addEventListener(this);
 246
 247         // Create a new listener container for the event focus.
 248         iDescriptor = maListeners.insert(
 249             ListenerMap::value_type(
 250                 rxEventFocus,
 251                 FocusDescriptor())).first;
 252     }
 253     if (iDescriptor != maListeners.end())
 254         return &iDescriptor->second;
 255     else
 256         return NULL;
 257 }
 258
 259
 260
 261
 262 // XSingleComponentFactory
 263
 264 cssu::Reference<cssu::XInterface> SAL_CALL ContextChangeEventMultiplexer::createInstanceWithContext (
 265     const cssu::Reference<cssu::XComponentContext>& rxContext)
 266     throw (cssu::Exception, cssu::RuntimeException)
 267 {
 268     (void)rxContext;
 269     return cssu::Reference<cssu::XInterface>();
 270 }
 271
 272
 273
 274
 275 cssu::Reference<cssu::XInterface > SAL_CALL ContextChangeEventMultiplexer::createInstanceWithArgumentsAndContext (
 276     const cssu::Sequence<cssu::Any>& rArguments,
 277     const cssu::Reference<cssu::XComponentContext>& rxContext)
 278     throw (cssu::Exception, cssu::RuntimeException)
 279 {
 280     (void)rArguments;
 281     (void)rxContext;
 282     return cssu::Reference<cssu::XInterface>();
 283 }
 284
 285
 286
 287
 288 // XServiceInfo
 289
 290 ::rtl::OUString SAL_CALL ContextChangeEventMultiplexer::getImplementationName (void)
 291     throw(cssu::RuntimeException)
 292 {
 293     return impl_getStaticImplementationName();
 294 }
 295
 296
 297
 298
 299
 300 sal_Bool SAL_CALL ContextChangeEventMultiplexer::supportsService (
 301     const ::rtl::OUString& rsServiceName)
 302     throw (cssu::RuntimeException)
 303 {
 304     return ::comphelper::findValue(static_GetSupportedServiceNames(), rsServiceName, sal_True).getLength() != 0;
 305 }
 306
 307
 308
 309
 310 cssu::Sequence<OUString> SAL_CALL ContextChangeEventMultiplexer::getSupportedServiceNames (void)
 311     throw (cssu::RuntimeException)
 312 {
 313     return static_GetSupportedServiceNames();
 314 }
 315
 316
 317
 318
 319 void SAL_CALL ContextChangeEventMultiplexer::disposing (
 320     const css::lang::EventObject& rEvent)
 321     throw (cssu::RuntimeException)
 322 {
 323     ListenerMap::iterator iDescriptor (maListeners.find(rEvent.Source));
 324
 325     if (iDescriptor == maListeners.end())
 326     {
 327         OSL_ASSERT(iDescriptor != maListeners.end());
 328         return;
 329     }
 330
 331     // Should we notify the remaining listeners?
 332
 333     maListeners.erase(iDescriptor);
 334 }
 335
 336
 337
 338
 339 // Local and static methods.
 340
 341 OUString SAL_CALL ContextChangeEventMultiplexer::impl_getStaticImplementationName (void)
 342 {
 343     return A2S(IMPLEMENTATION_NAME);
 344 }
 345
 346
 347
 348
 349 cssu::Sequence<OUString> SAL_CALL ContextChangeEventMultiplexer::static_GetSupportedServiceNames (void)
 350 {
 351     cssu::Sequence<OUString> aServiceNames (2);
 352     aServiceNames[0] = A2S(SERVICE_NAME);
 353     aServiceNames[1] = A2S(SINGLETON_NAME);
 354     return aServiceNames;
 355 }
 356
 357
 358
 359
 360 cssu::Reference<cssu::XInterface> ContextChangeEventMultiplexer::impl_createFactory (
 361     const cssu::Reference<cssl::XMultiServiceFactory>& rxServiceManager)
 362 {
 363     (void)rxServiceManager;
 364     return cppu::createSingleComponentFactory(
 365         ContextChangeEventMultiplexer::static_CreateInstance,
 366         ContextChangeEventMultiplexer::impl_getStaticImplementationName(),
 367         ContextChangeEventMultiplexer::static_GetSupportedServiceNames()
 368         );
 369 }
 370
 371
 372
 373
 374 cssu::Reference<cssu::XInterface> SAL_CALL ContextChangeEventMultiplexer::static_CreateInstance (
 375     const cssu::Reference<cssu::XComponentContext>& rxComponentContext)
 376     throw (cssu::Exception)
 377 {
 378     ContextChangeEventMultiplexer* pObject = new ContextChangeEventMultiplexer(rxComponentContext);
 379     cssu::Reference<cssu::XInterface> xService (static_cast<XWeak*>(pObject), cssu::UNO_QUERY);
 380     return xService;
 381 }
 382
 383 }  // end of namespace framework