| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _DTRANS_X11_SELECTION_HXX_ |
| #define _DTRANS_X11_SELECTION_HXX_ |
| |
| #include <cppuhelper/compbase3.hxx> |
| #include <cppuhelper/compbase4.hxx> |
| #include <com/sun/star/datatransfer/XTransferable.hpp> |
| #include <com/sun/star/datatransfer/dnd/XDropTarget.hpp> |
| #include <com/sun/star/datatransfer/dnd/XDragSource.hpp> |
| #include <com/sun/star/awt/XDisplayConnection.hpp> |
| #include <com/sun/star/lang/XInitialization.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/script/XInvocation.hpp> |
| #include <com/sun/star/frame/XDesktop.hpp> |
| #include <osl/thread.h> |
| |
| #ifndef _OSL_CONDITION_HXX_ |
| #include <osl/conditn.hxx> |
| #endif |
| |
| #include <hash_map> |
| #include <list> |
| |
| #include "tools/prex.h" |
| #include <X11/Xlib.h> |
| #include "tools/postx.h" |
| |
| #define XDND_IMPLEMENTATION_NAME "com.sun.star.datatransfer.dnd.XdndSupport" |
| #define XDND_DROPTARGET_IMPLEMENTATION_NAME "com.sun.star.datatransfer.dnd.XdndDropTarget" |
| |
| using namespace ::com::sun::star::uno; |
| |
| namespace x11 { |
| |
| class PixmapHolder; // in bmp.hxx |
| |
| // ------------------------------------------------------------------------ |
| rtl_TextEncoding getTextPlainEncoding( const ::rtl::OUString& rMimeType ); |
| |
| class SelectionAdaptor |
| { |
| public: |
| virtual com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > getTransferable() = 0; |
| virtual void clearTransferable() = 0; |
| virtual void fireContentsChanged() = 0; |
| virtual com::sun::star::uno::Reference< XInterface > getReference() = 0; |
| // returns a reference that will keep the SelectionAdaptor alive until the |
| // refernce is released |
| }; |
| |
| class DropTarget : |
| public ::cppu::WeakComponentImplHelper3< |
| ::com::sun::star::datatransfer::dnd::XDropTarget, |
| ::com::sun::star::lang::XInitialization, |
| ::com::sun::star::lang::XServiceInfo |
| > |
| { |
| public: |
| ::osl::Mutex m_aMutex; |
| bool m_bActive; |
| sal_Int8 m_nDefaultActions; |
| XLIB_Window m_aTargetWindow; |
| class SelectionManager* m_pSelectionManager; |
| com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource > |
| m_xSelectionManager; |
| ::std::list< com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTargetListener > > |
| m_aListeners; |
| |
| DropTarget(); |
| virtual ~DropTarget(); |
| |
| // convenience functions that loop over listeners |
| void dragEnter( const ::com::sun::star::datatransfer::dnd::DropTargetDragEnterEvent& dtde ) throw(); |
| void dragExit( const ::com::sun::star::datatransfer::dnd::DropTargetEvent& dte ) throw(); |
| void dragOver( const ::com::sun::star::datatransfer::dnd::DropTargetDragEvent& dtde ) throw(); |
| void drop( const ::com::sun::star::datatransfer::dnd::DropTargetDropEvent& dtde ) throw(); |
| |
| // XInitialization |
| virtual void SAL_CALL initialize( const Sequence< Any >& args ) throw ( ::com::sun::star::uno::Exception ); |
| |
| // XDropTarget |
| virtual void SAL_CALL addDropTargetListener( const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTargetListener >& ) throw(); |
| virtual void SAL_CALL removeDropTargetListener( const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTargetListener >& ) throw(); |
| virtual sal_Bool SAL_CALL isActive() throw(); |
| virtual void SAL_CALL setActive( sal_Bool active ) throw(); |
| virtual sal_Int8 SAL_CALL getDefaultActions() throw(); |
| virtual void SAL_CALL setDefaultActions( sal_Int8 actions ) throw(); |
| |
| // XServiceInfo |
| virtual ::rtl::OUString SAL_CALL getImplementationName() throw(); |
| virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw(); |
| virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > |
| SAL_CALL getSupportedServiceNames() throw(); |
| }; |
| |
| class SelectionManagerHolder : |
| public ::cppu::WeakComponentImplHelper3< |
| ::com::sun::star::datatransfer::dnd::XDragSource, |
| ::com::sun::star::lang::XInitialization, |
| ::com::sun::star::lang::XServiceInfo |
| > |
| { |
| ::osl::Mutex m_aMutex; |
| com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource > |
| m_xRealDragSource; |
| public: |
| SelectionManagerHolder(); |
| virtual ~SelectionManagerHolder(); |
| |
| // XServiceInfo |
| virtual ::rtl::OUString SAL_CALL getImplementationName() throw(); |
| virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw(); |
| virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > |
| SAL_CALL getSupportedServiceNames() throw(); |
| |
| // XInitialization |
| virtual void SAL_CALL initialize( const Sequence< Any >& arguments ) throw( ::com::sun::star::uno::Exception ); |
| |
| // XDragSource |
| virtual sal_Bool SAL_CALL isDragImageSupported() throw(); |
| virtual sal_Int32 SAL_CALL getDefaultCursor( sal_Int8 dragAction ) throw(); |
| virtual void SAL_CALL startDrag( |
| const ::com::sun::star::datatransfer::dnd::DragGestureEvent& trigger, |
| sal_Int8 sourceActions, sal_Int32 cursor, sal_Int32 image, |
| const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& transferable, |
| const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSourceListener >& listener |
| ) throw(); |
| |
| }; |
| |
| |
| class SelectionManager : |
| public ::cppu::WeakImplHelper4< |
| ::com::sun::star::datatransfer::dnd::XDragSource, |
| ::com::sun::star::lang::XInitialization, |
| ::com::sun::star::awt::XEventHandler, |
| ::com::sun::star::frame::XTerminateListener |
| >, |
| public SelectionAdaptor |
| { |
| static ::std::hash_map< ::rtl::OUString, SelectionManager*, ::rtl::OUStringHash >& getInstances(); |
| |
| // for INCR type selection transfer |
| // INCR protocol is used if the data cannot |
| // be transported at once but in parts |
| // IncrementalTransfer holds the bytes to be transmitted |
| // as well a the current position |
| // INCR triggers the delivery of the next part by deleting the |
| // property used to transfer the data |
| struct IncrementalTransfer |
| { |
| Sequence< sal_Int8 > m_aData; |
| int m_nBufferPos; |
| XLIB_Window m_aRequestor; |
| Atom m_aProperty; |
| Atom m_aTarget; |
| int m_nFormat; |
| int m_nTransferStartTime; |
| }; |
| int m_nIncrementalThreshold; |
| |
| // a struct to hold the data associated with a selection |
| struct Selection |
| { |
| enum State |
| { |
| Inactive, WaitingForResponse, WaitingForData, IncrementalTransfer |
| }; |
| |
| State m_eState; |
| SelectionAdaptor* m_pAdaptor; |
| Atom m_aAtom; |
| ::osl::Condition m_aDataArrived; |
| Sequence< sal_Int8 > m_aData; |
| Sequence< ::com::sun::star::datatransfer::DataFlavor > |
| m_aTypes; |
| std::vector< Atom > m_aNativeTypes; |
| // this is used for caching |
| // m_aTypes is invalid after 2 seconds |
| // m_aNativeTypes contains the corresponding original atom |
| Atom m_aRequestedType; |
| // m_aRequestedType is only valid while WaitingForResponse and WaitingFotData |
| int m_nLastTimestamp; |
| bool m_bHaveUTF16; |
| Atom m_aUTF8Type; |
| bool m_bHaveCompound; |
| bool m_bOwner; |
| XLIB_Window m_aLastOwner; |
| PixmapHolder* m_pPixmap; |
| // m_nOrigXLIB_Timestamp contains the XLIB_Timestamp at which the seclection |
| // was acquired; needed for XLIB_TimeSTAMP target |
| XLIB_Time m_nOrigTimestamp; |
| |
| Selection() : m_eState( Inactive ), |
| m_pAdaptor( NULL ), |
| m_aAtom( None ), |
| m_aRequestedType( None ), |
| m_nLastTimestamp( 0 ), |
| m_bHaveUTF16( false ), |
| m_aUTF8Type( None ), |
| m_bHaveCompound( false ), |
| m_bOwner( false ), |
| m_aLastOwner( None ), |
| m_pPixmap( NULL ), |
| m_nOrigTimestamp( CurrentTime ) |
| {} |
| }; |
| |
| // a struct to hold data associated with a XDropTarget |
| struct DropTargetEntry |
| { |
| DropTarget* m_pTarget; |
| XLIB_Window m_aRootWindow; |
| |
| DropTargetEntry() : m_pTarget( NULL ), m_aRootWindow( None ) {} |
| DropTargetEntry( DropTarget* pTarget ) : |
| m_pTarget( pTarget ), |
| m_aRootWindow( None ) |
| {} |
| DropTargetEntry( const DropTargetEntry& rEntry ) : |
| m_pTarget( rEntry.m_pTarget ), |
| m_aRootWindow( rEntry.m_aRootWindow ) |
| {} |
| ~DropTargetEntry() {} |
| |
| DropTarget* operator->() const { return m_pTarget; } |
| DropTargetEntry& operator=(const DropTargetEntry& rEntry) |
| { m_pTarget = rEntry.m_pTarget; m_aRootWindow = rEntry.m_aRootWindow; return *this; } |
| }; |
| |
| // internal data |
| Display* m_pDisplay; |
| oslThread m_aThread; |
| oslThread m_aDragExecuteThread; |
| ::osl::Condition m_aDragRunning; |
| XLIB_Window m_aWindow; |
| com::sun::star::uno::Reference< ::com::sun::star::awt::XDisplayConnection > |
| m_xDisplayConnection; |
| com::sun::star::uno::Reference< com::sun::star::script::XInvocation > |
| m_xBitmapConverter; |
| sal_Int32 m_nSelectionTimeout; |
| XLIB_Time m_nSelectionTimestamp; |
| |
| |
| // members used for Xdnd |
| |
| // drop only |
| |
| // contains the XdndEnterEvent of a drop action running |
| // with one of our targets. The data.l[0] member |
| // (conatining the drag source XLIB_Window) is set |
| // to None while that is not the case |
| XClientMessageEvent m_aDropEnterEvent; |
| // set to false on XdndEnter |
| // set to true on first XdndPosition or XdndLeave |
| bool m_bDropEnterSent; |
| XLIB_Window m_aCurrentDropWindow; |
| // XLIB_Time code of XdndDrop |
| XLIB_Time m_nDropTime; |
| sal_Int8 m_nLastDropAction; |
| // XTransferable for Xdnd with foreign drag source |
| com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > |
| m_xDropTransferable; |
| int m_nLastX, m_nLastY; |
| XLIB_Time m_nDropTimestamp; |
| // set to true when calling drop() |
| // if another XdndEnter is received this shows that |
| // someone forgot to call dropComplete - we should reset |
| // and react to the new drop |
| bool m_bDropWaitingForCompletion; |
| |
| // drag only |
| |
| // None if no Dnd action is running with us as source |
| XLIB_Window m_aDropWindow; |
| // either m_aDropXLIB_Window or its XdndProxy |
| XLIB_Window m_aDropProxy; |
| XLIB_Window m_aDragSourceWindow; |
| // XTransferable for Xdnd when we are drag source |
| com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > |
| m_xDragSourceTransferable; |
| com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSourceListener > |
| m_xDragSourceListener; |
| // root coordinates |
| int m_nLastDragX, m_nLastDragY; |
| Sequence< ::com::sun::star::datatransfer::DataFlavor > |
| m_aDragFlavors; |
| // the rectangle the pointer must leave until a new XdndPosition should |
| // be sent. empty unless the drop target told to fill |
| int m_nNoPosX, m_nNoPosY, m_nNoPosWidth, m_nNoPosHeight; |
| unsigned int m_nDragButton; |
| sal_Int8 m_nUserDragAction; |
| sal_Int8 m_nTargetAcceptAction; |
| sal_Int8 m_nSourceActions; |
| bool m_bLastDropAccepted; |
| bool m_bDropSuccess; |
| bool m_bDropSent; |
| time_t m_nDropTimeout; |
| bool m_bWaitingForPrimaryConversion; |
| XLIB_Time m_nDragTimestamp; |
| |
| // drag cursors |
| XLIB_Cursor m_aMoveCursor; |
| XLIB_Cursor m_aCopyCursor; |
| XLIB_Cursor m_aLinkCursor; |
| XLIB_Cursor m_aNoneCursor; |
| XLIB_Cursor m_aCurrentCursor; |
| |
| |
| // drag and drop |
| |
| int m_nCurrentProtocolVersion; |
| ::std::hash_map< XLIB_Window, DropTargetEntry > |
| m_aDropTargets; |
| |
| |
| // some special atoms that are needed often |
| Atom m_nCLIPBOARDAtom; |
| Atom m_nTARGETSAtom; |
| Atom m_nTIMESTAMPAtom; |
| Atom m_nTEXTAtom; |
| Atom m_nINCRAtom; |
| Atom m_nCOMPOUNDAtom; |
| Atom m_nMULTIPLEAtom; |
| Atom m_nUTF16Atom; |
| Atom m_nImageBmpAtom; |
| Atom m_nXdndAware; |
| Atom m_nXdndEnter; |
| Atom m_nXdndLeave; |
| Atom m_nXdndPosition; |
| Atom m_nXdndStatus; |
| Atom m_nXdndDrop; |
| Atom m_nXdndFinished; |
| Atom m_nXdndSelection; |
| Atom m_nXdndTypeList; |
| Atom m_nXdndProxy; |
| Atom m_nXdndActionCopy; |
| Atom m_nXdndActionMove; |
| Atom m_nXdndActionLink; |
| Atom m_nXdndActionAsk; |
| Atom m_nXdndActionPrivate; |
| |
| // caching for atoms |
| ::std::hash_map< Atom, ::rtl::OUString > |
| m_aAtomToString; |
| ::std::hash_map< ::rtl::OUString, Atom, ::rtl::OUStringHash > |
| m_aStringToAtom; |
| |
| // the registered selections |
| ::std::hash_map< Atom, Selection* > |
| m_aSelections; |
| // IncrementalTransfers in progress |
| std::hash_map< XLIB_Window, std::hash_map< Atom, IncrementalTransfer > > |
| m_aIncrementals; |
| |
| // do not use X11 multithreading capabilities |
| // since this leads to deadlocks in different Xlib implentations |
| // (XFree as well as Xsun) use an own mutex instead |
| ::osl::Mutex m_aMutex; |
| bool m_bShutDown; |
| |
| SelectionManager(); |
| ~SelectionManager(); |
| |
| SelectionAdaptor* getAdaptor( Atom selection ); |
| PixmapHolder* getPixmapHolder( Atom selection ); |
| |
| // handle various events |
| bool handleSelectionRequest( XSelectionRequestEvent& rRequest ); |
| bool handleSendPropertyNotify( XPropertyEvent& rNotify ); |
| bool handleReceivePropertyNotify( XPropertyEvent& rNotify ); |
| bool handleSelectionNotify( XSelectionEvent& rNotify ); |
| bool handleDragEvent( XEvent& rMessage ); |
| bool handleDropEvent( XClientMessageEvent& rMessage ); |
| |
| // dnd helpers |
| void sendDragStatus( Atom nDropAction ); |
| void sendDropPosition( bool bForce, XLIB_Time eventXLIB_Time ); |
| bool updateDragAction( int modifierState ); |
| int getXdndVersion( XLIB_Window aXLIB_Window, XLIB_Window& rProxy ); |
| XLIB_Cursor createCursor( const char* pPointerData, const char* pMaskData, int width, int height, int hotX, int hotY ); |
| // coordinates on root XLIB_Window |
| void updateDragWindow( int nX, int nY, XLIB_Window aRoot ); |
| |
| bool getPasteData( Atom selection, Atom type, Sequence< sal_Int8 >& rData ); |
| // returns true if conversion was successful |
| bool convertData( const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& xTransferable, |
| Atom nType, |
| Atom nSelection, |
| int & rFormat, |
| Sequence< sal_Int8 >& rData ); |
| bool sendData( SelectionAdaptor* pAdaptor, XLIB_Window requestor, Atom target, Atom property, Atom selection ); |
| |
| // thread dispatch loop |
| public: |
| // public for extern "C" stub |
| static void run( void* ); |
| private: |
| void dispatchEvent( int millisec ); |
| // drag thread dispatch |
| public: |
| // public for extern "C" stub |
| static void runDragExecute( void* ); |
| private: |
| void dragDoDispatch(); |
| bool handleXEvent( XEvent& rEvent ); |
| |
| // compound text conversion |
| ::rtl::OString convertToCompound( const ::rtl::OUString& rText ); |
| ::rtl::OUString convertFromCompound( const char* pText, int nLen = -1 ); |
| |
| sal_Int8 getUserDragAction() const; |
| sal_Int32 getSelectionTimeout(); |
| public: |
| static SelectionManager& get( const ::rtl::OUString& rDisplayName = ::rtl::OUString() ); |
| |
| Display * getDisplay() { return m_pDisplay; }; |
| XLIB_Window getWindow() { return m_aWindow; }; |
| |
| |
| void registerHandler( Atom selection, SelectionAdaptor& rAdaptor ); |
| void deregisterHandler( Atom selection ); |
| bool requestOwnership( Atom selection ); |
| |
| // allow for synchronization over one mutex for XClipboard |
| osl::Mutex& getMutex() { return m_aMutex; } |
| |
| |
| Atom getAtom( const ::rtl::OUString& rString ); |
| const ::rtl::OUString& getString( Atom nAtom ); |
| |
| // type conversion |
| // note: convertTypeToNative does NOT clear the list, so you can append |
| // multiple types to the same list |
| void convertTypeToNative( const ::rtl::OUString& rType, Atom selection, int& rFormat, ::std::list< Atom >& rConversions, bool bPushFront = false ); |
| ::rtl::OUString convertTypeFromNative( Atom nType, Atom selection, int& rFormat ); |
| void getNativeTypeList( const Sequence< com::sun::star::datatransfer::DataFlavor >& rTypes, std::list< Atom >& rOutTypeList, Atom targetselection ); |
| |
| // methods for transferable |
| bool getPasteDataTypes( Atom selection, Sequence< ::com::sun::star::datatransfer::DataFlavor >& rTypes ); |
| bool getPasteData( Atom selection, const ::rtl::OUString& rType, Sequence< sal_Int8 >& rData ); |
| |
| // for XDropTarget to register/deregister itself |
| void registerDropTarget( XLIB_Window aXLIB_Window, DropTarget* pTarget ); |
| void deregisterDropTarget( XLIB_Window aXLIB_Window ); |
| |
| // for XDropTarget{Drag|Drop}Context |
| void accept( sal_Int8 dragOperation, XLIB_Window aDropXLIB_Window, XLIB_Time aXLIB_Timestamp ); |
| void reject( XLIB_Window aDropXLIB_Window, XLIB_Time aXLIB_Timestamp ); |
| void dropComplete( sal_Bool success, XLIB_Window aDropXLIB_Window, XLIB_Time aXLIB_Timestamp ); |
| |
| // for XDragSourceContext |
| sal_Int32 getCurrentCursor(); |
| void setCursor( sal_Int32 cursor, XLIB_Window aDropXLIB_Window, XLIB_Time aXLIB_Timestamp ); |
| void setImage( sal_Int32 image, XLIB_Window aDropXLIB_Window, XLIB_Time aXLIB_Timestamp ); |
| void transferablesFlavorsChanged(); |
| |
| void shutdown() throw(); |
| |
| // XInitialization |
| virtual void SAL_CALL initialize( const Sequence< Any >& arguments ) throw( ::com::sun::star::uno::Exception ); |
| |
| // XEventHandler |
| virtual sal_Bool SAL_CALL handleEvent( const Any& event ) throw(); |
| |
| // XDragSource |
| virtual sal_Bool SAL_CALL isDragImageSupported() throw(); |
| virtual sal_Int32 SAL_CALL getDefaultCursor( sal_Int8 dragAction ) throw(); |
| virtual void SAL_CALL startDrag( |
| const ::com::sun::star::datatransfer::dnd::DragGestureEvent& trigger, |
| sal_Int8 sourceActions, sal_Int32 cursor, sal_Int32 image, |
| const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& transferable, |
| const com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSourceListener >& listener |
| ) throw(); |
| |
| // SelectionAdaptor for XdndSelection Drag (we are drag source) |
| virtual com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > getTransferable() throw(); |
| virtual void clearTransferable() throw(); |
| virtual void fireContentsChanged() throw(); |
| virtual com::sun::star::uno::Reference< XInterface > getReference() throw(); |
| |
| // XEventListener |
| virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw( ::com::sun::star::uno::RuntimeException ); |
| |
| // XTerminateListener |
| virtual void SAL_CALL queryTermination( const ::com::sun::star::lang::EventObject& aEvent ) |
| throw( ::com::sun::star::frame::TerminationVetoException, ::com::sun::star::uno::RuntimeException ); |
| virtual void SAL_CALL notifyTermination( const ::com::sun::star::lang::EventObject& aEvent ) |
| throw( ::com::sun::star::uno::RuntimeException ); |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL Xdnd_getSupportedServiceNames(); |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL Xdnd_createInstance( |
| const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & xMultiServiceFactory); |
| |
| ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL Xdnd_dropTarget_getSupportedServiceNames(); |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL Xdnd_dropTarget_createInstance( |
| const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & xMultiServiceFactory); |
| |
| // ------------------------------------------------------------------------ |
| |
| } |
| |
| #endif |
