Line data Source code
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 :
21 : #include <sot/factory.hxx>
22 : #include <tools/poly.hxx>
23 : #include <vcl/bmpacc.hxx>
24 : #include <vcl/virdev.hxx>
25 : #include <vcl/wrkwin.hxx>
26 : #include <svl/solar.hrc>
27 : #include <sfx2/docfile.hxx>
28 : #include <sfx2/app.hxx>
29 : #include "svx/xoutbmp.hxx"
30 : #include <svtools/FilterConfigItem.hxx>
31 : #include <svtools/filter.hxx>
32 :
33 : // -----------
34 : // - Defines -
35 : // -----------
36 :
37 : #define FORMAT_BMP String(RTL_CONSTASCII_USTRINGPARAM("bmp"))
38 : #define FORMAT_GIF String(RTL_CONSTASCII_USTRINGPARAM("gif"))
39 : #define FORMAT_JPG String(RTL_CONSTASCII_USTRINGPARAM("jpg"))
40 : #define FORMAT_PNG String(RTL_CONSTASCII_USTRINGPARAM("png"))
41 :
42 : // --------------
43 : // - XOutBitmap -
44 : // --------------
45 :
46 : GraphicFilter* XOutBitmap::pGrfFilter = NULL;
47 :
48 : // ------------------------------------------------------------------------
49 :
50 0 : Animation XOutBitmap::MirrorAnimation( const Animation& rAnimation, sal_Bool bHMirr, sal_Bool bVMirr )
51 : {
52 0 : Animation aNewAnim( rAnimation );
53 :
54 0 : if( bHMirr || bVMirr )
55 : {
56 0 : const Size& rGlobalSize = aNewAnim.GetDisplaySizePixel();
57 0 : sal_uIntPtr nMirrorFlags = 0L;
58 :
59 0 : if( bHMirr )
60 0 : nMirrorFlags |= BMP_MIRROR_HORZ;
61 :
62 0 : if( bVMirr )
63 0 : nMirrorFlags |= BMP_MIRROR_VERT;
64 :
65 0 : for( sal_uInt16 i = 0, nCount = aNewAnim.Count(); i < nCount; i++ )
66 : {
67 0 : AnimationBitmap aAnimBmp( aNewAnim.Get( i ) );
68 :
69 : // BitmapEx spiegeln
70 0 : aAnimBmp.aBmpEx.Mirror( nMirrorFlags );
71 :
72 : // Die Positionen innerhalb der Gesamtbitmap
73 : // muessen natuerlich auch angepasst werden
74 0 : if( bHMirr )
75 0 : aAnimBmp.aPosPix.X() = rGlobalSize.Width() - aAnimBmp.aPosPix.X() -
76 0 : aAnimBmp.aSizePix.Width();
77 :
78 0 : if( bVMirr )
79 0 : aAnimBmp.aPosPix.Y() = rGlobalSize.Height() - aAnimBmp.aPosPix.Y() -
80 0 : aAnimBmp.aSizePix.Height();
81 :
82 0 : aNewAnim.Replace( aAnimBmp, i );
83 0 : }
84 : }
85 :
86 0 : return aNewAnim;
87 : }
88 :
89 : // ------------------------------------------------------------------------
90 :
91 0 : Graphic XOutBitmap::MirrorGraphic( const Graphic& rGraphic, const sal_uIntPtr nMirrorFlags )
92 : {
93 0 : Graphic aRetGraphic;
94 :
95 0 : if( nMirrorFlags )
96 : {
97 0 : if( rGraphic.IsAnimated() )
98 : {
99 : aRetGraphic = MirrorAnimation( rGraphic.GetAnimation(),
100 : ( nMirrorFlags & BMP_MIRROR_HORZ ) == BMP_MIRROR_HORZ,
101 0 : ( nMirrorFlags & BMP_MIRROR_VERT ) == BMP_MIRROR_VERT );
102 : }
103 : else
104 : {
105 0 : if( rGraphic.IsTransparent() )
106 : {
107 0 : BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
108 :
109 0 : aBmpEx.Mirror( nMirrorFlags );
110 0 : aRetGraphic = aBmpEx;
111 : }
112 : else
113 : {
114 0 : Bitmap aBmp( rGraphic.GetBitmap() );
115 :
116 0 : aBmp.Mirror( nMirrorFlags );
117 0 : aRetGraphic = aBmp;
118 : }
119 : }
120 : }
121 : else
122 0 : aRetGraphic = rGraphic;
123 :
124 0 : return aRetGraphic;
125 : }
126 :
127 : // ------------------------------------------------------------------------
128 :
129 0 : sal_uInt16 XOutBitmap::WriteGraphic( const Graphic& rGraphic, String& rFileName,
130 : const String& rFilterName, const sal_uIntPtr nFlags,
131 : const Size* pMtfSize_100TH_MM )
132 : {
133 0 : if( rGraphic.GetType() != GRAPHIC_NONE )
134 : {
135 0 : INetURLObject aURL( rFileName );
136 0 : Graphic aGraphic;
137 0 : String aExt;
138 0 : GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
139 0 : sal_uInt16 nErr = GRFILTER_FILTERERROR, nFilter = GRFILTER_FORMAT_NOTFOUND;
140 0 : sal_Bool bTransparent = rGraphic.IsTransparent(), bAnimated = rGraphic.IsAnimated();
141 :
142 : DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "XOutBitmap::WriteGraphic(...): invalid URL" );
143 :
144 : // calculate correct file name
145 0 : if( !( nFlags & XOUTBMP_DONT_EXPAND_FILENAME ) )
146 : {
147 0 : String aName( aURL.getBase() );
148 0 : aName += '_';
149 0 : aName += String(aURL.getExtension());
150 0 : aName += '_';
151 0 : String aStr( String::CreateFromInt32( rGraphic.GetChecksum(), 16 ) );
152 0 : if ( aStr.GetChar(0) == '-' )
153 0 : aStr.SetChar(0,'m');
154 0 : aName += aStr;
155 0 : aURL.setBase( aName );
156 : }
157 :
158 0 : if( ( nFlags & XOUTBMP_USE_NATIVE_IF_POSSIBLE ) &&
159 0 : !( nFlags & XOUTBMP_MIRROR_HORZ ) &&
160 0 : !( nFlags & XOUTBMP_MIRROR_VERT ) &&
161 0 : ( rGraphic.GetType() != GRAPHIC_GDIMETAFILE ) && rGraphic.IsLink() )
162 : {
163 : // try to write native link
164 0 : const GfxLink aGfxLink( ( (Graphic&) rGraphic ).GetLink() );
165 :
166 0 : switch( aGfxLink.GetType() )
167 : {
168 0 : case( GFX_LINK_TYPE_NATIVE_GIF ): aExt = FORMAT_GIF; break;
169 0 : case( GFX_LINK_TYPE_NATIVE_JPG ): aExt = FORMAT_JPG; break;
170 0 : case( GFX_LINK_TYPE_NATIVE_PNG ): aExt = FORMAT_PNG; break;
171 :
172 : default:
173 0 : break;
174 : }
175 :
176 0 : if( aExt.Len() )
177 : {
178 0 : if( 0 == (nFlags & XOUTBMP_DONT_ADD_EXTENSION))
179 0 : aURL.setExtension( aExt );
180 0 : rFileName = aURL.GetMainURL( INetURLObject::NO_DECODE );
181 :
182 0 : SfxMedium aMedium( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_SHARE_DENYNONE | STREAM_TRUNC );
183 0 : SvStream* pOStm = aMedium.GetOutStream();
184 :
185 0 : if( pOStm && aGfxLink.GetDataSize() && aGfxLink.GetData() )
186 : {
187 0 : pOStm->Write( aGfxLink.GetData(), aGfxLink.GetDataSize() );
188 0 : aMedium.Commit();
189 :
190 0 : if( !aMedium.GetError() )
191 0 : nErr = GRFILTER_OK;
192 0 : }
193 0 : }
194 : }
195 :
196 0 : if( GRFILTER_OK != nErr )
197 : {
198 0 : String aFilter( rFilterName );
199 0 : sal_Bool bWriteTransGrf = ( aFilter.EqualsIgnoreCaseAscii( "transgrf" ) ) ||
200 0 : ( aFilter.EqualsIgnoreCaseAscii( "gif" ) ) ||
201 : ( nFlags & XOUTBMP_USE_GIF_IF_POSSIBLE ) ||
202 0 : ( ( nFlags & XOUTBMP_USE_GIF_IF_SENSIBLE ) && ( bAnimated || bTransparent ) );
203 :
204 : // get filter and extension
205 0 : if( bWriteTransGrf )
206 0 : aFilter = FORMAT_GIF;
207 :
208 0 : nFilter = rFilter.GetExportFormatNumberForShortName( aFilter );
209 :
210 0 : if( GRFILTER_FORMAT_NOTFOUND == nFilter )
211 : {
212 0 : nFilter = rFilter.GetExportFormatNumberForShortName( FORMAT_JPG );
213 :
214 0 : if( GRFILTER_FORMAT_NOTFOUND == nFilter )
215 0 : nFilter = rFilter.GetExportFormatNumberForShortName( FORMAT_BMP );
216 : }
217 :
218 0 : if( GRFILTER_FORMAT_NOTFOUND != nFilter )
219 : {
220 0 : aExt = rFilter.GetExportFormatShortName( nFilter ).ToLowerAscii();
221 :
222 0 : if( bWriteTransGrf )
223 : {
224 0 : if( bAnimated )
225 0 : aGraphic = rGraphic;
226 : else
227 : {
228 0 : if( pMtfSize_100TH_MM && ( rGraphic.GetType() != GRAPHIC_BITMAP ) )
229 : {
230 0 : VirtualDevice aVDev;
231 0 : const Size aSize( aVDev.LogicToPixel( *pMtfSize_100TH_MM, MAP_100TH_MM ) );
232 :
233 0 : if( aVDev.SetOutputSizePixel( aSize ) )
234 : {
235 0 : const Wallpaper aWallpaper( aVDev.GetBackground() );
236 0 : const Point aPt;
237 :
238 0 : aVDev.SetBackground( Wallpaper( Color( COL_BLACK ) ) );
239 0 : aVDev.Erase();
240 0 : rGraphic.Draw( &aVDev, aPt, aSize );
241 :
242 0 : const Bitmap aBitmap( aVDev.GetBitmap( aPt, aSize ) );
243 :
244 0 : aVDev.SetBackground( aWallpaper );
245 0 : aVDev.Erase();
246 0 : rGraphic.Draw( &aVDev, aPt, aSize );
247 :
248 0 : aVDev.SetRasterOp( ROP_XOR );
249 0 : aVDev.DrawBitmap( aPt, aSize, aBitmap );
250 0 : aGraphic = BitmapEx( aBitmap, aVDev.GetBitmap( aPt, aSize ) );
251 : }
252 : else
253 0 : aGraphic = rGraphic.GetBitmapEx();
254 : }
255 : else
256 0 : aGraphic = rGraphic.GetBitmapEx();
257 : }
258 : }
259 : else
260 : {
261 0 : if( pMtfSize_100TH_MM && ( rGraphic.GetType() != GRAPHIC_BITMAP ) )
262 : {
263 0 : VirtualDevice aVDev;
264 0 : const Size aSize( aVDev.LogicToPixel( *pMtfSize_100TH_MM, MAP_100TH_MM ) );
265 :
266 0 : if( aVDev.SetOutputSizePixel( aSize ) )
267 : {
268 0 : rGraphic.Draw( &aVDev, Point(), aSize );
269 0 : aGraphic = aVDev.GetBitmap( Point(), aSize );
270 : }
271 : else
272 0 : aGraphic = rGraphic.GetBitmap();
273 : }
274 : else
275 0 : aGraphic = rGraphic.GetBitmap();
276 : }
277 :
278 : // mirror?
279 0 : if( ( nFlags & XOUTBMP_MIRROR_HORZ ) || ( nFlags & XOUTBMP_MIRROR_VERT ) )
280 0 : aGraphic = MirrorGraphic( aGraphic, nFlags );
281 :
282 0 : if( ( GRFILTER_FORMAT_NOTFOUND != nFilter ) && ( aGraphic.GetType() != GRAPHIC_NONE ) )
283 : {
284 0 : if( 0 == (nFlags & XOUTBMP_DONT_ADD_EXTENSION))
285 0 : aURL.setExtension( aExt );
286 0 : rFileName = aURL.GetMainURL( INetURLObject::NO_DECODE );
287 0 : nErr = ExportGraphic( aGraphic, aURL, rFilter, nFilter, NULL );
288 : }
289 0 : }
290 : }
291 :
292 0 : return nErr;
293 : }
294 : else
295 : {
296 0 : return GRFILTER_OK;
297 : }
298 : }
299 :
300 : // ------------------------------------------------------------------------
301 :
302 : #ifdef _MSC_VER
303 : #pragma optimize ( "", off )
304 : #endif
305 :
306 0 : sal_uInt16 XOutBitmap::ExportGraphic( const Graphic& rGraphic, const INetURLObject& rURL,
307 : GraphicFilter& rFilter, const sal_uInt16 nFormat,
308 : const com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >* pFilterData )
309 : {
310 : DBG_ASSERT( rURL.GetProtocol() != INET_PROT_NOT_VALID, "XOutBitmap::ExportGraphic(...): invalid URL" );
311 :
312 0 : SfxMedium aMedium( rURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_SHARE_DENYNONE | STREAM_TRUNC );
313 0 : SvStream* pOStm = aMedium.GetOutStream();
314 0 : sal_uInt16 nRet = GRFILTER_IOERROR;
315 :
316 0 : if( pOStm )
317 : {
318 0 : pGrfFilter = &rFilter;
319 :
320 0 : nRet = rFilter.ExportGraphic( rGraphic, rURL.GetMainURL( INetURLObject::NO_DECODE ), *pOStm, nFormat, pFilterData );
321 :
322 0 : pGrfFilter = NULL;
323 0 : aMedium.Commit();
324 :
325 0 : if( aMedium.GetError() && ( GRFILTER_OK == nRet ) )
326 0 : nRet = GRFILTER_IOERROR;
327 : }
328 :
329 0 : return nRet;
330 : }
331 :
332 : #ifdef _MSC_VER
333 : #pragma optimize ( "", on )
334 : #endif
335 :
336 : // ------------------------------------------------------------------------
337 :
338 0 : Bitmap XOutBitmap::DetectEdges( const Bitmap& rBmp, const sal_uInt8 cThreshold )
339 : {
340 0 : const Size aSize( rBmp.GetSizePixel() );
341 0 : Bitmap aRetBmp;
342 0 : sal_Bool bRet = sal_False;
343 :
344 0 : if( ( aSize.Width() > 2L ) && ( aSize.Height() > 2L ) )
345 : {
346 0 : Bitmap aWorkBmp( rBmp );
347 :
348 0 : if( aWorkBmp.Convert( BMP_CONVERSION_8BIT_GREYS ) )
349 : {
350 0 : Bitmap aDstBmp( aSize, 1 );
351 0 : BitmapReadAccess* pReadAcc = aWorkBmp.AcquireReadAccess();
352 0 : BitmapWriteAccess* pWriteAcc = aDstBmp.AcquireWriteAccess();
353 :
354 0 : if( pReadAcc && pWriteAcc )
355 : {
356 0 : const long nWidth = aSize.Width();
357 0 : const long nWidth2 = nWidth - 2L;
358 0 : const long nHeight = aSize.Height();
359 0 : const long nHeight2 = nHeight - 2L;
360 0 : const long lThres2 = (long) cThreshold * cThreshold;
361 0 : const BitmapColor aWhite = (sal_uInt8) pWriteAcc->GetBestMatchingColor( Color( COL_WHITE ) );
362 0 : const BitmapColor aBlack = (sal_uInt8) pWriteAcc->GetBestMatchingColor( Color( COL_BLACK ) );
363 : long nSum1;
364 : long nSum2;
365 : long lGray;
366 :
367 : // Rand mit Weiss init.
368 0 : pWriteAcc->SetLineColor( Color( COL_WHITE) );
369 0 : pWriteAcc->DrawLine( Point(), Point( nWidth - 1L, 0L ) );
370 0 : pWriteAcc->DrawLine( Point( nWidth - 1L, 0L ), Point( nWidth - 1L, nHeight - 1L ) );
371 0 : pWriteAcc->DrawLine( Point( nWidth - 1L, nHeight - 1L ), Point( 0L, nHeight - 1L ) );
372 0 : pWriteAcc->DrawLine( Point( 0, nHeight - 1L ), Point() );
373 :
374 0 : for( long nY = 0L, nY1 = 1L, nY2 = 2; nY < nHeight2; nY++, nY1++, nY2++ )
375 : {
376 0 : for( long nX = 0L, nXDst = 1L, nXTmp; nX < nWidth2; nX++, nXDst++ )
377 : {
378 0 : nXTmp = nX;
379 :
380 0 : nSum1 = -( nSum2 = lGray = (sal_uInt8) pReadAcc->GetPixel( nY, nXTmp++ ) );
381 0 : nSum2 += ( (long) (sal_uInt8) pReadAcc->GetPixel( nY, nXTmp++ ) ) << 1;
382 0 : nSum1 += ( lGray = pReadAcc->GetPixel( nY, nXTmp ) );
383 0 : nSum2 += lGray;
384 :
385 0 : nSum1 += ( (long) (sal_uInt8) pReadAcc->GetPixel( nY1, nXTmp ) ) << 1;
386 0 : nSum1 -= ( (long) (sal_uInt8) pReadAcc->GetPixel( nY1, nXTmp -= 2 ) ) << 1;
387 :
388 0 : nSum1 += ( lGray = -(long) (sal_uInt8) pReadAcc->GetPixel( nY2, nXTmp++ ) );
389 0 : nSum2 += lGray;
390 0 : nSum2 -= ( (long) (sal_uInt8) pReadAcc->GetPixel( nY2, nXTmp++ ) ) << 1;
391 0 : nSum1 += ( lGray = (long) (sal_uInt8) pReadAcc->GetPixel( nY2, nXTmp ) );
392 0 : nSum2 -= lGray;
393 :
394 0 : if( ( nSum1 * nSum1 + nSum2 * nSum2 ) < lThres2 )
395 0 : pWriteAcc->SetPixel( nY1, nXDst, aWhite );
396 : else
397 0 : pWriteAcc->SetPixel( nY1, nXDst, aBlack );
398 : }
399 : }
400 :
401 0 : bRet = sal_True;
402 : }
403 :
404 0 : aWorkBmp.ReleaseAccess( pReadAcc );
405 0 : aDstBmp.ReleaseAccess( pWriteAcc );
406 :
407 0 : if( bRet )
408 0 : aRetBmp = aDstBmp;
409 0 : }
410 : }
411 :
412 0 : if( !aRetBmp )
413 0 : aRetBmp = rBmp;
414 : else
415 : {
416 0 : aRetBmp.SetPrefMapMode( rBmp.GetPrefMapMode() );
417 0 : aRetBmp.SetPrefSize( rBmp.GetPrefSize() );
418 : }
419 :
420 0 : return aRetBmp;
421 : };
422 :
423 : // ------------------------------------------------------------------------
424 :
425 0 : Polygon XOutBitmap::GetCountour( const Bitmap& rBmp, const sal_uIntPtr nFlags,
426 : const sal_uInt8 cEdgeDetectThreshold, const Rectangle* pWorkRectPixel )
427 : {
428 0 : Bitmap aWorkBmp;
429 0 : Polygon aRetPoly;
430 0 : Point aTmpPoint;
431 0 : Rectangle aWorkRect( aTmpPoint, rBmp.GetSizePixel() );
432 :
433 0 : if( pWorkRectPixel )
434 0 : aWorkRect.Intersection( *pWorkRectPixel );
435 :
436 0 : aWorkRect.Justify();
437 :
438 0 : if( ( aWorkRect.GetWidth() > 4 ) && ( aWorkRect.GetHeight() > 4 ) )
439 : {
440 : // falls Flag gesetzt, muessen wir Kanten detektieren
441 0 : if( nFlags & XOUTBMP_CONTOUR_EDGEDETECT )
442 0 : aWorkBmp = DetectEdges( rBmp, cEdgeDetectThreshold );
443 : else
444 0 : aWorkBmp = rBmp;
445 :
446 0 : BitmapReadAccess* pAcc = aWorkBmp.AcquireReadAccess();
447 :
448 0 : if( pAcc )
449 : {
450 0 : const Size& rPrefSize = aWorkBmp.GetPrefSize();
451 0 : const long nWidth = pAcc->Width();
452 0 : const long nHeight = pAcc->Height();
453 0 : const double fFactorX = (double) rPrefSize.Width() / nWidth;
454 0 : const double fFactorY = (double) rPrefSize.Height() / nHeight;
455 0 : const long nStartX1 = aWorkRect.Left() + 1L;
456 0 : const long nEndX1 = aWorkRect.Right();
457 0 : const long nStartX2 = nEndX1 - 1L;
458 : // const long nEndX2 = nStartX1 - 1L;
459 0 : const long nStartY1 = aWorkRect.Top() + 1L;
460 0 : const long nEndY1 = aWorkRect.Bottom();
461 0 : const long nStartY2 = nEndY1 - 1L;
462 : // const long nEndY2 = nStartY1 - 1L;
463 0 : Point* pPoints1 = NULL;
464 0 : Point* pPoints2 = NULL;
465 : long nX, nY;
466 0 : sal_uInt16 nPolyPos = 0;
467 0 : const BitmapColor aBlack = pAcc->GetBestMatchingColor( Color( COL_BLACK ) );
468 :
469 0 : if( nFlags & XOUTBMP_CONTOUR_VERT )
470 : {
471 0 : pPoints1 = new Point[ nWidth ];
472 0 : pPoints2 = new Point[ nWidth ];
473 :
474 0 : for( nX = nStartX1; nX < nEndX1; nX++ )
475 : {
476 0 : nY = nStartY1;
477 :
478 : // zunaechst Zeile von Links nach Rechts durchlaufen
479 0 : while( nY < nEndY1 )
480 : {
481 0 : if( aBlack == pAcc->GetPixel( nY, nX ) )
482 : {
483 0 : pPoints1[ nPolyPos ] = Point( nX, nY );
484 0 : nY = nStartY2;
485 :
486 : // diese Schleife wird immer gebreaked da hier ja min. ein Pixel ist
487 0 : while( sal_True )
488 : {
489 0 : if( aBlack == pAcc->GetPixel( nY, nX ) )
490 : {
491 0 : pPoints2[ nPolyPos ] = Point( nX, nY );
492 0 : break;
493 : }
494 :
495 0 : nY--;
496 : }
497 :
498 0 : nPolyPos++;
499 0 : break;
500 : }
501 :
502 0 : nY++;
503 : }
504 : }
505 : }
506 : else
507 : {
508 0 : pPoints1 = new Point[ nHeight ];
509 0 : pPoints2 = new Point[ nHeight ];
510 :
511 0 : for ( nY = nStartY1; nY < nEndY1; nY++ )
512 : {
513 0 : nX = nStartX1;
514 :
515 : // zunaechst Zeile von Links nach Rechts durchlaufen
516 0 : while( nX < nEndX1 )
517 : {
518 0 : if( aBlack == pAcc->GetPixel( nY, nX ) )
519 : {
520 0 : pPoints1[ nPolyPos ] = Point( nX, nY );
521 0 : nX = nStartX2;
522 :
523 : // diese Schleife wird immer gebreaked da hier ja min. ein Pixel ist
524 0 : while( sal_True )
525 : {
526 0 : if( aBlack == pAcc->GetPixel( nY, nX ) )
527 : {
528 0 : pPoints2[ nPolyPos ] = Point( nX, nY );
529 0 : break;
530 : }
531 :
532 0 : nX--;
533 : }
534 :
535 0 : nPolyPos++;
536 0 : break;
537 : }
538 :
539 0 : nX++;
540 : }
541 : }
542 : }
543 :
544 0 : const sal_uInt16 nNewSize1 = nPolyPos << 1;
545 :
546 0 : aRetPoly = Polygon( nPolyPos, pPoints1 );
547 0 : aRetPoly.SetSize( nNewSize1 + 1 );
548 0 : aRetPoly[ nNewSize1 ] = aRetPoly[ 0 ];
549 :
550 0 : for( sal_uInt16 j = nPolyPos; nPolyPos < nNewSize1; )
551 0 : aRetPoly[ nPolyPos++ ] = pPoints2[ --j ];
552 :
553 0 : if( ( fFactorX != 0. ) && ( fFactorY != 0. ) )
554 0 : aRetPoly.Scale( fFactorX, fFactorY );
555 :
556 0 : delete[] pPoints1;
557 0 : delete[] pPoints2;
558 : }
559 : }
560 :
561 0 : return aRetPoly;
562 : };
563 :
564 : // ----------------
565 : // - DitherBitmap -
566 : // ----------------
567 :
568 0 : sal_Bool DitherBitmap( Bitmap& rBitmap )
569 : {
570 0 : sal_Bool bRet = sal_False;
571 :
572 0 : if( ( rBitmap.GetBitCount() >= 8 ) && ( Application::GetDefaultDevice()->GetColorCount() < 257 ) )
573 0 : bRet = rBitmap.Dither( BMP_DITHER_FLOYD );
574 : else
575 0 : bRet = sal_False;
576 :
577 0 : return bRet;
578 : }
579 :
580 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
