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