vcl/win/dtrans/WinClipboard.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 <sal/config.h>
  21
  22 #include <osl/diagnose.h>
  23 #include <comphelper/diagnose_ex.hxx>
  24 #include <com/sun/star/datatransfer/clipboard/ClipboardEvent.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  27 #include <com/sun/star/uno/XComponentContext.hpp>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <cppuhelper/weak.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <svdata.hxx>
  32 #include <salinst.hxx>
  33
  34 #include <com/sun/star/datatransfer/clipboard/RenderingCapabilities.hpp>
  35 #include "XNotifyingDataObject.hxx"
  36
  37 #include <systools/win32/comtools.hxx>
  38 #include "DtObjFactory.hxx"
  39 #include "APNDataObject.hxx"
  40 #include "DOTransferable.hxx"
  41 #include "WinClipboard.hxx"
  42
  43 #if !defined WIN32_LEAN_AND_MEAN
  44 #define WIN32_LEAN_AND_MEAN
  45 #endif
  46 #include <windows.h>
  47 #include <ole2.h>
  48 #include <objidl.h>
  49
  50 using namespace com::sun::star;
  51
  52 namespace
  53 {
  54 CWinClipboard* s_pCWinClipbImpl = nullptr;
  55 osl::Mutex s_aClipboardSingletonMutex;
  56 }
  57
  58 /*XEventListener,*/
  59 CWinClipboard::CWinClipboard(const uno::Reference<uno::XComponentContext>& rxContext,
  60                              const OUString& aClipboardName)
  61     : m_xContext(rxContext)
  62     , m_itsName(aClipboardName)
  63     , m_pCurrentClipContent(nullptr)
  64 {
  65     // necessary to reassociate from
  66     // the static callback function
  67     {
  68         osl::MutexGuard aGuard(s_aClipboardSingletonMutex);
  69         s_pCWinClipbImpl = this;
  70     }
  71
  72     registerClipboardViewer();
  73 }
  74
  75 CWinClipboard::~CWinClipboard()
  76 {
  77     {
  78         osl::MutexGuard aGuard(s_aClipboardSingletonMutex);
  79         s_pCWinClipbImpl = nullptr;
  80     }
  81
  82     unregisterClipboardViewer();
  83 }
  84
  85 // XClipboard
  86
  87 // to avoid unnecessary traffic we check first if there is a clipboard
  88 // content which was set via setContent, in this case we don't need
  89 // to query the content from the clipboard, create a new wrapper object
  90 // and so on, we simply return the original XTransferable instead of our
  91 // DOTransferable
  92
  93 uno::Reference<datatransfer::XTransferable> SAL_CALL CWinClipboard::getContents()
  94 {
  95     osl::MutexGuard aGuard(m_aContentMutex);
  96
  97     if (m_bDisposed)
  98         throw lang::DisposedException("object is already disposed",
  99                                       static_cast<XClipboardEx*>(this));
 100
 101     // use the shortcut or create a transferable from
 102     // system clipboard
 103     {
 104         osl::MutexGuard aGuard2(m_aContentCacheMutex);
 105
 106         if (nullptr != m_pCurrentClipContent)
 107             return m_pCurrentClipContent->m_XTransferable;
 108
 109         // Content cached?
 110         if (m_foreignContent.is())
 111             return m_foreignContent;
 112
 113         // release the mutex, so that the variable may be
 114         // changed by other threads
 115     }
 116
 117     uno::Reference<datatransfer::XTransferable> rClipContent;
 118
 119     // get the current format list from clipboard
 120     if (UINT nFormats; !GetUpdatedClipboardFormats(nullptr, 0, &nFormats)
 121                        && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 122     {
 123         std::vector<UINT> aUINTFormats(nFormats);
 124         if (GetUpdatedClipboardFormats(aUINTFormats.data(), nFormats, &nFormats))
 125         {
 126             std::vector<sal_uInt32> aFormats(aUINTFormats.begin(), aUINTFormats.end());
 127             rClipContent = new CDOTransferable(m_xContext, this, aFormats);
 128
 129             osl::MutexGuard aGuard2(m_aContentCacheMutex);
 130             m_foreignContent = rClipContent;
 131         }
 132     }
 133
 134     return rClipContent;
 135 }
 136
 137 IDataObjectPtr CWinClipboard::getIDataObject()
 138 {
 139     osl::MutexGuard aGuard(m_aContentMutex);
 140
 141     if (m_bDisposed)
 142         throw lang::DisposedException("object is already disposed",
 143                                       static_cast<XClipboardEx*>(this));
 144
 145     // get the current dataobject from clipboard
 146     IDataObjectPtr pIDataObject;
 147     HRESULT hr = m_MtaOleClipboard.getClipboard(&pIDataObject);
 148
 149     if (SUCCEEDED(hr))
 150     {
 151         // create an apartment neutral dataobject and initialize it with a
 152         // com smart pointer to the IDataObject from clipboard
 153         pIDataObject = new CAPNDataObject(pIDataObject);
 154     }
 155
 156     return pIDataObject;
 157 }
 158
 159 void SAL_CALL CWinClipboard::setContents(
 160     const uno::Reference<datatransfer::XTransferable>& xTransferable,
 161     const uno::Reference<datatransfer::clipboard::XClipboardOwner>& xClipboardOwner)
 162 {
 163     osl::MutexGuard aGuard(m_aContentMutex);
 164
 165     if (m_bDisposed)
 166         throw lang::DisposedException("object is already disposed",
 167                                       static_cast<XClipboardEx*>(this));
 168
 169     IDataObjectPtr pIDataObj;
 170
 171     if (xTransferable.is())
 172     {
 173         {
 174             osl::MutexGuard aGuard2(m_aContentCacheMutex);
 175
 176             m_foreignContent.clear();
 177
 178             m_pCurrentClipContent = new CXNotifyingDataObject(
 179                 CDTransObjFactory::createDataObjFromTransferable(m_xContext, xTransferable),
 180                 xTransferable, xClipboardOwner, this);
 181         }
 182
 183         pIDataObj = IDataObjectPtr(m_pCurrentClipContent);
 184     }
 185
 186     m_MtaOleClipboard.setClipboard(pIDataObj.get());
 187 }
 188
 189 OUString SAL_CALL CWinClipboard::getName()
 190 {
 191     if (m_bDisposed)
 192         throw lang::DisposedException("object is already disposed",
 193                                       static_cast<XClipboardEx*>(this));
 194
 195     return m_itsName;
 196 }
 197
 198 // XFlushableClipboard
 199
 200 void SAL_CALL CWinClipboard::flushClipboard()
 201 {
 202     osl::MutexGuard aGuard(m_aContentMutex);
 203
 204     if (m_bDisposed)
 205         throw lang::DisposedException("object is already disposed",
 206                                       static_cast<XClipboardEx*>(this));
 207
 208     // actually it should be ClearableMutexGuard aGuard( m_aContentCacheMutex );
 209     // but it does not work since FlushClipboard does a callback and frees DataObject
 210     // which results in a deadlock in onReleaseDataObject.
 211     // FlushClipboard had to be synchron in order to prevent shutdown until all
 212     // clipboard-formats are rendered.
 213     // The request is needed to prevent flushing if we are not clipboard owner (it is
 214     // not known what happens if we flush but aren't clipboard owner).
 215     // It may be possible to move the request to the clipboard STA thread by saving the
 216     // DataObject and call OleIsCurrentClipboard before flushing.
 217
 218     if (nullptr != m_pCurrentClipContent)
 219         m_MtaOleClipboard.flushClipboard();
 220 }
 221
 222 // XClipboardEx
 223
 224 sal_Int8 SAL_CALL CWinClipboard::getRenderingCapabilities()
 225 {
 226     if (m_bDisposed)
 227         throw lang::DisposedException("object is already disposed",
 228                                       static_cast<XClipboardEx*>(this));
 229
 230     using namespace datatransfer::clipboard::RenderingCapabilities;
 231     return (Delayed | Persistent);
 232 }
 233
 234 // XClipboardNotifier
 235
 236 void SAL_CALL CWinClipboard::addClipboardListener(
 237     const uno::Reference<datatransfer::clipboard::XClipboardListener>& listener)
 238 {
 239     if (m_bDisposed)
 240         throw lang::DisposedException("object is already disposed",
 241                                       static_cast<XClipboardEx*>(this));
 242
 243     // check input parameter
 244     if (!listener.is())
 245         throw lang::IllegalArgumentException("empty reference", static_cast<XClipboardEx*>(this),
 246                                              1);
 247
 248     std::unique_lock aGuard(m_aMutex);
 249     maClipboardListeners.addInterface(aGuard, listener);
 250 }
 251
 252 void SAL_CALL CWinClipboard::removeClipboardListener(
 253     const uno::Reference<datatransfer::clipboard::XClipboardListener>& listener)
 254 {
 255     if (m_bDisposed)
 256         throw lang::DisposedException("object is already disposed",
 257                                       static_cast<XClipboardEx*>(this));
 258
 259     // check input parameter
 260     if (!listener.is())
 261         throw lang::IllegalArgumentException("empty reference", static_cast<XClipboardEx*>(this),
 262                                              1);
 263
 264     std::unique_lock aGuard(m_aMutex);
 265     maClipboardListeners.removeInterface(aGuard, listener);
 266 }
 267
 268 void CWinClipboard::notifyAllClipboardListener()
 269 {
 270     if (m_bDisposed)
 271         return;
 272
 273     std::unique_lock aGuard(m_aMutex);
 274     if (m_bDisposed)
 275         return;
 276
 277     if (!maClipboardListeners.getLength(aGuard))
 278         return;
 279
 280     try
 281     {
 282         uno::Reference<datatransfer::XTransferable> rXTransf(getContents());
 283         datatransfer::clipboard::ClipboardEvent aClipbEvent(static_cast<XClipboard*>(this),
 284                                                             rXTransf);
 285         maClipboardListeners.notifyEach(
 286             aGuard, &datatransfer::clipboard::XClipboardListener::changedContents, aClipbEvent);
 287     }
 288     catch (const lang::DisposedException&)
 289     {
 290         OSL_FAIL("Service Manager disposed");
 291
 292         aGuard.unlock();
 293         // no further clipboard changed notifications
 294         unregisterClipboardViewer();
 295     }
 296 }
 297
 298 // XServiceInfo
 299
 300 OUString SAL_CALL CWinClipboard::getImplementationName()
 301 {
 302     return "com.sun.star.datatransfer.clipboard.ClipboardW32";
 303 }
 304
 305 sal_Bool SAL_CALL CWinClipboard::supportsService(const OUString& ServiceName)
 306 {
 307     return cppu::supportsService(this, ServiceName);
 308 }
 309
 310 uno::Sequence<OUString> SAL_CALL CWinClipboard::getSupportedServiceNames()
 311 {
 312     return { "com.sun.star.datatransfer.clipboard.SystemClipboard" };
 313 }
 314
 315 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 316 dtrans_CWinClipboard_get_implementation(css::uno::XComponentContext* context,
 317                                         css::uno::Sequence<css::uno::Any> const& args)
 318 {
 319     // We run unit tests in parallel, which is a problem when touching a shared resource
 320     // like the system clipboard, so rather use the dummy GenericClipboard.
 321     static const bool bRunningUnitTest = getenv("LO_TESTNAME");
 322
 323     if (bRunningUnitTest)
 324     {
 325         SolarMutexGuard aGuard;
 326         auto xClipboard = ImplGetSVData()->mpDefInst->CreateClipboard(args);
 327         if (xClipboard.is())
 328             xClipboard->acquire();
 329         return xClipboard.get();
 330     }
 331     else
 332     {
 333         return cppu::acquire(new CWinClipboard(context, ""));
 334     }
 335 }
 336
 337 void CWinClipboard::onReleaseDataObject(CXNotifyingDataObject* theCaller)
 338 {
 339     OSL_ASSERT(nullptr != theCaller);
 340
 341     if (theCaller)
 342         theCaller->lostOwnership();
 343
 344     // if the current caller is the one we currently hold, then set it to NULL
 345     // because an external source must be the clipboardowner now
 346     osl::MutexGuard aGuard(m_aContentCacheMutex);
 347
 348     if (m_pCurrentClipContent == theCaller)
 349         m_pCurrentClipContent = nullptr;
 350 }
 351
 352 void CWinClipboard::registerClipboardViewer()
 353 {
 354     m_MtaOleClipboard.registerClipViewer(CWinClipboard::onClipboardContentChanged);
 355 }
 356
 357 void CWinClipboard::unregisterClipboardViewer() { m_MtaOleClipboard.registerClipViewer(nullptr); }
 358
 359 void WINAPI CWinClipboard::onClipboardContentChanged()
 360 {
 361     osl::MutexGuard aGuard(s_aClipboardSingletonMutex);
 362
 363     // reassociation to instance through static member
 364     if (nullptr != s_pCWinClipbImpl)
 365     {
 366         s_pCWinClipbImpl->m_foreignContent.clear();
 367         s_pCWinClipbImpl->notifyAllClipboardListener();
 368     }
 369 }
 370
 371 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */