1*9f62ea84SAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 3*9f62ea84SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4*9f62ea84SAndrew Rist * or more contributor license agreements. See the NOTICE file 5*9f62ea84SAndrew Rist * distributed with this work for additional information 6*9f62ea84SAndrew Rist * regarding copyright ownership. The ASF licenses this file 7*9f62ea84SAndrew Rist * to you under the Apache License, Version 2.0 (the 8*9f62ea84SAndrew Rist * "License"); you may not use this file except in compliance 9*9f62ea84SAndrew Rist * with the License. You may obtain a copy of the License at 10*9f62ea84SAndrew Rist * 11*9f62ea84SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12*9f62ea84SAndrew Rist * 13*9f62ea84SAndrew Rist * Unless required by applicable law or agreed to in writing, 14*9f62ea84SAndrew Rist * software distributed under the License is distributed on an 15*9f62ea84SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*9f62ea84SAndrew Rist * KIND, either express or implied. See the License for the 17*9f62ea84SAndrew Rist * specific language governing permissions and limitations 18*9f62ea84SAndrew Rist * under the License. 19*9f62ea84SAndrew Rist * 20*9f62ea84SAndrew Rist *************************************************************/ 21*9f62ea84SAndrew Rist 22*9f62ea84SAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir #include <svpm.h> 25cdf0e10cSrcweir 26cdf0e10cSrcweir #define _SV_SALBMP_CXX 27cdf0e10cSrcweir #include <rtl/alloc.h> 28cdf0e10cSrcweir #include <vcl/salbtype.hxx> 29cdf0e10cSrcweir #include <salgdi.h> 30cdf0e10cSrcweir #include <saldata.hxx> 31cdf0e10cSrcweir #include <salbmp.h> 32cdf0e10cSrcweir #include <vcl/bitmap.hxx> // for BitmapSystemData 33cdf0e10cSrcweir #include <string.h> 34cdf0e10cSrcweir 35cdf0e10cSrcweir #ifndef __H_FT2LIB 36cdf0e10cSrcweir #include <wingdi.h> 37cdf0e10cSrcweir #include <ft2lib.h> 38cdf0e10cSrcweir #endif 39cdf0e10cSrcweir 40cdf0e10cSrcweir // ----------- 41cdf0e10cSrcweir // - Inlines - 42cdf0e10cSrcweir // ----------- 43cdf0e10cSrcweir 44cdf0e10cSrcweir inline void ImplSetPixel4( const HPBYTE pScanline, long nX, const BYTE cIndex ) 45cdf0e10cSrcweir { 46cdf0e10cSrcweir BYTE& rByte = pScanline[ nX >> 1 ]; 47cdf0e10cSrcweir 48cdf0e10cSrcweir ( nX & 1 ) ? ( rByte &= 0xf0, rByte |= ( cIndex & 0x0f ) ) : 49cdf0e10cSrcweir ( rByte &= 0x0f, rByte |= ( cIndex << 4 ) ); 50cdf0e10cSrcweir } 51cdf0e10cSrcweir 52cdf0e10cSrcweir // ------------- 53cdf0e10cSrcweir // - Os2SalBitmap - 54cdf0e10cSrcweir // ------------- 55cdf0e10cSrcweir 56cdf0e10cSrcweir Os2SalBitmap::Os2SalBitmap() : 57cdf0e10cSrcweir mhDIB ( 0 ), 58cdf0e10cSrcweir mhDIB1Subst ( 0 ), 59cdf0e10cSrcweir mhDDB ( 0 ), 60cdf0e10cSrcweir mnBitCount ( 0 ) 61cdf0e10cSrcweir { 62cdf0e10cSrcweir } 63cdf0e10cSrcweir 64cdf0e10cSrcweir // ------------------------------------------------------------------ 65cdf0e10cSrcweir 66cdf0e10cSrcweir Os2SalBitmap::~Os2SalBitmap() 67cdf0e10cSrcweir { 68cdf0e10cSrcweir Destroy(); 69cdf0e10cSrcweir } 70cdf0e10cSrcweir 71cdf0e10cSrcweir // ------------------------------------------------------------------ 72cdf0e10cSrcweir 73cdf0e10cSrcweir bool Os2SalBitmap::Create( HANDLE hBitmap, bool bDIB, bool bCopyHandle ) 74cdf0e10cSrcweir { 75cdf0e10cSrcweir BOOL bRet = TRUE; 76cdf0e10cSrcweir 77cdf0e10cSrcweir if( bDIB ) 78cdf0e10cSrcweir mhDIB = (HANDLE) ( bCopyHandle ? ImplCopyDIBOrDDB( hBitmap, TRUE ) : hBitmap ); 79cdf0e10cSrcweir else 80cdf0e10cSrcweir mhDDB = (HBITMAP) ( bCopyHandle ? ImplCopyDIBOrDDB( hBitmap, FALSE ) : hBitmap ); 81cdf0e10cSrcweir 82cdf0e10cSrcweir if( mhDIB ) 83cdf0e10cSrcweir { 84cdf0e10cSrcweir // bitmap-header is the beginning of memory block 85cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) mhDIB; 86cdf0e10cSrcweir 87cdf0e10cSrcweir maSize = Size( pBIH->cx, pBIH->cy ); 88cdf0e10cSrcweir mnBitCount = pBIH->cBitCount; 89cdf0e10cSrcweir 90cdf0e10cSrcweir if( mnBitCount ) 91cdf0e10cSrcweir mnBitCount = ( mnBitCount <= 1 ) ? 1 : ( mnBitCount <= 4 ) ? 4 : ( mnBitCount <= 8 ) ? 8 : 24; 92cdf0e10cSrcweir } 93cdf0e10cSrcweir else if( mhDDB ) 94cdf0e10cSrcweir { 95cdf0e10cSrcweir BITMAPINFOHEADER2 aDDBInfoHeader; 96cdf0e10cSrcweir 97cdf0e10cSrcweir aDDBInfoHeader.cbFix = sizeof( aDDBInfoHeader ); 98cdf0e10cSrcweir 99cdf0e10cSrcweir if( GpiQueryBitmapInfoHeader( mhDDB, &aDDBInfoHeader ) ) 100cdf0e10cSrcweir { 101cdf0e10cSrcweir maSize = Size( aDDBInfoHeader.cx, aDDBInfoHeader.cy ); 102cdf0e10cSrcweir mnBitCount = aDDBInfoHeader.cPlanes * aDDBInfoHeader.cBitCount; 103cdf0e10cSrcweir 104cdf0e10cSrcweir if( mnBitCount ) 105cdf0e10cSrcweir { 106cdf0e10cSrcweir mnBitCount = ( mnBitCount <= 1 ) ? 1 : 107cdf0e10cSrcweir ( mnBitCount <= 4 ) ? 4 : 108cdf0e10cSrcweir ( mnBitCount <= 8 ) ? 8 : 24; 109cdf0e10cSrcweir } 110cdf0e10cSrcweir } 111cdf0e10cSrcweir else 112cdf0e10cSrcweir { 113cdf0e10cSrcweir mhDDB = 0; 114cdf0e10cSrcweir bRet = FALSE; 115cdf0e10cSrcweir } 116cdf0e10cSrcweir 117cdf0e10cSrcweir } 118cdf0e10cSrcweir else 119cdf0e10cSrcweir bRet = FALSE; 120cdf0e10cSrcweir 121cdf0e10cSrcweir return bRet; 122cdf0e10cSrcweir } 123cdf0e10cSrcweir 124cdf0e10cSrcweir // ------------------------------------------------------------------ 125cdf0e10cSrcweir 126cdf0e10cSrcweir bool Os2SalBitmap::Create( const Size& rSize, USHORT nBitCount, const BitmapPalette& rPal ) 127cdf0e10cSrcweir { 128cdf0e10cSrcweir bool bRet = FALSE; 129cdf0e10cSrcweir 130cdf0e10cSrcweir mhDIB = ImplCreateDIB( rSize, nBitCount, rPal ); 131cdf0e10cSrcweir 132cdf0e10cSrcweir if( mhDIB ) 133cdf0e10cSrcweir { 134cdf0e10cSrcweir maSize = rSize; 135cdf0e10cSrcweir mnBitCount = nBitCount; 136cdf0e10cSrcweir bRet = TRUE; 137cdf0e10cSrcweir } 138cdf0e10cSrcweir 139cdf0e10cSrcweir return bRet; 140cdf0e10cSrcweir } 141cdf0e10cSrcweir 142cdf0e10cSrcweir // ------------------------------------------------------------------ 143cdf0e10cSrcweir 144cdf0e10cSrcweir bool Os2SalBitmap::Create( const SalBitmap& rSSalBitmap ) 145cdf0e10cSrcweir { 146cdf0e10cSrcweir bool bRet = FALSE; 147cdf0e10cSrcweir const Os2SalBitmap& rSalBitmap = static_cast<const Os2SalBitmap&>(rSSalBitmap); 148cdf0e10cSrcweir 149cdf0e10cSrcweir if ( rSalBitmap.mhDIB || rSalBitmap.mhDDB ) 150cdf0e10cSrcweir { 151cdf0e10cSrcweir HANDLE hNewHdl = ImplCopyDIBOrDDB( rSalBitmap.mhDIB ? rSalBitmap.mhDIB : rSalBitmap.mhDDB, 152cdf0e10cSrcweir rSalBitmap.mhDIB != 0 ); 153cdf0e10cSrcweir 154cdf0e10cSrcweir if( hNewHdl ) 155cdf0e10cSrcweir { 156cdf0e10cSrcweir if( rSalBitmap.mhDIB ) 157cdf0e10cSrcweir mhDIB = (HANDLE) hNewHdl; 158cdf0e10cSrcweir else if( rSalBitmap.mhDDB ) 159cdf0e10cSrcweir mhDDB = (HBITMAP) hNewHdl; 160cdf0e10cSrcweir 161cdf0e10cSrcweir maSize = rSalBitmap.maSize; 162cdf0e10cSrcweir mnBitCount = rSalBitmap.mnBitCount; 163cdf0e10cSrcweir bRet = TRUE; 164cdf0e10cSrcweir } 165cdf0e10cSrcweir } 166cdf0e10cSrcweir 167cdf0e10cSrcweir return bRet; 168cdf0e10cSrcweir } 169cdf0e10cSrcweir 170cdf0e10cSrcweir // ------------------------------------------------------------------ 171cdf0e10cSrcweir 172cdf0e10cSrcweir bool Os2SalBitmap::Create( const SalBitmap& rSSalBmp, SalGraphics* pSGraphics ) 173cdf0e10cSrcweir { 174cdf0e10cSrcweir bool bRet = FALSE; 175cdf0e10cSrcweir const Os2SalBitmap& rSalBmp = static_cast<const Os2SalBitmap&>(rSSalBmp); 176cdf0e10cSrcweir Os2SalGraphics* pGraphics = static_cast<Os2SalGraphics*>(pSGraphics); 177cdf0e10cSrcweir 178cdf0e10cSrcweir if( rSalBmp.mhDIB ) 179cdf0e10cSrcweir { 180cdf0e10cSrcweir HPS hPS = pGraphics->mhPS; 181cdf0e10cSrcweir HBITMAP hNewDDB; 182cdf0e10cSrcweir BITMAPINFOHEADER2 aInfoHeader; 183cdf0e10cSrcweir const Size aSize( rSalBmp.GetSize() ); 184cdf0e10cSrcweir long nFormat[ 2 ]; 185cdf0e10cSrcweir 186cdf0e10cSrcweir memset( &aInfoHeader, 0, sizeof( aInfoHeader ) ); 187cdf0e10cSrcweir aInfoHeader.cbFix = 16; 188cdf0e10cSrcweir aInfoHeader.cx = aSize.Width(); 189cdf0e10cSrcweir aInfoHeader.cy = aSize.Height(); 190cdf0e10cSrcweir 191cdf0e10cSrcweir GpiQueryDeviceBitmapFormats( hPS, 2L, (PLONG) &nFormat ); 192cdf0e10cSrcweir aInfoHeader.cPlanes = nFormat[ 0 ]; 193cdf0e10cSrcweir aInfoHeader.cBitCount = nFormat[ 1 ]; 194cdf0e10cSrcweir 195cdf0e10cSrcweir // ! wegen Postscript-Treiber 196cdf0e10cSrcweir if( !aInfoHeader.cBitCount ) 197cdf0e10cSrcweir aInfoHeader.cBitCount = 24; 198cdf0e10cSrcweir else if( ( aInfoHeader.cPlanes == 1 ) && ( aInfoHeader.cBitCount == 1 ) ) 199cdf0e10cSrcweir aInfoHeader.cBitCount = 4; 200cdf0e10cSrcweir 201cdf0e10cSrcweir // BitCount == 1 ist wegen aller moeglichen Treiberfehler nicht moeglich 202cdf0e10cSrcweir if( rSalBmp.GetBitCount() == 1 ) 203cdf0e10cSrcweir { 204cdf0e10cSrcweir HANDLE hTmp = ImplCreateDIB4FromDIB1( rSalBmp.mhDIB ); 205cdf0e10cSrcweir PBYTE pBits = (PBYTE) hTmp + *(ULONG*) hTmp + ImplGetDIBColorCount( hTmp ) * sizeof( RGB2 ); 206cdf0e10cSrcweir 207cdf0e10cSrcweir hNewDDB = GpiCreateBitmap( hPS, &aInfoHeader, CBM_INIT, pBits, (PBITMAPINFO2) hTmp ); 208cdf0e10cSrcweir rtl_freeMemory( (void*)hTmp ); 209cdf0e10cSrcweir } 210cdf0e10cSrcweir else 211cdf0e10cSrcweir { 212cdf0e10cSrcweir PBYTE pBits = (PBYTE) rSalBmp.mhDIB + *(ULONG*) rSalBmp.mhDIB + ImplGetDIBColorCount( rSalBmp.mhDIB ) * sizeof( RGB2 ); 213cdf0e10cSrcweir hNewDDB = GpiCreateBitmap( hPS, &aInfoHeader, CBM_INIT, pBits, (PBITMAPINFO2) rSalBmp.mhDIB ); 214cdf0e10cSrcweir } 215cdf0e10cSrcweir 216cdf0e10cSrcweir aInfoHeader.cbFix = sizeof( aInfoHeader ); 217cdf0e10cSrcweir 218cdf0e10cSrcweir if( hNewDDB && GpiQueryBitmapInfoHeader( hNewDDB, &aInfoHeader ) ) 219cdf0e10cSrcweir { 220cdf0e10cSrcweir mhDDB = hNewDDB; 221cdf0e10cSrcweir maSize = Size( aInfoHeader.cx, aInfoHeader.cy ); 222cdf0e10cSrcweir mnBitCount = aInfoHeader.cPlanes * aInfoHeader.cBitCount; 223cdf0e10cSrcweir 224cdf0e10cSrcweir if( mnBitCount ) 225cdf0e10cSrcweir { 226cdf0e10cSrcweir mnBitCount = ( mnBitCount <= 1 ) ? 1 : 227cdf0e10cSrcweir ( mnBitCount <= 4 ) ? 4 : 228cdf0e10cSrcweir ( mnBitCount <= 8 ) ? 8 : 24; 229cdf0e10cSrcweir } 230cdf0e10cSrcweir 231cdf0e10cSrcweir bRet = TRUE; 232cdf0e10cSrcweir } 233cdf0e10cSrcweir else if( hNewDDB ) 234cdf0e10cSrcweir GpiDeleteBitmap( hNewDDB ); 235cdf0e10cSrcweir } 236cdf0e10cSrcweir 237cdf0e10cSrcweir return bRet; 238cdf0e10cSrcweir } 239cdf0e10cSrcweir 240cdf0e10cSrcweir // ------------------------------------------------------------------ 241cdf0e10cSrcweir 242cdf0e10cSrcweir bool Os2SalBitmap::Create( const SalBitmap& rSSalBmp, USHORT nNewBitCount ) 243cdf0e10cSrcweir { 244cdf0e10cSrcweir bool bRet = FALSE; 245cdf0e10cSrcweir const Os2SalBitmap& rSalBmp = static_cast<const Os2SalBitmap&>(rSSalBmp); 246cdf0e10cSrcweir 247cdf0e10cSrcweir if( rSalBmp.mhDDB ) 248cdf0e10cSrcweir { 249cdf0e10cSrcweir mhDIB = ImplCreateDIB( rSalBmp.maSize, nNewBitCount, BitmapPalette() ); 250cdf0e10cSrcweir 251cdf0e10cSrcweir if( mhDIB ) 252cdf0e10cSrcweir { 253cdf0e10cSrcweir // bitmap-header is the beginning of memory block 254cdf0e10cSrcweir PBITMAPINFO2 pBI = (PBITMAPINFO2) mhDIB; 255cdf0e10cSrcweir const int nLines = (int) rSalBmp.maSize.Height(); 256cdf0e10cSrcweir PBYTE pBits = (PBYTE) pBI + *(ULONG*) pBI + ImplGetDIBColorCount( mhDIB ) * sizeof( RGB2 ); 257cdf0e10cSrcweir SIZEL aSizeL = { rSalBmp.maSize.Width(), nLines }; 258cdf0e10cSrcweir HAB hAB = GetSalData()->mhAB; 259cdf0e10cSrcweir DEVOPENSTRUC aDevOpenStruc = { NULL, (PSZ)"DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; 260cdf0e10cSrcweir HDC hMemDC = DevOpenDC( hAB, OD_MEMORY, (PSZ)"*", 5L, (PDEVOPENDATA)&aDevOpenStruc, 0 ); 261cdf0e10cSrcweir HPS hMemPS = Ft2CreatePS( hAB, hMemDC, &aSizeL, GPIT_MICRO | GPIA_ASSOC | PU_PELS ); 262cdf0e10cSrcweir HBITMAP hMemOld = (HBITMAP) Ft2SetBitmap( hMemPS, rSalBmp.mhDDB ); 263cdf0e10cSrcweir 264cdf0e10cSrcweir if( GpiQueryBitmapBits( hMemPS, 0, nLines, pBits, pBI ) == nLines ) 265cdf0e10cSrcweir { 266cdf0e10cSrcweir maSize = rSalBmp.maSize; 267cdf0e10cSrcweir mnBitCount = nNewBitCount; 268cdf0e10cSrcweir bRet = TRUE; 269cdf0e10cSrcweir } 270cdf0e10cSrcweir else 271cdf0e10cSrcweir { 272cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB ); 273cdf0e10cSrcweir mhDIB = 0; 274cdf0e10cSrcweir } 275cdf0e10cSrcweir 276cdf0e10cSrcweir Ft2SetBitmap( hMemPS, hMemOld ); 277cdf0e10cSrcweir Ft2DestroyPS( hMemPS ); 278cdf0e10cSrcweir DevCloseDC( hMemDC ); 279cdf0e10cSrcweir } 280cdf0e10cSrcweir } 281cdf0e10cSrcweir 282cdf0e10cSrcweir return bRet; 283cdf0e10cSrcweir } 284cdf0e10cSrcweir 285cdf0e10cSrcweir // ------------------------------------------------------------------ 286cdf0e10cSrcweir 287cdf0e10cSrcweir void Os2SalBitmap::Destroy() 288cdf0e10cSrcweir { 289cdf0e10cSrcweir if( mhDIB ) 290cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB ); 291cdf0e10cSrcweir else if( mhDDB ) 292cdf0e10cSrcweir GpiDeleteBitmap( mhDDB ); 293cdf0e10cSrcweir 294cdf0e10cSrcweir if( mhDIB1Subst ) 295cdf0e10cSrcweir { 296cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB1Subst ); 297cdf0e10cSrcweir mhDIB1Subst = NULL; 298cdf0e10cSrcweir } 299cdf0e10cSrcweir 300cdf0e10cSrcweir maSize = Size(); 301cdf0e10cSrcweir mnBitCount = 0; 302cdf0e10cSrcweir } 303cdf0e10cSrcweir 304cdf0e10cSrcweir // ------------------------------------------------------------------ 305cdf0e10cSrcweir 306cdf0e10cSrcweir void Os2SalBitmap::ImplReplacehDIB1Subst( HANDLE hDIB1Subst ) 307cdf0e10cSrcweir { 308cdf0e10cSrcweir if( mhDIB1Subst ) 309cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB1Subst ); 310cdf0e10cSrcweir 311cdf0e10cSrcweir mhDIB1Subst = hDIB1Subst; 312cdf0e10cSrcweir } 313cdf0e10cSrcweir 314cdf0e10cSrcweir // ------------------------------------------------------------------ 315cdf0e10cSrcweir 316cdf0e10cSrcweir USHORT Os2SalBitmap::ImplGetDIBColorCount( HANDLE hDIB ) 317cdf0e10cSrcweir { 318cdf0e10cSrcweir USHORT nColors = 0; 319cdf0e10cSrcweir 320cdf0e10cSrcweir if( hDIB ) 321cdf0e10cSrcweir { 322cdf0e10cSrcweir // bitmap infos can be found at the beginning of the memory 323cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) hDIB; 324cdf0e10cSrcweir 325cdf0e10cSrcweir if( pBIH->cBitCount <= 8 ) 326cdf0e10cSrcweir { 327cdf0e10cSrcweir if( pBIH->cclrUsed ) 328cdf0e10cSrcweir nColors = (USHORT) pBIH->cclrUsed; 329cdf0e10cSrcweir else 330cdf0e10cSrcweir nColors = 1 << pBIH->cBitCount; 331cdf0e10cSrcweir } 332cdf0e10cSrcweir } 333cdf0e10cSrcweir 334cdf0e10cSrcweir return nColors; 335cdf0e10cSrcweir } 336cdf0e10cSrcweir 337cdf0e10cSrcweir // ------------------------------------------------------------------ 338cdf0e10cSrcweir 339cdf0e10cSrcweir HANDLE Os2SalBitmap::ImplCreateDIB( const Size& rSize, USHORT nBits, const BitmapPalette& rPal ) 340cdf0e10cSrcweir { 341cdf0e10cSrcweir DBG_ASSERT( nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24, "Unsupported BitCount!" ); 342cdf0e10cSrcweir 343cdf0e10cSrcweir HANDLE hDIB = 0; 344cdf0e10cSrcweir 345cdf0e10cSrcweir if ( rSize.Width() && rSize.Height() && ( nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24 ) ) 346cdf0e10cSrcweir { 347cdf0e10cSrcweir const ULONG nImageSize = AlignedWidth4Bytes( nBits * rSize.Width() ) * rSize.Height(); 348cdf0e10cSrcweir const USHORT nColors = ( nBits <= 8 ) ? ( 1 << nBits ) : 0; 349cdf0e10cSrcweir 350cdf0e10cSrcweir hDIB = (HANDLE) rtl_allocateZeroMemory( sizeof( BITMAPINFOHEADER2 ) + nColors * sizeof( RGB2 ) + nImageSize ); 351cdf0e10cSrcweir 352cdf0e10cSrcweir if( hDIB ) 353cdf0e10cSrcweir { 354cdf0e10cSrcweir // bitmap infos can be found at the beginning of the memory 355cdf0e10cSrcweir PBITMAPINFO2 pBI = (PBITMAPINFO2) hDIB; 356cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) pBI; 357cdf0e10cSrcweir 358cdf0e10cSrcweir pBIH->cbFix = sizeof( BITMAPINFOHEADER2 ); 359cdf0e10cSrcweir pBIH->cx = rSize.Width(); 360cdf0e10cSrcweir pBIH->cy = rSize.Height(); 361cdf0e10cSrcweir pBIH->cPlanes = 1; 362cdf0e10cSrcweir pBIH->cBitCount = nBits; 363cdf0e10cSrcweir pBIH->ulCompression = BCA_UNCOMP; // BI_RGB; 364cdf0e10cSrcweir pBIH->cbImage = nImageSize; 365cdf0e10cSrcweir pBIH->cxResolution = 0; 366cdf0e10cSrcweir pBIH->cyResolution = 0; 367cdf0e10cSrcweir pBIH->cclrUsed = 0; 368cdf0e10cSrcweir pBIH->cclrImportant = 0; 369cdf0e10cSrcweir 370cdf0e10cSrcweir // Rest auf 0 setzen 371cdf0e10cSrcweir memset( (PBYTE) &pBIH->usUnits, 0, (PBYTE) pBI->argbColor - (PBYTE) &pBIH->usUnits ); 372cdf0e10cSrcweir 373cdf0e10cSrcweir if( nColors ) 374cdf0e10cSrcweir { 375cdf0e10cSrcweir const USHORT nMinCount = Min( nColors, rPal.GetEntryCount() ); 376cdf0e10cSrcweir 377cdf0e10cSrcweir if( nMinCount ) 378cdf0e10cSrcweir memcpy( pBI->argbColor, rPal.ImplGetColorBuffer(), nMinCount * sizeof( RGB2 ) ); 379cdf0e10cSrcweir } 380cdf0e10cSrcweir } 381cdf0e10cSrcweir } 382cdf0e10cSrcweir 383cdf0e10cSrcweir return hDIB; 384cdf0e10cSrcweir } 385cdf0e10cSrcweir 386cdf0e10cSrcweir // ------------------------------------------------------------------ 387cdf0e10cSrcweir 388cdf0e10cSrcweir HANDLE Os2SalBitmap::ImplCreateDIB4FromDIB1( HANDLE hDIB1 ) 389cdf0e10cSrcweir { 390cdf0e10cSrcweir PBITMAPINFO2 pBI = (PBITMAPINFO2) hDIB1; 391cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) pBI; 392cdf0e10cSrcweir PBYTE pBits = (PBYTE) pBI + *(ULONG*) pBIH + Os2SalBitmap::ImplGetDIBColorCount( hDIB1 ) * sizeof( RGB2 ); 393cdf0e10cSrcweir ULONG nWidth = pBIH->cx, nHeight = pBIH->cy; 394cdf0e10cSrcweir ULONG nAligned = AlignedWidth4Bytes( nWidth ); 395cdf0e10cSrcweir ULONG nAligned4 = AlignedWidth4Bytes( nWidth << 2 ); 396cdf0e10cSrcweir ULONG nSize4 = sizeof( BITMAPINFOHEADER2 ) + ( sizeof( RGB2 ) << 4 ) + nAligned4 * nHeight; 397cdf0e10cSrcweir PBYTE pDIB4 = (PBYTE) rtl_allocateZeroMemory( nSize4 ); 398cdf0e10cSrcweir PBITMAPINFO2 pBI4 = (PBITMAPINFO2) pDIB4; 399cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH4 = (PBITMAPINFOHEADER2) pBI4; 400cdf0e10cSrcweir BYTE aMap[ 4 ] = { 0x00, 0x01, 0x10, 0x11 }; 401cdf0e10cSrcweir 402cdf0e10cSrcweir memset( pBIH4, 0, sizeof( BITMAPINFOHEADER2 ) ); 403cdf0e10cSrcweir pBIH4->cbFix = sizeof( BITMAPINFOHEADER2 ); 404cdf0e10cSrcweir pBIH4->cx = nWidth; 405cdf0e10cSrcweir pBIH4->cy = nHeight; 406cdf0e10cSrcweir pBIH4->cPlanes = 1; 407cdf0e10cSrcweir pBIH4->cBitCount = 4; 408cdf0e10cSrcweir 409cdf0e10cSrcweir // die ersten beiden Eintraege der 1Bit-Farbtabelle kopieren 410cdf0e10cSrcweir memcpy( pBI4->argbColor, pBI->argbColor, sizeof( RGB2 ) << 1 ); 411cdf0e10cSrcweir 412cdf0e10cSrcweir PBYTE pBits4 = (PBYTE) pBI4 + *(ULONG*) pBIH4 + ( sizeof( RGB2 ) << 4 ); 413cdf0e10cSrcweir 414cdf0e10cSrcweir // 4Bit-DIB-Bilddaten setzen 415cdf0e10cSrcweir for( ULONG nY = 0UL; nY < nHeight; nY++ ) 416cdf0e10cSrcweir { 417cdf0e10cSrcweir PBYTE pTmp = pBits; pBits += nAligned; 418cdf0e10cSrcweir PBYTE pTmp4 = pBits4; pBits4 += nAligned4; 419cdf0e10cSrcweir 420cdf0e10cSrcweir for( ULONG nX = 0UL; nX < nWidth; nX += 8UL ) 421cdf0e10cSrcweir { 422cdf0e10cSrcweir *pTmp4++ = aMap[ ( *pTmp >> 6 ) & 3 ]; 423cdf0e10cSrcweir *pTmp4++ = aMap[ ( *pTmp >> 4 ) & 3 ]; 424cdf0e10cSrcweir *pTmp4++ = aMap[ ( *pTmp >> 2 ) & 3 ]; 425cdf0e10cSrcweir *pTmp4++ = aMap[ *pTmp++ & 3 ]; 426cdf0e10cSrcweir } 427cdf0e10cSrcweir } 428cdf0e10cSrcweir 429cdf0e10cSrcweir return (HANDLE) pDIB4; 430cdf0e10cSrcweir } 431cdf0e10cSrcweir 432cdf0e10cSrcweir // ------------------------------------------------------------------ 433cdf0e10cSrcweir 434cdf0e10cSrcweir HANDLE Os2SalBitmap::ImplCopyDIBOrDDB( HANDLE hHdl, BOOL bDIB ) 435cdf0e10cSrcweir { 436cdf0e10cSrcweir HANDLE hCopy = 0; 437cdf0e10cSrcweir 438cdf0e10cSrcweir if( bDIB && hHdl ) 439cdf0e10cSrcweir { 440cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) hHdl; 441cdf0e10cSrcweir const ULONG nSize = sizeof( BITMAPINFOHEADER2 ) 442cdf0e10cSrcweir + ImplGetDIBColorCount( hHdl ) * sizeof( RGB2 ) + 443cdf0e10cSrcweir ( pBIH->cbImage ? pBIH->cbImage : AlignedWidth4Bytes( pBIH->cx * pBIH->cBitCount ) ); 444cdf0e10cSrcweir 445cdf0e10cSrcweir BYTE* pCopy = (BYTE*)rtl_allocateZeroMemory( nSize ); 446cdf0e10cSrcweir memcpy( pCopy, (BYTE*) hHdl, nSize ); 447cdf0e10cSrcweir hCopy = (HANDLE) pCopy; 448cdf0e10cSrcweir } 449cdf0e10cSrcweir else if( hHdl ) 450cdf0e10cSrcweir { 451cdf0e10cSrcweir HAB hAB = GetSalData()->mhAB; 452cdf0e10cSrcweir HDC hSrcMemDC; 453cdf0e10cSrcweir HDC hDestMemDC; 454cdf0e10cSrcweir HPS hSrcMemPS; 455cdf0e10cSrcweir HPS hDestMemPS; 456cdf0e10cSrcweir HBITMAP hCopyBitmap; 457cdf0e10cSrcweir BITMAPINFOHEADER2 aInfoHeader; 458cdf0e10cSrcweir DEVOPENSTRUC aDevOpenStruc; 459cdf0e10cSrcweir SIZEL size; 460cdf0e10cSrcweir 461cdf0e10cSrcweir aInfoHeader.cbFix = sizeof( BITMAPINFOHEADER2 ); 462cdf0e10cSrcweir GpiQueryBitmapInfoHeader( hHdl, &aInfoHeader ); 463cdf0e10cSrcweir size.cx = aInfoHeader.cx; 464cdf0e10cSrcweir size.cy = aInfoHeader.cy; 465cdf0e10cSrcweir 466cdf0e10cSrcweir // Memory DCs erzeugen 467cdf0e10cSrcweir aDevOpenStruc.pszLogAddress = 0; 468cdf0e10cSrcweir aDevOpenStruc.pszDriverName = (PSZ)"DISPLAY"; 469cdf0e10cSrcweir 470cdf0e10cSrcweir hSrcMemDC = DevOpenDC( hAB, OD_MEMORY, (PSZ)"*", 2, (PDEVOPENDATA)&aDevOpenStruc, 0 ); 471cdf0e10cSrcweir hDestMemDC = DevOpenDC( hAB, OD_MEMORY, (PSZ)"*", 2, (PDEVOPENDATA)&aDevOpenStruc, 0 ); 472cdf0e10cSrcweir 473cdf0e10cSrcweir // Memory PSs erzeugen 474cdf0e10cSrcweir hSrcMemPS = Ft2CreatePS( hAB, hSrcMemDC, &size, GPIT_MICRO | GPIA_ASSOC | PU_PELS ); 475cdf0e10cSrcweir hDestMemPS = Ft2CreatePS( hAB, hDestMemDC, &size, GPIT_MICRO | GPIA_ASSOC | PU_PELS ); 476cdf0e10cSrcweir 477cdf0e10cSrcweir Ft2SetBitmap( hSrcMemPS, hHdl ); 478cdf0e10cSrcweir 479cdf0e10cSrcweir if( !hHdl ) 480cdf0e10cSrcweir { 481cdf0e10cSrcweir memset( &aInfoHeader, 0, sizeof( BITMAPINFOHEADER2 ) ); 482cdf0e10cSrcweir aInfoHeader.cbFix = sizeof( BITMAPINFOHEADER2 ); 483cdf0e10cSrcweir aInfoHeader.cx = 0; 484cdf0e10cSrcweir aInfoHeader.cy = 0; 485cdf0e10cSrcweir aInfoHeader.cPlanes = 1; 486cdf0e10cSrcweir aInfoHeader.cBitCount = 1; 487cdf0e10cSrcweir } 488cdf0e10cSrcweir 489cdf0e10cSrcweir hCopy = GpiCreateBitmap( hDestMemPS, &aInfoHeader, 0, NULL, NULL ); 490cdf0e10cSrcweir Ft2SetBitmap( hDestMemPS, hCopy ); 491cdf0e10cSrcweir 492cdf0e10cSrcweir POINTL pts[3]; 493cdf0e10cSrcweir 494cdf0e10cSrcweir pts[0].x = 0; 495cdf0e10cSrcweir pts[0].y = 0; 496cdf0e10cSrcweir pts[1].x = size.cx; 497cdf0e10cSrcweir pts[1].y = size.cy; 498cdf0e10cSrcweir pts[2].x = 0; 499cdf0e10cSrcweir pts[2].y = 0; 500cdf0e10cSrcweir 501cdf0e10cSrcweir GpiBitBlt( hDestMemPS, hSrcMemPS, 3, pts, ROP_SRCCOPY, BBO_IGNORE ); 502cdf0e10cSrcweir 503cdf0e10cSrcweir Ft2SetBitmap( hSrcMemPS, (HBITMAP)0L); 504cdf0e10cSrcweir Ft2SetBitmap( hDestMemPS, (HBITMAP)0L); 505cdf0e10cSrcweir Ft2Associate( hSrcMemPS, NULLHANDLE ); 506cdf0e10cSrcweir Ft2Associate( hDestMemPS, NULLHANDLE ); 507cdf0e10cSrcweir Ft2DestroyPS( hSrcMemPS ); 508cdf0e10cSrcweir Ft2DestroyPS( hDestMemPS ); 509cdf0e10cSrcweir DevCloseDC( hSrcMemDC ); 510cdf0e10cSrcweir DevCloseDC( hDestMemDC ); 511cdf0e10cSrcweir } 512cdf0e10cSrcweir 513cdf0e10cSrcweir return hCopy; 514cdf0e10cSrcweir } 515cdf0e10cSrcweir 516cdf0e10cSrcweir // ------------------------------------------------------------------ 517cdf0e10cSrcweir 518cdf0e10cSrcweir BitmapBuffer* Os2SalBitmap::AcquireBuffer( bool bReadOnly ) 519cdf0e10cSrcweir { 520cdf0e10cSrcweir BitmapBuffer* pBuffer = NULL; 521cdf0e10cSrcweir 522cdf0e10cSrcweir if( mhDIB ) 523cdf0e10cSrcweir { 524cdf0e10cSrcweir // bitmap infos can be found at the beginning of the memory 525cdf0e10cSrcweir PBITMAPINFO2 pBI = (PBITMAPINFO2) mhDIB; 526cdf0e10cSrcweir PBITMAPINFOHEADER2 pBIH = (PBITMAPINFOHEADER2) pBI; 527cdf0e10cSrcweir 528cdf0e10cSrcweir if( ( pBIH->ulCompression == BCA_RLE4 ) || ( pBIH->ulCompression == BCA_RLE8 ) ) 529cdf0e10cSrcweir { 530cdf0e10cSrcweir Size aSizePix( pBIH->cx, pBIH->cy ); 531cdf0e10cSrcweir HANDLE hNewDIB = ImplCreateDIB( aSizePix, pBIH->cBitCount, BitmapPalette() ); 532cdf0e10cSrcweir 533cdf0e10cSrcweir if( hNewDIB ) 534cdf0e10cSrcweir { 535cdf0e10cSrcweir // bitmap infos can be found at the beginning of the memory 536cdf0e10cSrcweir PBITMAPINFO2 pNewBI = (PBITMAPINFO2) hNewDIB; 537cdf0e10cSrcweir PBITMAPINFOHEADER2 pNewBIH = (PBITMAPINFOHEADER2) pNewBI; 538cdf0e10cSrcweir const USHORT nColorCount = ImplGetDIBColorCount( hNewDIB ); 539cdf0e10cSrcweir const ULONG nOffset = *(ULONG*) pBI + nColorCount * sizeof( RGB2 ); 540cdf0e10cSrcweir BYTE* pOldBits = (BYTE*) pBI + nOffset; 541cdf0e10cSrcweir BYTE* pNewBits = (BYTE*) pNewBI + nOffset; 542cdf0e10cSrcweir 543cdf0e10cSrcweir memcpy( pNewBI, pBI, nOffset ); 544cdf0e10cSrcweir pNewBIH->ulCompression = 0; 545cdf0e10cSrcweir ImplDecodeRLEBuffer( pOldBits, pNewBits, aSizePix, pBIH->ulCompression == BCA_RLE4 ); 546cdf0e10cSrcweir 547cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB ); 548cdf0e10cSrcweir 549cdf0e10cSrcweir mhDIB = hNewDIB; 550cdf0e10cSrcweir pBI = pNewBI; 551cdf0e10cSrcweir pBIH = pNewBIH; 552cdf0e10cSrcweir } 553cdf0e10cSrcweir } 554cdf0e10cSrcweir 555cdf0e10cSrcweir if( pBIH->cPlanes == 1 ) 556cdf0e10cSrcweir { 557cdf0e10cSrcweir pBuffer = new BitmapBuffer; 558cdf0e10cSrcweir 559cdf0e10cSrcweir pBuffer->mnFormat = BMP_FORMAT_BOTTOM_UP | 560cdf0e10cSrcweir ( pBIH->cBitCount == 1 ? BMP_FORMAT_1BIT_MSB_PAL : 561cdf0e10cSrcweir pBIH->cBitCount == 4 ? BMP_FORMAT_4BIT_MSN_PAL : 562cdf0e10cSrcweir pBIH->cBitCount == 8 ? BMP_FORMAT_8BIT_PAL : 563cdf0e10cSrcweir pBIH->cBitCount == 16 ? BMP_FORMAT_16BIT_TC_LSB_MASK : 564cdf0e10cSrcweir pBIH->cBitCount == 24 ? BMP_FORMAT_24BIT_TC_BGR : 565cdf0e10cSrcweir pBIH->cBitCount == 32 ? BMP_FORMAT_32BIT_TC_MASK : 0UL ); 566cdf0e10cSrcweir 567cdf0e10cSrcweir if( BMP_SCANLINE_FORMAT( pBuffer->mnFormat ) ) 568cdf0e10cSrcweir { 569cdf0e10cSrcweir pBuffer->mnWidth = maSize.Width(); 570cdf0e10cSrcweir pBuffer->mnHeight = maSize.Height(); 571cdf0e10cSrcweir pBuffer->mnScanlineSize = AlignedWidth4Bytes( maSize.Width() * pBIH->cBitCount ); 572cdf0e10cSrcweir pBuffer->mnBitCount = (USHORT) pBIH->cBitCount; 573cdf0e10cSrcweir 574cdf0e10cSrcweir if( pBuffer->mnBitCount <= 8 ) 575cdf0e10cSrcweir { 576cdf0e10cSrcweir const USHORT nPalCount = ImplGetDIBColorCount( mhDIB ); 577cdf0e10cSrcweir 578cdf0e10cSrcweir pBuffer->maPalette.SetEntryCount( nPalCount ); 579cdf0e10cSrcweir 580cdf0e10cSrcweir if( nPalCount ) 581cdf0e10cSrcweir memcpy( pBuffer->maPalette.ImplGetColorBuffer(), pBI->argbColor, nPalCount * sizeof( RGB2 ) ); 582cdf0e10cSrcweir 583cdf0e10cSrcweir pBuffer->mpBits = (BYTE*) pBI + *(ULONG*) pBI + nPalCount * sizeof( RGB2 ); 584cdf0e10cSrcweir } 585cdf0e10cSrcweir else 586cdf0e10cSrcweir pBuffer->mpBits = (BYTE*) pBI + *(ULONG*) pBI; 587cdf0e10cSrcweir } 588cdf0e10cSrcweir else 589cdf0e10cSrcweir { 590cdf0e10cSrcweir delete pBuffer; 591cdf0e10cSrcweir pBuffer = NULL; 592cdf0e10cSrcweir } 593cdf0e10cSrcweir } 594cdf0e10cSrcweir } 595cdf0e10cSrcweir 596cdf0e10cSrcweir if( pBuffer && mhDIB1Subst ) 597cdf0e10cSrcweir { 598cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB1Subst ); 599cdf0e10cSrcweir mhDIB1Subst = 0; 600cdf0e10cSrcweir } 601cdf0e10cSrcweir 602cdf0e10cSrcweir return pBuffer; 603cdf0e10cSrcweir } 604cdf0e10cSrcweir 605cdf0e10cSrcweir // ------------------------------------------------------------------ 606cdf0e10cSrcweir 607cdf0e10cSrcweir void Os2SalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, bool bReadOnly ) 608cdf0e10cSrcweir { 609cdf0e10cSrcweir if( pBuffer ) 610cdf0e10cSrcweir { 611cdf0e10cSrcweir if( mhDIB ) 612cdf0e10cSrcweir { 613cdf0e10cSrcweir if( !bReadOnly && !!pBuffer->maPalette ) 614cdf0e10cSrcweir { 615cdf0e10cSrcweir // bitmap infos can be found at the beginning of the memory 616cdf0e10cSrcweir PBITMAPINFO2 pBI = (PBITMAPINFO2) mhDIB; 617cdf0e10cSrcweir const USHORT nCount = pBuffer->maPalette.GetEntryCount(); 618cdf0e10cSrcweir 619cdf0e10cSrcweir if( nCount ) 620cdf0e10cSrcweir memcpy( pBI->argbColor, pBuffer->maPalette.ImplGetColorBuffer(), nCount * sizeof( RGB2 ) ); 621cdf0e10cSrcweir } 622cdf0e10cSrcweir } 623cdf0e10cSrcweir 624cdf0e10cSrcweir delete pBuffer; 625cdf0e10cSrcweir } 626cdf0e10cSrcweir } 627cdf0e10cSrcweir 628cdf0e10cSrcweir // ------------------------------------------------------------------ 629cdf0e10cSrcweir 630cdf0e10cSrcweir void Os2SalBitmap::ImplDecodeRLEBuffer( const BYTE* pSrcBuf, BYTE* pDstBuf, 631cdf0e10cSrcweir const Size& rSizePixel, BOOL bRLE4 ) 632cdf0e10cSrcweir { 633cdf0e10cSrcweir HPBYTE pRLE = (HPBYTE) pSrcBuf; 634cdf0e10cSrcweir HPBYTE pDIB = (HPBYTE) pDstBuf; 635cdf0e10cSrcweir HPBYTE pRow = (HPBYTE) pDstBuf; 636cdf0e10cSrcweir ULONG nWidthAl = AlignedWidth4Bytes( rSizePixel.Width() * ( bRLE4 ? 4UL : 8UL ) ); 637cdf0e10cSrcweir HPBYTE pLast = pDIB + rSizePixel.Height() * nWidthAl - 1; 638cdf0e10cSrcweir ULONG nCountByte; 639cdf0e10cSrcweir ULONG nRunByte; 640cdf0e10cSrcweir ULONG nX = 0; 641cdf0e10cSrcweir ULONG i; 642cdf0e10cSrcweir BYTE cTmp; 643cdf0e10cSrcweir BOOL bEndDecoding = FALSE; 644cdf0e10cSrcweir 645cdf0e10cSrcweir if( pRLE && pDIB ) 646cdf0e10cSrcweir { 647cdf0e10cSrcweir do 648cdf0e10cSrcweir { 649cdf0e10cSrcweir if( !( nCountByte = *pRLE++ ) ) 650cdf0e10cSrcweir { 651cdf0e10cSrcweir nRunByte = *pRLE++; 652cdf0e10cSrcweir 653cdf0e10cSrcweir if( nRunByte > 2UL ) 654cdf0e10cSrcweir { 655cdf0e10cSrcweir if( bRLE4 ) 656cdf0e10cSrcweir { 657cdf0e10cSrcweir nCountByte = nRunByte >> 1UL; 658cdf0e10cSrcweir 659cdf0e10cSrcweir for( i = 0; i < nCountByte; i++ ) 660cdf0e10cSrcweir { 661cdf0e10cSrcweir cTmp = *pRLE++; 662cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, cTmp >> 4 ); 663cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, cTmp & 0x0f ); 664cdf0e10cSrcweir } 665cdf0e10cSrcweir 666cdf0e10cSrcweir if( nRunByte & 1 ) 667cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, *pRLE++ >> 4 ); 668cdf0e10cSrcweir 669cdf0e10cSrcweir if( ( ( nRunByte + 1 ) >> 1 ) & 1 ) 670cdf0e10cSrcweir pRLE++; 671cdf0e10cSrcweir } 672cdf0e10cSrcweir else 673cdf0e10cSrcweir { 674cdf0e10cSrcweir memcpy( &pDIB[ nX ], pRLE, nRunByte ); 675cdf0e10cSrcweir pRLE += nRunByte; 676cdf0e10cSrcweir nX += nRunByte; 677cdf0e10cSrcweir 678cdf0e10cSrcweir if( nRunByte & 1 ) 679cdf0e10cSrcweir pRLE++; 680cdf0e10cSrcweir } 681cdf0e10cSrcweir } 682cdf0e10cSrcweir else if( !nRunByte ) 683cdf0e10cSrcweir { 684cdf0e10cSrcweir pDIB = ( pRow += nWidthAl ); 685cdf0e10cSrcweir nX = 0UL; 686cdf0e10cSrcweir } 687cdf0e10cSrcweir else if( nRunByte == 1 ) 688cdf0e10cSrcweir bEndDecoding = TRUE; 689cdf0e10cSrcweir else 690cdf0e10cSrcweir { 691cdf0e10cSrcweir nX += *pRLE++; 692cdf0e10cSrcweir pDIB = ( pRow += ( *pRLE++ ) * nWidthAl ); 693cdf0e10cSrcweir } 694cdf0e10cSrcweir } 695cdf0e10cSrcweir else 696cdf0e10cSrcweir { 697cdf0e10cSrcweir cTmp = *pRLE++; 698cdf0e10cSrcweir 699cdf0e10cSrcweir if( bRLE4 ) 700cdf0e10cSrcweir { 701cdf0e10cSrcweir nRunByte = nCountByte >> 1; 702cdf0e10cSrcweir 703cdf0e10cSrcweir for( i = 0; i < nRunByte; i++ ) 704cdf0e10cSrcweir { 705cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, cTmp >> 4 ); 706cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, cTmp & 0x0f ); 707cdf0e10cSrcweir } 708cdf0e10cSrcweir 709cdf0e10cSrcweir if( nCountByte & 1 ) 710cdf0e10cSrcweir ImplSetPixel4( pDIB, nX++, cTmp >> 4 ); 711cdf0e10cSrcweir } 712cdf0e10cSrcweir else 713cdf0e10cSrcweir { 714cdf0e10cSrcweir for( i = 0; i < nCountByte; i++ ) 715cdf0e10cSrcweir pDIB[ nX++ ] = cTmp; 716cdf0e10cSrcweir } 717cdf0e10cSrcweir } 718cdf0e10cSrcweir } 719cdf0e10cSrcweir while( !bEndDecoding && ( pDIB <= pLast ) ); 720cdf0e10cSrcweir } 721cdf0e10cSrcweir } 722cdf0e10cSrcweir 723cdf0e10cSrcweir bool Os2SalBitmap::GetSystemData( BitmapSystemData& rData ) 724cdf0e10cSrcweir { 725cdf0e10cSrcweir bool bRet = false; 726cdf0e10cSrcweir if( mhDIB || mhDDB ) 727cdf0e10cSrcweir { 728cdf0e10cSrcweir bRet = true; 729cdf0e10cSrcweir rData.pDIB = (void*)mhDIB; 730cdf0e10cSrcweir rData.pDDB = (void*)mhDDB; 731cdf0e10cSrcweir } 732cdf0e10cSrcweir return bRet; 733cdf0e10cSrcweir } 734