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