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 #include <sal/config.h> 21 #include <sal/log.hxx> 22 23 #include <boost/cast.hpp> 24 25 #include <basegfx/range/b2drectangle.hxx> 26 #include <rtl/math.hxx> 27 #include <tools/diagnose_ex.h> 28 #include <vcl/canvastools.hxx> 29 #include <vcl/outdev.hxx> 30 #include <vcl/window.hxx> 31 32 #include <canvas/canvastools.hxx> 33 34 #include "canvascustomsprite.hxx" 35 #include "spritecanvashelper.hxx" 36 #include "spritecanvas.hxx" 37 38 using namespace ::com::sun::star; 39 40 #define FPS_BOUNDS ::tools::Rectangle(0,0,130,90) 41 #define INFO_COLOR COL_RED 42 43 namespace vclcanvas 44 { 45 namespace 46 { 47 /** Sprite redraw at original position 48 49 Used to repaint the whole canvas (background and all 50 sprites) 51 */ spriteRedraw(OutputDevice & rOutDev,const::canvas::Sprite::Reference & rSprite)52 void spriteRedraw( OutputDevice& rOutDev, 53 const ::canvas::Sprite::Reference& rSprite ) 54 { 55 // downcast to derived vclcanvas::Sprite interface, which 56 // provides the actual redraw methods. 57 ::boost::polymorphic_downcast< Sprite* >(rSprite.get())->redraw(rOutDev, 58 true); 59 } 60 calcNumPixel(const::canvas::Sprite::Reference & rSprite)61 double calcNumPixel( const ::canvas::Sprite::Reference& rSprite ) 62 { 63 const ::basegfx::B2DSize& rSize( 64 ::boost::polymorphic_downcast< Sprite* >(rSprite.get())->getSizePixel() ); 65 66 return rSize.getX() * rSize.getY(); 67 } 68 repaintBackground(OutputDevice & rOutDev,OutputDevice const & rBackBuffer,const::basegfx::B2DRange & rArea)69 void repaintBackground( OutputDevice& rOutDev, 70 OutputDevice const & rBackBuffer, 71 const ::basegfx::B2DRange& rArea ) 72 { 73 const ::Point& rPos( vcl::unotools::pointFromB2DPoint( rArea.getMinimum()) ); 74 const ::Size& rSize( vcl::unotools::sizeFromB2DSize( rArea.getRange()) ); 75 76 rOutDev.DrawOutDev( rPos, rSize, rPos, rSize, rBackBuffer ); 77 } 78 opaqueUpdateSpriteArea(const::canvas::Sprite::Reference & rSprite,OutputDevice & rOutDev,const::basegfx::B2IRange & rArea)79 void opaqueUpdateSpriteArea( const ::canvas::Sprite::Reference& rSprite, 80 OutputDevice& rOutDev, 81 const ::basegfx::B2IRange& rArea ) 82 { 83 const ::tools::Rectangle& rRequestedArea( 84 vcl::unotools::rectangleFromB2IRectangle( rArea ) ); 85 86 // clip output to actual update region (otherwise a) 87 // wouldn't save much render time, and b) will clutter 88 // scrolled sprite content outside this area) 89 rOutDev.EnableMapMode( false ); 90 rOutDev.SetAntialiasing( AntialiasingFlags::Enable ); 91 rOutDev.SetClipRegion(vcl::Region(rRequestedArea)); 92 93 // repaint affected sprite directly to output device (at 94 // the actual screen output position) 95 ::boost::polymorphic_downcast< Sprite* >( 96 rSprite.get() )->redraw( rOutDev, 97 false ); // rendering 98 // directly to 99 // frontbuffer 100 } 101 renderInfoText(OutputDevice & rOutDev,const OUString & rStr,const Point & rPos)102 void renderInfoText( OutputDevice& rOutDev, 103 const OUString& rStr, 104 const Point& rPos ) 105 { 106 vcl::Font aVCLFont; 107 aVCLFont.SetFontHeight( 20 ); 108 aVCLFont.SetColor( INFO_COLOR ); 109 110 rOutDev.SetTextAlign(ALIGN_TOP); 111 rOutDev.SetTextColor( INFO_COLOR ); 112 rOutDev.SetFont( aVCLFont ); 113 114 rOutDev.DrawText( rPos, rStr ); 115 } 116 117 } 118 SpriteCanvasHelper()119 SpriteCanvasHelper::SpriteCanvasHelper() : 120 mpRedrawManager( nullptr ), 121 mpOwningSpriteCanvas( nullptr ), 122 maVDev(VclPtr<VirtualDevice>::Create()), 123 maLastUpdate(), 124 mbShowFrameInfo( false ), 125 mbShowSpriteBounds( false ), 126 mbIsUnsafeScrolling( false ) 127 { 128 #if OSL_DEBUG_LEVEL > 0 129 // inverse defaults for verbose debug mode 130 mbShowFrameInfo = true; 131 // this looks like drawing errors, enable only if explicitly asked for 132 static bool enableShowSpriteBounds = getenv("CANVAS_SPRITE_BOUNDS") != nullptr; 133 mbShowSpriteBounds = enableShowSpriteBounds; 134 #endif 135 } 136 ~SpriteCanvasHelper()137 SpriteCanvasHelper::~SpriteCanvasHelper() 138 { 139 SolarMutexGuard aGuard; 140 maVDev.disposeAndClear(); 141 } 142 init(const OutDevProviderSharedPtr & rOutDev,SpriteCanvas & rOwningSpriteCanvas,::canvas::SpriteRedrawManager & rManager,bool bProtect,bool bHaveAlpha)143 void SpriteCanvasHelper::init( const OutDevProviderSharedPtr& rOutDev, 144 SpriteCanvas& rOwningSpriteCanvas, 145 ::canvas::SpriteRedrawManager& rManager, 146 bool bProtect, 147 bool bHaveAlpha ) 148 { 149 mpOwningSpriteCanvas = &rOwningSpriteCanvas; 150 mpRedrawManager = &rManager; 151 152 CanvasHelper::init(rOwningSpriteCanvas,rOutDev,bProtect,bHaveAlpha); 153 } 154 disposing()155 void SpriteCanvasHelper::disposing() 156 { 157 mpRedrawManager = nullptr; 158 mpOwningSpriteCanvas = nullptr; 159 160 // forward to base 161 CanvasHelper::disposing(); 162 } 163 createSpriteFromAnimation(const uno::Reference<rendering::XAnimation> &)164 uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromAnimation( 165 const uno::Reference< rendering::XAnimation >& ) 166 { 167 return uno::Reference< rendering::XAnimatedSprite >(); 168 } 169 createSpriteFromBitmaps(const uno::Sequence<uno::Reference<rendering::XBitmap>> &,sal_Int8)170 uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromBitmaps( 171 const uno::Sequence< uno::Reference< rendering::XBitmap > >& , 172 sal_Int8 ) 173 { 174 return uno::Reference< rendering::XAnimatedSprite >(); 175 } 176 createCustomSprite(const geometry::RealSize2D & spriteSize)177 uno::Reference< rendering::XCustomSprite > SpriteCanvasHelper::createCustomSprite( const geometry::RealSize2D& spriteSize ) 178 { 179 if( !mpRedrawManager || !mpDevice ) 180 return uno::Reference< rendering::XCustomSprite >(); // we're disposed 181 182 return uno::Reference< rendering::XCustomSprite >( 183 new CanvasCustomSprite( spriteSize, 184 *mpDevice, 185 mpOwningSpriteCanvas, 186 mpOwningSpriteCanvas->getFrontBuffer(), 187 mbShowSpriteBounds ) ); 188 } 189 createClonedSprite(const uno::Reference<rendering::XSprite> &)190 uno::Reference< rendering::XSprite > SpriteCanvasHelper::createClonedSprite( const uno::Reference< rendering::XSprite >& ) 191 { 192 return uno::Reference< rendering::XSprite >(); 193 } 194 updateScreen(bool bUpdateAll,bool & io_bSurfaceDirty)195 bool SpriteCanvasHelper::updateScreen( bool bUpdateAll, 196 bool& io_bSurfaceDirty ) 197 { 198 if( !mpRedrawManager || 199 !mpOwningSpriteCanvas || 200 !mpOwningSpriteCanvas->getFrontBuffer() || 201 !mpOwningSpriteCanvas->getBackBuffer() ) 202 { 203 return false; // disposed, or otherwise dysfunctional 204 } 205 206 // commit to backbuffer 207 flush(); 208 209 OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() ); 210 BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() ); 211 OutputDevice& rBackOutDev( pBackBuffer->getOutDev() ); 212 213 // actual OutputDevice is a shared resource - restore its 214 // state when done. 215 tools::OutDevStateKeeper aStateKeeper( rOutDev ); 216 217 const Size aOutDevSize( rBackOutDev.GetOutputSizePixel() ); 218 const Point aEmptyPoint(0,0); 219 220 vcl::Window* pTargetWindow = nullptr; 221 if( rOutDev.GetOutDevType() == OUTDEV_WINDOW ) 222 { 223 pTargetWindow = rOutDev.GetOwnerWindow(); // TODO(Q3): Evil downcast. 224 225 // we're double-buffered, thus no need for paint area-limiting 226 // clips. besides that, will interfere with animations (as for 227 // Window-invalidate repaints, only parts of the window will 228 // be redrawn otherwise) 229 const vcl::Region aFullWindowRegion( ::tools::Rectangle(aEmptyPoint, 230 aOutDevSize) ); 231 pTargetWindow->ExpandPaintClipRegion(aFullWindowRegion); 232 } 233 234 // TODO(P1): Might be worthwhile to track areas of background 235 // changes, too. 236 if( !bUpdateAll && !io_bSurfaceDirty ) 237 { 238 if( mbShowFrameInfo ) 239 { 240 // also repaint background below frame counter (fake 241 // that as a sprite vanishing in this area) 242 mpRedrawManager->updateSprite( ::canvas::Sprite::Reference(), 243 ::basegfx::B2DPoint(), 244 ::basegfx::B2DRectangle( 0.0, 0.0, 245 FPS_BOUNDS.Right(), 246 FPS_BOUNDS.Bottom() ) ); 247 } 248 249 // background has not changed, so we're free to optimize 250 // repaint to areas where a sprite has changed 251 252 // process each independent area of overlapping sprites 253 // separately. 254 mpRedrawManager->forEachSpriteArea( *this ); 255 } 256 else 257 { 258 // background has changed, so we currently have no choice 259 // but repaint everything (or caller requested that) 260 261 maVDev->SetOutputSizePixel( aOutDevSize ); 262 maVDev->EnableMapMode( false ); 263 maVDev->DrawOutDev( aEmptyPoint, aOutDevSize, 264 aEmptyPoint, aOutDevSize, 265 rBackOutDev ); 266 267 // repaint all active sprites on top of background into 268 // VDev. 269 OutputDevice& rTmpOutDev( *maVDev ); 270 mpRedrawManager->forEachSprite( 271 [&rTmpOutDev]( const ::canvas::Sprite::Reference& rSprite ) 272 { spriteRedraw( rTmpOutDev, rSprite ); } 273 ); 274 275 // flush to screen 276 rOutDev.EnableMapMode( false ); 277 rOutDev.SetAntialiasing( AntialiasingFlags::Enable ); 278 rOutDev.SetClipRegion(); 279 rOutDev.DrawOutDev( aEmptyPoint, aOutDevSize, 280 aEmptyPoint, aOutDevSize, 281 *maVDev ); 282 } 283 284 // change record vector must be cleared, for the next turn of 285 // rendering and sprite changing 286 mpRedrawManager->clearChangeRecords(); 287 288 io_bSurfaceDirty = false; 289 290 if( mbShowFrameInfo ) 291 { 292 renderFrameCounter( rOutDev ); 293 renderSpriteCount( rOutDev ); 294 renderMemUsage( rOutDev ); 295 } 296 297 #if OSL_DEBUG_LEVEL > 0 298 static ::canvas::tools::ElapsedTime aElapsedTime; 299 300 // log time immediately after surface flip 301 SAL_INFO("canvas.vcl", "SpriteCanvasHelper::updateScreen(): flip done at " << 302 aElapsedTime.getElapsedTime() ); 303 #endif 304 305 // sync output with screen, to ensure that we don't queue up 306 // render requests (calling code might rely on timing, 307 // i.e. assume that things are visible on screen after 308 // updateScreen() returns). 309 if( pTargetWindow ) 310 { 311 // commit to screen 312 pTargetWindow->GetOutDev()->Flush(); 313 } 314 315 return true; 316 } 317 backgroundPaint(const::basegfx::B2DRange & rUpdateRect)318 void SpriteCanvasHelper::backgroundPaint( const ::basegfx::B2DRange& rUpdateRect ) 319 { 320 ENSURE_OR_THROW( mpOwningSpriteCanvas && 321 mpOwningSpriteCanvas->getBackBuffer() && 322 mpOwningSpriteCanvas->getFrontBuffer(), 323 "SpriteCanvasHelper::backgroundPaint(): NULL device pointer " ); 324 325 OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() ); 326 BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() ); 327 OutputDevice& rBackOutDev( pBackBuffer->getOutDev() ); 328 329 repaintBackground( rOutDev, rBackOutDev, rUpdateRect ); 330 } 331 scrollUpdate(const::basegfx::B2DRange & rMoveStart,const::basegfx::B2DRange & rMoveEnd,const::canvas::SpriteRedrawManager::UpdateArea & rUpdateArea)332 void SpriteCanvasHelper::scrollUpdate( const ::basegfx::B2DRange& rMoveStart, 333 const ::basegfx::B2DRange& rMoveEnd, 334 const ::canvas::SpriteRedrawManager::UpdateArea& rUpdateArea ) 335 { 336 ENSURE_OR_THROW( mpOwningSpriteCanvas && 337 mpOwningSpriteCanvas->getBackBuffer() && 338 mpOwningSpriteCanvas->getFrontBuffer(), 339 "SpriteCanvasHelper::scrollUpdate(): NULL device pointer " ); 340 341 OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() ); 342 BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() ); 343 OutputDevice& rBackOutDev( pBackBuffer->getOutDev() ); 344 345 const Size& rTargetSizePixel( rOutDev.GetOutputSizePixel() ); 346 const ::basegfx::B2IRange aOutputBounds( 0,0, 347 rTargetSizePixel.Width(), 348 rTargetSizePixel.Height() ); 349 350 // round rectangles to integer pixel. Note: have to be 351 // extremely careful here, to avoid off-by-one errors for 352 // the destination area: otherwise, the next scroll update 353 // would copy pixel that are not supposed to be part of 354 // the sprite. 355 ::basegfx::B2IRange aSourceRect( 356 ::canvas::tools::spritePixelAreaFromB2DRange( rMoveStart ) ); 357 const ::basegfx::B2IRange& rDestRect( 358 ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) ); 359 ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() ); 360 361 std::vector< ::basegfx::B2IRange > aUnscrollableAreas; 362 363 // Since strictly speaking, this scroll algorithm is plain 364 // buggy, the scrolled area might actually lie _below_ another 365 // window - we've made this feature configurable via 366 // mbIsUnsafeScrolling. 367 368 // clip to output bounds (cannot properly scroll stuff 369 // _outside_ our screen area) 370 if( !mbIsUnsafeScrolling || 371 !::canvas::tools::clipScrollArea( aSourceRect, 372 aDestPos, 373 aUnscrollableAreas, 374 aOutputBounds ) ) 375 { 376 // fully clipped scroll area: cannot simply scroll 377 // then. Perform normal opaque update (can use that, since 378 // one of the preconditions for scrollable update is 379 // opaque sprite content) 380 381 // repaint all affected sprites directly to output device 382 for( const auto& rComponent : rUpdateArea.maComponentList ) 383 { 384 const ::canvas::Sprite::Reference& rSprite( rComponent.second.getSprite() ); 385 386 if( rSprite.is() ) 387 ::boost::polymorphic_downcast< Sprite* >( 388 rSprite.get() )->redraw( rOutDev, 389 false ); 390 } 391 } 392 else 393 { 394 // scroll rOutDev content 395 rOutDev.CopyArea( vcl::unotools::pointFromB2IPoint( aDestPos ), 396 vcl::unotools::pointFromB2IPoint( aSourceRect.getMinimum() ), 397 // TODO(Q2): use numeric_cast to check range 398 ::Size( static_cast<sal_Int32>(aSourceRect.getRange().getX()), 399 static_cast<sal_Int32>(aSourceRect.getRange().getY()) ) ); 400 401 const ::canvas::SpriteRedrawManager::SpriteConnectedRanges::ComponentListType::const_iterator 402 aFirst( rUpdateArea.maComponentList.begin() ); 403 404 ENSURE_OR_THROW( aFirst->second.getSprite().is(), 405 "VCLCanvas::scrollUpdate(): no sprite" ); 406 407 // repaint uncovered areas from sprite. Need to actually 408 // clip here, since we're only repainting _parts_ of the 409 // sprite 410 rOutDev.Push( PushFlags::CLIPREGION ); 411 412 for( const auto& rArea : aUnscrollableAreas ) 413 opaqueUpdateSpriteArea( aFirst->second.getSprite(), 414 rOutDev, rArea ); 415 416 rOutDev.Pop(); 417 } 418 419 // repaint uncovered areas from backbuffer - take the 420 // _rounded_ rectangles from above, to have the update 421 // consistent with the scroll above. 422 std::vector< ::basegfx::B2DRange > aUncoveredAreas; 423 ::basegfx::computeSetDifference( aUncoveredAreas, 424 rUpdateArea.maTotalBounds, 425 ::basegfx::B2DRange( rDestRect ) ); 426 427 for( const auto& rArea : aUncoveredAreas ) 428 repaintBackground( rOutDev, rBackOutDev, rArea ); 429 } 430 opaqueUpdate(SAL_UNUSED_PARAMETER const::basegfx::B2DRange &,const std::vector<::canvas::Sprite::Reference> & rSortedUpdateSprites)431 void SpriteCanvasHelper::opaqueUpdate( SAL_UNUSED_PARAMETER const ::basegfx::B2DRange&, 432 const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites ) 433 { 434 ENSURE_OR_THROW( mpOwningSpriteCanvas && 435 mpOwningSpriteCanvas->getBackBuffer() && 436 mpOwningSpriteCanvas->getFrontBuffer(), 437 "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer " ); 438 439 OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() ); 440 441 // no need to clip output to actual update region - there will 442 // always be ALL sprites contained in the rectangular update 443 // area contained in rTotalArea (that's the way 444 // B2DConnectedRanges work). If rTotalArea appears to be 445 // smaller than the sprite - then this sprite carries a clip, 446 // and the update will be constrained to that rect. 447 448 // repaint all affected sprites directly to output device 449 for( const auto& rSprite : rSortedUpdateSprites ) 450 { 451 if( rSprite.is() ) 452 ::boost::polymorphic_downcast< Sprite* >( 453 rSprite.get() )->redraw( rOutDev, 454 false ); 455 } 456 } 457 genericUpdate(const::basegfx::B2DRange & rRequestedArea,const std::vector<::canvas::Sprite::Reference> & rSortedUpdateSprites)458 void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange& rRequestedArea, 459 const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites ) 460 { 461 ENSURE_OR_THROW( mpOwningSpriteCanvas && 462 mpOwningSpriteCanvas->getBackBuffer() && 463 mpOwningSpriteCanvas->getFrontBuffer(), 464 "SpriteCanvasHelper::genericUpdate(): NULL device pointer " ); 465 466 OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() ); 467 BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() ); 468 OutputDevice& rBackOutDev( pBackBuffer->getOutDev() ); 469 470 // limit size of update VDev to target outdev's size 471 const Size& rTargetSizePixel( rOutDev.GetOutputSizePixel() ); 472 473 // round output position towards zero. Don't want to truncate 474 // a fraction of a sprite pixel... Clip position at origin, 475 // otherwise, truncation of size below might leave visible 476 // areas uncovered by VDev. 477 const ::Point aOutputPosition( 478 std::max( sal_Int32( 0 ), 479 static_cast< sal_Int32 >(rRequestedArea.getMinX()) ), 480 std::max( sal_Int32( 0 ), 481 static_cast< sal_Int32 >(rRequestedArea.getMinY()) ) ); 482 // round output size towards +infty. Don't want to truncate a 483 // fraction of a sprite pixel... Limit coverage of VDev to 484 // output device's area (i.e. not only to total size, but to 485 // cover _only_ the visible parts). 486 const ::Size aOutputSize( 487 std::max( sal_Int32( 0 ), 488 std::min( static_cast< sal_Int32 >(rTargetSizePixel.Width() - aOutputPosition.X()), 489 ::canvas::tools::roundUp( rRequestedArea.getMaxX() - aOutputPosition.X() ))), 490 std::max( sal_Int32( 0 ), 491 std::min( static_cast< sal_Int32 >(rTargetSizePixel.Height() - aOutputPosition.Y()), 492 ::canvas::tools::roundUp( rRequestedArea.getMaxY() - aOutputPosition.Y() )))); 493 494 // early exit for empty output area. 495 if( aOutputSize.Width() == 0 && 496 aOutputSize.Height() == 0 ) 497 { 498 return; 499 } 500 501 const Point aEmptyPoint(0,0); 502 const Size aCurrOutputSize( maVDev->GetOutputSizePixel() ); 503 504 // adapt maVDev's size to the area that actually needs the 505 // repaint. 506 if( aCurrOutputSize.Width() < aOutputSize.Width() || 507 aCurrOutputSize.Height() < aOutputSize.Height() ) 508 { 509 // TODO(P1): Come up with a clever tactic to reduce maVDev 510 // from time to time. Reduction with threshold (say, if 511 // maVDev is more than twice too large) is not wise, as 512 // this might then toggle within the same updateScreen(), 513 // but for different disjunct sprite areas. 514 maVDev->SetOutputSizePixel( aOutputSize ); 515 } 516 517 // paint background 518 maVDev->EnableMapMode( false ); 519 maVDev->SetAntialiasing( AntialiasingFlags::Enable ); 520 maVDev->SetClipRegion(); 521 maVDev->DrawOutDev( aEmptyPoint, aOutputSize, 522 aOutputPosition, aOutputSize, 523 rBackOutDev ); 524 525 // repaint all affected sprites on top of background into 526 // VDev. 527 for( const auto& rSprite : rSortedUpdateSprites ) 528 { 529 if( rSprite.is() ) 530 { 531 Sprite* pSprite = ::boost::polymorphic_downcast< Sprite* >( rSprite.get() ); 532 533 // calc relative sprite position in rUpdateArea (which 534 // need not be the whole screen!) 535 const ::basegfx::B2DPoint& rSpriteScreenPos( pSprite->getPosPixel() ); 536 const ::basegfx::B2DPoint& rSpriteRenderPos( 537 rSpriteScreenPos - vcl::unotools::b2DPointFromPoint(aOutputPosition) 538 ); 539 540 pSprite->redraw( *maVDev, rSpriteRenderPos, true ); 541 } 542 } 543 544 // flush to screen 545 rOutDev.EnableMapMode( false ); 546 rOutDev.SetAntialiasing( AntialiasingFlags::Enable ); 547 rOutDev.DrawOutDev( aOutputPosition, aOutputSize, 548 aEmptyPoint, aOutputSize, 549 *maVDev ); 550 } 551 renderFrameCounter(OutputDevice & rOutDev)552 void SpriteCanvasHelper::renderFrameCounter( OutputDevice& rOutDev ) 553 { 554 const double denominator( maLastUpdate.getElapsedTime() ); 555 maLastUpdate.reset(); 556 557 OUString text( ::rtl::math::doubleToUString( denominator == 0.0 ? 100.0 : 1.0/denominator, 558 rtl_math_StringFormat_F, 559 2,'.',nullptr,' ') ); 560 561 // pad with leading space 562 while( text.getLength() < 6 ) 563 text = " " + text; 564 565 text += " fps"; 566 567 renderInfoText( rOutDev, 568 text, 569 Point(0, 0) ); 570 } 571 572 namespace 573 { 574 template< typename T > struct Adder 575 { 576 typedef void result_type; 577 Addervclcanvas::__anon79639b000311::Adder578 Adder( T& rAdderTarget, 579 T nIncrement ) : 580 mpTarget( &rAdderTarget ), 581 mnIncrement( nIncrement ) 582 { 583 } 584 operator ()vclcanvas::__anon79639b000311::Adder585 void operator()( const ::canvas::Sprite::Reference& ) { *mpTarget += mnIncrement; } operator ()vclcanvas::__anon79639b000311::Adder586 void operator()( T nIncrement ) { *mpTarget += nIncrement; } 587 588 T* mpTarget; 589 T mnIncrement; 590 }; 591 makeAdder(T & rAdderTarget,T nIncrement)592 template< typename T> Adder<T> makeAdder( T& rAdderTarget, 593 T nIncrement ) 594 { 595 return Adder<T>(rAdderTarget, nIncrement); 596 } 597 } 598 renderSpriteCount(OutputDevice & rOutDev)599 void SpriteCanvasHelper::renderSpriteCount( OutputDevice& rOutDev ) 600 { 601 if( !mpRedrawManager ) 602 return; 603 604 sal_Int32 nCount(0); 605 606 mpRedrawManager->forEachSprite( makeAdder(nCount,sal_Int32(1)) ); 607 OUString text( OUString::number(nCount) ); 608 609 // pad with leading space 610 while( text.getLength() < 3 ) 611 text = " " + text; 612 613 text = "Sprites: " + text; 614 615 renderInfoText( rOutDev, 616 text, 617 Point(0, 30) ); 618 } 619 renderMemUsage(OutputDevice & rOutDev)620 void SpriteCanvasHelper::renderMemUsage( OutputDevice& rOutDev ) 621 { 622 BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() ); 623 624 if( !(mpRedrawManager && 625 pBackBuffer) ) 626 return; 627 628 double nPixel(0.0); 629 630 // accumulate pixel count for each sprite into fCount 631 mpRedrawManager->forEachSprite( 632 [&nPixel]( const ::canvas::Sprite::Reference& rSprite ) 633 { makeAdder( nPixel, 1.0 )( calcNumPixel(rSprite) ); } 634 ); 635 636 static const int NUM_VIRDEV(2); 637 static const int BYTES_PER_PIXEL(3); 638 639 const Size& rVDevSize( maVDev->GetOutputSizePixel() ); 640 const Size& rBackBufferSize( pBackBuffer->getOutDev().GetOutputSizePixel() ); 641 642 const double nMemUsage( nPixel * NUM_VIRDEV * BYTES_PER_PIXEL + 643 rVDevSize.Width()*rVDevSize.Height() * BYTES_PER_PIXEL + 644 rBackBufferSize.Width()*rBackBufferSize.Height() * BYTES_PER_PIXEL ); 645 646 OUString text( ::rtl::math::doubleToUString( nMemUsage / 1048576.0, 647 rtl_math_StringFormat_F, 648 2,'.',nullptr,' ') ); 649 650 // pad with leading space 651 while( text.getLength() < 4 ) 652 text = " " + text; 653 654 text = "Mem: " + text + "MB"; 655 656 renderInfoText( rOutDev, 657 text, 658 Point(0, 60) ); 659 } 660 } 661 662 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ 663