?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Branch libreoffice-5-0-4
[LibreOffice.git] / vcl / win / source / gdi / salgdi.cxx
blob3ed0c073c05c693adfeb278759c15729454137a8
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 <stdio.h>
21 #include <string.h>
22 #include <svsys.h>
23 #include <rtl/strbuf.hxx>
24 #include <tools/debug.hxx>
25 #include <tools/poly.hxx>
26 #include <basegfx/polygon/b2dpolygon.hxx>
27 #include <basegfx/polygon/b2dpolygontools.hxx>
28 #include <basegfx/polygon/b2dpolypolygontools.hxx>
29 #include <win/wincomp.hxx>
30 #include <win/saldata.hxx>
31 #include <win/salgdi.h>
32 #include <win/salframe.h>
33 #include <win/salvd.h>
34 #include <basegfx/matrix/b2dhommatrixtools.hxx>
35
36 #include "salgdiimpl.hxx"
37 #include "gdiimpl.hxx"
38 #include "opengl/win/gdiimpl.hxx"
39 #include <config_cairo_canvas.h>
40 #if ENABLE_CAIRO_CANVAS
41 #include "cairo_win32_cairo.cxx"
42 #endif
43
44 #include <vcl/opengl/OpenGLHelper.hxx>
45
46
47 #define DITHER_PAL_DELTA 51
48 #define DITHER_PAL_STEPS 6
49 #define DITHER_PAL_COUNT (DITHER_PAL_STEPS*DITHER_PAL_STEPS*DITHER_PAL_STEPS)
50 #define DITHER_MAX_SYSCOLOR 16
51 #define DITHER_EXTRA_COLORS 1
52 #define DMAP( _def_nVal, _def_nThres ) ((pDitherDiff[_def_nVal]>(_def_nThres))?pDitherHigh[_def_nVal]:pDitherLow[_def_nVal])
53
54 struct SysColorEntry
55 {
56 DWORD nRGB;
57 SysColorEntry* pNext;
58 };
59
60 static SysColorEntry* pFirstSysColor = NULL;
61 static SysColorEntry* pActSysColor = NULL;
62
63 // Blue7
64 static PALETTEENTRY aImplExtraColor1 =
65 {
66 0, 184, 255, 0
67 };
68
69 static PALETTEENTRY aImplSalSysPalEntryAry[ DITHER_MAX_SYSCOLOR ] =
70 {
71 { 0, 0, 0, 0 },
72 { 0, 0, 0x80, 0 },
73 { 0, 0x80, 0, 0 },
74 { 0, 0x80, 0x80, 0 },
75 { 0x80, 0, 0, 0 },
76 { 0x80, 0, 0x80, 0 },
77 { 0x80, 0x80, 0, 0 },
78 { 0x80, 0x80, 0x80, 0 },
79 { 0xC0, 0xC0, 0xC0, 0 },
80 { 0, 0, 0xFF, 0 },
81 { 0, 0xFF, 0, 0 },
82 { 0, 0xFF, 0xFF, 0 },
83 { 0xFF, 0, 0, 0 },
84 { 0xFF, 0, 0xFF, 0 },
85 { 0xFF, 0xFF, 0, 0 },
86 { 0xFF, 0xFF, 0xFF, 0 }
87 };
88
89 static BYTE aOrdDither8Bit[8][8] =
90 {
91 { 0, 38, 9, 48, 2, 40, 12, 50 },
92 { 25, 12, 35, 22, 28, 15, 37, 24 },
93 { 6, 44, 3, 41, 8, 47, 5, 44 },
94 { 32, 19, 28, 16, 34, 21, 31, 18 },
95 { 1, 40, 11, 49, 0, 39, 10, 48 },
96 { 27, 14, 36, 24, 26, 13, 36, 23 },
97 { 8, 46, 4, 43, 7, 45, 4, 42 },
98 { 33, 20, 30, 17, 32, 20, 29, 16 }
99 };
100
101 static BYTE aOrdDither16Bit[8][8] =
102 {
103 { 0, 6, 1, 7, 0, 6, 1, 7 },
104 { 4, 2, 5, 3, 4, 2, 5, 3 },
105 { 1, 7, 0, 6, 1, 7, 0, 6 },
106 { 5, 3, 4, 2, 5, 3, 4, 2 },
107 { 0, 6, 1, 7, 0, 6, 1, 7 },
108 { 4, 2, 5, 3, 4, 2, 5, 3 },
109 { 1, 7, 0, 6, 1, 7, 0, 6 },
110 { 5, 3, 4, 2, 5, 3, 4, 2 }
111 };
112
113 // we must create pens with 1-pixel width; otherwise the S3-graphics card
114 // map has many paint problems when drawing polygons/polyLines and a
115 // complex is set
116 #define GSL_PEN_WIDTH 1
117
118 void ImplInitSalGDI()
119 {
120 SalData* pSalData = GetSalData();
121
122 pSalData->mbResourcesAlreadyFreed = false;
123
124 // init stock brushes
125 pSalData->maStockPenColorAry[0] = PALETTERGB( 0, 0, 0 );
126 pSalData->maStockPenColorAry[1] = PALETTERGB( 0xFF, 0xFF, 0xFF );
127 pSalData->maStockPenColorAry[2] = PALETTERGB( 0xC0, 0xC0, 0xC0 );
128 pSalData->maStockPenColorAry[3] = PALETTERGB( 0x80, 0x80, 0x80 );
129 pSalData->mhStockPenAry[0] = CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[0] );
130 pSalData->mhStockPenAry[1] = CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[1] );
131 pSalData->mhStockPenAry[2] = CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[2] );
132 pSalData->mhStockPenAry[3] = CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[3] );
133 pSalData->mnStockPenCount = 4;
134
135 pSalData->maStockBrushColorAry[0] = PALETTERGB( 0, 0, 0 );
136 pSalData->maStockBrushColorAry[1] = PALETTERGB( 0xFF, 0xFF, 0xFF );
137 pSalData->maStockBrushColorAry[2] = PALETTERGB( 0xC0, 0xC0, 0xC0 );
138 pSalData->maStockBrushColorAry[3] = PALETTERGB( 0x80, 0x80, 0x80 );
139 pSalData->mhStockBrushAry[0] = CreateSolidBrush( pSalData->maStockBrushColorAry[0] );
140 pSalData->mhStockBrushAry[1] = CreateSolidBrush( pSalData->maStockBrushColorAry[1] );
141 pSalData->mhStockBrushAry[2] = CreateSolidBrush( pSalData->maStockBrushColorAry[2] );
142 pSalData->mhStockBrushAry[3] = CreateSolidBrush( pSalData->maStockBrushColorAry[3] );
143 pSalData->mnStockBrushCount = 4;
144
145 // initialize cache of device contexts
146 pSalData->mpHDCCache = new HDCCache[ CACHESIZE_HDC ];
147 memset( pSalData->mpHDCCache, 0, CACHESIZE_HDC * sizeof( HDCCache ) );
148
149 // initialize temporary font list
150 pSalData->mpTempFontItem = NULL;
151
152 // support palettes for 256 color displays
153 HDC hDC = GetDC( 0 );
154 int nBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
155 int nPlanes = GetDeviceCaps( hDC, PLANES );
156 int nRasterCaps = GetDeviceCaps( hDC, RASTERCAPS );
157 int nBitCount = nBitsPixel * nPlanes;
158
159 if ( (nBitCount > 8) && (nBitCount < 24) )
160 {
161 // test if we have to dither
162 HDC hMemDC = ::CreateCompatibleDC( hDC );
163 HBITMAP hMemBmp = ::CreateCompatibleBitmap( hDC, 8, 8 );
164 HBITMAP hBmpOld = (HBITMAP) ::SelectObject( hMemDC, hMemBmp );
165 HBRUSH hMemBrush = ::CreateSolidBrush( PALETTERGB( 175, 171, 169 ) );
166 HBRUSH hBrushOld = (HBRUSH) ::SelectObject( hMemDC, hMemBrush );
167 bool bDither16 = TRUE;
168
169 ::PatBlt( hMemDC, 0, 0, 8, 8, PATCOPY );
170 const COLORREF aCol( ::GetPixel( hMemDC, 0, 0 ) );
171
172 for( int nY = 0; ( nY < 8 ) && bDither16; nY++ )
173 for( int nX = 0; ( nX < 8 ) && bDither16; nX++ )
174 if( ::GetPixel( hMemDC, nX, nY ) != aCol )
175 bDither16 = FALSE;
176
177 ::SelectObject( hMemDC, hBrushOld ), ::DeleteObject( hMemBrush );
178 ::SelectObject( hMemDC, hBmpOld ), ::DeleteObject( hMemBmp );
179 ::DeleteDC( hMemDC );
180
181 if( bDither16 )
182 {
183 // create DIBPattern for 16Bit dithering
184 long n;
185
186 pSalData->mhDitherDIB = GlobalAlloc( GMEM_FIXED, sizeof( BITMAPINFOHEADER ) + 192 );
187 pSalData->mpDitherDIB = (BYTE*) GlobalLock( pSalData->mhDitherDIB );
188 pSalData->mpDitherDiff = new long[ 256 ];
189 pSalData->mpDitherLow = new BYTE[ 256 ];
190 pSalData->mpDitherHigh = new BYTE[ 256 ];
191 pSalData->mpDitherDIBData = pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER );
192 memset( pSalData->mpDitherDIB, 0, sizeof( BITMAPINFOHEADER ) );
193
194 BITMAPINFOHEADER* pBIH = (BITMAPINFOHEADER*) pSalData->mpDitherDIB;
195
196 pBIH->biSize = sizeof( BITMAPINFOHEADER );
197 pBIH->biWidth = 8;
198 pBIH->biHeight = 8;
199 pBIH->biPlanes = 1;
200 pBIH->biBitCount = 24;
201
202 for( n = 0; n < 256L; n++ )
203 pSalData->mpDitherDiff[ n ] = n - ( n & 248L );
204
205 for( n = 0; n < 256L; n++ )
206 pSalData->mpDitherLow[ n ] = (BYTE) ( n & 248 );
207
208 for( n = 0; n < 256L; n++ )
209 pSalData->mpDitherHigh[ n ] = (BYTE) std::min( pSalData->mpDitherLow[ n ] + 8L, 255L );
210 }
211 }
212 else if ( (nRasterCaps & RC_PALETTE) && (nBitCount == 8) )
213 {
214 BYTE nRed, nGreen, nBlue;
215 BYTE nR, nG, nB;
216 PALETTEENTRY* pPalEntry;
217 LOGPALETTE* pLogPal;
218 const sal_uInt16 nDitherPalCount = DITHER_PAL_COUNT;
219 sal_uLong nTotalCount = DITHER_MAX_SYSCOLOR + nDitherPalCount + DITHER_EXTRA_COLORS;
220
221 // create logical palette
222 pLogPal = (LOGPALETTE*) new char[ sizeof( LOGPALETTE ) + ( nTotalCount * sizeof( PALETTEENTRY ) ) ];
223 pLogPal->palVersion = 0x0300;
224 pLogPal->palNumEntries = (sal_uInt16) nTotalCount;
225 pPalEntry = pLogPal->palPalEntry;
226
227 // Standard colors
228 memcpy( pPalEntry, aImplSalSysPalEntryAry, DITHER_MAX_SYSCOLOR * sizeof( PALETTEENTRY ) );
229 pPalEntry += DITHER_MAX_SYSCOLOR;
230
231 // own palette (6/6/6)
232 for( nB=0, nBlue=0; nB < DITHER_PAL_STEPS; nB++, nBlue += DITHER_PAL_DELTA )
233 {
234 for( nG=0, nGreen=0; nG < DITHER_PAL_STEPS; nG++, nGreen += DITHER_PAL_DELTA )
235 {
236 for( nR=0, nRed=0; nR < DITHER_PAL_STEPS; nR++, nRed += DITHER_PAL_DELTA )
237 {
238 pPalEntry->peRed = nRed;
239 pPalEntry->peGreen = nGreen;
240 pPalEntry->peBlue = nBlue;
241 pPalEntry->peFlags = 0;
242 pPalEntry++;
243 }
244 }
245 }
246
247 // insert special 'Blue' as standard drawing color
248 *pPalEntry++ = aImplExtraColor1;
249
250 // create palette
251 pSalData->mhDitherPal = CreatePalette( pLogPal );
252 delete[] (char*) pLogPal;
253
254 if( pSalData->mhDitherPal )
255 {
256 // create DIBPattern for 8Bit dithering
257 long nSize = sizeof( BITMAPINFOHEADER ) + ( 256 * sizeof( short ) ) + 64;
258 long n;
259
260 pSalData->mhDitherDIB = GlobalAlloc( GMEM_FIXED, nSize );
261 pSalData->mpDitherDIB = (BYTE*) GlobalLock( pSalData->mhDitherDIB );
262 pSalData->mpDitherDiff = new long[ 256 ];
263 pSalData->mpDitherLow = new BYTE[ 256 ];
264 pSalData->mpDitherHigh = new BYTE[ 256 ];
265 pSalData->mpDitherDIBData = pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER ) + ( 256 * sizeof( short ) );
266 memset( pSalData->mpDitherDIB, 0, sizeof( BITMAPINFOHEADER ) );
267
268 BITMAPINFOHEADER* pBIH = (BITMAPINFOHEADER*) pSalData->mpDitherDIB;
269 short* pColors = (short*) ( pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER ) );
270
271 pBIH->biSize = sizeof( BITMAPINFOHEADER );
272 pBIH->biWidth = 8;
273 pBIH->biHeight = 8;
274 pBIH->biPlanes = 1;
275 pBIH->biBitCount = 8;
276
277 for( n = 0; n < nDitherPalCount; n++ )
278 pColors[ n ] = (short)( n + DITHER_MAX_SYSCOLOR );
279
280 for( n = 0; n < 256L; n++ )
281 pSalData->mpDitherDiff[ n ] = n % 51L;
282
283 for( n = 0; n < 256L; n++ )
284 pSalData->mpDitherLow[ n ] = (BYTE) ( n / 51L );
285
286 for( n = 0; n < 256L; n++ )
287 pSalData->mpDitherHigh[ n ] = (BYTE)std::min( pSalData->mpDitherLow[ n ] + 1, 5 );
288 }
289
290 // get system color entries
291 ImplUpdateSysColorEntries();
292 }
293
294 ReleaseDC( 0, hDC );
295 }
296
297 void ImplFreeSalGDI()
298 {
299 SalData* pSalData = GetSalData();
300
301 if (pSalData->mbResourcesAlreadyFreed)
302 return;
303
304 // destroy stock objects
305 int i;
306 for ( i = 0; i < pSalData->mnStockPenCount; i++ )
307 DeletePen( pSalData->mhStockPenAry[i] );
308 for ( i = 0; i < pSalData->mnStockBrushCount; i++ )
309 DeleteBrush( pSalData->mhStockBrushAry[i] );
310
311 // delete 50% Brush
312 if ( pSalData->mh50Brush )
313 {
314 DeleteBrush( pSalData->mh50Brush );
315 pSalData->mh50Brush = 0;
316 }
317
318 // delete 50% Bitmap
319 if ( pSalData->mh50Bmp )
320 {
321 DeleteBitmap( pSalData->mh50Bmp );
322 pSalData->mh50Bmp = 0;
323 }
324
325 ImplClearHDCCache( pSalData );
326 delete[] pSalData->mpHDCCache;
327
328 // delete Ditherpalette, if existing
329 if ( pSalData->mhDitherPal )
330 {
331 DeleteObject( pSalData->mhDitherPal );
332 pSalData->mhDitherPal = 0;
333 }
334
335 // delete buffers for dithering DIB patterns, if necessary
336 if ( pSalData->mhDitherDIB )
337 {
338 GlobalUnlock( pSalData->mhDitherDIB );
339 GlobalFree( pSalData->mhDitherDIB );
340 pSalData->mhDitherDIB = 0;
341 delete[] pSalData->mpDitherDiff;
342 delete[] pSalData->mpDitherLow;
343 delete[] pSalData->mpDitherHigh;
344 }
345
346 // delete SysColorList
347 SysColorEntry* pEntry = pFirstSysColor;
348 while( pEntry )
349 {
350 SysColorEntry* pTmp = pEntry->pNext;
351 delete pEntry;
352 pEntry = pTmp;
353 }
354 pFirstSysColor = NULL;
355
356 // delete icon cache
357 SalIcon* pIcon = pSalData->mpFirstIcon;
358 pSalData->mpFirstIcon = NULL;
359 while( pIcon )
360 {
361 SalIcon* pTmp = pIcon->pNext;
362 DestroyIcon( pIcon->hIcon );
363 DestroyIcon( pIcon->hSmallIcon );
364 delete pIcon;
365 pIcon = pTmp;
366 }
367
368 // delete temporary font list
369 ImplReleaseTempFonts( *pSalData );
370
371 pSalData->mbResourcesAlreadyFreed = true;
372 }
373
374 int ImplIsSysColorEntry( SalColor nSalColor )
375 {
376 SysColorEntry* pEntry = pFirstSysColor;
377 const DWORD nTestRGB = (DWORD)RGB( SALCOLOR_RED( nSalColor ),
378 SALCOLOR_GREEN( nSalColor ),
379 SALCOLOR_BLUE( nSalColor ) );
380
381 while ( pEntry )
382 {
383 if ( pEntry->nRGB == nTestRGB )
384 return TRUE;
385 pEntry = pEntry->pNext;
386 }
387
388 return FALSE;
389 }
390
391 static int ImplIsPaletteEntry( BYTE nRed, BYTE nGreen, BYTE nBlue )
392 {
393 // dither color?
394 if ( !(nRed % DITHER_PAL_DELTA) && !(nGreen % DITHER_PAL_DELTA) && !(nBlue % DITHER_PAL_DELTA) )
395 return TRUE;
396
397 PALETTEENTRY* pPalEntry = aImplSalSysPalEntryAry;
398
399 // standard palette color?
400 for ( sal_uInt16 i = 0; i < DITHER_MAX_SYSCOLOR; i++, pPalEntry++ )
401 {
402 if( pPalEntry->peRed == nRed && pPalEntry->peGreen == nGreen && pPalEntry->peBlue == nBlue )
403 return TRUE;
404 }
405
406 // extra color?
407 if ( aImplExtraColor1.peRed == nRed &&
408 aImplExtraColor1.peGreen == nGreen &&
409 aImplExtraColor1.peBlue == nBlue )
410 {
411 return TRUE;
412 }
413
414 return FALSE;
415 }
416
417 static void ImplInsertSysColorEntry( int nSysIndex )
418 {
419 const DWORD nRGB = GetSysColor( nSysIndex );
420
421 if ( !ImplIsPaletteEntry( GetRValue( nRGB ), GetGValue( nRGB ), GetBValue( nRGB ) ) )
422 {
423 if ( !pFirstSysColor )
424 {
425 pActSysColor = pFirstSysColor = new SysColorEntry;
426 pFirstSysColor->nRGB = nRGB;
427 pFirstSysColor->pNext = NULL;
428 }
429 else
430 {
431 pActSysColor = pActSysColor->pNext = new SysColorEntry;
432 pActSysColor->nRGB = nRGB;
433 pActSysColor->pNext = NULL;
434 }
435 }
436 }
437
438 void ImplUpdateSysColorEntries()
439 {
440 // delete old SysColorList
441 SysColorEntry* pEntry = pFirstSysColor;
442 while( pEntry )
443 {
444 SysColorEntry* pTmp = pEntry->pNext;
445 delete pEntry;
446 pEntry = pTmp;
447 }
448 pActSysColor = pFirstSysColor = NULL;
449
450 // create new sys color list
451 ImplInsertSysColorEntry( COLOR_ACTIVEBORDER );
452 ImplInsertSysColorEntry( COLOR_INACTIVEBORDER );
453 ImplInsertSysColorEntry( COLOR_GRADIENTACTIVECAPTION );
454 ImplInsertSysColorEntry( COLOR_GRADIENTINACTIVECAPTION );
455 ImplInsertSysColorEntry( COLOR_3DFACE );
456 ImplInsertSysColorEntry( COLOR_3DHILIGHT );
457 ImplInsertSysColorEntry( COLOR_3DLIGHT );
458 ImplInsertSysColorEntry( COLOR_3DSHADOW );
459 ImplInsertSysColorEntry( COLOR_3DDKSHADOW );
460 ImplInsertSysColorEntry( COLOR_INFOBK );
461 ImplInsertSysColorEntry( COLOR_INFOTEXT );
462 ImplInsertSysColorEntry( COLOR_BTNTEXT );
463 ImplInsertSysColorEntry( COLOR_WINDOW );
464 ImplInsertSysColorEntry( COLOR_WINDOWTEXT );
465 ImplInsertSysColorEntry( COLOR_HIGHLIGHT );
466 ImplInsertSysColorEntry( COLOR_HIGHLIGHTTEXT );
467 ImplInsertSysColorEntry( COLOR_MENU );
468 ImplInsertSysColorEntry( COLOR_MENUTEXT );
469 ImplInsertSysColorEntry( COLOR_ACTIVECAPTION );
470 ImplInsertSysColorEntry( COLOR_CAPTIONTEXT );
471 ImplInsertSysColorEntry( COLOR_INACTIVECAPTION );
472 ImplInsertSysColorEntry( COLOR_INACTIVECAPTIONTEXT );
473 }
474
475 void WinSalGraphics::InitGraphics()
476 {
477 // calculate the minimal line width for the printer
478 if ( isPrinter() )
479 {
480 int nDPIX = GetDeviceCaps( getHDC(), LOGPIXELSX );
481 if ( nDPIX <= 300 )
482 mnPenWidth = 0;
483 else
484 mnPenWidth = nDPIX/300;
485 }
486
487 ::SetTextAlign( getHDC(), TA_BASELINE | TA_LEFT | TA_NOUPDATECP );
488 ::SetBkMode( getHDC(), TRANSPARENT );
489 ::SetROP2( getHDC(), R2_COPYPEN );
490
491 mpImpl->Init();
492 }
493
494 void WinSalGraphics::DeInitGraphics()
495 {
496 // clear clip region
497 SelectClipRgn( getHDC(), 0 );
498 // select default objects
499 if ( mhDefPen )
500 SelectPen( getHDC(), mhDefPen );
501 if ( mhDefBrush )
502 SelectBrush( getHDC(), mhDefBrush );
503 if ( mhDefFont )
504 SelectFont( getHDC(), mhDefFont );
505
506 mpImpl->DeInit();
507 }
508
509 HDC ImplGetCachedDC( sal_uLong nID, HBITMAP hBmp )
510 {
511 SalData* pSalData = GetSalData();
512 HDCCache* pC = &pSalData->mpHDCCache[ nID ];
513
514 if( !pC->mhDC )
515 {
516 HDC hDC = GetDC( 0 );
517
518 // create new DC with DefaultBitmap
519 pC->mhDC = CreateCompatibleDC( hDC );
520
521 if( pSalData->mhDitherPal )
522 {
523 pC->mhDefPal = SelectPalette( pC->mhDC, pSalData->mhDitherPal, TRUE );
524 RealizePalette( pC->mhDC );
525 }
526
527 pC->mhSelBmp = CreateCompatibleBitmap( hDC, CACHED_HDC_DEFEXT, CACHED_HDC_DEFEXT );
528 pC->mhDefBmp = (HBITMAP) SelectObject( pC->mhDC, pC->mhSelBmp );
529
530 ReleaseDC( 0, hDC );
531 }
532
533 if ( hBmp )
534 SelectObject( pC->mhDC, pC->mhActBmp = hBmp );
535 else
536 pC->mhActBmp = 0;
537
538 return pC->mhDC;
539 }
540
541 void ImplReleaseCachedDC( sal_uLong nID )
542 {
543 SalData* pSalData = GetSalData();
544 HDCCache* pC = &pSalData->mpHDCCache[ nID ];
545
546 if ( pC->mhActBmp )
547 SelectObject( pC->mhDC, pC->mhSelBmp );
548 }
549
550 void ImplClearHDCCache( SalData* pData )
551 {
552 for( sal_uLong i = 0; i < CACHESIZE_HDC; i++ )
553 {
554 HDCCache* pC = &pData->mpHDCCache[ i ];
555
556 if( pC->mhDC )
557 {
558 SelectObject( pC->mhDC, pC->mhDefBmp );
559
560 if( pC->mhDefPal )
561 SelectPalette( pC->mhDC, pC->mhDefPal, TRUE );
562
563 DeleteDC( pC->mhDC );
564 DeleteObject( pC->mhSelBmp );
565 }
566 }
567 }
568
569 OpenGLCompatibleDC::OpenGLCompatibleDC(SalGraphics &rGraphics, int x, int y, int width, int height)
570 : mhBitmap(0)
571 , mpData(NULL)
572 , maRects(0, 0, width, height, x, y, width, height)
573 {
574 WinSalGraphics& rWinGraphics = static_cast<WinSalGraphics&>(rGraphics);
575 mpImpl = dynamic_cast<WinOpenGLSalGraphicsImpl*>(rWinGraphics.mpImpl.get());
576
577 if (!mpImpl)
578 {
579 // we avoid the OpenGL drawing, instead we draw directly to the DC
580 mhCompatibleDC = rWinGraphics.getHDC();
581 return;
582 }
583
584 mhCompatibleDC = CreateCompatibleDC(rWinGraphics.getHDC());
585
586 // move the origin so that we always paint at 0,0 - to keep the bitmap
587 // small
588 OffsetViewportOrgEx(mhCompatibleDC, -x, -y, NULL);
589
590 mhBitmap = WinSalVirtualDevice::ImplCreateVirDevBitmap(mhCompatibleDC, width, height, 32, reinterpret_cast<void **>(&mpData));
591
592 mhOrigBitmap = (HBITMAP) SelectObject(mhCompatibleDC, mhBitmap);
593 }
594
595 OpenGLCompatibleDC::~OpenGLCompatibleDC()
596 {
597 if (mpImpl)
598 {
599 SelectObject(mhCompatibleDC, mhOrigBitmap);
600 DeleteObject(mhBitmap);
601 DeleteDC(mhCompatibleDC);
602 }
603 }
604
605 void OpenGLCompatibleDC::fill(sal_uInt32 color)
606 {
607 if (!mpData)
608 return;
609
610 sal_uInt32 *p = mpData;
611 for (int i = maRects.mnSrcWidth * maRects.mnSrcHeight; i > 0; --i)
612 *p++ = color;
613 }
614
615 OpenGLTexture* OpenGLCompatibleDC::getTexture()
616 {
617 if (!mpImpl)
618 return NULL;
619
620 // turn what's in the mpData into a texture
621 return new OpenGLTexture(maRects.mnSrcWidth, maRects.mnSrcHeight, GL_BGRA, GL_UNSIGNED_BYTE, reinterpret_cast<sal_uInt8*>(mpData));
622 }
623
624 WinSalGraphics::WinSalGraphics(WinSalGraphics::Type eType, bool bScreen, HWND hWnd, SalGeometryProvider *pProvider):
625 mhLocalDC(0),
626 mbPrinter(eType == WinSalGraphics::PRINTER),
627 mbVirDev(eType == WinSalGraphics::VIRTUAL_DEVICE),
628 mbWindow(eType == WinSalGraphics::WINDOW),
629 mhWnd(hWnd),
630 mbScreen(bScreen),
631 mfCurrentFontScale(1.0),
632 mhRegion(0),
633 mhDefPen(0),
634 mhDefBrush(0),
635 mhDefFont(0),
636 mhDefPal(0),
637 mpStdClipRgnData(NULL),
638 mpFontAttrCache(NULL),
639 mnPenWidth(GSL_PEN_WIDTH)
640 {
641 if (OpenGLHelper::isVCLOpenGLEnabled() && !mbPrinter)
642 mpImpl.reset(new WinOpenGLSalGraphicsImpl(*this, pProvider));
643 else
644 mpImpl.reset(new WinSalGraphicsImpl(*this));
645
646 for( int i = 0; i < MAX_FALLBACK; ++i )
647 {
648 mhFonts[ i ] = 0;
649 mpWinFontData[ i ] = NULL;
650 mpWinFontEntry[ i ] = NULL;
651 mfFontScale[ i ] = 1.0;
652 }
653 }
654
655 WinSalGraphics::~WinSalGraphics()
656 {
657 // free obsolete GDI objects
658 ReleaseFonts();
659
660 if ( mhRegion )
661 {
662 DeleteRegion( mhRegion );
663 mhRegion = 0;
664 }
665
666 // delete cache data
667 delete [] mpStdClipRgnData;
668 }
669
670 SalGraphicsImpl* WinSalGraphics::GetImpl() const
671 {
672 return mpImpl.get();
673 }
674
675 bool WinSalGraphics::isPrinter() const
676 {
677 return mbPrinter;
678 }
679
680 bool WinSalGraphics::isVirtualDevice() const
681 {
682 return mbVirDev;
683 }
684
685 bool WinSalGraphics::isWindow() const
686 {
687 return mbWindow;
688 }
689
690 bool WinSalGraphics::isScreen() const
691 {
692 return mbScreen;
693 }
694
695 HWND WinSalGraphics::gethWnd()
696 {
697 return mhWnd;
698 }
699
700 void WinSalGraphics::setHWND(HWND hWnd)
701 {
702 mhWnd = hWnd;
703 }
704
705 HPALETTE WinSalGraphics::getDefPal() const
706 {
707 return mhDefPal;
708 }
709
710 void WinSalGraphics::setDefPal(HPALETTE hDefPal)
711 {
712 mhDefPal = hDefPal;
713 }
714
715 HRGN WinSalGraphics::getRegion() const
716 {
717 return mhRegion;
718 }
719
720 void WinSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
721 {
722 rDPIX = GetDeviceCaps( getHDC(), LOGPIXELSX );
723 rDPIY = GetDeviceCaps( getHDC(), LOGPIXELSY );
724
725 // #111139# this fixes the symptom of div by zero on startup
726 // however, printing will fail most likely as communication with
727 // the printer seems not to work in this case
728 if( !rDPIX || !rDPIY )
729 rDPIX = rDPIY = 600;
730 }
731
732 sal_uInt16 WinSalGraphics::GetBitCount() const
733 {
734 return mpImpl->GetBitCount();
735 }
736
737 long WinSalGraphics::GetGraphicsWidth() const
738 {
739 return mpImpl->GetGraphicsWidth();
740 }
741
742 void WinSalGraphics::ResetClipRegion()
743 {
744 mpImpl->ResetClipRegion();
745 }
746
747 bool WinSalGraphics::setClipRegion( const vcl::Region& i_rClip )
748 {
749 return mpImpl->setClipRegion( i_rClip );
750 }
751
752 void WinSalGraphics::SetLineColor()
753 {
754 mpImpl->SetLineColor();
755 }
756
757 void WinSalGraphics::SetLineColor( SalColor nSalColor )
758 {
759 mpImpl->SetLineColor( nSalColor );
760 }
761
762 void WinSalGraphics::SetFillColor()
763 {
764 mpImpl->SetFillColor();
765 }
766
767 void WinSalGraphics::SetFillColor( SalColor nSalColor )
768 {
769 mpImpl->SetFillColor( nSalColor );
770 }
771
772 void WinSalGraphics::SetXORMode( bool bSet, bool bInvertOnly )
773 {
774 mpImpl->SetXORMode( bSet, bInvertOnly );
775 }
776
777 void WinSalGraphics::SetROPLineColor( SalROPColor nROPColor )
778 {
779 mpImpl->SetROPLineColor( nROPColor );
780 }
781
782 void WinSalGraphics::SetROPFillColor( SalROPColor nROPColor )
783 {
784 mpImpl->SetROPFillColor( nROPColor );
785 }
786
787 void WinSalGraphics::drawPixel( long nX, long nY )
788 {
789 mpImpl->drawPixel( nX, nY );
790 }
791
792 void WinSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
793 {
794 mpImpl->drawPixel( nX, nY, nSalColor );
795 }
796
797 void WinSalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
798 {
799 mpImpl->drawLine( nX1, nY1, nX2, nY2 );
800 }
801
802 void WinSalGraphics::drawRect( long nX, long nY, long nWidth, long nHeight )
803 {
804 mpImpl->drawRect( nX, nY, nWidth, nHeight );
805 }
806
807 void WinSalGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry )
808 {
809 mpImpl->drawPolyLine( nPoints, pPtAry );
810 }
811
812 void WinSalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
813 {
814 mpImpl->drawPolygon( nPoints, pPtAry );
815 }
816
817 void WinSalGraphics::drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
818 PCONSTSALPOINT* pPtAry )
819 {
820 mpImpl->drawPolyPolygon( nPoly, pPoints, pPtAry );
821 }
822
823 bool WinSalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
824 {
825 return mpImpl->drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
826 }
827
828 bool WinSalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
829 {
830 return mpImpl->drawPolygonBezier( nPoints, pPtAry, pFlgAry );
831 }
832
833 bool WinSalGraphics::drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints,
834 const SalPoint* const* pPtAry, const BYTE* const* pFlgAry )
835 {
836 return mpImpl->drawPolyPolygonBezier( nPoly, pPoints, pPtAry, pFlgAry );
837 }
838
839 static BYTE* ImplSearchEntry( BYTE* pSource, BYTE* pDest, sal_uLong nComp, sal_uLong nSize )
840 {
841 while ( nComp-- >= nSize )
842 {
843 sal_uLong i;
844 for ( i = 0; i < nSize; i++ )
845 {
846 if ( ( pSource[i]&~0x20 ) != ( pDest[i]&~0x20 ) )
847 break;
848 }
849 if ( i == nSize )
850 return pSource;
851 pSource++;
852 }
853 return NULL;
854 }
855
856 static bool ImplGetBoundingBox( double* nNumb, BYTE* pSource, sal_uLong nSize )
857 {
858 bool bRetValue = FALSE;
859 BYTE* pDest = ImplSearchEntry( pSource, (BYTE*)"%%BoundingBox:", nSize, 14 );
860 if ( pDest )
861 {
862 nNumb[0] = nNumb[1] = nNumb[2] = nNumb[3] = 0;
863 pDest += 14;
864
865 int nSizeLeft = nSize - ( pDest - pSource );
866 if ( nSizeLeft > 100 )
867 nSizeLeft = 100; // only 100 bytes following the bounding box will be checked
868
869 int i;
870 for ( i = 0; ( i < 4 ) && nSizeLeft; i++ )
871 {
872 int nDivision = 1;
873 bool bDivision = FALSE;
874 bool bNegative = FALSE;
875 bool bValid = TRUE;
876
877 while ( ( --nSizeLeft ) && ( ( *pDest == ' ' ) || ( *pDest == 0x9 ) ) ) pDest++;
878 BYTE nByte = *pDest;
879 while ( nSizeLeft && ( nByte != ' ' ) && ( nByte != 0x9 ) && ( nByte != 0xd ) && ( nByte != 0xa ) )
880 {
881 switch ( nByte )
882 {
883 case '.' :
884 if ( bDivision )
885 bValid = FALSE;
886 else
887 bDivision = TRUE;
888 break;
889 case '-' :
890 bNegative = TRUE;
891 break;
892 default :
893 if ( ( nByte < '0' ) || ( nByte > '9' ) )
894 nSizeLeft = 1; // error parsing the bounding box values
895 else if ( bValid )
896 {
897 if ( bDivision )
898 nDivision*=10;
899 nNumb[i] *= 10;
900 nNumb[i] += nByte - '0';
901 }
902 break;
903 }
904 nSizeLeft--;
905 nByte = *(++pDest);
906 }
907 if ( bNegative )
908 nNumb[i] = -nNumb[i];
909 if ( bDivision && ( nDivision != 1 ) )
910 nNumb[i] /= nDivision;
911 }
912 if ( i == 4 )
913 bRetValue = TRUE;
914 }
915 return bRetValue;
916 }
917
918 #define POSTSCRIPT_BUFSIZE 0x4000 // MAXIMUM BUFSIZE EQ 0xFFFF
919
920 bool WinSalGraphics::drawEPS( long nX, long nY, long nWidth, long nHeight, void* pPtr, sal_uLong nSize )
921 {
922 bool bRetValue = false;
923
924 if ( mbPrinter )
925 {
926 int nEscape = POSTSCRIPT_PASSTHROUGH;
927
928 if ( Escape( getHDC(), QUERYESCSUPPORT, sizeof( int ), ( LPSTR )&nEscape, 0 ) )
929 {
930 double nBoundingBox[4];
931
932 if ( ImplGetBoundingBox( nBoundingBox, (BYTE*)pPtr, nSize ) )
933 {
934 OStringBuffer aBuf( POSTSCRIPT_BUFSIZE );
935
936 // reserve place for a sal_uInt16
937 aBuf.append( "aa" );
938
939 // #107797# Write out EPS encapsulation header
940
941 // directly taken from the PLRM 3.0, p. 726. Note:
942 // this will definitely cause problems when
943 // recursively creating and embedding PostScript files
944 // in OOo, since we use statically-named variables
945 // here (namely, b4_Inc_state_salWin, dict_count_salWin and
946 // op_count_salWin). Currently, I have no idea on how to
947 // work around that, except from scanning and
948 // interpreting the EPS for unused identifiers.
949
950 // append the real text
951 aBuf.append( "\n\n/b4_Inc_state_salWin save def\n"
952 "/dict_count_salWin countdictstack def\n"
953 "/op_count_salWin count 1 sub def\n"
954 "userdict begin\n"
955 "/showpage {} def\n"
956 "0 setgray 0 setlinecap\n"
957 "1 setlinewidth 0 setlinejoin\n"
958 "10 setmiterlimit [] 0 setdash newpath\n"
959 "/languagelevel where\n"
960 "{\n"
961 " pop languagelevel\n"
962 " 1 ne\n"
963 " {\n"
964 " false setstrokeadjust false setoverprint\n"
965 " } if\n"
966 "} if\n\n" );
967
968 // #i10737# Apply clipping manually
969
970 // Windows seems to ignore any clipping at the HDC,
971 // when followed by a POSTSCRIPT_PASSTHROUGH
972
973 // Check whether we've got a clipping, consisting of
974 // exactly one rect (other cases should be, but aren't
975 // handled currently)
976
977 // TODO: Handle more than one rectangle here (take
978 // care, the buffer can handle only POSTSCRIPT_BUFSIZE
979 // characters!)
980 if ( mhRegion != 0 &&
981 mpStdClipRgnData != NULL &&
982 mpClipRgnData == mpStdClipRgnData &&
983 mpClipRgnData->rdh.nCount == 1 )
984 {
985 RECT* pRect = &(mpClipRgnData->rdh.rcBound);
986
987 aBuf.append( "\nnewpath\n" );
988 aBuf.append( pRect->left );
989 aBuf.append( " " );
990 aBuf.append( pRect->top );
991 aBuf.append( " moveto\n" );
992 aBuf.append( pRect->right );
993 aBuf.append( " " );
994 aBuf.append( pRect->top );
995 aBuf.append( " lineto\n" );
996 aBuf.append( pRect->right );
997 aBuf.append( " " );
998 aBuf.append( pRect->bottom );
999 aBuf.append( " lineto\n" );
1000 aBuf.append( pRect->left );
1001 aBuf.append( " " );
1002 aBuf.append( pRect->bottom );
1003 aBuf.append( " lineto\n"
1004 "closepath\n"
1005 "clip\n"
1006 "newpath\n" );
1007 }
1008
1009 // #107797# Write out buffer
1010
1011 *((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
1012 Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );
1013
1014 // #107797# Write out EPS transformation code
1015
1016 double dM11 = nWidth / ( nBoundingBox[2] - nBoundingBox[0] );
1017 double dM22 = nHeight / (nBoundingBox[1] - nBoundingBox[3] );
1018 // reserve a sal_uInt16 again
1019 aBuf.setLength( 2 );
1020 aBuf.append( "\n\n[" );
1021 aBuf.append( dM11 );
1022 aBuf.append( " 0 0 " );
1023 aBuf.append( dM22 );
1024 aBuf.append( ' ' );
1025 aBuf.append( nX - ( dM11 * nBoundingBox[0] ) );
1026 aBuf.append( ' ' );
1027 aBuf.append( nY - ( dM22 * nBoundingBox[3] ) );
1028 aBuf.append( "] concat\n"
1029 "%%BeginDocument:\n" );
1030 *((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
1031 Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );
1032
1033 // #107797# Write out actual EPS content
1034
1035 sal_uLong nToDo = nSize;
1036 sal_uLong nDoNow;
1037 while ( nToDo )
1038 {
1039 nDoNow = nToDo;
1040 if ( nToDo > POSTSCRIPT_BUFSIZE - 2 )
1041 nDoNow = POSTSCRIPT_BUFSIZE - 2;
1042 // the following is based on the string buffer allocation
1043 // of size POSTSCRIPT_BUFSIZE at construction time of aBuf
1044 *((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)nDoNow;
1045 memcpy( (void*)(aBuf.getStr() + 2), (BYTE*)pPtr + nSize - nToDo, nDoNow );
1046 sal_uLong nResult = Escape ( getHDC(), nEscape, nDoNow + 2, (LPTSTR)aBuf.getStr(), 0 );
1047 if (!nResult )
1048 break;
1049 nToDo -= nResult;
1050 }
1051
1052 // #107797# Write out EPS encapsulation footer
1053
1054 // reserve a sal_uInt16 again
1055 aBuf.setLength( 2 );
1056 aBuf.append( "%%EndDocument\n"
1057 "count op_count_salWin sub {pop} repeat\n"
1058 "countdictstack dict_count_salWin sub {end} repeat\n"
1059 "b4_Inc_state_salWin restore\n\n" );
1060 *((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
1061 Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );
1062 bRetValue = TRUE;
1063 }
1064 }
1065 }
1066
1067 return bRetValue;
1068 }
1069
1070 SystemGraphicsData WinSalGraphics::GetGraphicsData() const
1071 {
1072 SystemGraphicsData aRes;
1073 aRes.nSize = sizeof(aRes);
1074 aRes.hDC = const_cast< WinSalGraphics* >(this)->getHDC();
1075 return aRes;
1076 }
1077
1078 bool WinSalGraphics::SupportsCairo() const
1079 {
1080 #if ENABLE_CAIRO_CANVAS
1081 return true;
1082 #else
1083 return false;
1084 #endif
1085 }
1086
1087 /**
1088 * cairo::createSurface: Create generic Canvas surface using given Cairo Surface
1089 *
1090 * @param rSurface Cairo Surface
1091 *
1092 * @return new Surface
1093 */
1094 cairo::SurfaceSharedPtr WinSalGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const
1095 {
1096 #if ENABLE_CAIRO_CANVAS
1097 return cairo::SurfaceSharedPtr(new cairo::Win32Surface(rSurface));
1098 #else
1099 (void)rSurface;
1100 return cairo::SurfaceSharedPtr();
1101 #endif
1102 }
1103
1104 /**
1105 * cairo::createSurface: Create Canvas surface using given VCL Window or Virtualdevice
1106 *
1107 * @param rSurface Cairo Surface
1108 *
1109 * For VCL Window, use platform native system environment data (struct SystemEnvData in vcl/inc/sysdata.hxx)
1110 * For VCL Virtualdevice, use platform native system graphics data (struct SystemGraphicsData in vcl/inc/sysdata.hxx)
1111 *
1112 * @return new Surface
1113 */
1114 cairo::SurfaceSharedPtr WinSalGraphics::CreateSurface( const OutputDevice& rRefDevice,
1115 int x, int y, int /* width */, int /* height */) const
1116 {
1117 cairo::SurfaceSharedPtr surf;
1118
1119 #if ENABLE_CAIRO_CANVAS
1120 if( rRefDevice.GetOutDevType() == OUTDEV_WINDOW )
1121 {
1122 const vcl::Window &rWindow = (const vcl::Window &) rRefDevice;
1123 const SystemEnvData* pSysData = GetSysData(&rWindow);
1124 if (pSysData && pSysData->hWnd)
1125 surf = cairo::SurfaceSharedPtr(new cairo::Win32Surface(GetDC((HWND) pSysData->hWnd), x, y));
1126 }
1127 else if( rRefDevice.GetOutDevType() == OUTDEV_VIRDEV )
1128 {
1129 SystemGraphicsData aSysData = ((const VirtualDevice&) rRefDevice).GetSystemGfxData();
1130 if (aSysData.hDC)
1131 surf = cairo::SurfaceSharedPtr(new cairo::Win32Surface((HDC) aSysData.hDC, x, y));
1132 }
1133 #else
1134 (void)rRefDevice;
1135 (void)x;
1136 (void)y;
1137 #endif
1138
1139 return surf;
1140 }
1141
1142 /**
1143 * cairo::createBitmapSurface: Create platform native Canvas surface from BitmapSystemData
1144 * @param OutputDevice (not used)
1145 * @param rData Platform native image data (struct BitmapSystemData in vcl/inc/bitmap.hxx)
1146 * @param rSize width and height of the new surface
1147 *
1148 * Create a surface based on image data on rData
1149 *
1150 * @return new surface or empty surface
1151 **/
1152 cairo::SurfaceSharedPtr WinSalGraphics::CreateBitmapSurface( const OutputDevice& /* rRefDevice */,
1153 const BitmapSystemData& rData,
1154 const Size& rSize ) const
1155 {
1156 OSL_TRACE( "requested size: %d x %d available size: %d x %d",
1157 rSize.Width(), rSize.Height(), rData.mnWidth, rData.mnHeight );
1158
1159 #if ENABLE_CAIRO_CANVAS
1160 if ( rData.mnWidth == rSize.Width() && rData.mnHeight == rSize.Height() )
1161 return cairo::SurfaceSharedPtr(new cairo::Win32Surface( rData ));
1162 #else
1163 (void)rData;
1164 (void)rSize;
1165 #endif
1166 return cairo::SurfaceSharedPtr();
1167 }
1168
1169 #if ENABLE_CAIRO_CANVAS
1170 namespace
1171 {
1172 HBITMAP surface2HBitmap( const SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize )
1173 {
1174 // can't seem to retrieve HBITMAP from cairo. copy content then
1175 HDC hScreenDC=GetDC(NULL);
1176 HBITMAP hBmpBitmap = CreateCompatibleBitmap( hScreenDC,
1177 rSize.getX(),
1178 rSize.getY() );
1179
1180 HDC hBmpDC = CreateCompatibleDC( 0 );
1181 HBITMAP hBmpOld = (HBITMAP) SelectObject( hBmpDC, hBmpBitmap );
1182
1183 BitBlt( hBmpDC, 0, 0, rSize.getX(), rSize.getX(),
1184 cairo_win32_surface_get_dc(rSurface->getCairoSurface().get()),
1185 0, 0, SRCCOPY );
1186
1187 SelectObject( hBmpDC, hBmpOld );
1188 DeleteDC( hBmpDC );
1189
1190 return hBmpBitmap;
1191 }
1192 }
1193 #endif
1194
1195 css::uno::Any WinSalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const ::basegfx::B2ISize& rSize) const
1196 {
1197 // TODO(F2): check whether under all circumstances,
1198 // the alpha channel is ignored here.
1199 css::uno::Sequence< css::uno::Any > args( 1 );
1200 sal_Int64 nHandle;
1201 #if ENABLE_CAIRO_CANVAS
1202 nHandle = sal_Int64(surface2HBitmap(rSurface, rSize));
1203 #else
1204 (void)rSurface;
1205 (void)rSize;
1206 nHandle = 0;
1207 #endif
1208 args[1] = css::uno::Any(nHandle);
1209 // caller frees the bitmap
1210 return css::uno::Any( args );
1211 }
1212
1213 OpenGLContext *WinSalGraphics::BeginPaint()
1214 {
1215 return mpImpl->beginPaint();
1216 }
1217
1218 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE