include/vcl/transfer.hxx

   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 #ifndef INCLUDED_VCL_TRANSFER_HXX
  21 #define INCLUDED_VCL_TRANSFER_HXX
  22
  23 #include <vcl/dllapi.h>
  24 #include <tools/globname.hxx>
  25 #include <tools/gen.hxx>
  26 #include <tools/solar.h>
  27 #include <sot/formats.hxx>
  28 #include <sot/exchange.hxx>
  29 #include <cppuhelper/implbase.hxx>
  30 #include <com/sun/star/frame/XTerminateListener.hpp>
  31 #include <com/sun/star/lang/XServiceInfo.hpp>
  32 #include <com/sun/star/lang/XUnoTunnel.hpp>
  33 #include <com/sun/star/datatransfer/XTransferable2.hpp>
  34 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  35 #include <com/sun/star/datatransfer/clipboard/XClipboardOwner.hpp>
  36 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  37 #include <com/sun/star/datatransfer/dnd/XDragGestureListener.hpp>
  38 #include <com/sun/star/datatransfer/dnd/DropTargetDragEvent.hpp>
  39 #include <com/sun/star/datatransfer/dnd/DropTargetDropEvent.hpp>
  40 #include <com/sun/star/datatransfer/dnd/XDragSourceListener.hpp>
  41 #include <com/sun/star/datatransfer/dnd/XDropTargetListener.hpp>
  42 #include <com/sun/star/embed/Aspects.hpp>
  43 #include <memory>
  44 #include <mutex>
  45 #include <utility>
  46
  47 namespace com::sun::star::datatransfer::dnd { class XDragGestureRecognizer; }
  48 namespace com::sun::star::io { class XInputStream; }
  49 namespace com::sun::star::datatransfer::dnd { class XDropTarget; }
  50
  51 namespace tools { template <typename T> class SvRef; }
  52 template <typename Arg, typename Ret> class Link;
  53
  54 class BitmapEx;
  55 class GDIMetaFile;
  56 class Graphic;
  57 class ImageMap;
  58 class INetBookmark;
  59 class INetImage;
  60 class FileList;
  61 class SotStorageStream;
  62 class SotTempStream;
  63 namespace vcl { class Window; }
  64
  65 // Drag&Drop defines
  66
  67 #define DND_ACTION_NONE     css::datatransfer::dnd::DNDConstants::ACTION_NONE
  68 #define DND_ACTION_COPY     css::datatransfer::dnd::DNDConstants::ACTION_COPY
  69 #define DND_ACTION_MOVE     css::datatransfer::dnd::DNDConstants::ACTION_MOVE
  70 #define DND_ACTION_COPYMOVE css::datatransfer::dnd::DNDConstants::ACTION_COPY_OR_MOVE
  71 #define DND_ACTION_LINK     css::datatransfer::dnd::DNDConstants::ACTION_LINK
  72
  73 #define DND_POINTER_NONE    0
  74 #define DND_IMAGE_NONE      0
  75
  76 struct TransferableObjectDescriptor
  77 {
  78     SvGlobalName        maClassName;
  79     sal_uInt16          mnViewAspect;
  80     Point               maDragStartPos;
  81     Size                maSize;
  82     OUString            maTypeName;
  83     OUString            maDisplayName;
  84
  85     TransferableObjectDescriptor()
  86         : mnViewAspect(css::embed::Aspects::MSOLE_CONTENT)
  87     {}
  88
  89     VCL_DLLPUBLIC friend SvStream&  WriteTransferableObjectDescriptor( SvStream& rOStm, const TransferableObjectDescriptor& rObjDesc );
  90 };
  91
  92 struct AcceptDropEvent
  93 {
  94     Point                                                           maPosPixel;
  95     const css::datatransfer::dnd::DropTargetDragEvent               maDragEvent;
  96     sal_Int8                                                        mnAction;
  97     bool                                                            mbLeaving;
  98     bool                                                            mbDefault;
  99
 100     AcceptDropEvent() :
 101         mnAction( DND_ACTION_NONE ),
 102         mbLeaving( false ),
 103         mbDefault( false ) {}
 104
 105     AcceptDropEvent( sal_Int8 nAction,
 106                      const Point& rPosPixel,
 107                      css::datatransfer::dnd::DropTargetDragEvent aDragEvent ) :
 108         maPosPixel( rPosPixel ),
 109         maDragEvent(std::move( aDragEvent )),
 110         mnAction( nAction ),
 111         mbLeaving( false ),
 112         mbDefault( false ) {}
 113 };
 114
 115 struct ExecuteDropEvent
 116 {
 117     Point                                                           maPosPixel;
 118     const css::datatransfer::dnd::DropTargetDropEvent               maDropEvent;
 119     sal_Int8                                                        mnAction;
 120     bool                                                            mbDefault;
 121
 122     ExecuteDropEvent( sal_Int8 nAction,
 123                       const Point& rPosPixel,
 124                       css::datatransfer::dnd::DropTargetDropEvent aDropEvent ) :
 125         maPosPixel( rPosPixel ),
 126         maDropEvent(std::move( aDropEvent )),
 127         mnAction( nAction ),
 128         mbDefault( false ) {}
 129 };
 130
 131 class VCL_DLLPUBLIC TransferableHelper : public cppu::WeakImplHelper< css::datatransfer::XTransferable2,
 132                                                            css::datatransfer::clipboard::XClipboardOwner,
 133                                                            css::datatransfer::dnd::XDragSourceListener,
 134                                                            css::lang::XUnoTunnel >
 135 {
 136 private:
 137
 138     // nested class to implement the XTerminateListener interface
 139     class VCL_DLLPRIVATE TerminateListener final : public cppu::WeakImplHelper< css::frame::XTerminateListener, css::lang::XServiceInfo >
 140     {
 141     private:
 142
 143         TransferableHelper& mrParent;
 144
 145     private:
 146
 147         // XEventListener
 148         virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 149
 150         // XTerminateListener
 151         virtual void SAL_CALL queryTermination( const css::lang::EventObject& aEvent ) override;
 152         virtual void SAL_CALL notifyTermination( const css::lang::EventObject& aEvent ) override;
 153
 154         // XServiceInfo
 155         virtual OUString SAL_CALL getImplementationName() override;
 156         virtual sal_Bool SAL_CALL supportsService( const OUString& sServiceName ) override;
 157         virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 158
 159     public:
 160
 161                               TerminateListener( TransferableHelper& rDropTargetHelper );
 162         virtual               ~TerminateListener() override;
 163     };
 164
 165     friend class TransferableHelper::TerminateListener;
 166
 167 private:
 168
 169     css::uno::Any                                                             maAny;
 170     OUString                                                                  maLastFormat;
 171     mutable css::uno::Reference< css::datatransfer::clipboard::XClipboard >   mxClipboard;
 172     css::uno::Reference< css::frame::XTerminateListener >                     mxTerminateListener;
 173     DataFlavorExVector                                                        maFormats;
 174     std::unique_ptr<TransferableObjectDescriptor>                             mxObjDesc;
 175
 176 protected:
 177     ~TransferableHelper();
 178
 179     const css::uno::Reference< css::datatransfer::clipboard::XClipboard >&
 180         getOwnClipboard() const { return mxClipboard; }
 181
 182 public:
 183
 184     // XTransferable
 185     virtual css::uno::Any SAL_CALL getTransferData( const css::datatransfer::DataFlavor& rFlavor ) override;
 186     virtual css::uno::Sequence< css::datatransfer::DataFlavor > SAL_CALL getTransferDataFlavors() override;
 187     virtual sal_Bool SAL_CALL isDataFlavorSupported( const css::datatransfer::DataFlavor& rFlavor ) override;
 188
 189     // Transferable2
 190     virtual css::uno::Any SAL_CALL getTransferData2(
 191         const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) override;
 192     virtual sal_Bool SAL_CALL isComplex() override;
 193
 194 private:
 195
 196     // XEventListener
 197     virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 198
 199     // XDragSourceListener
 200     virtual void SAL_CALL dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& dsde ) override;
 201     virtual void SAL_CALL dragEnter( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override;
 202     virtual void SAL_CALL dragExit( const css::datatransfer::dnd::DragSourceEvent& dse ) override;
 203     virtual void SAL_CALL dragOver( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override;
 204     virtual void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override;
 205
 206     // XClipboardOwner
 207     virtual void SAL_CALL lostOwnership( const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& xClipboard, const css::uno::Reference< css::datatransfer::XTransferable >& xTrans ) override;
 208
 209 protected:
 210     // derivees need to access lostOwnership in case hey override it
 211     // on windows, changing the access rights to a method gives unresolved externals, so we introduce
 212     // this impl-method here 'til the next incompatible update
 213     void    implCallOwnLostOwnership(
 214                         const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& _rxClipboard,
 215                         const css::uno::Reference< css::datatransfer::XTransferable >& _rxTrans
 216                     )
 217             {
 218                 TransferableHelper::lostOwnership( _rxClipboard, _rxTrans );
 219             }
 220
 221
 222 private:
 223
 224     VCL_DLLPRIVATE void             ImplFlush();
 225
 226 protected:
 227
 228     void                AddFormat( SotClipboardFormatId nFormat );
 229     void                AddFormat( const css::datatransfer::DataFlavor& rFlavor );
 230     void                RemoveFormat( SotClipboardFormatId nFormat );
 231     void                RemoveFormat( const css::datatransfer::DataFlavor& rFlavor );
 232     bool                HasFormat( SotClipboardFormatId nFormat );
 233     void                ClearFormats();
 234
 235     bool                SetAny( const css::uno::Any& rAny );
 236     bool                SetString( const OUString& rString );
 237     bool                SetBitmapEx( const BitmapEx& rBitmap, const css::datatransfer::DataFlavor& rFlavor );
 238     bool                SetGDIMetaFile( const GDIMetaFile& rMtf );
 239     bool                SetGraphic( const Graphic& rGraphic );
 240     bool                SetImageMap( const ImageMap& rIMap );
 241     bool                SetTransferableObjectDescriptor( const TransferableObjectDescriptor& rDesc );
 242     bool                SetINetBookmark( const INetBookmark& rBmk, const css::datatransfer::DataFlavor& rFlavor );
 243     bool                SetINetImage( const INetImage& rINtImg, const css::datatransfer::DataFlavor& rFlavor );
 244     bool                SetObject( void* pUserObject, sal_uInt32 nUserObjectId, const css::datatransfer::DataFlavor& rFlavor );
 245
 246 protected:
 247
 248     virtual void        AddSupportedFormats() = 0;
 249     virtual bool        GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) = 0;
 250     virtual bool        WriteObject( tools::SvRef<SotTempStream>& rxOStm, void* pUserObject, sal_uInt32 nUserObjectId, const css::datatransfer::DataFlavor& rFlavor );
 251     virtual void        DragFinished( sal_Int8 nDropAction );
 252     virtual void        ObjectReleased();
 253
 254     void                CopyToSelection(const css::uno::Reference<css::datatransfer::clipboard::XClipboard> &rClipboard) const;
 255 public:
 256
 257     void                PrepareOLE( const TransferableObjectDescriptor& rObjDesc );
 258
 259     void                CopyToClipboard(const css::uno::Reference<css::datatransfer::clipboard::XClipboard> &rClipboard) const;
 260
 261     // convenience versions of the above which extract the XClipboard from the pWindow
 262     void                CopyToClipboard( vcl::Window *pWindow ) const;
 263     void                CopyToPrimarySelection() const;
 264
 265     void                StartDrag( vcl::Window* pWindow, sal_Int8 nDragSourceActions );
 266
 267     static void         ClearPrimarySelection();
 268
 269     static const css::uno::Sequence< sal_Int8 >& getUnoTunnelId();
 270
 271 public:
 272
 273     virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& rId ) override;
 274 };
 275
 276 struct TransferableDataHelper_Impl;
 277
 278 class VCL_DLLPUBLIC TransferableDataHelper final
 279 {
 280     friend class DropTargetHelper;
 281
 282     css::uno::Reference< css::datatransfer::XTransferable >           mxTransfer;
 283     css::uno::Reference< css::datatransfer::clipboard::XClipboard >   mxClipboard;
 284     DataFlavorExVector                                                maFormats;
 285     std::unique_ptr<TransferableObjectDescriptor>                     mxObjDesc;
 286     std::unique_ptr<TransferableDataHelper_Impl>                      mxImpl;
 287
 288     void                        InitFormats();
 289
 290 public:
 291
 292     static void                 FillDataFlavorExVector( const css::uno::Sequence< css::datatransfer::DataFlavor >& rDataFlavorSeq,
 293                                                         DataFlavorExVector& rDataFlavorExVector );
 294
 295                                 TransferableDataHelper();
 296                                 TransferableDataHelper( const TransferableDataHelper& rDataHelper );
 297                                 TransferableDataHelper( TransferableDataHelper&& rDataHelper ) noexcept;
 298                                 TransferableDataHelper( const css::uno::Reference< css::datatransfer::XTransferable >& rxTransferable );
 299                                 ~TransferableDataHelper();
 300
 301     TransferableDataHelper&     operator=( const TransferableDataHelper& rDataHelper );
 302     TransferableDataHelper&     operator=( TransferableDataHelper&& rDataHelper );
 303
 304     const css::uno::Reference< css::datatransfer::XTransferable >&    GetTransferable() const { return mxTransfer; }
 305     css::uno::Reference< css::datatransfer::XTransferable >           GetXTransferable() const;
 306
 307     bool                        HasFormat( SotClipboardFormatId nFormat ) const;
 308     bool                        HasFormat( const css::datatransfer::DataFlavor& rFlavor ) const;
 309
 310     sal_uInt32                  GetFormatCount() const;
 311
 312     SotClipboardFormatId           GetFormat( sal_uInt32 nFormat ) const;
 313     css::datatransfer::DataFlavor  GetFormatDataFlavor( sal_uInt32 nFormat ) const;
 314
 315     const DataFlavorExVector&   GetDataFlavorExVector() const {return maFormats; }
 316
 317     bool                        StartClipboardListening( );
 318     void                        StopClipboardListening( );
 319
 320     void                        Rebind( const css::uno::Reference< css::datatransfer::XTransferable >& _rxNewData );
 321
 322     css::uno::Any GetAny( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const;
 323     css::uno::Any GetAny( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const;
 324
 325     bool                        GetString( SotClipboardFormatId nFormat, OUString& rStr ) const;
 326     bool                        GetString( const css::datatransfer::DataFlavor& rFlavor, OUString& rStr ) const;
 327
 328     bool                        GetBitmapEx( SotClipboardFormatId nFormat, BitmapEx& rBmp ) const;
 329     bool                        GetBitmapEx( const css::datatransfer::DataFlavor& rFlavor, BitmapEx& rBmp ) const;
 330
 331     /** Return as GDI metafile.
 332
 333         @param nMaxAction Allows you to limit the amount of actions; defaults to 0 which means no limit.
 334
 335         When you eg. Ctrl+a in Excel, you can get the entire sheet as
 336         metafile, with over 3 million (!) actions; which is just too large for
 337         any reasonable handling - and you need to set a limit.
 338     */
 339     bool                        GetGDIMetaFile( SotClipboardFormatId nFormat, GDIMetaFile& rMtf, size_t nMaxActions = 0 ) const;
 340     bool                        GetGDIMetaFile( const css::datatransfer::DataFlavor& rFlavor, GDIMetaFile& rMtf ) const;
 341
 342     bool                        GetGraphic( SotClipboardFormatId nFormat, Graphic& rGraphic ) const;
 343     bool                        GetGraphic( const css::datatransfer::DataFlavor& rFlavor, Graphic& rGraphic ) const;
 344
 345     bool                        GetImageMap( SotClipboardFormatId nFormat, ImageMap& rIMap ) const;
 346     bool                        GetImageMap( const css::datatransfer::DataFlavor& rFlavor, ImageMap& rImap ) const;
 347
 348     bool                        GetTransferableObjectDescriptor( SotClipboardFormatId nFormat, TransferableObjectDescriptor& rDesc );
 349     bool                        GetTransferableObjectDescriptor( TransferableObjectDescriptor& rDesc );
 350
 351     bool                        GetINetBookmark( SotClipboardFormatId nFormat, INetBookmark& rBmk ) const;
 352     bool                        GetINetBookmark( const css::datatransfer::DataFlavor& rFlavor, INetBookmark& rBmk ) const;
 353
 354     bool                        GetINetImage( SotClipboardFormatId nFormat, INetImage& rINtImg ) const;
 355     bool                        GetINetImage( const css::datatransfer::DataFlavor& rFlavor, INetImage& rINtImg ) const;
 356
 357     bool                        GetFileList( SotClipboardFormatId nFormat, FileList& rFileList ) const;
 358     bool                        GetFileList( FileList& rFileList ) const;
 359
 360     css::uno::Sequence<sal_Int8> GetSequence( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const;
 361     css::uno::Sequence<sal_Int8> GetSequence( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const;
 362
 363     bool                        GetSotStorageStream( SotClipboardFormatId nFormat, tools::SvRef<SotTempStream>& rStreamRef ) const;
 364     bool                        GetSotStorageStream( const css::datatransfer::DataFlavor& rFlavor, tools::SvRef<SotTempStream>& rStreamRef ) const;
 365
 366     css::uno::Reference<css::io::XInputStream> GetInputStream( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const;
 367     css::uno::Reference<css::io::XInputStream> GetInputStream( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const;
 368
 369     static TransferableDataHelper   CreateFromClipboard(const css::uno::Reference<css::datatransfer::clipboard::XClipboard>& rClipboard);
 370     static TransferableDataHelper   CreateFromSystemClipboard( vcl::Window * pWindow );
 371     static TransferableDataHelper   CreateFromPrimarySelection();
 372     static bool                     IsEqual( const css::datatransfer::DataFlavor& rInternalFlavor,
 373                                              const css::datatransfer::DataFlavor& rRequestFlavor );
 374 };
 375
 376 class VCL_DLLPUBLIC SAL_LOPLUGIN_ANNOTATE("crosscast") DragSourceHelper
 377 {
 378 private:
 379
 380     // nested class to implement the XDragGestureListener interface
 381     class SAL_DLLPRIVATE DragGestureListener final : public cppu::WeakImplHelper< css::datatransfer::dnd::XDragGestureListener >
 382     {
 383     private:
 384
 385         DragSourceHelper&   mrParent;
 386
 387     private:
 388
 389         // XEventListener
 390         virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 391
 392         // XDragGestureListener
 393         virtual void SAL_CALL dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& rDGE ) override;
 394
 395     public:
 396
 397         DragGestureListener( DragSourceHelper& rDragSourceHelper );
 398         virtual ~DragGestureListener() override;
 399     };
 400
 401     friend class DragSourceHelper::DragGestureListener;
 402
 403 private:
 404     std::mutex                                                            maMutex;
 405     css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > mxDragGestureRecognizer;
 406
 407     css::uno::Reference< css::datatransfer::dnd::XDragGestureListener >   mxDragGestureListener;
 408
 409     DragSourceHelper&   operator=( const DragSourceHelper& rDragSourceHelper ) = delete;
 410     bool                operator==( const DragSourceHelper& rDragSourceHelper ) const = delete;
 411
 412 public:
 413
 414                         // to be overridden by the application
 415     virtual void        StartDrag( sal_Int8 nAction, const Point& rPosPixel );
 416
 417                         DragSourceHelper( vcl::Window* pWindow );
 418     void                dispose();
 419     virtual             ~DragSourceHelper();
 420 };
 421
 422 class VCL_DLLPUBLIC SAL_LOPLUGIN_ANNOTATE("crosscast") DropTargetHelper
 423 {
 424 private:
 425
 426     // nested class to implement the XDropTargetListener interface
 427     class SAL_DLLPRIVATE DropTargetListener final : public cppu::WeakImplHelper< css::datatransfer::dnd::XDropTargetListener >
 428     {
 429     private:
 430
 431         DropTargetHelper&                  mrParent;
 432         std::unique_ptr<AcceptDropEvent>   mpLastDragOverEvent;
 433
 434         // XEventListener
 435         virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 436
 437         // XDropTargetListener
 438         virtual void SAL_CALL drop( const css::datatransfer::dnd::DropTargetDropEvent& dtde ) override;
 439         virtual void SAL_CALL dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee ) override;
 440         virtual void SAL_CALL dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ) override;
 441         virtual void SAL_CALL dragOver( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override;
 442         virtual void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override;
 443
 444     public:
 445
 446         DropTargetListener( DropTargetHelper& rDropTargetHelper );
 447         virtual ~DropTargetListener() override;
 448     };
 449
 450     friend class DropTargetHelper::DropTargetListener;
 451
 452 private:
 453     std::mutex                                                            maMutex;
 454     css::uno::Reference< css::datatransfer::dnd::XDropTarget >            mxDropTarget;
 455
 456     css::uno::Reference< css::datatransfer::dnd::XDropTargetListener >    mxDropTargetListener;
 457     DataFlavorExVector                                                    maFormats;
 458
 459                         DropTargetHelper() = delete;
 460     DropTargetHelper&   operator=( const DropTargetHelper& rDropTargetHelper ) = delete;
 461     bool                operator==( const DropTargetHelper& rDropTargetHelper ) const = delete;
 462
 463     void                ImplConstruct();
 464
 465                         // called by our own implementation of XDropTargetListener (DropTargetListener instance)
 466     void                ImplBeginDrag( const css::uno::Sequence< css::datatransfer::DataFlavor >& rSupportedDataFlavors );
 467     void                ImplEndDrag();
 468
 469 public:
 470
 471                         // to be overridden by the application
 472     virtual sal_Int8    AcceptDrop( const AcceptDropEvent& rEvt );
 473     virtual sal_Int8    ExecuteDrop( const ExecuteDropEvent& rEvt );
 474
 475                         DropTargetHelper( vcl::Window* pWindow );
 476                         DropTargetHelper( const css::uno::Reference< css::datatransfer::dnd::XDropTarget >& rxDropTarget );
 477
 478     void                dispose();
 479     virtual             ~DropTargetHelper();
 480
 481                         // typically called by the application in ::AcceptDrop and ::ExecuteDrop and (see above)
 482     bool                IsDropFormatSupported(SotClipboardFormatId nFormat) const;
 483
 484     const DataFlavorExVector& GetDataFlavorExVector() const {return maFormats; }
 485
 486 };
 487
 488 struct TransferDataContainer_Impl;
 489
 490 class VCL_DLLPUBLIC TransferDataContainer : public TransferableHelper
 491 {
 492     std::unique_ptr<TransferDataContainer_Impl> pImpl;
 493
 494     virtual void        AddSupportedFormats() override;
 495     virtual bool        GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) override;
 496
 497 public:
 498
 499                         TransferDataContainer();
 500                         virtual ~TransferDataContainer() override;
 501
 502     void                CopyINetBookmark( const INetBookmark& rBkmk );
 503     void                CopyString( const OUString& rStr );
 504     void                CopyString( SotClipboardFormatId nFmt, const OUString& rStr );
 505
 506     void                CopyByteString( SotClipboardFormatId nFormatId, const OString& rStr );
 507     void                CopyAnyData( SotClipboardFormatId nFormatId, const char* pData, sal_uLong nLen );
 508
 509     bool                HasAnyData() const;
 510
 511     using TransferableHelper::StartDrag;
 512     void                StartDrag( vcl::Window* pWindow, sal_Int8 nDragSourceActions,
 513                                    const Link<sal_Int8,void>& rCallback );
 514     virtual void        DragFinished( sal_Int8 nDropAction ) override;
 515 };
 516
 517 css::uno::Reference<css::datatransfer::clipboard::XClipboard> VCL_DLLPUBLIC GetSystemClipboard();
 518 css::uno::Reference<css::datatransfer::clipboard::XClipboard> VCL_DLLPUBLIC GetSystemPrimarySelection();
 519
 520 #endif
 521
 522 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */