toolkit/source/awt/vclxgraphics.cxx

   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 <toolkit/awt/vclxgraphics.hxx>
  22 #include <toolkit/awt/vclxdevice.hxx>
  23 #include <toolkit/awt/vclxfont.hxx>
  24 #include <toolkit/helper/macros.hxx>
  25 #include <toolkit/helper/vclunohelper.hxx>
  26 #include <cppuhelper/typeprovider.hxx>
  27 #include <cppuhelper/queryinterface.hxx>
  28 #include <rtl/uuid.h>
  29
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/outdev.hxx>
  32 #include <vcl/image.hxx>
  33 #include <vcl/gradient.hxx>
  34 #include <tools/debug.hxx>
  35
  36 using namespace com::sun::star;
  37
  38
  39 //  class VCLXGraphics
  40
  41
  42 // uno::XInterface
  43 uno::Any VCLXGraphics::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException, std::exception)
  44 {
  45     uno::Any aRet = ::cppu::queryInterface( rType,
  46                                         (static_cast< css::awt::XGraphics* >(this)),
  47                                         (static_cast< css::lang::XTypeProvider* >(this)),
  48                                         (static_cast< css::lang::XUnoTunnel* >(this)) );
  49     return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
  50 }
  51
  52 // lang::XUnoTunnel
  53 IMPL_XUNOTUNNEL( VCLXGraphics )
  54
  55 // lang::XTypeProvider
  56 IMPL_XTYPEPROVIDER_START( VCLXGraphics )
  57     cppu::UnoType<awt::XGraphics>::get()
  58 IMPL_XTYPEPROVIDER_END
  59
  60 VCLXGraphics::VCLXGraphics()
  61     : mpOutputDevice(nullptr)
  62     , meRasterOp(ROP_OVERPAINT)
  63     , mpClipRegion(nullptr)
  64 {
  65 }
  66
  67 VCLXGraphics::~VCLXGraphics()
  68 {
  69     std::vector< VCLXGraphics* > *pLst = mpOutputDevice ? mpOutputDevice->GetUnoGraphicsList() : nullptr;
  70     if ( pLst )
  71     {
  72         for( std::vector< VCLXGraphics* >::iterator it = pLst->begin(); it != pLst->end(); ++it )
  73         {
  74             if( *it == this ) {
  75                 pLst->erase( it );
  76                 break;
  77             }
  78         }
  79     }
  80
  81     delete mpClipRegion;
  82
  83     SolarMutexGuard g;
  84     mpOutputDevice.reset();
  85 }
  86
  87 void VCLXGraphics::SetOutputDevice( OutputDevice* pOutDev )
  88 {
  89     mpOutputDevice = pOutDev;
  90     mxDevice = nullptr;
  91     initAttrs();
  92 }
  93
  94 void VCLXGraphics::Init( OutputDevice* pOutDev )
  95 {
  96     DBG_ASSERT( !mpOutputDevice, "VCLXGraphics::Init already has pOutDev !" );
  97     mpOutputDevice  = pOutDev;
  98
  99     initAttrs();
 100     mpClipRegion    = nullptr;
 101
 102     // Register at OutputDevice
 103     std::vector< VCLXGraphics* > *pLst = mpOutputDevice->GetUnoGraphicsList();
 104     if ( !pLst )
 105         pLst = mpOutputDevice->CreateUnoGraphicsList();
 106     pLst->push_back( this );
 107 }
 108
 109 void VCLXGraphics::initAttrs()
 110 {
 111     if ( !mpOutputDevice )
 112         return;
 113
 114     maFont          = mpOutputDevice->GetFont();
 115     maTextColor     = mpOutputDevice->GetTextColor(); /* COL_BLACK */
 116     maTextFillColor = mpOutputDevice->GetTextFillColor(); /* COL_TRANSPARENT */
 117     maLineColor     = mpOutputDevice->GetLineColor(); /* COL_BLACK */
 118     maFillColor     = mpOutputDevice->GetFillColor(); /* COL_WHITE */
 119     meRasterOp      = mpOutputDevice->GetRasterOp(); /* ROP_OVERPAINT */
 120 }
 121
 122 void VCLXGraphics::InitOutputDevice( InitOutDevFlags nFlags )
 123 {
 124     if(mpOutputDevice)
 125     {
 126         SolarMutexGuard aVclGuard;
 127
 128         if ( nFlags & InitOutDevFlags::FONT )
 129         {
 130             mpOutputDevice->SetFont( maFont );
 131             mpOutputDevice->SetTextColor( maTextColor );
 132             mpOutputDevice->SetTextFillColor( maTextFillColor );
 133         }
 134
 135         if ( nFlags & InitOutDevFlags::COLORS )
 136         {
 137             mpOutputDevice->SetLineColor( maLineColor );
 138             mpOutputDevice->SetFillColor( maFillColor );
 139         }
 140
 141         if ( nFlags & InitOutDevFlags::RASTEROP )
 142         {
 143             mpOutputDevice->SetRasterOp( meRasterOp );
 144         }
 145
 146         if ( nFlags & InitOutDevFlags::CLIPREGION )
 147         {
 148             if( mpClipRegion )
 149                 mpOutputDevice->SetClipRegion( *mpClipRegion );
 150             else
 151                 mpOutputDevice->SetClipRegion();
 152         }
 153     }
 154 }
 155
 156 uno::Reference< awt::XDevice > VCLXGraphics::getDevice() throw(uno::RuntimeException, std::exception)
 157 {
 158     SolarMutexGuard aGuard;
 159
 160     if( !mxDevice.is() && mpOutputDevice )
 161     {
 162         VCLXDevice* pDev = new VCLXDevice;
 163         pDev->SetOutputDevice( mpOutputDevice );
 164         mxDevice = pDev;
 165     }
 166     return mxDevice;
 167 }
 168
 169 awt::SimpleFontMetric VCLXGraphics::getFontMetric() throw(uno::RuntimeException, std::exception)
 170 {
 171     SolarMutexGuard aGuard;
 172
 173     awt::SimpleFontMetric aM;
 174     if( mpOutputDevice )
 175     {
 176         mpOutputDevice->SetFont( maFont );
 177         aM = VCLUnoHelper::CreateFontMetric( mpOutputDevice->GetFontMetric() );
 178     }
 179     return aM;
 180 }
 181
 182 void VCLXGraphics::setFont( const uno::Reference< awt::XFont >& rxFont ) throw(uno::RuntimeException, std::exception)
 183 {
 184     SolarMutexGuard aGuard;
 185
 186     maFont = VCLUnoHelper::CreateFont( rxFont );
 187 }
 188
 189 void VCLXGraphics::selectFont( const awt::FontDescriptor& rDescription ) throw(uno::RuntimeException, std::exception)
 190 {
 191     SolarMutexGuard aGuard;
 192
 193     maFont = VCLUnoHelper::CreateFont( rDescription, vcl::Font() );
 194 }
 195
 196 void VCLXGraphics::setTextColor( sal_Int32 nColor ) throw(uno::RuntimeException, std::exception)
 197 {
 198     SolarMutexGuard aGuard;
 199
 200     maTextColor = Color( (sal_uInt32)nColor );
 201 }
 202
 203 void VCLXGraphics::setTextFillColor( sal_Int32 nColor ) throw(uno::RuntimeException, std::exception)
 204 {
 205     SolarMutexGuard aGuard;
 206
 207     maTextFillColor = Color( (sal_uInt32)nColor );
 208 }
 209
 210 void VCLXGraphics::setLineColor( sal_Int32 nColor ) throw(uno::RuntimeException, std::exception)
 211 {
 212     SolarMutexGuard aGuard;
 213
 214     maLineColor = Color( (sal_uInt32)nColor );
 215 }
 216
 217 void VCLXGraphics::setFillColor( sal_Int32 nColor ) throw(uno::RuntimeException, std::exception)
 218 {
 219     SolarMutexGuard aGuard;
 220
 221     maFillColor = Color( (sal_uInt32)nColor );
 222 }
 223
 224 void VCLXGraphics::setRasterOp( awt::RasterOperation eROP ) throw(uno::RuntimeException, std::exception)
 225 {
 226     SolarMutexGuard aGuard;
 227
 228     meRasterOp = (RasterOp)eROP;
 229 }
 230
 231 void VCLXGraphics::setClipRegion( const uno::Reference< awt::XRegion >& rxRegion ) throw(uno::RuntimeException, std::exception)
 232 {
 233     SolarMutexGuard aGuard;
 234
 235     delete mpClipRegion;
 236     if ( rxRegion.is() )
 237         mpClipRegion = new vcl::Region( VCLUnoHelper::GetRegion( rxRegion ) );
 238     else
 239         mpClipRegion = nullptr;
 240 }
 241
 242 void VCLXGraphics::intersectClipRegion( const uno::Reference< awt::XRegion >& rxRegion ) throw(uno::RuntimeException, std::exception)
 243 {
 244     SolarMutexGuard aGuard;
 245
 246     if ( rxRegion.is() )
 247     {
 248         vcl::Region aRegion( VCLUnoHelper::GetRegion( rxRegion ) );
 249         if ( !mpClipRegion )
 250             mpClipRegion = new vcl::Region( aRegion );
 251         else
 252             mpClipRegion->Intersect( aRegion );
 253     }
 254 }
 255
 256 void VCLXGraphics::push(  ) throw(uno::RuntimeException, std::exception)
 257 {
 258     SolarMutexGuard aGuard;
 259
 260
 261     if( mpOutputDevice )
 262         mpOutputDevice->Push();
 263 }
 264
 265 void VCLXGraphics::pop(  ) throw(uno::RuntimeException, std::exception)
 266 {
 267     SolarMutexGuard aGuard;
 268
 269
 270     if( mpOutputDevice )
 271         mpOutputDevice->Pop();
 272 }
 273
 274 void VCLXGraphics::clear(
 275     const awt::Rectangle& aRect )
 276 throw(uno::RuntimeException, std::exception)
 277 {
 278     SolarMutexGuard aGuard;
 279
 280     if( mpOutputDevice )
 281     {
 282         const ::Rectangle aVCLRect = VCLUnoHelper::ConvertToVCLRect( aRect );
 283         mpOutputDevice->Erase( aVCLRect );
 284     }
 285 }
 286
 287 void VCLXGraphics::copy( const uno::Reference< awt::XDevice >& rxSource, sal_Int32 nSourceX, sal_Int32 nSourceY, sal_Int32 nSourceWidth, sal_Int32 nSourceHeight, sal_Int32 nDestX, sal_Int32 nDestY, sal_Int32 nDestWidth, sal_Int32 nDestHeight ) throw(uno::RuntimeException, std::exception)
 288 {
 289     SolarMutexGuard aGuard;
 290
 291     if ( mpOutputDevice )
 292     {
 293         VCLXDevice* pFromDev = VCLXDevice::GetImplementation( rxSource );
 294         DBG_ASSERT( pFromDev, "VCLXGraphics::copy - invalid device" );
 295         if ( pFromDev )
 296         {
 297             InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP );
 298             mpOutputDevice->DrawOutDev( Point( nDestX, nDestY ), Size( nDestWidth, nDestHeight ),
 299                                     Point( nSourceX, nSourceY ), Size( nSourceWidth, nSourceHeight ), *pFromDev->GetOutputDevice() );
 300         }
 301     }
 302 }
 303
 304 void VCLXGraphics::draw( const uno::Reference< awt::XDisplayBitmap >& rxBitmapHandle, sal_Int32 nSourceX, sal_Int32 nSourceY, sal_Int32 nSourceWidth, sal_Int32 nSourceHeight, sal_Int32 nDestX, sal_Int32 nDestY, sal_Int32 nDestWidth, sal_Int32 nDestHeight ) throw(uno::RuntimeException, std::exception)
 305 {
 306     SolarMutexGuard aGuard;
 307
 308     if( mpOutputDevice )
 309     {
 310         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP);
 311         uno::Reference< awt::XBitmap > xBitmap( rxBitmapHandle, uno::UNO_QUERY );
 312         BitmapEx aBmpEx = VCLUnoHelper::GetBitmap( xBitmap );
 313
 314         Point aPos(nDestX - nSourceX, nDestY - nSourceY);
 315           Size aSz = aBmpEx.GetSizePixel();
 316
 317         if(nDestWidth != nSourceWidth)
 318         {
 319             float zoomX = (float)nDestWidth / (float)nSourceWidth;
 320             aSz.Width() = (long) ((float)aSz.Width() * zoomX);
 321         }
 322
 323         if(nDestHeight != nSourceHeight)
 324         {
 325             float zoomY = (float)nDestHeight / (float)nSourceHeight;
 326             aSz.Height() = (long) ((float)aSz.Height() * zoomY);
 327         }
 328
 329         if(nSourceX || nSourceY || aSz.Width() != nSourceWidth || aSz.Height() != nSourceHeight)
 330             mpOutputDevice->IntersectClipRegion(vcl::Region(Rectangle(nDestX, nDestY, nDestX + nDestWidth - 1, nDestY + nDestHeight - 1)));
 331
 332         mpOutputDevice->DrawBitmapEx( aPos, aSz, aBmpEx );
 333     }
 334 }
 335
 336 void VCLXGraphics::drawPixel( sal_Int32 x, sal_Int32 y ) throw(uno::RuntimeException, std::exception)
 337 {
 338     SolarMutexGuard aGuard;
 339
 340     if( mpOutputDevice )
 341     {
 342         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 343         mpOutputDevice->DrawPixel( Point( x, y ) );
 344     }
 345 }
 346
 347 void VCLXGraphics::drawLine( sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException, std::exception)
 348 {
 349     SolarMutexGuard aGuard;
 350
 351     if( mpOutputDevice )
 352     {
 353         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 354         mpOutputDevice->DrawLine( Point( x1, y1 ), Point( x2, y2 ) );
 355     }
 356 }
 357
 358 void VCLXGraphics::drawRect( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height ) throw(uno::RuntimeException, std::exception)
 359 {
 360     SolarMutexGuard aGuard;
 361
 362     if( mpOutputDevice )
 363     {
 364         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 365         mpOutputDevice->DrawRect( Rectangle( Point( x, y ), Size( width, height ) ) );
 366     }
 367 }
 368
 369 void VCLXGraphics::drawRoundedRect( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 nHorzRound, sal_Int32 nVertRound ) throw(uno::RuntimeException, std::exception)
 370 {
 371     SolarMutexGuard aGuard;
 372
 373     if( mpOutputDevice )
 374     {
 375         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 376         mpOutputDevice->DrawRect( Rectangle( Point( x, y ), Size( width, height ) ), nHorzRound, nVertRound );
 377     }
 378 }
 379
 380 void VCLXGraphics::drawPolyLine( const uno::Sequence< sal_Int32 >& DataX, const uno::Sequence< sal_Int32 >& DataY ) throw(uno::RuntimeException, std::exception)
 381 {
 382     SolarMutexGuard aGuard;
 383
 384     if( mpOutputDevice )
 385     {
 386         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 387         mpOutputDevice->DrawPolyLine( VCLUnoHelper::CreatePolygon( DataX, DataY ) );
 388     }
 389 }
 390
 391 void VCLXGraphics::drawPolygon( const uno::Sequence< sal_Int32 >& DataX, const uno::Sequence< sal_Int32 >& DataY ) throw(uno::RuntimeException, std::exception)
 392 {
 393     SolarMutexGuard aGuard;
 394
 395     if( mpOutputDevice )
 396     {
 397         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 398         mpOutputDevice->DrawPolygon( VCLUnoHelper::CreatePolygon( DataX, DataY ) );
 399     }
 400 }
 401
 402 void VCLXGraphics::drawPolyPolygon( const uno::Sequence< uno::Sequence< sal_Int32 > >& DataX, const uno::Sequence< uno::Sequence< sal_Int32 > >& DataY ) throw(uno::RuntimeException, std::exception)
 403 {
 404     SolarMutexGuard aGuard;
 405
 406     if( mpOutputDevice )
 407     {
 408         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 409         sal_uInt16 nPolys = (sal_uInt16) DataX.getLength();
 410         tools::PolyPolygon aPolyPoly( nPolys );
 411         for ( sal_uInt16 n = 0; n < nPolys; n++ )
 412             aPolyPoly[n] = VCLUnoHelper::CreatePolygon( DataX.getConstArray()[n], DataY.getConstArray()[n] );
 413
 414         mpOutputDevice->DrawPolyPolygon( aPolyPoly );
 415     }
 416 }
 417
 418 void VCLXGraphics::drawEllipse( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height ) throw(uno::RuntimeException, std::exception)
 419 {
 420     SolarMutexGuard aGuard;
 421
 422     if( mpOutputDevice )
 423     {
 424         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 425         mpOutputDevice->DrawEllipse( Rectangle( Point( x, y ), Size( width, height ) ) );
 426     }
 427 }
 428
 429 void VCLXGraphics::drawArc( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException, std::exception)
 430 {
 431     SolarMutexGuard aGuard;
 432
 433     if( mpOutputDevice )
 434     {
 435         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 436         mpOutputDevice->DrawArc( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
 437     }
 438 }
 439
 440 void VCLXGraphics::drawPie( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException, std::exception)
 441 {
 442     SolarMutexGuard aGuard;
 443
 444     if( mpOutputDevice )
 445     {
 446         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 447         mpOutputDevice->DrawPie( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
 448     }
 449 }
 450
 451 void VCLXGraphics::drawChord( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException, std::exception)
 452 {
 453     SolarMutexGuard aGuard;
 454
 455     if( mpOutputDevice )
 456     {
 457         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 458         mpOutputDevice->DrawChord( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
 459     }
 460 }
 461
 462 void VCLXGraphics::drawGradient( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, const awt::Gradient& rGradient ) throw(uno::RuntimeException, std::exception)
 463 {
 464     SolarMutexGuard aGuard;
 465
 466     if( mpOutputDevice )
 467     {
 468         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 469         Gradient aGradient((GradientStyle)rGradient.Style, rGradient.StartColor, rGradient.EndColor);
 470         aGradient.SetAngle(rGradient.Angle);
 471         aGradient.SetBorder(rGradient.Border);
 472         aGradient.SetOfsX(rGradient.XOffset);
 473         aGradient.SetOfsY(rGradient.YOffset);
 474         aGradient.SetStartIntensity(rGradient.StartIntensity);
 475         aGradient.SetEndIntensity(rGradient.EndIntensity);
 476         aGradient.SetSteps(rGradient.StepCount);
 477         mpOutputDevice->DrawGradient( Rectangle( Point( x, y ), Size( width, height ) ), aGradient );
 478     }
 479 }
 480
 481 void VCLXGraphics::drawText( sal_Int32 x, sal_Int32 y, const OUString& rText ) throw(uno::RuntimeException, std::exception)
 482 {
 483     SolarMutexGuard aGuard;
 484
 485     if( mpOutputDevice )
 486     {
 487         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS |InitOutDevFlags::FONT);
 488         mpOutputDevice->DrawText( Point( x, y ), rText );
 489     }
 490 }
 491
 492 void VCLXGraphics::drawTextArray( sal_Int32 x, sal_Int32 y, const OUString& rText, const uno::Sequence< sal_Int32 >& rLongs ) throw(uno::RuntimeException, std::exception)
 493 {
 494     SolarMutexGuard aGuard;
 495
 496     if( mpOutputDevice )
 497     {
 498         InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS|InitOutDevFlags::FONT );
 499         std::unique_ptr<long []> pDXA(new long[rText.getLength()]);
 500         for(int i = 0; i < rText.getLength(); i++)
 501         {
 502             pDXA[i] = rLongs[i];
 503         }
 504         mpOutputDevice->DrawTextArray( Point( x, y ), rText, pDXA.get() );
 505     }
 506 }
 507
 508
 509 void VCLXGraphics::drawImage( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int16 nStyle, const uno::Reference< graphic::XGraphic >& xGraphic ) throw(uno::RuntimeException, std::exception)
 510 {
 511     SolarMutexGuard aGuard;
 512
 513     if( mpOutputDevice && xGraphic.is() )
 514     {
 515         Image aImage( xGraphic );
 516         if ( !!aImage )
 517         {
 518             InitOutputDevice( InitOutDevFlags::CLIPREGION|InitOutDevFlags::RASTEROP|InitOutDevFlags::COLORS );
 519             mpOutputDevice->DrawImage( Point( x, y ), Size( width, height ), aImage, static_cast<DrawImageFlags>(nStyle) );
 520         }
 521     }
 522 }
 523 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */