1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_vcl.hxx" 26 27 #include <rtl/logfile.hxx> 28 #include <cppuhelper/compbase1.hxx> 29 30 #include <com/sun/star/geometry/RealSize2D.hpp> 31 #include <com/sun/star/geometry/RealPoint2D.hpp> 32 #include <com/sun/star/geometry/RealRectangle2D.hpp> 33 #include <com/sun/star/geometry/IntegerSize2D.hpp> 34 #include <com/sun/star/geometry/IntegerPoint2D.hpp> 35 #include <com/sun/star/geometry/IntegerRectangle2D.hpp> 36 #include <com/sun/star/geometry/RealBezierSegment2D.hpp> 37 38 #include <com/sun/star/rendering/ColorSpaceType.hpp> 39 #include <com/sun/star/rendering/RenderingIntent.hpp> 40 #include <com/sun/star/rendering/XGraphicDevice.hpp> 41 #include <com/sun/star/rendering/XBitmap.hpp> 42 #include <com/sun/star/rendering/XPolyPolygon2D.hpp> 43 #include <com/sun/star/rendering/IntegerBitmapLayout.hpp> 44 #include <com/sun/star/rendering/XIntegerBitmap.hpp> 45 #include <com/sun/star/rendering/ColorComponentTag.hpp> 46 47 #include <basegfx/matrix/b2dhommatrix.hxx> 48 #include <basegfx/vector/b2dsize.hxx> 49 #include <basegfx/point/b2dpoint.hxx> 50 #include <basegfx/range/b2drectangle.hxx> 51 #include <basegfx/vector/b2isize.hxx> 52 #include <basegfx/point/b2ipoint.hxx> 53 #include <basegfx/range/b2irectangle.hxx> 54 55 // #i79917# 56 #include <basegfx/polygon/b2dpolygon.hxx> 57 #include <basegfx/tools/canvastools.hxx> 58 #include <basegfx/polygon/b2dpolypolygon.hxx> 59 60 #include <tools/poly.hxx> 61 #include <tools/diagnose_ex.h> 62 #include <rtl/uuid.h> 63 64 #include <vcl/salbtype.hxx> 65 #include <vcl/bmpacc.hxx> 66 #include <vcl/bitmapex.hxx> 67 68 #include <canvasbitmap.hxx> 69 #include <vcl/canvastools.hxx> 70 #include <hash_map> 71 72 73 using namespace ::com::sun::star; 74 75 namespace vcl 76 { 77 namespace unotools 78 { 79 // #i79917# removed helpers bezierSequenceFromPolygon and 80 // pointSequenceFromPolygon here 81 // Also all helpers using tools Polygon and PolyPolygon will get mapped to the 82 // B2DPolygon helpers for these cases, see comments with the same TaskID below. 83 // TODO: Remove those wrapped methods 84 85 //--------------------------------------------------------------------------------------- 86 xPolyPolygonFromPolygon(const uno::Reference<rendering::XGraphicDevice> & xGraphicDevice,const::Polygon & inputPolygon)87 uno::Reference< rendering::XPolyPolygon2D > xPolyPolygonFromPolygon( const uno::Reference< rendering::XGraphicDevice >& xGraphicDevice, 88 const ::Polygon& inputPolygon ) 89 { 90 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::xPolyPolygonFromPolygon()" ); 91 92 // #i79917# map to basegfx 93 const basegfx::B2DPolygon aB2DPolygon(inputPolygon.getB2DPolygon()); 94 return basegfx::unotools::xPolyPolygonFromB2DPolygon(xGraphicDevice, aB2DPolygon); 95 } 96 97 //--------------------------------------------------------------------------------------- 98 xPolyPolygonFromPolyPolygon(const uno::Reference<rendering::XGraphicDevice> & xGraphicDevice,const::PolyPolygon & inputPolyPolygon)99 uno::Reference< rendering::XPolyPolygon2D > xPolyPolygonFromPolyPolygon( const uno::Reference< rendering::XGraphicDevice >& xGraphicDevice, 100 const ::PolyPolygon& inputPolyPolygon ) 101 { 102 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::xPolyPolygonFromPolyPolygon()" ); 103 104 // #i79917# map to basegfx 105 const basegfx::B2DPolyPolygon aB2DPolyPolygon(inputPolyPolygon.getB2DPolyPolygon()); 106 return basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(xGraphicDevice, aB2DPolyPolygon); 107 } 108 109 //--------------------------------------------------------------------------------------- 110 polygonFromPoint2DSequence(const uno::Sequence<geometry::RealPoint2D> & points)111 ::Polygon polygonFromPoint2DSequence( const uno::Sequence< geometry::RealPoint2D >& points ) 112 { 113 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::polygonFromPoint2DSequence()" ); 114 115 const sal_uInt16 nCurrSize( sal::static_int_cast<sal_uInt16>(points.getLength()) ); 116 117 ::Polygon aPoly( nCurrSize ); 118 119 sal_uInt16 nCurrPoint; 120 for( nCurrPoint=0; nCurrPoint<nCurrSize; ++nCurrPoint ) 121 aPoly[nCurrPoint] = pointFromRealPoint2D( points[nCurrPoint] ); 122 123 return aPoly; 124 } 125 126 //--------------------------------------------------------------------------------------- 127 polyPolygonFromPoint2DSequenceSequence(const uno::Sequence<uno::Sequence<geometry::RealPoint2D>> & points)128 ::PolyPolygon polyPolygonFromPoint2DSequenceSequence( const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >& points ) 129 { 130 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::polyPolygonFromPoint2DSequenceSequence()" ); 131 132 ::PolyPolygon aRes; 133 134 int nCurrPoly; 135 for( nCurrPoly=0; nCurrPoly<points.getLength(); ++nCurrPoly ) 136 { 137 aRes.Insert( polygonFromPoint2DSequence( points[nCurrPoly] ) ); 138 } 139 140 return aRes; 141 } 142 143 //--------------------------------------------------------------------------------------- 144 polygonFromBezier2DSequence(const uno::Sequence<geometry::RealBezierSegment2D> & curves)145 ::Polygon polygonFromBezier2DSequence( const uno::Sequence< geometry::RealBezierSegment2D >& curves ) 146 { 147 // #i79917# map to basegfx 148 const basegfx::B2DPolygon aB2DPolygon(basegfx::unotools::polygonFromBezier2DSequence(curves)); 149 return ::Polygon(aB2DPolygon); 150 } 151 152 //--------------------------------------------------------------------------------------- 153 polyPolygonFromBezier2DSequenceSequence(const uno::Sequence<uno::Sequence<geometry::RealBezierSegment2D>> & curves)154 ::PolyPolygon polyPolygonFromBezier2DSequenceSequence( const uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > >& curves ) 155 { 156 // #i79917# map to basegfx 157 const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::unotools::polyPolygonFromBezier2DSequenceSequence(curves)); 158 return ::PolyPolygon(aB2DPolyPolygon); 159 } 160 161 //--------------------------------------------------------------------------------------- 162 xBitmapFromBitmap(const uno::Reference<rendering::XGraphicDevice> &,const::Bitmap & inputBitmap)163 uno::Reference< rendering::XBitmap > xBitmapFromBitmap( const uno::Reference< rendering::XGraphicDevice >& /*xGraphicDevice*/, 164 const ::Bitmap& inputBitmap ) 165 { 166 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::xBitmapFromBitmap()" ); 167 168 return new vcl::unotools::VclCanvasBitmap( BitmapEx( inputBitmap ) ); 169 } 170 171 //--------------------------------------------------------------------------------------- 172 xBitmapFromBitmapEx(const uno::Reference<rendering::XGraphicDevice> &,const::BitmapEx & inputBitmap)173 uno::Reference< rendering::XBitmap > xBitmapFromBitmapEx( const uno::Reference< rendering::XGraphicDevice >& /*xGraphicDevice*/, 174 const ::BitmapEx& inputBitmap ) 175 { 176 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::xBitmapFromBitmapEx()" ); 177 178 return new vcl::unotools::VclCanvasBitmap( inputBitmap ); 179 } 180 181 //--------------------------------------------------------------------------------------- 182 getTunnelIdentifier(TunnelIdentifierType eType)183 const uno::Sequence< sal_Int8 > getTunnelIdentifier( TunnelIdentifierType eType ) 184 { 185 static std::hash_map< int, uno::Sequence< sal_Int8 > > aIds; 186 std::hash_map< int, uno::Sequence< sal_Int8 > >::iterator it = 187 aIds.find( eType ); 188 if( it == aIds.end() ) 189 { 190 uno::Sequence< sal_Int8 > aNewId( 16 ); 191 rtl_createUuid( (sal_uInt8*)aNewId.getArray(), NULL, sal_True ); 192 aIds[ eType ] = aNewId; 193 it = aIds.find( eType ); 194 } 195 return it->second; 196 } 197 198 //--------------------------------------------------------------------------------------- 199 200 namespace 201 { operator ==(const rendering::IntegerBitmapLayout & rLHS,const rendering::IntegerBitmapLayout & rRHS)202 inline bool operator==( const rendering::IntegerBitmapLayout& rLHS, 203 const rendering::IntegerBitmapLayout& rRHS ) 204 { 205 return 206 rLHS.ScanLineBytes == rRHS.ScanLineBytes && 207 rLHS.ScanLineStride == rRHS.ScanLineStride && 208 rLHS.PlaneStride == rRHS.PlaneStride && 209 rLHS.ColorSpace == rRHS.ColorSpace && 210 rLHS.Palette == rRHS.Palette && 211 rLHS.IsMsbFirst == rRHS.IsMsbFirst; 212 } 213 readBmp(sal_Int32 nWidth,sal_Int32 nHeight,const rendering::IntegerBitmapLayout & rLayout,const uno::Reference<rendering::XIntegerReadOnlyBitmap> & xInputBitmap,ScopedBitmapWriteAccess & rWriteAcc,ScopedBitmapWriteAccess & rAlphaAcc)214 bool readBmp( sal_Int32 nWidth, 215 sal_Int32 nHeight, 216 const rendering::IntegerBitmapLayout& rLayout, 217 const uno::Reference< rendering::XIntegerReadOnlyBitmap >& xInputBitmap, 218 ScopedBitmapWriteAccess& rWriteAcc, 219 ScopedBitmapWriteAccess& rAlphaAcc ) 220 { 221 rendering::IntegerBitmapLayout aCurrLayout; 222 geometry::IntegerRectangle2D aRect; 223 uno::Sequence<sal_Int8> aPixelData; 224 uno::Sequence<rendering::RGBColor> aRGBColors; 225 uno::Sequence<rendering::ARGBColor> aARGBColors; 226 227 for( aRect.Y1=0; aRect.Y1<nHeight; ++aRect.Y1 ) 228 { 229 aRect.X1 = 0; aRect.X2 = nWidth; aRect.Y2 = aRect.Y1+1; 230 try 231 { 232 aPixelData = xInputBitmap->getData(aCurrLayout,aRect); 233 } 234 catch( rendering::VolatileContentDestroyedException& ) 235 { 236 // re-read bmp from the start 237 return false; 238 } 239 if( !(aCurrLayout == rLayout) ) 240 return false; // re-read bmp from the start 241 242 if( rAlphaAcc.get() ) 243 { 244 // read ARGB color 245 aARGBColors = rLayout.ColorSpace->convertIntegerToARGB(aPixelData); 246 247 if( rWriteAcc->HasPalette() ) 248 { 249 for( sal_Int32 x=0; x<nWidth; ++x ) 250 { 251 const rendering::ARGBColor& rColor=aARGBColors[x]; 252 rWriteAcc->SetPixelIndex( aRect.Y1, x, 253 (sal_uInt8) rWriteAcc->GetBestPaletteIndex( 254 BitmapColor( toByteColor(rColor.Red), 255 toByteColor(rColor.Green), 256 toByteColor(rColor.Blue))) ); 257 rAlphaAcc->SetPixel( aRect.Y1, x, 258 BitmapColor( 255 - toByteColor(rColor.Alpha) )); 259 } 260 } 261 else 262 { 263 for( sal_Int32 x=0; x<nWidth; ++x ) 264 { 265 const rendering::ARGBColor& rColor=aARGBColors[x]; 266 rWriteAcc->SetPixel( aRect.Y1, x, 267 BitmapColor( toByteColor(rColor.Red), 268 toByteColor(rColor.Green), 269 toByteColor(rColor.Blue) )); 270 rAlphaAcc->SetPixel( aRect.Y1, x, 271 BitmapColor( 255 - toByteColor(rColor.Alpha) )); 272 } 273 } 274 } 275 else 276 { 277 // read RGB color 278 aRGBColors = rLayout.ColorSpace->convertIntegerToRGB(aPixelData); 279 if( rWriteAcc->HasPalette() ) 280 { 281 for( sal_Int32 x=0; x<nWidth; ++x ) 282 { 283 const rendering::RGBColor& rColor=aRGBColors[x]; 284 rWriteAcc->SetPixelIndex( aRect.Y1, x, 285 (sal_uInt8) rWriteAcc->GetBestPaletteIndex( 286 BitmapColor( toByteColor(rColor.Red), 287 toByteColor(rColor.Green), 288 toByteColor(rColor.Blue))) ); 289 } 290 } 291 else 292 { 293 for( sal_Int32 x=0; x<nWidth; ++x ) 294 { 295 const rendering::RGBColor& rColor=aRGBColors[x]; 296 rWriteAcc->SetPixel( aRect.Y1, x, 297 BitmapColor( toByteColor(rColor.Red), 298 toByteColor(rColor.Green), 299 toByteColor(rColor.Blue) )); 300 } 301 } 302 } 303 } 304 305 return true; 306 } 307 } 308 bitmapExFromXBitmap(const uno::Reference<rendering::XIntegerReadOnlyBitmap> & xInputBitmap)309 ::BitmapEx VCL_DLLPUBLIC bitmapExFromXBitmap( const uno::Reference< rendering::XIntegerReadOnlyBitmap >& xInputBitmap ) 310 { 311 RTL_LOGFILE_CONTEXT( aLog, "::vcl::unotools::bitmapExFromXBitmap()" ); 312 313 if( !xInputBitmap.is() ) 314 return ::BitmapEx(); 315 316 // tunnel directly for known implementation 317 // ---------------------------------------------------------------- 318 VclCanvasBitmap* pImplBitmap = dynamic_cast<VclCanvasBitmap*>(xInputBitmap.get()); 319 if( pImplBitmap ) 320 return pImplBitmap->getBitmapEx(); 321 322 // retrieve data via UNO interface 323 // ---------------------------------------------------------------- 324 325 // volatile bitmaps are a bit more complicated to read 326 // from.. 327 uno::Reference<rendering::XVolatileBitmap> xVolatileBitmap( 328 xInputBitmap, uno::UNO_QUERY); 329 330 // loop a few times, until successfully read (for XVolatileBitmap) 331 for( int i=0; i<10; ++i ) 332 { 333 sal_Int32 nDepth=0; 334 sal_Int32 nAlphaDepth=0; 335 const rendering::IntegerBitmapLayout aLayout( 336 xInputBitmap->getMemoryLayout()); 337 338 OSL_ENSURE(aLayout.ColorSpace.is(), 339 "Cannot convert image without color space!"); 340 if( !aLayout.ColorSpace.is() ) 341 return ::BitmapEx(); 342 343 nDepth = aLayout.ColorSpace->getBitsPerPixel(); 344 345 if( xInputBitmap->hasAlpha() ) 346 { 347 // determine alpha channel depth 348 const uno::Sequence<sal_Int8> aTags( 349 aLayout.ColorSpace->getComponentTags() ); 350 const uno::Sequence<sal_Int32> aDepths( 351 aLayout.ColorSpace->getComponentBitCounts() ); 352 const sal_Int8* pStart(aTags.getConstArray()); 353 const sal_Size nLen(aTags.getLength()); 354 const sal_Int8* pEnd(pStart+nLen); 355 356 const std::ptrdiff_t nAlphaIndex = 357 std::find(pStart,pEnd, 358 rendering::ColorComponentTag::ALPHA) - pStart; 359 360 if( nAlphaIndex < sal::static_int_cast<std::ptrdiff_t>(nLen) ) 361 { 362 nAlphaDepth = aLayout.ColorSpace->getComponentBitCounts()[nAlphaIndex] > 1 ? 8 : 1; 363 nDepth -= nAlphaDepth; 364 } 365 } 366 367 BitmapPalette aPalette; 368 if( aLayout.Palette.is() ) 369 { 370 uno::Reference< rendering::XColorSpace > xPaletteColorSpace( 371 aLayout.Palette->getColorSpace()); 372 ENSURE_OR_THROW(xPaletteColorSpace.is(), 373 "Palette without color space"); 374 375 const sal_Int32 nEntryCount( aLayout.Palette->getNumberOfEntries() ); 376 if( nEntryCount <= 256 ) 377 { 378 if( nEntryCount <= 2 ) 379 nDepth = 1; 380 else 381 nDepth = 8; 382 383 const sal_uInt16 nPaletteEntries( 384 sal::static_int_cast<sal_uInt16>( 385 std::min(sal_Int32(255), nEntryCount))); 386 387 // copy palette entries 388 aPalette.SetEntryCount(nPaletteEntries); 389 uno::Reference<rendering::XBitmapPalette> xPalette( aLayout.Palette ); 390 uno::Reference<rendering::XColorSpace> xPalColorSpace( xPalette->getColorSpace() ); 391 392 uno::Sequence<double> aPaletteEntry; 393 for( sal_uInt16 j=0; j<nPaletteEntries; ++j ) 394 { 395 if( !xPalette->getIndex(aPaletteEntry,j) && 396 nAlphaDepth == 0 ) 397 { 398 nAlphaDepth = 1; 399 } 400 uno::Sequence<rendering::RGBColor> aColors=xPalColorSpace->convertToRGB(aPaletteEntry); 401 ENSURE_OR_THROW(aColors.getLength() == 1, 402 "Palette returned more or less than one entry"); 403 const rendering::RGBColor& rColor=aColors[0]; 404 aPalette[j] = BitmapColor(toByteColor(rColor.Red), 405 toByteColor(rColor.Green), 406 toByteColor(rColor.Blue)); 407 } 408 } 409 } 410 411 const ::Size aPixelSize( 412 sizeFromIntegerSize2D(xInputBitmap->getSize())); 413 414 // normalize bitcount 415 nDepth = 416 ( nDepth <= 1 ) ? 1 : 417 ( nDepth <= 4 ) ? 4 : 418 ( nDepth <= 8 ) ? 8 : 24; 419 420 ::Bitmap aBitmap( aPixelSize, 421 sal::static_int_cast<sal_uInt16>(nDepth), 422 aLayout.Palette.is() ? &aPalette : NULL ); 423 ::Bitmap aAlpha; 424 if( nAlphaDepth ) 425 aAlpha = ::Bitmap( aPixelSize, 426 sal::static_int_cast<sal_uInt16>(nAlphaDepth), 427 &::Bitmap::GetGreyPalette( 428 sal::static_int_cast<sal_uInt16>(1L << nAlphaDepth)) ); 429 430 { // limit scoped access 431 ScopedBitmapWriteAccess pWriteAccess( aBitmap.AcquireWriteAccess(), 432 aBitmap ); 433 ScopedBitmapWriteAccess pAlphaWriteAccess( nAlphaDepth ? aAlpha.AcquireWriteAccess() : NULL, 434 aAlpha ); 435 436 ENSURE_OR_THROW(pWriteAccess.get() != NULL, 437 "Cannot get write access to bitmap"); 438 439 const sal_Int32 nWidth(aPixelSize.Width()); 440 const sal_Int32 nHeight(aPixelSize.Height()); 441 442 if( !readBmp(nWidth,nHeight,aLayout,xInputBitmap, 443 pWriteAccess,pAlphaWriteAccess) ) 444 continue; 445 } // limit scoped access 446 447 if( nAlphaDepth ) 448 return ::BitmapEx( aBitmap, 449 AlphaMask( aAlpha ) ); 450 else 451 return ::BitmapEx( aBitmap ); 452 } 453 454 // failed to read data 10 times - bail out 455 return ::BitmapEx(); 456 } 457 458 //--------------------------------------------------------------------------------------- 459 size2DFromSize(const Size & rSize)460 geometry::RealSize2D size2DFromSize( const Size& rSize ) 461 { 462 return geometry::RealSize2D( rSize.Width(), 463 rSize.Height() ); 464 } 465 point2DFromPoint(const Point & rPoint)466 geometry::RealPoint2D point2DFromPoint( const Point& rPoint ) 467 { 468 return geometry::RealPoint2D( rPoint.X(), 469 rPoint.Y() ); 470 } 471 rectangle2DFromRectangle(const Rectangle & rRect)472 geometry::RealRectangle2D rectangle2DFromRectangle( const Rectangle& rRect ) 473 { 474 return geometry::RealRectangle2D( rRect.Left(), rRect.Top(), 475 rRect.Right(), rRect.Bottom() ); 476 } 477 sizeFromRealSize2D(const geometry::RealSize2D & rSize)478 Size sizeFromRealSize2D( const geometry::RealSize2D& rSize ) 479 { 480 return Size( static_cast<long>(rSize.Width + .5), 481 static_cast<long>(rSize.Height + .5) ); 482 } 483 pointFromRealPoint2D(const geometry::RealPoint2D & rPoint)484 Point pointFromRealPoint2D( const geometry::RealPoint2D& rPoint ) 485 { 486 return Point( static_cast<long>(rPoint.X + .5), 487 static_cast<long>(rPoint.Y + .5) ); 488 } 489 rectangleFromRealRectangle2D(const geometry::RealRectangle2D & rRect)490 Rectangle rectangleFromRealRectangle2D( const geometry::RealRectangle2D& rRect ) 491 { 492 return Rectangle( static_cast<long>(rRect.X1 + .5), 493 static_cast<long>(rRect.Y1 + .5), 494 static_cast<long>(rRect.X2 + .5), 495 static_cast<long>(rRect.Y2 + .5) ); 496 } 497 sizeFromB2DSize(const::basegfx::B2DVector & rVec)498 ::Size sizeFromB2DSize( const ::basegfx::B2DVector& rVec ) 499 { 500 return ::Size( FRound( rVec.getX() ), 501 FRound( rVec.getY() ) ); 502 } 503 pointFromB2DPoint(const::basegfx::B2DPoint & rPoint)504 ::Point pointFromB2DPoint( const ::basegfx::B2DPoint& rPoint ) 505 { 506 return ::Point( FRound( rPoint.getX() ), 507 FRound( rPoint.getY() ) ); 508 } 509 rectangleFromB2DRectangle(const::basegfx::B2DRange & rRect)510 ::Rectangle rectangleFromB2DRectangle( const ::basegfx::B2DRange& rRect ) 511 { 512 return ::Rectangle( FRound( rRect.getMinX() ), 513 FRound( rRect.getMinY() ), 514 FRound( rRect.getMaxX() ), 515 FRound( rRect.getMaxY() ) ); 516 } 517 sizeFromB2ISize(const::basegfx::B2IVector & rVec)518 Size sizeFromB2ISize( const ::basegfx::B2IVector& rVec ) 519 { 520 return ::Size( rVec.getX(), 521 rVec.getY() ); 522 } 523 pointFromB2IPoint(const::basegfx::B2IPoint & rPoint)524 Point pointFromB2IPoint( const ::basegfx::B2IPoint& rPoint ) 525 { 526 return ::Point( rPoint.getX(), 527 rPoint.getY() ); 528 } 529 rectangleFromB2IRectangle(const::basegfx::B2IRange & rRect)530 Rectangle rectangleFromB2IRectangle( const ::basegfx::B2IRange& rRect ) 531 { 532 return ::Rectangle( rRect.getMinX(), 533 rRect.getMinY(), 534 rRect.getMaxX(), 535 rRect.getMaxY() ); 536 } 537 b2DSizeFromSize(const::Size & rSize)538 ::basegfx::B2DVector b2DSizeFromSize( const ::Size& rSize ) 539 { 540 return ::basegfx::B2DVector( rSize.Width(), 541 rSize.Height() ); 542 } 543 b2DPointFromPoint(const::Point & rPoint)544 ::basegfx::B2DPoint b2DPointFromPoint( const ::Point& rPoint ) 545 { 546 return ::basegfx::B2DPoint( rPoint.X(), 547 rPoint.Y() ); 548 } 549 b2DRectangleFromRectangle(const::Rectangle & rRect)550 ::basegfx::B2DRange b2DRectangleFromRectangle( const ::Rectangle& rRect ) 551 { 552 return ::basegfx::B2DRange( rRect.Left(), 553 rRect.Top(), 554 rRect.Right(), 555 rRect.Bottom() ); 556 } 557 b2ISizeFromSize(const Size & rSize)558 basegfx::B2IVector b2ISizeFromSize( const Size& rSize ) 559 { 560 return ::basegfx::B2IVector( rSize.Width(), 561 rSize.Height() ); 562 } 563 b2IPointFromPoint(const Point & rPoint)564 basegfx::B2IPoint b2IPointFromPoint( const Point& rPoint ) 565 { 566 return ::basegfx::B2IPoint( rPoint.X(), 567 rPoint.Y() ); 568 } 569 b2IRectangleFromRectangle(const Rectangle & rRect)570 basegfx::B2IRange b2IRectangleFromRectangle( const Rectangle& rRect ) 571 { 572 return ::basegfx::B2IRange( rRect.Left(), 573 rRect.Top(), 574 rRect.Right(), 575 rRect.Bottom() ); 576 } 577 integerSize2DFromSize(const Size & rSize)578 geometry::IntegerSize2D integerSize2DFromSize( const Size& rSize ) 579 { 580 return geometry::IntegerSize2D( rSize.Width(), 581 rSize.Height() ); 582 } 583 integerPoint2DFromPoint(const Point & rPoint)584 geometry::IntegerPoint2D integerPoint2DFromPoint( const Point& rPoint ) 585 { 586 return geometry::IntegerPoint2D( rPoint.X(), 587 rPoint.Y() ); 588 } 589 integerRectangle2DFromRectangle(const Rectangle & rRectangle)590 geometry::IntegerRectangle2D integerRectangle2DFromRectangle( const Rectangle& rRectangle ) 591 { 592 return geometry::IntegerRectangle2D( rRectangle.Left(), rRectangle.Top(), 593 rRectangle.Right(), rRectangle.Bottom() ); 594 } 595 sizeFromIntegerSize2D(const geometry::IntegerSize2D & rSize)596 Size sizeFromIntegerSize2D( const geometry::IntegerSize2D& rSize ) 597 { 598 return Size( rSize.Width, 599 rSize.Height ); 600 } 601 pointFromIntegerPoint2D(const geometry::IntegerPoint2D & rPoint)602 Point pointFromIntegerPoint2D( const geometry::IntegerPoint2D& rPoint ) 603 { 604 return Point( rPoint.X, 605 rPoint.Y ); 606 } 607 rectangleFromIntegerRectangle2D(const geometry::IntegerRectangle2D & rRectangle)608 Rectangle rectangleFromIntegerRectangle2D( const geometry::IntegerRectangle2D& rRectangle ) 609 { 610 return Rectangle( rRectangle.X1, rRectangle.Y1, 611 rRectangle.X2, rRectangle.Y2 ); 612 } 613 614 namespace 615 { 616 class StandardColorSpace : public cppu::WeakImplHelper1< com::sun::star::rendering::XColorSpace > 617 { 618 private: 619 uno::Sequence< sal_Int8 > m_aComponentTags; 620 getType()621 virtual ::sal_Int8 SAL_CALL getType( ) throw (uno::RuntimeException) 622 { 623 return rendering::ColorSpaceType::RGB; 624 } getComponentTags()625 virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags( ) throw (uno::RuntimeException) 626 { 627 return m_aComponentTags; 628 } getRenderingIntent()629 virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) throw (uno::RuntimeException) 630 { 631 return rendering::RenderingIntent::PERCEPTUAL; 632 } getProperties()633 virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) throw (uno::RuntimeException) 634 { 635 return uno::Sequence< beans::PropertyValue >(); 636 } convertColorSpace(const uno::Sequence<double> & deviceColor,const uno::Reference<rendering::XColorSpace> & targetColorSpace)637 virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor, 638 const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException, 639 uno::RuntimeException) 640 { 641 // TODO(P3): if we know anything about target 642 // colorspace, this can be greatly sped up 643 uno::Sequence<rendering::ARGBColor> aIntermediate( 644 convertToARGB(deviceColor)); 645 return targetColorSpace->convertFromARGB(aIntermediate); 646 } convertToRGB(const uno::Sequence<double> & deviceColor)647 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 648 { 649 const double* pIn( deviceColor.getConstArray() ); 650 const sal_Size nLen( deviceColor.getLength() ); 651 ENSURE_ARG_OR_THROW2(nLen%4==0, 652 "number of channels no multiple of 4", 653 static_cast<rendering::XColorSpace*>(this), 0); 654 655 uno::Sequence< rendering::RGBColor > aRes(nLen/4); 656 rendering::RGBColor* pOut( aRes.getArray() ); 657 for( sal_Size i=0; i<nLen; i+=4 ) 658 { 659 *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]); 660 pIn += 4; 661 } 662 return aRes; 663 } convertToARGB(const uno::Sequence<double> & deviceColor)664 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 665 { 666 const double* pIn( deviceColor.getConstArray() ); 667 const sal_Size nLen( deviceColor.getLength() ); 668 ENSURE_ARG_OR_THROW2(nLen%4==0, 669 "number of channels no multiple of 4", 670 static_cast<rendering::XColorSpace*>(this), 0); 671 672 uno::Sequence< rendering::ARGBColor > aRes(nLen/4); 673 rendering::ARGBColor* pOut( aRes.getArray() ); 674 for( sal_Size i=0; i<nLen; i+=4 ) 675 { 676 *pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]); 677 pIn += 4; 678 } 679 return aRes; 680 } convertToPARGB(const uno::Sequence<double> & deviceColor)681 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 682 { 683 const double* pIn( deviceColor.getConstArray() ); 684 const sal_Size nLen( deviceColor.getLength() ); 685 ENSURE_ARG_OR_THROW2(nLen%4==0, 686 "number of channels no multiple of 4", 687 static_cast<rendering::XColorSpace*>(this), 0); 688 689 uno::Sequence< rendering::ARGBColor > aRes(nLen/4); 690 rendering::ARGBColor* pOut( aRes.getArray() ); 691 for( sal_Size i=0; i<nLen; i+=4 ) 692 { 693 *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]); 694 pIn += 4; 695 } 696 return aRes; 697 } convertFromRGB(const uno::Sequence<rendering::RGBColor> & rgbColor)698 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 699 { 700 const rendering::RGBColor* pIn( rgbColor.getConstArray() ); 701 const sal_Size nLen( rgbColor.getLength() ); 702 703 uno::Sequence< double > aRes(nLen*4); 704 double* pColors=aRes.getArray(); 705 for( sal_Size i=0; i<nLen; ++i ) 706 { 707 *pColors++ = pIn->Red; 708 *pColors++ = pIn->Green; 709 *pColors++ = pIn->Blue; 710 *pColors++ = 1.0; 711 ++pIn; 712 } 713 return aRes; 714 } convertFromARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)715 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 716 { 717 const rendering::ARGBColor* pIn( rgbColor.getConstArray() ); 718 const sal_Size nLen( rgbColor.getLength() ); 719 720 uno::Sequence< double > aRes(nLen*4); 721 double* pColors=aRes.getArray(); 722 for( sal_Size i=0; i<nLen; ++i ) 723 { 724 *pColors++ = pIn->Red; 725 *pColors++ = pIn->Green; 726 *pColors++ = pIn->Blue; 727 *pColors++ = pIn->Alpha; 728 ++pIn; 729 } 730 return aRes; 731 } convertFromPARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)732 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException) 733 { 734 const rendering::ARGBColor* pIn( rgbColor.getConstArray() ); 735 const sal_Size nLen( rgbColor.getLength() ); 736 737 uno::Sequence< double > aRes(nLen*4); 738 double* pColors=aRes.getArray(); 739 for( sal_Size i=0; i<nLen; ++i ) 740 { 741 *pColors++ = pIn->Red/pIn->Alpha; 742 *pColors++ = pIn->Green/pIn->Alpha; 743 *pColors++ = pIn->Blue/pIn->Alpha; 744 *pColors++ = pIn->Alpha; 745 ++pIn; 746 } 747 return aRes; 748 } 749 750 public: StandardColorSpace()751 StandardColorSpace() : m_aComponentTags(4) 752 { 753 sal_Int8* pTags = m_aComponentTags.getArray(); 754 pTags[0] = rendering::ColorComponentTag::RGB_RED; 755 pTags[1] = rendering::ColorComponentTag::RGB_GREEN; 756 pTags[2] = rendering::ColorComponentTag::RGB_BLUE; 757 pTags[3] = rendering::ColorComponentTag::ALPHA; 758 } 759 }; 760 } 761 createStandardColorSpace()762 uno::Reference<rendering::XColorSpace> VCL_DLLPUBLIC createStandardColorSpace() 763 { 764 return new StandardColorSpace(); 765 } 766 767 //--------------------------------------------------------------------------------------- 768 colorToStdColorSpaceSequence(const Color & rColor)769 uno::Sequence< double > colorToStdColorSpaceSequence( const Color& rColor ) 770 { 771 uno::Sequence< double > aRet(4); 772 double* pRet = aRet.getArray(); 773 774 pRet[0] = toDoubleColor(rColor.GetRed()); 775 pRet[1] = toDoubleColor(rColor.GetGreen()); 776 pRet[2] = toDoubleColor(rColor.GetBlue()); 777 778 // VCL's notion of alpha is different from the rest of the world's 779 pRet[3] = 1.0 - toDoubleColor(rColor.GetTransparency()); 780 781 return aRet; 782 } 783 stdColorSpaceSequenceToColor(const uno::Sequence<double> & rColor)784 Color stdColorSpaceSequenceToColor( const uno::Sequence< double >& rColor ) 785 { 786 ENSURE_ARG_OR_THROW( rColor.getLength() == 4, 787 "color must have 4 channels" ); 788 789 Color aColor; 790 791 aColor.SetRed ( toByteColor(rColor[0]) ); 792 aColor.SetGreen( toByteColor(rColor[1]) ); 793 aColor.SetBlue ( toByteColor(rColor[2]) ); 794 // VCL's notion of alpha is different from the rest of the world's 795 aColor.SetTransparency( 255 - toByteColor(rColor[3]) ); 796 797 return aColor; 798 } 799 colorToDoubleSequence(const Color & rColor,const uno::Reference<rendering::XColorSpace> & xColorSpace)800 uno::Sequence< double > VCL_DLLPUBLIC colorToDoubleSequence( 801 const Color& rColor, 802 const uno::Reference< rendering::XColorSpace >& xColorSpace ) 803 { 804 uno::Sequence<rendering::ARGBColor> aSeq(1); 805 aSeq[0] = rendering::ARGBColor( 806 1.0-toDoubleColor(rColor.GetTransparency()), 807 toDoubleColor(rColor.GetRed()), 808 toDoubleColor(rColor.GetGreen()), 809 toDoubleColor(rColor.GetBlue()) ); 810 811 return xColorSpace->convertFromARGB(aSeq); 812 } 813 doubleSequenceToColor(const uno::Sequence<double> rColor,const uno::Reference<rendering::XColorSpace> & xColorSpace)814 Color VCL_DLLPUBLIC doubleSequenceToColor( 815 const uno::Sequence< double > rColor, 816 const uno::Reference< rendering::XColorSpace >& xColorSpace ) 817 { 818 const rendering::ARGBColor& rARGBColor( 819 xColorSpace->convertToARGB(rColor)[0]); 820 821 return Color( 255-toByteColor(rARGBColor.Alpha), 822 toByteColor(rARGBColor.Red), 823 toByteColor(rARGBColor.Green), 824 toByteColor(rARGBColor.Blue) ); 825 } 826 827 //--------------------------------------------------------------------------------------- 828 829 } // namespace vcltools 830 831 } // namespace canvas 832 833 // eof 834