| /************************************************************** |
| * |
| * 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 _DTRANSHELPER_HXX_ |
| #define _DTRANSHELPER_HXX_ |
| |
| //------------------------------------------------------------------------ |
| // includes |
| //------------------------------------------------------------------------ |
| |
| #if defined _MSC_VER |
| #pragma warning(push,1) |
| #endif |
| #include <windows.h> |
| #if defined _MSC_VER |
| #pragma warning(pop) |
| #endif |
| #include "..\misc\WinClip.hxx" |
| |
| //------------------------------------------------------------------------ |
| // defines |
| //------------------------------------------------------------------------ |
| |
| #define AUTO_INIT TRUE |
| #define NO_AUTO_INIT FALSE |
| #define MEM_DESTROY_ON_RELEASE TRUE |
| #define NO_MEM_DESTROY_ON_RELEASE FALSE |
| |
| //------------------------------------------------------------------------ |
| // deklarations |
| //------------------------------------------------------------------------ |
| |
| |
| //------------------------------------------------------------------------- |
| // a helper class to manage a global memory area, the clients can write |
| // into the global memory area and extract the handle to the global mem |
| // note: not thread-safe |
| //------------------------------------------------------------------------- |
| |
| class CStgTransferHelper |
| { |
| public: |
| // will be thrown in case of failures |
| class CStgTransferException |
| { |
| public: |
| HRESULT m_hr; |
| CStgTransferException( HRESULT hr ) : m_hr( hr ) {}; |
| }; |
| |
| public: |
| CStgTransferHelper( |
| sal_Bool bAutoInit = sal_False, |
| HGLOBAL hGlob = NULL, |
| sal_Bool bDelStgOnRelease = sal_False ); |
| |
| ~CStgTransferHelper( ); |
| |
| void SAL_CALL write( const void* lpData, ULONG cb, ULONG* cbWritten = NULL ); |
| void SAL_CALL read( LPVOID pv, ULONG cb, ULONG* pcbRead = NULL ); |
| |
| HGLOBAL SAL_CALL getHGlobal( ) const; |
| void SAL_CALL getIStream( LPSTREAM* ppStream ); |
| |
| void SAL_CALL init( |
| SIZE_T newSize, |
| sal_uInt32 uiFlags = GHND, |
| sal_Bool bDelStgOnRelease = sal_False ); |
| |
| void SAL_CALL init( |
| HGLOBAL hGlob, |
| sal_Bool bDelStgOnRelease = sal_False ); |
| |
| // returns the size of the managed memory |
| sal_uInt32 SAL_CALL memSize( CLIPFORMAT cf = CF_INVALID ) const; |
| |
| // free the global memory and necessary |
| // release the internal stream pointer |
| void SAL_CALL cleanup( ); |
| |
| private: |
| LPSTREAM m_lpStream; |
| sal_Bool m_bDelStgOnRelease; |
| |
| private: |
| CStgTransferHelper( const CStgTransferHelper& ); |
| CStgTransferHelper& operator=( const CStgTransferHelper& ); |
| }; |
| |
| //------------------------------------------------------------------------- |
| // something like an auto-pointer - allows access to the memory belonging |
| // to a HGLOBAL and automatically unlocks a global memory at destruction |
| // time |
| //------------------------------------------------------------------------- |
| |
| class CRawHGlobalPtr |
| { |
| public: |
| |
| //--------------------------------------------- |
| // ctor |
| //--------------------------------------------- |
| |
| CRawHGlobalPtr( HGLOBAL hGlob ) : |
| m_hGlob( hGlob ), |
| m_bIsLocked( FALSE ), |
| m_pGlobMem( NULL ) |
| { |
| } |
| |
| |
| //--------------------------------------------- |
| // ctor |
| //--------------------------------------------- |
| |
| CRawHGlobalPtr( const CStgTransferHelper& theHGlobalHelper ) : |
| m_hGlob( theHGlobalHelper.getHGlobal( ) ), |
| m_bIsLocked( FALSE ), |
| m_pGlobMem( NULL ) |
| { |
| } |
| |
| //--------------------------------------------- |
| // dtor |
| //--------------------------------------------- |
| |
| ~CRawHGlobalPtr( ) |
| { |
| if ( m_bIsLocked ) |
| GlobalUnlock( m_hGlob ); |
| } |
| |
| //--------------------------------------------- |
| // lock the global memory (initializes a |
| // pointer to this memory) |
| //--------------------------------------------- |
| |
| BOOL Lock( ) |
| { |
| if ( !m_bIsLocked && ( NULL != m_hGlob ) ) |
| { |
| m_pGlobMem = GlobalLock( m_hGlob ); |
| m_bIsLocked = ( NULL != m_pGlobMem ); |
| } |
| |
| return m_bIsLocked; |
| } |
| |
| //--------------------------------------------- |
| // unlock the global memory (invalidates the |
| // pointer to this memory) |
| //--------------------------------------------- |
| |
| BOOL Unlock( ) |
| { |
| GlobalUnlock( m_hGlob ); |
| m_bIsLocked = FALSE; |
| m_pGlobMem = NULL; |
| |
| return ( NO_ERROR == GetLastError( ) ); |
| } |
| |
| //--------------------------------------------- |
| // locks the global memory and returns a |
| // pointer to this memory |
| //--------------------------------------------- |
| |
| LPVOID GetMemPtr( ) |
| { |
| Lock( ); |
| return m_pGlobMem; |
| } |
| |
| //--------------------------------------------- |
| // size of mem we point to |
| //--------------------------------------------- |
| |
| int MemSize( ) const |
| { |
| return GlobalSize( m_hGlob ); |
| } |
| |
| private: |
| HGLOBAL m_hGlob; |
| BOOL m_bIsLocked; |
| LPVOID m_pGlobMem; |
| }; |
| |
| #endif |