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