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