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