dtrans/source/win32/clipb/WinClipbImpl.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/diagnose.h>
  21 #include "WinClipbImpl.hxx"
  22
  23 #include <systools/win32/comtools.hxx>
  24 #include "../../inc/DtObjFactory.hxx"
  25 #include "../dtobj/APNDataObject.hxx"
  26 #include "WinClipboard.hxx"
  27 #include <com/sun/star/datatransfer/clipboard/RenderingCapabilities.hpp>
  28 #include "../dtobj/XNotifyingDataObject.hxx"
  29
  30 #if defined _MSC_VER
  31 #pragma warning(push,1)
  32 #endif
  33 #include <windows.h>
  34 #include <ole2.h>
  35 #include <objidl.h>
  36 #if defined _MSC_VER
  37 #pragma warning(pop)
  38 #endif
  39
  40 // namespace directives
  41
  42 using namespace osl;
  43 using namespace std;
  44 using namespace cppu;
  45
  46 using namespace com::sun::star::uno;
  47 using namespace com::sun::star::datatransfer;
  48 using namespace com::sun::star::datatransfer::clipboard;
  49 using namespace com::sun::star::datatransfer::clipboard::RenderingCapabilities;
  50
  51 // definition of static members
  52 CWinClipbImpl* CWinClipbImpl::s_pCWinClipbImpl = NULL;
  53 osl::Mutex     CWinClipbImpl::s_aMutex;
  54
  55 CWinClipbImpl::CWinClipbImpl( const OUString& aClipboardName, CWinClipboard* theWinClipboard ) :
  56     m_itsName( aClipboardName ),
  57     m_pWinClipboard( theWinClipboard ),
  58     m_pCurrentClipContent( NULL )
  59 {
  60     OSL_ASSERT( NULL != m_pWinClipboard );
  61
  62     // necessary to reassociate from
  63     // the static callback function
  64     s_pCWinClipbImpl = this;
  65     registerClipboardViewer( );
  66 }
  67
  68 CWinClipbImpl::~CWinClipbImpl( )
  69 {
  70     ClearableMutexGuard aGuard( s_aMutex );
  71     s_pCWinClipbImpl = NULL;
  72     aGuard.clear( );
  73
  74     unregisterClipboardViewer( );
  75 }
  76
  77 // getContent
  78
  79 Reference< XTransferable > SAL_CALL CWinClipbImpl::getContents( ) throw( RuntimeException )
  80 {
  81     // use the shotcut or create a transferable from
  82     // system clipboard
  83     ClearableMutexGuard aGuard( m_ClipContentMutex );
  84
  85     if ( NULL != m_pCurrentClipContent )
  86     {
  87         return m_pCurrentClipContent->m_XTransferable;
  88     }
  89
  90     // release the mutex, so that the variable may be
  91     // changed by other threads
  92     aGuard.clear( );
  93
  94     Reference< XTransferable > rClipContent;
  95
  96     // get the current dataobject from clipboard
  97     IDataObjectPtr pIDataObject;
  98     HRESULT hr = m_MtaOleClipboard.getClipboard( &pIDataObject );
  99
 100     if ( SUCCEEDED( hr ) )
 101     {
 102         // create an apartment neutral dataobject and initialize it with a
 103         // com smart pointer to the IDataObject from clipboard
 104         IDataObjectPtr pIDo( new CAPNDataObject( pIDataObject ) );
 105
 106         CDTransObjFactory objFactory;
 107
 108         // remember pIDo destroys itself due to the smart pointer
 109         rClipContent = objFactory.createTransferableFromDataObj( m_pWinClipboard->m_xContext, pIDo );
 110     }
 111
 112     return rClipContent;
 113 }
 114
 115 // setContent
 116
 117 void SAL_CALL CWinClipbImpl::setContents(
 118     const Reference< XTransferable >& xTransferable,
 119     const Reference< XClipboardOwner >& xClipboardOwner )
 120     throw( RuntimeException )
 121 {
 122     CDTransObjFactory objFactory;
 123     IDataObjectPtr    pIDataObj;
 124
 125     if ( xTransferable.is( ) )
 126     {
 127         ClearableMutexGuard aGuard( m_ClipContentMutex );
 128
 129         m_pCurrentClipContent = new CXNotifyingDataObject(
 130             objFactory.createDataObjFromTransferable( m_pWinClipboard->m_xContext , xTransferable ),
 131             xTransferable,
 132             xClipboardOwner,
 133             this );
 134
 135         aGuard.clear( );
 136
 137         pIDataObj = IDataObjectPtr( m_pCurrentClipContent );
 138     }
 139
 140     m_MtaOleClipboard.setClipboard(pIDataObj.get());
 141 }
 142
 143 OUString SAL_CALL CWinClipbImpl::getName(  ) throw( RuntimeException )
 144 {
 145     return m_itsName;
 146 }
 147
 148 sal_Int8 SAL_CALL CWinClipbImpl::getRenderingCapabilities(  ) throw( RuntimeException )
 149 {
 150     return ( Delayed | Persistant );
 151 }
 152
 153 void SAL_CALL CWinClipbImpl::flushClipboard( ) throw( RuntimeException )
 154 {
 155     // actually it should be ClearableMutexGuard aGuard( m_ClipContentMutex );
 156     // but it does not work since FlushClipboard does a callback and frees DataObject
 157     // which results in a deadlock in onReleaseDataObject.
 158     // FlushClipboard had to be synchron in order to prevent shutdown until all
 159     // clipboard-formats are redered.
 160     // The request is needed to prevent flushing if we are not clipboard owner (it is
 161     // not known what happens if we flush but aren't clipoard owner).
 162     // It may be possible to move the request to the clipboard STA thread by saving the
 163     // DataObject and call OleIsCurrentClipboard bevore flushing.
 164
 165     if ( NULL != m_pCurrentClipContent )
 166         m_MtaOleClipboard.flushClipboard( );
 167 }
 168
 169 void SAL_CALL CWinClipbImpl::registerClipboardViewer( )
 170 {
 171     m_MtaOleClipboard.registerClipViewer( CWinClipbImpl::onClipboardContentChanged );
 172 }
 173
 174 void SAL_CALL CWinClipbImpl::unregisterClipboardViewer( )
 175 {
 176     m_MtaOleClipboard.registerClipViewer( NULL );
 177 }
 178
 179 void SAL_CALL CWinClipbImpl::dispose() throw( RuntimeException )
 180 {
 181     OSL_ENSURE( !m_pCurrentClipContent, "Clipboard was not flushed before shutdown!" );
 182 }
 183
 184 void WINAPI CWinClipbImpl::onClipboardContentChanged()
 185 {
 186     MutexGuard aGuard( s_aMutex );
 187
 188     // reassocition to instance through static member
 189     if ( NULL != s_pCWinClipbImpl )
 190         s_pCWinClipbImpl->m_pWinClipboard->notifyAllClipboardListener( );
 191 }
 192
 193 void SAL_CALL CWinClipbImpl::onReleaseDataObject( CXNotifyingDataObject* theCaller )
 194 {
 195     OSL_ASSERT( NULL != theCaller );
 196
 197     if ( theCaller )
 198         theCaller->lostOwnership( );
 199
 200     // if the current caller is the one we currently
 201     // hold, then set it to NULL because an external
 202     // source must be the clipboardowner now
 203     MutexGuard aGuard( m_ClipContentMutex );
 204
 205     if ( m_pCurrentClipContent == theCaller )
 206         m_pCurrentClipContent = NULL;
 207 }
 208
 209 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */