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