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