vcl/source/components/dtranscomp.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 <comphelper/lok.hxx>
  23 #include <comphelper/processfactory.hxx>
  24 #include <o3tl/test_info.hxx>
  25 #include <osl/mutex.hxx>
  26 #include <tools/debug.hxx>
  27 #include <vcl/svapp.hxx>
  28
  29 #include <factory.hxx>
  30 #include <svdata.hxx>
  31 #include <salinst.hxx>
  32
  33 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  34 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  35 #include <com/sun/star/lang/XServiceInfo.hpp>
  36 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  37 #include <com/sun/star/lang/XInitialization.hpp>
  38 #include <com/sun/star/datatransfer/XTransferable.hpp>
  39 #include <com/sun/star/datatransfer/clipboard/LokClipboard.hpp>
  40 #include <com/sun/star/datatransfer/clipboard/XClipboardListener.hpp>
  41 #include <com/sun/star/datatransfer/clipboard/XSystemClipboard.hpp>
  42 #include <com/sun/star/datatransfer/dnd/XDragSource.hpp>
  43 #include <com/sun/star/datatransfer/dnd/XDropTarget.hpp>
  44 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  45
  46 #include <comphelper/compbase.hxx>
  47 #include <cppuhelper/supportsservice.hxx>
  48
  49 using namespace com::sun::star;
  50 using namespace com::sun::star::uno;
  51 using namespace com::sun::star::lang;
  52
  53 namespace vcl
  54 {
  55 namespace {
  56
  57 // generic implementation to satisfy SalInstance
  58 class GenericClipboard :
  59         public comphelper::WeakComponentImplHelper<
  60         datatransfer::clipboard::XSystemClipboard,
  61         XServiceInfo
  62         >
  63 {
  64     Reference< css::datatransfer::XTransferable >                           m_aContents;
  65     Reference< css::datatransfer::clipboard::XClipboardOwner >              m_aOwner;
  66     std::vector< Reference< css::datatransfer::clipboard::XClipboardListener > > m_aListeners;
  67
  68 public:
  69
  70     GenericClipboard()
  71     {}
  72
  73     /*
  74      * XServiceInfo
  75      */
  76
  77     virtual OUString SAL_CALL getImplementationName() override;
  78     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  79     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
  80
  81     static Sequence< OUString > getSupportedServiceNames_static();
  82
  83     /*
  84      * XClipboard
  85      */
  86
  87     virtual Reference< css::datatransfer::XTransferable > SAL_CALL getContents() override;
  88
  89     virtual void SAL_CALL setContents(
  90         const Reference< css::datatransfer::XTransferable >& xTrans,
  91         const Reference< css::datatransfer::clipboard::XClipboardOwner >& xClipboardOwner ) override;
  92
  93     virtual OUString SAL_CALL getName() override;
  94
  95     /*
  96      * XClipboardEx
  97      */
  98
  99     virtual sal_Int8 SAL_CALL getRenderingCapabilities() override;
 100
 101     /*
 102      * XClipboardNotifier
 103      */
 104     virtual void SAL_CALL addClipboardListener(
 105         const Reference< css::datatransfer::clipboard::XClipboardListener >& listener ) override;
 106
 107     virtual void SAL_CALL removeClipboardListener(
 108         const Reference< css::datatransfer::clipboard::XClipboardListener >& listener ) override;
 109 };
 110
 111 }
 112
 113 Sequence< OUString > GenericClipboard::getSupportedServiceNames_static()
 114 {
 115     Sequence< OUString > aRet { u"com.sun.star.datatransfer.clipboard.SystemClipboard"_ustr };
 116     return aRet;
 117 }
 118
 119 OUString GenericClipboard::getImplementationName()
 120 {
 121     return u"com.sun.star.datatransfer.VCLGenericClipboard"_ustr;
 122 }
 123
 124 Sequence< OUString > GenericClipboard::getSupportedServiceNames()
 125 {
 126     return getSupportedServiceNames_static();
 127 }
 128
 129 sal_Bool GenericClipboard::supportsService( const OUString& ServiceName )
 130 {
 131     return cppu::supportsService(this, ServiceName);
 132 }
 133
 134 Reference< css::datatransfer::XTransferable > GenericClipboard::getContents()
 135 {
 136     std::unique_lock aGuard(m_aMutex);
 137     return m_aContents;
 138 }
 139
 140 void GenericClipboard::setContents(
 141         const Reference< css::datatransfer::XTransferable >& xTrans,
 142         const Reference< css::datatransfer::clipboard::XClipboardOwner >& xClipboardOwner )
 143 {
 144     std::unique_lock aGuard( m_aMutex );
 145     Reference< datatransfer::clipboard::XClipboardOwner > xOldOwner( m_aOwner );
 146     Reference< datatransfer::XTransferable > xOldContents( m_aContents );
 147     m_aContents = xTrans;
 148     m_aOwner = xClipboardOwner;
 149
 150     std::vector< Reference< datatransfer::clipboard::XClipboardListener > > aListeners( m_aListeners );
 151     datatransfer::clipboard::ClipboardEvent aEv;
 152     aEv.Contents = m_aContents;
 153
 154     aGuard.unlock();
 155
 156     if( xOldOwner.is() && xOldOwner != xClipboardOwner )
 157         xOldOwner->lostOwnership( this, xOldContents );
 158     for (auto const& listener : aListeners)
 159     {
 160         listener->changedContents( aEv );
 161     }
 162 }
 163
 164 OUString GenericClipboard::getName()
 165 {
 166     return u"CLIPBOARD"_ustr;
 167 }
 168
 169 sal_Int8 GenericClipboard::getRenderingCapabilities()
 170 {
 171     return 0;
 172 }
 173
 174 void GenericClipboard::addClipboardListener( const Reference< datatransfer::clipboard::XClipboardListener >& listener )
 175 {
 176     std::unique_lock aGuard(m_aMutex);
 177
 178     m_aListeners.push_back( listener );
 179 }
 180
 181 void GenericClipboard::removeClipboardListener( const Reference< datatransfer::clipboard::XClipboardListener >& listener )
 182 {
 183     std::unique_lock aGuard(m_aMutex);
 184
 185     std::erase(m_aListeners, listener);
 186 }
 187
 188
 189
 190 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 191 vcl_SystemClipboard_get_implementation(
 192     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const& args)
 193 {
 194     SolarMutexGuard aGuard;
 195     auto xClipboard = ImplGetSVData()->mpDefInst->CreateClipboard( args );
 196     if (xClipboard.is())
 197         xClipboard->acquire();
 198     return xClipboard.get();
 199 }
 200
 201 namespace {
 202
 203 /*
 204 *   generic DragSource dummy
 205 */
 206 class GenericDragSource : public ::comphelper::WeakComponentImplHelper<
 207             datatransfer::dnd::XDragSource,
 208             XInitialization,
 209             css::lang::XServiceInfo
 210             >
 211 {
 212     css::uno::Reference<css::datatransfer::XTransferable> m_xTrans;
 213 public:
 214     GenericDragSource() {}
 215
 216     // XDragSource
 217     virtual sal_Bool    SAL_CALL isDragImageSupported() override;
 218     virtual sal_Int32   SAL_CALL getDefaultCursor( sal_Int8 dragAction ) override;
 219     virtual void        SAL_CALL startDrag(
 220                                      const datatransfer::dnd::DragGestureEvent& trigger,
 221                                      sal_Int8 sourceActions, sal_Int32 cursor, sal_Int32 image,
 222                                      const Reference< datatransfer::XTransferable >& transferable,
 223                                      const Reference< datatransfer::dnd::XDragSourceListener >& listener
 224                                      ) override;
 225
 226     // XInitialization
 227     virtual void        SAL_CALL initialize( const Sequence< Any >& arguments ) override;
 228
 229     OUString SAL_CALL getImplementationName() override
 230     { return u"com.sun.star.datatransfer.dnd.VclGenericDragSource"_ustr; }
 231
 232     sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
 233     { return cppu::supportsService(this, ServiceName); }
 234
 235     css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
 236     { return getSupportedServiceNames_static(); }
 237
 238     static Sequence< OUString > getSupportedServiceNames_static()
 239     {
 240        return { u"com.sun.star.datatransfer.dnd.GenericDragSource"_ustr };
 241     }
 242 };
 243
 244 }
 245
 246 sal_Bool GenericDragSource::isDragImageSupported()
 247 {
 248     return false;
 249 }
 250
 251 sal_Int32 GenericDragSource::getDefaultCursor( sal_Int8 )
 252 {
 253     return 0;
 254 }
 255
 256 void GenericDragSource::startDrag( const datatransfer::dnd::DragGestureEvent&,
 257                                    sal_Int8 /*sourceActions*/, sal_Int32 /*cursor*/, sal_Int32 /*image*/,
 258                                    const Reference< datatransfer::XTransferable >& rTrans,
 259                                    const Reference< datatransfer::dnd::XDragSourceListener >& listener
 260                                    )
 261 {
 262     if (comphelper::LibreOfficeKit::isActive()) {
 263         m_xTrans = rTrans;
 264         return;
 265     }
 266
 267     datatransfer::dnd::DragSourceDropEvent aEv;
 268     aEv.DropAction = datatransfer::dnd::DNDConstants::ACTION_COPY;
 269     aEv.DropSuccess = false;
 270     listener->dragDropEnd( aEv );
 271 }
 272
 273 void GenericDragSource::initialize( const Sequence< Any >& )
 274 {
 275 }
 276
 277 Sequence< OUString > DragSource_getSupportedServiceNames()
 278 {
 279 #if defined MACOSX
 280     return { "com.sun.star.datatransfer.dnd.OleDragSource" };
 281 #elif defined UNX
 282     return { u"com.sun.star.datatransfer.dnd.X11DragSource"_ustr };
 283 #else
 284     return { "com.sun.star.datatransfer.dnd.VclGenericDragSource" };
 285 #endif
 286 }
 287
 288 OUString DragSource_getImplementationName()
 289 {
 290 #if defined MACOSX
 291     return "com.sun.star.comp.datatransfer.dnd.OleDragSource_V1";
 292 #elif defined UNX
 293     return u"com.sun.star.datatransfer.dnd.XdndSupport"_ustr;
 294 #else
 295     return "com.sun.star.datatransfer.dnd.VclGenericDragSource";
 296 #endif
 297 }
 298
 299 Reference< XInterface > DragSource_createInstance( const Reference< XMultiServiceFactory >&  )
 300 {
 301     SolarMutexGuard aGuard;
 302     Reference< XInterface > xResult = ImplGetSVData()->mpDefInst->CreateDragSource();
 303     return xResult;
 304 }
 305
 306 /*
 307 *   generic DragSource dummy
 308 */
 309
 310 namespace {
 311
 312 class GenericDropTarget : public comphelper::WeakComponentImplHelper<
 313                                            datatransfer::dnd::XDropTarget,
 314                                            XInitialization,
 315                                            css::lang::XServiceInfo
 316                                            >
 317 {
 318 public:
 319     GenericDropTarget() {}
 320
 321     // XInitialization
 322     virtual void        SAL_CALL initialize( const Sequence< Any >& args ) override;
 323
 324     // XDropTarget
 325     virtual void        SAL_CALL addDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) override;
 326     virtual void        SAL_CALL removeDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) override;
 327     virtual sal_Bool    SAL_CALL isActive() override;
 328     virtual void        SAL_CALL setActive( sal_Bool active ) override;
 329     virtual sal_Int8    SAL_CALL getDefaultActions() override;
 330     virtual void        SAL_CALL setDefaultActions( sal_Int8 actions ) override;
 331
 332     OUString SAL_CALL getImplementationName() override
 333     { return u"com.sun.star.datatransfer.dnd.VclGenericDropTarget"_ustr; }
 334
 335     sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
 336     { return cppu::supportsService(this, ServiceName); }
 337
 338     css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
 339     { return getSupportedServiceNames_static(); }
 340
 341     static Sequence< OUString > getSupportedServiceNames_static()
 342     {
 343       return { u"com.sun.star.datatransfer.dnd.GenericDropTarget"_ustr };
 344     }
 345 };
 346
 347 }
 348
 349 void GenericDropTarget::initialize( const Sequence< Any >& )
 350 {
 351 }
 352
 353 void GenericDropTarget::addDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& )
 354 {
 355 }
 356
 357 void GenericDropTarget::removeDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& )
 358 {
 359 }
 360
 361 sal_Bool GenericDropTarget::isActive()
 362 {
 363     return false;
 364 }
 365
 366 void GenericDropTarget::setActive( sal_Bool )
 367 {
 368 }
 369
 370 sal_Int8 GenericDropTarget::getDefaultActions()
 371 {
 372     return 0;
 373 }
 374
 375 void GenericDropTarget::setDefaultActions( sal_Int8)
 376 {
 377 }
 378
 379 Sequence< OUString > DropTarget_getSupportedServiceNames()
 380 {
 381 #if defined MACOSX
 382     return {  "com.sun.star.datatransfer.dnd.OleDropTarget" };
 383 #elif defined UNX
 384     return { u"com.sun.star.datatransfer.dnd.X11DropTarget"_ustr };
 385 #else
 386     return GenericDropTarget::getSupportedServiceNames_static();
 387 #endif
 388 }
 389
 390 OUString DropTarget_getImplementationName()
 391 {
 392     return
 393     #if defined MACOSX
 394     "com.sun.star.comp.datatransfer.dnd.OleDropTarget_V1"
 395     #elif defined UNX
 396     u"com.sun.star.datatransfer.dnd.XdndDropTarget"_ustr
 397     #else
 398     "com.sun.star.datatransfer.dnd.VclGenericDropTarget"
 399     #endif
 400                    ;
 401 }
 402
 403 Reference< XInterface > DropTarget_createInstance( const Reference< XMultiServiceFactory >&  )
 404 {
 405     SolarMutexGuard aGuard;
 406     Reference< XInterface > xResult = ImplGetSVData()->mpDefInst->CreateDropTarget();
 407     return xResult;
 408 }
 409
 410 } // namespace vcl
 411
 412 /*
 413 *   SalInstance generic
 414 */
 415 Reference< XInterface > SalInstance::CreateClipboard( const Sequence< Any >& arguments )
 416 {
 417     if (arguments.hasElements()) {
 418         throw css::lang::IllegalArgumentException(
 419             u"non-empty SalInstance::CreateClipboard arguments"_ustr, {}, -1);
 420     }
 421 #ifdef IOS
 422     return getXWeak(new vcl::GenericClipboard());
 423 #else
 424     if (comphelper::LibreOfficeKit::isActive()) {
 425         // In LOK, each document view shall have its own clipboard instance (whereas
 426         // in non-LOK below we keep handing out one single instance; see also
 427         // <https://lists.freedesktop.org/archives/libreoffice/2020-April/084824.html> "Re: Linux
 428         // SAL_USE_VCLPLUGIN=svp and the clipboard"):
 429         css::uno::Reference<css::datatransfer::clipboard::XClipboard> xClipboard =
 430             css::datatransfer::clipboard::LokClipboard::create(
 431                 comphelper::getProcessComponentContext());
 432         return xClipboard;
 433     }
 434 #endif
 435     DBG_TESTSOLARMUTEX();
 436     if (!m_clipboard.is()) {
 437         m_clipboard = getXWeak(new vcl::GenericClipboard());
 438     }
 439     return m_clipboard;
 440 }
 441
 442 uno::Reference<uno::XInterface> SalInstance::ImplCreateDragSource(const SystemEnvData*)
 443 {
 444     return css::uno::Reference<css::uno::XInterface>();
 445 }
 446
 447 Reference< XInterface > SalInstance::CreateDragSource(const SystemEnvData* pSysEnv)
 448 {
 449     // We run unit tests in parallel, which is a problem when touching a shared resource
 450     // the system clipboard, so rather use the dummy GenericClipboard.
 451     if (Application::IsHeadlessModeEnabled() || o3tl::IsRunningUnitTest() || o3tl::IsRunningUITest())
 452         return getXWeak(new vcl::GenericDragSource());
 453     return ImplCreateDragSource(pSysEnv);
 454 }
 455
 456 uno::Reference<uno::XInterface> SalInstance::ImplCreateDropTarget(const SystemEnvData*)
 457 {
 458     return css::uno::Reference<css::uno::XInterface>();
 459 }
 460
 461 Reference< XInterface > SalInstance::CreateDropTarget(const SystemEnvData* pSysEnv)
 462 {
 463     // see SalInstance::CreateDragSource
 464     if (Application::IsHeadlessModeEnabled() || o3tl::IsRunningUnitTest() || o3tl::IsRunningUITest())
 465         return getXWeak(new vcl::GenericDropTarget());
 466     return ImplCreateDropTarget(pSysEnv);
 467 }
 468
 469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */