19f62ea84SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
39f62ea84SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
49f62ea84SAndrew Rist * or more contributor license agreements. See the NOTICE file
59f62ea84SAndrew Rist * distributed with this work for additional information
69f62ea84SAndrew Rist * regarding copyright ownership. The ASF licenses this file
79f62ea84SAndrew Rist * to you under the Apache License, Version 2.0 (the
89f62ea84SAndrew Rist * "License"); you may not use this file except in compliance
99f62ea84SAndrew Rist * with the License. You may obtain a copy of the License at
109f62ea84SAndrew Rist *
119f62ea84SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
129f62ea84SAndrew Rist *
139f62ea84SAndrew Rist * Unless required by applicable law or agreed to in writing,
149f62ea84SAndrew Rist * software distributed under the License is distributed on an
159f62ea84SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
169f62ea84SAndrew Rist * KIND, either express or implied. See the License for the
179f62ea84SAndrew Rist * specific language governing permissions and limitations
189f62ea84SAndrew Rist * under the License.
199f62ea84SAndrew Rist *
209f62ea84SAndrew Rist *************************************************************/
219f62ea84SAndrew Rist
229f62ea84SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include <svpm.h>
25cdf0e10cSrcweir
26cdf0e10cSrcweir #define _SV_SALBMP_CXX
27cdf0e10cSrcweir #include <rtl/alloc.h>
28cdf0e10cSrcweir #include <vcl/salbtype.hxx>
29*fc9fd3f1SPedro Giffuni #include <os2/salgdi.h>
30*fc9fd3f1SPedro Giffuni #include <os2/saldata.hxx>
31*fc9fd3f1SPedro Giffuni #include <os2/salbmp.h>
32cdf0e10cSrcweir #include <vcl/bitmap.hxx> // for BitmapSystemData
33cdf0e10cSrcweir #include <string.h>
34cdf0e10cSrcweir
35cdf0e10cSrcweir #ifndef __H_FT2LIB
36*fc9fd3f1SPedro Giffuni #include <os2/wingdi.h>
37cdf0e10cSrcweir #include <ft2lib.h>
38cdf0e10cSrcweir #endif
39cdf0e10cSrcweir
40cdf0e10cSrcweir // -----------
41cdf0e10cSrcweir // - Inlines -
42cdf0e10cSrcweir // -----------
43cdf0e10cSrcweir
ImplSetPixel4(const HPBYTE pScanline,long nX,const PM_BYTE cIndex)44*fc9fd3f1SPedro Giffuni inline void ImplSetPixel4( const HPBYTE pScanline, long nX, const PM_BYTE cIndex )
45cdf0e10cSrcweir {
46*fc9fd3f1SPedro Giffuni PM_BYTE rByte = pScanline[ nX >> 1 ];
47cdf0e10cSrcweir
48*fc9fd3f1SPedro Giffuni ( nX & 1 ) ? ( rByte &= 0xf0, rByte |= ( cIndex & 0x0f ) ) :
49*fc9fd3f1SPedro Giffuni ( rByte &= 0x0f, rByte |= ( cIndex << 4 ) );
50cdf0e10cSrcweir }
51cdf0e10cSrcweir
52cdf0e10cSrcweir // -------------
53cdf0e10cSrcweir // - Os2SalBitmap -
54cdf0e10cSrcweir // -------------
55cdf0e10cSrcweir
Os2SalBitmap()56cdf0e10cSrcweir Os2SalBitmap::Os2SalBitmap() :
57cdf0e10cSrcweir mhDIB ( 0 ),
58cdf0e10cSrcweir mhDIB1Subst ( 0 ),
59cdf0e10cSrcweir mhDDB ( 0 ),
60cdf0e10cSrcweir mnBitCount ( 0 )
61cdf0e10cSrcweir {
62cdf0e10cSrcweir }
63cdf0e10cSrcweir
64cdf0e10cSrcweir // ------------------------------------------------------------------
65cdf0e10cSrcweir
~Os2SalBitmap()66cdf0e10cSrcweir Os2SalBitmap::~Os2SalBitmap()
67cdf0e10cSrcweir {
68cdf0e10cSrcweir Destroy();
69cdf0e10cSrcweir }
70cdf0e10cSrcweir
71cdf0e10cSrcweir // ------------------------------------------------------------------
72cdf0e10cSrcweir
Create(HANDLE hBitmap,bool bDIB,bool bCopyHandle)73cdf0e10cSrcweir bool Os2SalBitmap::Create( HANDLE hBitmap, bool bDIB, bool bCopyHandle )
74cdf0e10cSrcweir {
75*fc9fd3f1SPedro Giffuni sal_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
Create(const Size & rSize,USHORT nBitCount,const BitmapPalette & rPal)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
Create(const SalBitmap & rSSalBitmap)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
Create(const SalBitmap & rSSalBmp,SalGraphics * pSGraphics)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
Create(const SalBitmap & rSSalBmp,USHORT nNewBitCount)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
Destroy()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
ImplReplacehDIB1Subst(HANDLE hDIB1Subst)306cdf0e10cSrcweir void Os2SalBitmap::ImplReplacehDIB1Subst( HANDLE hDIB1Subst )
307cdf0e10cSrcweir {
308cdf0e10cSrcweir if( mhDIB1Subst )
309cdf0e10cSrcweir rtl_freeMemory( (void*)mhDIB1Subst );
310cdf0e10cSrcweir
311cdf0e10cSrcweir mhDIB1Subst = hDIB1Subst;
312cdf0e10cSrcweir }
313cdf0e10cSrcweir
314cdf0e10cSrcweir // ------------------------------------------------------------------
315cdf0e10cSrcweir
ImplGetDIBColorCount(HANDLE hDIB)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
ImplCreateDIB(const Size & rSize,USHORT nBits,const BitmapPalette & rPal)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
ImplCreateDIB4FromDIB1(HANDLE hDIB1)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;
400*fc9fd3f1SPedro Giffuni PM_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
ImplCopyDIBOrDDB(HANDLE hHdl,bool bDIB)434*fc9fd3f1SPedro Giffuni 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
445*fc9fd3f1SPedro Giffuni PM_BYTE* pCopy = (PM_BYTE*)rtl_allocateZeroMemory( nSize );
446*fc9fd3f1SPedro Giffuni memcpy( pCopy, (PM_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
AcquireBuffer(bool bReadOnly)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 );
540*fc9fd3f1SPedro Giffuni PM_BYTE* pOldBits = (PM_BYTE*) pBI + nOffset;
541*fc9fd3f1SPedro Giffuni PM_BYTE* pNewBits = (PM_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
583*fc9fd3f1SPedro Giffuni pBuffer->mpBits = (sal_uInt8*) pBI + *(ULONG*) pBI + nPalCount * sizeof( RGB2 );
584cdf0e10cSrcweir }
585cdf0e10cSrcweir else
586*fc9fd3f1SPedro Giffuni pBuffer->mpBits = (sal_uInt8*) 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
ReleaseBuffer(BitmapBuffer * pBuffer,bool bReadOnly)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
ImplDecodeRLEBuffer(const PM_BYTE * pSrcBuf,PM_BYTE * pDstBuf,const Size & rSizePixel,bool bRLE4)630*fc9fd3f1SPedro Giffuni void Os2SalBitmap::ImplDecodeRLEBuffer( const PM_BYTE* pSrcBuf, PM_BYTE* pDstBuf,
631*fc9fd3f1SPedro Giffuni 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;
642*fc9fd3f1SPedro Giffuni PM_BYTE cTmp;
643*fc9fd3f1SPedro Giffuni sal_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
GetSystemData(BitmapSystemData & rData)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