dtrans/source/win32/dtobj/DTransHelper.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_DTRANS_SOURCE_WIN32_DTOBJ_DTRANSHELPER_HXX
  21 #define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DTRANSHELPER_HXX
  22
  23 #if defined _MSC_VER
  24 #pragma warning(push,1)
  25 #endif
  26 #include <windows.h>
  27 #if defined _MSC_VER
  28 #pragma warning(pop)
  29 #endif
  30 #include "../misc/WinClip.hxx"
  31
  32 #define AUTO_INIT                 TRUE
  33
  34 // a helper class to manage a global memory area, the clients can write
  35 // into the global memory area and extract the handle to the global mem
  36 // note: not thread-safe
  37
  38 class CStgTransferHelper
  39 {
  40 public:
  41     // will be thrown in case of failures
  42     class CStgTransferException
  43     {
  44     public:
  45         HRESULT m_hr;
  46         CStgTransferException( HRESULT hr ) : m_hr( hr ) {};
  47     };
  48
  49 public:
  50     CStgTransferHelper(
  51         sal_Bool bAutoInit = sal_False,
  52         HGLOBAL  hGlob = NULL,
  53         sal_Bool bDelStgOnRelease = sal_False );
  54
  55     ~CStgTransferHelper( );
  56
  57     void SAL_CALL write( const void* lpData, ULONG cb, ULONG* cbWritten = NULL );
  58     void SAL_CALL read( LPVOID pv, ULONG cb, ULONG* pcbRead = NULL );
  59
  60     HGLOBAL SAL_CALL getHGlobal( ) const;
  61     void    SAL_CALL getIStream( LPSTREAM* ppStream );
  62
  63     void SAL_CALL init(
  64         SIZE_T newSize,
  65         sal_uInt32 uiFlags = GHND,
  66         sal_Bool bDelStgOnRelease = sal_False );
  67
  68     void SAL_CALL init(
  69         HGLOBAL hGlob,
  70         sal_Bool bDelStgOnRelease = sal_False );
  71
  72     // returns the size of the managed memory
  73     sal_uInt32 SAL_CALL memSize( CLIPFORMAT cf = CF_INVALID ) const;
  74
  75     // free the global memory and necessary
  76     // release the internal stream pointer
  77     void SAL_CALL cleanup( );
  78
  79 private:
  80     LPSTREAM m_lpStream;
  81     sal_Bool m_bDelStgOnRelease;
  82
  83 private:
  84     CStgTransferHelper( const CStgTransferHelper& );
  85     CStgTransferHelper& operator=( const CStgTransferHelper& );
  86 };
  87
  88 // something like an auto-pointer - allows access to the memory belonging
  89 // to a HGLOBAL and automatically unlocks a global memory at destruction
  90 // time
  91
  92 class CRawHGlobalPtr
  93 {
  94 public:
  95
  96     // ctor
  97
  98     CRawHGlobalPtr( HGLOBAL hGlob ) :
  99         m_hGlob( hGlob ),
 100         m_bIsLocked( FALSE ),
 101         m_pGlobMem( NULL )
 102     {
 103     }
 104
 105     // ctor
 106
 107     CRawHGlobalPtr( const CStgTransferHelper& theHGlobalHelper ) :
 108         m_hGlob( theHGlobalHelper.getHGlobal( ) ),
 109         m_bIsLocked( FALSE ),
 110         m_pGlobMem( NULL )
 111     {
 112     }
 113
 114     // dtor
 115
 116     ~CRawHGlobalPtr( )
 117     {
 118         if ( m_bIsLocked )
 119             GlobalUnlock( m_hGlob );
 120     }
 121
 122     // lock the global memory (initializes a
 123     // pointer to this memory)
 124
 125     BOOL Lock( )
 126     {
 127         if ( !m_bIsLocked && ( NULL != m_hGlob ) )
 128         {
 129             m_pGlobMem = GlobalLock( m_hGlob );
 130             m_bIsLocked = ( NULL != m_pGlobMem );
 131         }
 132
 133         return m_bIsLocked;
 134     }
 135
 136     // unlock the global memory (invalidates the
 137     // pointer to this memory)
 138
 139     BOOL Unlock( )
 140     {
 141         GlobalUnlock( m_hGlob );
 142         m_bIsLocked = FALSE;
 143         m_pGlobMem = NULL;
 144
 145         return ( NO_ERROR == GetLastError( ) );
 146     }
 147
 148     // locks the global memory and returns a
 149     // pointer to this memory
 150
 151     LPVOID GetMemPtr( )
 152     {
 153         Lock( );
 154         return m_pGlobMem;
 155     }
 156
 157     // size of mem we point to
 158
 159     int MemSize( ) const
 160     {
 161         return GlobalSize( m_hGlob );
 162     }
 163
 164 private:
 165     HGLOBAL m_hGlob;
 166     BOOL    m_bIsLocked;
 167     LPVOID  m_pGlobMem;
 168 };
 169
 170 #endif
 171
 172 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */