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