/************************************************************** * * 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 _TARGET_HXX_ #define _TARGET_HXX_ #include #include #include #include #ifndef _CPPUHELPER_COMPBASE2_HXX_ #include #endif #include #ifndef _OSL_MUTEX_H_ #include #endif #if defined _MSC_VER #pragma warning(push,1) #endif #include #if defined _MSC_VER #pragma warning(pop) #endif #include "globals.hxx" #include "../../inc/DtObjFactory.hxx" using namespace ::com::sun::star::lang; using namespace ::com::sun::star::uno; using namespace cppu; using namespace osl; using namespace rtl; using namespace ::com::sun::star::datatransfer; using namespace ::com::sun::star::datatransfer::dnd; // The client // has to call XComponent::dispose. The thread that calls initialize // must also execute the destruction of the instance. This is because // initialize calls OleInitialize and the destructor calls OleUninitialize. // If the service calls OleInitialize then it also calls OleUnitialize when // it is destroyed. Therefore no second instance may exist which was // created in the same thread and still needs OLE. class DropTarget: public MutexDummy, public WeakComponentImplHelper3< XInitialization, XDropTarget, XServiceInfo> { private: friend DWORD WINAPI DndTargetOleSTAFunc(LPVOID pParams); // The native window which acts as drop target. // It is set in initialize. In case RegisterDragDrop fails it is set // to NULL HWND m_hWnd; // set by initialize // Holds the thread id of the thread which created the window that is the // drop target. Only used when DropTarget::initialize is called from an MTA // thread DWORD m_threadIdWindow; // This is the thread id of the OLE thread that is created in DropTarget::initialize // when the calling thread is an MTA DWORD m_threadIdTarget; // The handle of the thread that is created in DropTarget::initialize // when the calling thread is an MTA HANDLE m_hOleThread; // The thread id of the thread which called initialize. When the service dies // than m_oleThreadId is used to determine if the service successfully called // OleInitialize. If so then OleUninitialize has to be called. DWORD m_oleThreadId; // An Instance of IDropTargetImpl which receives calls from the system's drag // and drop implementation. It delegate the calls to name alike functions in // this class. IDropTarget* m_pDropTarget; Reference m_serviceFactory; // If m_bActive == sal_True then events are fired to XDropTargetListener s, // none otherwise. The default value is sal_True. sal_Bool m_bActive; sal_Int8 m_nDefaultActions; // This value is set when a XDropTargetListener calls accept or reject on // the XDropTargetDropContext or XDropTargetDragContext. // The values are from the DNDConstants group. sal_Int8 m_nCurrentDropAction; // This value is manipulated by the XDropTargetListener sal_Int8 m_nLastDropAction; Reference m_currentData; // The current action is used to determine if the USER // action has changed (dropActionChanged) // sal_Int8 m_userAction; // Set by listeners when they call XDropTargetDropContext::dropComplete sal_Bool m_bDropComplete; // converts IDataObject objects to XTransferable objects. CDTransObjFactory m_aDataConverter; Reference m_currentDragContext; Reference m_currentDropContext; private: DropTarget(); DropTarget(DropTarget&); DropTarget &operator= (DropTarget&); public: DropTarget(const Reference& sf); virtual ~DropTarget(); // Overrides WeakComponentImplHelper::disposing which is called by // WeakComponentImplHelper::dispose // Must be called. virtual void SAL_CALL disposing(); // XInitialization virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException); // XDropTarget virtual void SAL_CALL addDropTargetListener( const Reference< XDropTargetListener >& dtl ) throw(RuntimeException); virtual void SAL_CALL removeDropTargetListener( const Reference< XDropTargetListener >& dtl ) throw(RuntimeException); // Default is not active virtual sal_Bool SAL_CALL isActive( ) throw(RuntimeException); virtual void SAL_CALL setActive( sal_Bool isActive ) throw(RuntimeException); virtual sal_Int8 SAL_CALL getDefaultActions( ) throw(RuntimeException); virtual void SAL_CALL setDefaultActions( sal_Int8 actions ) throw(RuntimeException); // XServiceInfo virtual OUString SAL_CALL getImplementationName( ) throw (RuntimeException); virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) throw (RuntimeException); // Functions called from the IDropTarget implementation ( m_pDropTarget) virtual HRESULT DragEnter( /* [unique][in] */ IDataObject *pDataObj, /* [in] */ DWORD grfKeyState, /* [in] */ POINTL pt, /* [out][in] */ DWORD *pdwEffect); virtual HRESULT STDMETHODCALLTYPE DragOver( /* [in] */ DWORD grfKeyState, /* [in] */ POINTL pt, /* [out][in] */ DWORD *pdwEffect); virtual HRESULT STDMETHODCALLTYPE DragLeave( ) ; virtual HRESULT STDMETHODCALLTYPE Drop( /* [unique][in] */ IDataObject *pDataObj, /* [in] */ DWORD grfKeyState, /* [in] */ POINTL pt, /* [out][in] */ DWORD *pdwEffect); // Non - interface functions -------------------------------------------------- // XDropTargetDropContext delegated from DropContext void _acceptDrop( sal_Int8 dropOperation, const Reference& context); void _rejectDrop( const Reference& context); void _dropComplete( sal_Bool success, const Reference& context); // XDropTargetDragContext delegated from DragContext void _acceptDrag( sal_Int8 dragOperation, const Reference& context); void _rejectDrag( const Reference& context); protected: // Gets the current action dependend on the pressed modifiers, the effects // supported by the drop source (IDropSource) and the default actions of the // drop target (XDropTarget, this class)) inline sal_Int8 getFilteredActions( DWORD grfKeyState, DWORD sourceActions); // Only filters with the default actions inline sal_Int8 getFilteredActions( DWORD grfKeyState); void fire_drop( const DropTargetDropEvent& dte); void fire_dragEnter( const DropTargetDragEnterEvent& dtde ); void fire_dragExit( const DropTargetEvent& dte ); void fire_dragOver( const DropTargetDragEvent& dtde ); void fire_dropActionChanged( const DropTargetDragEvent& dtde ); }; #endif