dtrans/source/generic/clipboardmanager.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 <clipboardmanager.hxx>
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22
  23 using namespace com::sun::star::container;
  24 using namespace com::sun::star::datatransfer;
  25 using namespace com::sun::star::datatransfer::clipboard;
  26 using namespace com::sun::star::lang;
  27 using namespace com::sun::star::uno;
  28 using namespace cppu;
  29 using namespace osl;
  30 using namespace std;
  31
  32 using ::dtrans::ClipboardManager;
  33
  34 // ------------------------------------------------------------------------
  35
  36 ClipboardManager::ClipboardManager():
  37     WeakComponentImplHelper3< XClipboardManager, XEventListener, XServiceInfo > (m_aMutex),
  38     m_aDefaultName(OUString("default"))
  39 {
  40 }
  41
  42 // ------------------------------------------------------------------------
  43
  44 ClipboardManager::~ClipboardManager()
  45 {
  46 }
  47
  48 // ------------------------------------------------------------------------
  49
  50 OUString SAL_CALL ClipboardManager::getImplementationName(  )
  51     throw(RuntimeException)
  52 {
  53     return OUString(CLIPBOARDMANAGER_IMPLEMENTATION_NAME);
  54 }
  55
  56 // ------------------------------------------------------------------------
  57
  58 sal_Bool SAL_CALL ClipboardManager::supportsService( const OUString& ServiceName )
  59     throw(RuntimeException)
  60 {
  61     Sequence < OUString > SupportedServicesNames = ClipboardManager_getSupportedServiceNames();
  62
  63     for ( sal_Int32 n = 0, nmax = SupportedServicesNames.getLength(); n < nmax; n++ )
  64         if ( SupportedServicesNames[n] == ServiceName )
  65             return sal_True;
  66
  67     return sal_False;
  68 }
  69
  70 // ------------------------------------------------------------------------
  71
  72 Sequence< OUString > SAL_CALL ClipboardManager::getSupportedServiceNames(  )
  73     throw(RuntimeException)
  74 {
  75     return ClipboardManager_getSupportedServiceNames();
  76 }
  77
  78 // ------------------------------------------------------------------------
  79
  80 Reference< XClipboard > SAL_CALL ClipboardManager::getClipboard( const OUString& aName )
  81     throw(NoSuchElementException, RuntimeException)
  82 {
  83     MutexGuard aGuard(m_aMutex);
  84
  85     // object is disposed already
  86     if (rBHelper.bDisposed)
  87         throw DisposedException(OUString("object is disposed."),
  88                                 static_cast < XClipboardManager * > (this));
  89
  90     ClipboardMap::iterator iter =
  91         m_aClipboardMap.find(aName.getLength() ? aName : m_aDefaultName);
  92
  93     if (iter != m_aClipboardMap.end())
  94         return iter->second;
  95
  96     throw NoSuchElementException(aName, static_cast < XClipboardManager * > (this));
  97 }
  98
  99 // ------------------------------------------------------------------------
 100
 101 void SAL_CALL ClipboardManager::addClipboard( const Reference< XClipboard >& xClipboard )
 102     throw(IllegalArgumentException, ElementExistException, RuntimeException)
 103 {
 104     OSL_ASSERT(xClipboard.is());
 105
 106     // check parameter
 107     if (!xClipboard.is())
 108         throw IllegalArgumentException(OUString("empty reference"),
 109                                        static_cast < XClipboardManager * > (this), 1);
 110
 111     // the name "default" is reserved for internal use
 112     OUString aName = xClipboard->getName();
 113     if ( m_aDefaultName == aName )
 114         throw IllegalArgumentException(OUString("name reserved"),
 115                                        static_cast < XClipboardManager * > (this), 1);
 116
 117     // try to add new clipboard to the list
 118     ClearableMutexGuard aGuard(m_aMutex);
 119     if (!rBHelper.bDisposed && !rBHelper.bInDispose)
 120     {
 121         pair< const OUString, Reference< XClipboard > > value (
 122             aName.getLength() ? aName : m_aDefaultName,
 123             xClipboard );
 124
 125         pair< ClipboardMap::iterator, bool > p = m_aClipboardMap.insert(value);
 126         aGuard.clear();
 127
 128         // insert failed, element must exist already
 129         if (!p.second)
 130             throw ElementExistException(aName, static_cast < XClipboardManager * > (this));
 131
 132         // request disposing notifications
 133         Reference< XComponent > xComponent(xClipboard, UNO_QUERY);
 134         if (xComponent.is())
 135             xComponent->addEventListener(static_cast < XEventListener * > (this));
 136     }
 137 }
 138
 139 // ------------------------------------------------------------------------
 140
 141 void SAL_CALL ClipboardManager::removeClipboard( const OUString& aName )
 142      throw(RuntimeException)
 143 {
 144     MutexGuard aGuard(m_aMutex);
 145     if (!rBHelper.bDisposed)
 146         m_aClipboardMap.erase(aName.getLength() ? aName : m_aDefaultName );
 147 }
 148
 149 // ------------------------------------------------------------------------
 150
 151 Sequence< OUString > SAL_CALL ClipboardManager::listClipboardNames()
 152     throw(RuntimeException)
 153 {
 154     MutexGuard aGuard(m_aMutex);
 155
 156     if (rBHelper.bDisposed)
 157         throw DisposedException(OUString("object is disposed."),
 158                                 static_cast < XClipboardManager * > (this));
 159
 160     if (rBHelper.bInDispose)
 161         return Sequence< OUString > ();
 162
 163     Sequence< OUString > aRet(m_aClipboardMap.size());
 164     ClipboardMap::iterator iter = m_aClipboardMap.begin();
 165     ClipboardMap::iterator imax = m_aClipboardMap.end();
 166
 167     for (sal_Int32 n = 0; iter != imax; ++iter)
 168         aRet[n++] = iter->first;
 169
 170     return aRet;
 171 }
 172
 173 // ------------------------------------------------------------------------
 174
 175 void SAL_CALL ClipboardManager::dispose()
 176     throw(RuntimeException)
 177 {
 178     ClearableMutexGuard aGuard( rBHelper.rMutex );
 179     if (!rBHelper.bDisposed && !rBHelper.bInDispose)
 180     {
 181         rBHelper.bInDispose = sal_True;
 182         aGuard.clear();
 183
 184         // give everyone a chance to save his clipboard instance
 185         EventObject aEvt(static_cast < XClipboardManager * > (this));
 186         rBHelper.aLC.disposeAndClear( aEvt );
 187
 188         // removeClipboard is still allowed here,  so make a copy of the
 189         // list (to ensure integrety) and clear the original.
 190         ClearableMutexGuard aGuard2( rBHelper.rMutex );
 191         ClipboardMap aCopy(m_aClipboardMap);
 192         m_aClipboardMap.clear();
 193         aGuard2.clear();
 194
 195         // dispose all clipboards still in list
 196         ClipboardMap::iterator iter = aCopy.begin();
 197         ClipboardMap::iterator imax = aCopy.end();
 198
 199         for (; iter != imax; ++iter)
 200         {
 201             Reference< XComponent > xComponent(iter->second, UNO_QUERY);
 202             if (xComponent.is())
 203             {
 204                 try
 205                 {
 206                     xComponent->removeEventListener(static_cast < XEventListener * > (this));
 207                     xComponent->dispose();
 208                 }
 209                 catch (const Exception&)
 210                 {
 211                     // exceptions can be safely ignored here.
 212                 }
 213             }
 214         }
 215
 216         rBHelper.bDisposed = sal_True;
 217         rBHelper.bInDispose = sal_False;
 218     }
 219 }
 220
 221 // ------------------------------------------------------------------------
 222
 223 void SAL_CALL  ClipboardManager::disposing( const EventObject& event )
 224     throw(RuntimeException)
 225 {
 226     Reference < XClipboard > xClipboard(event.Source, UNO_QUERY);
 227
 228     if (xClipboard.is())
 229         removeClipboard(xClipboard->getName());
 230 }
 231
 232 // ------------------------------------------------------------------------
 233
 234 Reference< XInterface > SAL_CALL ClipboardManager_createInstance(
 235     const Reference< XMultiServiceFactory > & /*xMultiServiceFactory*/)
 236 {
 237     return Reference < XInterface >( ( OWeakObject * ) new ClipboardManager());
 238 }
 239
 240 // ------------------------------------------------------------------------
 241
 242 Sequence< OUString > SAL_CALL ClipboardManager_getSupportedServiceNames()
 243 {
 244     Sequence < OUString > SupportedServicesNames( 1 );
 245     SupportedServicesNames[0] =
 246         OUString("com.sun.star.datatransfer.clipboard.ClipboardManager");
 247     return SupportedServicesNames;
 248 }
 249
 250
 251
 252
 253
 254 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */