326 lines
11 KiB
C++
326 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <memory>
|
|
#include <animate/AnimationRenderer.hxx>
|
|
|
|
#include <vcl/virdev.hxx>
|
|
#include <vcl/window.hxx>
|
|
#include <tools/helpers.hxx>
|
|
|
|
#include <window.h>
|
|
|
|
AnimationRenderer::AnimationRenderer( Animation* pParent, OutputDevice* pOut,
|
|
const Point& rPt, const Size& rSz,
|
|
sal_uLong nRendererId,
|
|
OutputDevice* pFirstFrameOutDev ) :
|
|
mpParent ( pParent ),
|
|
mpRenderContext ( pFirstFrameOutDev ? pFirstFrameOutDev : pOut ),
|
|
mnRendererId ( nRendererId ),
|
|
maOriginPt ( rPt ),
|
|
maLogicalSize ( rSz ),
|
|
maSizePx ( mpRenderContext->LogicToPixel( maLogicalSize ) ),
|
|
maClip ( mpRenderContext->GetClipRegion() ),
|
|
mpBackground ( VclPtr<VirtualDevice>::Create() ),
|
|
mpRestore ( VclPtr<VirtualDevice>::Create() ),
|
|
mnActIndex ( 0 ),
|
|
meLastDisposal ( Disposal::Back ),
|
|
mbIsPaused ( false ),
|
|
mbIsMarked ( false ),
|
|
mbIsMirroredHorizontally( maLogicalSize.Width() < 0 ),
|
|
mbIsMirroredVertically( maLogicalSize.Height() < 0 )
|
|
{
|
|
Animation::ImplIncAnimCount();
|
|
|
|
// Mirrored horizontally?
|
|
if( mbIsMirroredHorizontally )
|
|
{
|
|
maDispPt.setX( maOriginPt.X() + maLogicalSize.Width() + 1 );
|
|
maDispSz.setWidth( -maLogicalSize.Width() );
|
|
maSizePx.setWidth( -maSizePx.Width() );
|
|
}
|
|
else
|
|
{
|
|
maDispPt.setX( maOriginPt.X() );
|
|
maDispSz.setWidth( maLogicalSize.Width() );
|
|
}
|
|
|
|
// Mirrored vertically?
|
|
if( mbIsMirroredVertically )
|
|
{
|
|
maDispPt.setY( maOriginPt.Y() + maLogicalSize.Height() + 1 );
|
|
maDispSz.setHeight( -maLogicalSize.Height() );
|
|
maSizePx.setHeight( -maSizePx.Height() );
|
|
}
|
|
else
|
|
{
|
|
maDispPt.setY( maOriginPt.Y() );
|
|
maDispSz.setHeight( maLogicalSize.Height() );
|
|
}
|
|
|
|
// save background
|
|
mpBackground->SetOutputSizePixel( maSizePx );
|
|
mpRenderContext->SaveBackground(*mpBackground, maDispPt, maDispSz, maSizePx);
|
|
|
|
// Initialize drawing to actual position
|
|
drawToIndex( mpParent->ImplGetCurPos() );
|
|
|
|
// If first frame OutputDevice is set, update variables now for real OutputDevice
|
|
if( pFirstFrameOutDev )
|
|
{
|
|
mpRenderContext = pOut;
|
|
maClip = mpRenderContext->GetClipRegion();
|
|
}
|
|
}
|
|
|
|
AnimationRenderer::~AnimationRenderer()
|
|
{
|
|
mpBackground.disposeAndClear();
|
|
mpRestore.disposeAndClear();
|
|
|
|
Animation::ImplDecAnimCount();
|
|
}
|
|
|
|
bool AnimationRenderer::matches(const OutputDevice* pOut, tools::Long nRendererId) const
|
|
{
|
|
return (!pOut || pOut == mpRenderContext) && (nRendererId == 0 || nRendererId == mnRendererId);
|
|
}
|
|
|
|
void AnimationRenderer::getPosSize( const AnimationFrame& rAnimationFrame, Point& rPosPix, Size& rSizePix )
|
|
{
|
|
const Size& rAnmSize = mpParent->GetDisplaySizePixel();
|
|
Point aPt2( rAnimationFrame.maPositionPixel.X() + rAnimationFrame.maSizePixel.Width() - 1,
|
|
rAnimationFrame.maPositionPixel.Y() + rAnimationFrame.maSizePixel.Height() - 1 );
|
|
double fFactX, fFactY;
|
|
|
|
// calculate x scaling
|
|
if( rAnmSize.Width() > 1 )
|
|
fFactX = static_cast<double>( maSizePx.Width() - 1 ) / ( rAnmSize.Width() - 1 );
|
|
else
|
|
fFactX = 1.0;
|
|
|
|
// calculate y scaling
|
|
if( rAnmSize.Height() > 1 )
|
|
fFactY = static_cast<double>( maSizePx.Height() - 1 ) / ( rAnmSize.Height() - 1 );
|
|
else
|
|
fFactY = 1.0;
|
|
|
|
rPosPix.setX(basegfx::fround<tools::Long>(rAnimationFrame.maPositionPixel.X() * fFactX));
|
|
rPosPix.setY(basegfx::fround<tools::Long>(rAnimationFrame.maPositionPixel.Y() * fFactY));
|
|
|
|
aPt2.setX(basegfx::fround<tools::Long>(aPt2.X() * fFactX));
|
|
aPt2.setY(basegfx::fround<tools::Long>(aPt2.Y() * fFactY));
|
|
|
|
rSizePix.setWidth( aPt2.X() - rPosPix.X() + 1 );
|
|
rSizePix.setHeight( aPt2.Y() - rPosPix.Y() + 1 );
|
|
|
|
// Mirrored horizontally?
|
|
if( mbIsMirroredHorizontally )
|
|
rPosPix.setX( maSizePx.Width() - 1 - aPt2.X() );
|
|
|
|
// Mirrored vertically?
|
|
if( mbIsMirroredVertically )
|
|
rPosPix.setY( maSizePx.Height() - 1 - aPt2.Y() );
|
|
}
|
|
|
|
void AnimationRenderer::drawToIndex( sal_uLong nIndex )
|
|
{
|
|
VclPtr<vcl::RenderContext> pRenderContext = mpRenderContext;
|
|
|
|
vcl::PaintBufferGuardPtr pGuard;
|
|
if (mpRenderContext->GetOutDevType() == OUTDEV_WINDOW)
|
|
{
|
|
vcl::Window* pWindow = static_cast<vcl::WindowOutputDevice*>(mpRenderContext.get())->GetOwnerWindow();
|
|
pGuard.reset(new vcl::PaintBufferGuard(pWindow->ImplGetWindowImpl()->mpFrameData, pWindow));
|
|
pRenderContext = pGuard->GetRenderContext();
|
|
}
|
|
|
|
ScopedVclPtrInstance<VirtualDevice> aVDev;
|
|
std::optional<vcl::Region> xOldClip;
|
|
if (!maClip.IsNull())
|
|
xOldClip = pRenderContext->GetClipRegion();
|
|
|
|
aVDev->SetOutputSizePixel( maSizePx, false );
|
|
nIndex = std::min( nIndex, static_cast<sal_uLong>(mpParent->Count()) - 1 );
|
|
|
|
for( sal_uLong i = 0; i <= nIndex; i++ )
|
|
draw( i, aVDev.get() );
|
|
|
|
if (xOldClip)
|
|
pRenderContext->SetClipRegion( maClip );
|
|
|
|
pRenderContext->DrawOutDev( maDispPt, maDispSz, Point(), maSizePx, *aVDev );
|
|
if (pGuard)
|
|
pGuard->SetPaintRect(tools::Rectangle(maDispPt, maDispSz));
|
|
|
|
if (xOldClip)
|
|
pRenderContext->SetClipRegion(*xOldClip);
|
|
}
|
|
|
|
void AnimationRenderer::draw( sal_uLong nIndex, VirtualDevice* pVDev )
|
|
{
|
|
VclPtr<vcl::RenderContext> pRenderContext = mpRenderContext;
|
|
|
|
vcl::PaintBufferGuardPtr pGuard;
|
|
if (!pVDev && mpRenderContext->GetOutDevType() == OUTDEV_WINDOW)
|
|
{
|
|
vcl::Window* pWindow = static_cast<vcl::WindowOutputDevice*>(mpRenderContext.get())->GetOwnerWindow();
|
|
pGuard.reset(new vcl::PaintBufferGuard(pWindow->ImplGetWindowImpl()->mpFrameData, pWindow));
|
|
pRenderContext = pGuard->GetRenderContext();
|
|
}
|
|
|
|
tools::Rectangle aOutRect( pRenderContext->PixelToLogic( Point() ), pRenderContext->GetOutputSize() );
|
|
|
|
// check, if output lies out of display
|
|
if( aOutRect.Intersection( tools::Rectangle( maDispPt, maDispSz ) ).IsEmpty() )
|
|
{
|
|
setMarked( true );
|
|
}
|
|
else if( !mbIsPaused )
|
|
{
|
|
VclPtr<VirtualDevice> pDev;
|
|
Point aPosPix;
|
|
Point aBmpPosPix;
|
|
Size aSizePix;
|
|
Size aBmpSizePix;
|
|
const sal_uLong nLastPos = mpParent->Count() - 1;
|
|
mnActIndex = std::min( nIndex, nLastPos );
|
|
const AnimationFrame& rAnimationFrame = mpParent->Get( static_cast<sal_uInt16>( mnActIndex ) );
|
|
|
|
getPosSize( rAnimationFrame, aPosPix, aSizePix );
|
|
|
|
// Mirrored horizontally?
|
|
if( mbIsMirroredHorizontally )
|
|
{
|
|
aBmpPosPix.setX( aPosPix.X() + aSizePix.Width() - 1 );
|
|
aBmpSizePix.setWidth( -aSizePix.Width() );
|
|
}
|
|
else
|
|
{
|
|
aBmpPosPix.setX( aPosPix.X() );
|
|
aBmpSizePix.setWidth( aSizePix.Width() );
|
|
}
|
|
|
|
// Mirrored vertically?
|
|
if( mbIsMirroredVertically )
|
|
{
|
|
aBmpPosPix.setY( aPosPix.Y() + aSizePix.Height() - 1 );
|
|
aBmpSizePix.setHeight( -aSizePix.Height() );
|
|
}
|
|
else
|
|
{
|
|
aBmpPosPix.setY( aPosPix.Y() );
|
|
aBmpSizePix.setHeight( aSizePix.Height() );
|
|
}
|
|
|
|
// get output device
|
|
if( !pVDev )
|
|
{
|
|
pDev = VclPtr<VirtualDevice>::Create();
|
|
pDev->SetOutputSizePixel( maSizePx, false );
|
|
pDev->DrawOutDev( Point(), maSizePx, maDispPt, maDispSz, *pRenderContext );
|
|
}
|
|
else
|
|
pDev = pVDev;
|
|
|
|
// restore background after each run
|
|
if( !nIndex )
|
|
{
|
|
meLastDisposal = Disposal::Back;
|
|
maRestPt = Point();
|
|
maRestSz = maSizePx;
|
|
}
|
|
|
|
// restore
|
|
if( ( Disposal::Not != meLastDisposal ) && maRestSz.Width() && maRestSz.Height() )
|
|
{
|
|
if( Disposal::Back == meLastDisposal )
|
|
pDev->DrawOutDev( maRestPt, maRestSz, maRestPt, maRestSz, *mpBackground );
|
|
else
|
|
pDev->DrawOutDev( maRestPt, maRestSz, Point(), maRestSz, *mpRestore );
|
|
}
|
|
|
|
meLastDisposal = rAnimationFrame.meDisposal;
|
|
maRestPt = aPosPix;
|
|
maRestSz = aSizePix;
|
|
|
|
// What do we need to restore the next time?
|
|
// Put it into a bitmap if needed, else delete
|
|
// SaveBitmap to conserve memory
|
|
if( ( meLastDisposal == Disposal::Back ) || ( meLastDisposal == Disposal::Not ) )
|
|
mpRestore->SetOutputSizePixel( Size( 1, 1 ), false );
|
|
else
|
|
{
|
|
mpRestore->SetOutputSizePixel( maRestSz, false );
|
|
mpRestore->DrawOutDev( Point(), maRestSz, aPosPix, aSizePix, *pDev );
|
|
}
|
|
|
|
pDev->DrawBitmapEx( aBmpPosPix, aBmpSizePix, rAnimationFrame.maBitmapEx );
|
|
|
|
if( !pVDev )
|
|
{
|
|
std::optional<vcl::Region> xOldClip;
|
|
if (!maClip.IsNull())
|
|
xOldClip = pRenderContext->GetClipRegion();
|
|
|
|
if (xOldClip)
|
|
pRenderContext->SetClipRegion( maClip );
|
|
|
|
pRenderContext->DrawOutDev( maDispPt, maDispSz, Point(), maSizePx, *pDev );
|
|
if (pGuard)
|
|
pGuard->SetPaintRect(tools::Rectangle(maDispPt, maDispSz));
|
|
|
|
if( xOldClip)
|
|
{
|
|
pRenderContext->SetClipRegion(*xOldClip);
|
|
xOldClip.reset();
|
|
}
|
|
|
|
pDev.disposeAndClear();
|
|
pRenderContext->Flush();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationRenderer::repaint()
|
|
{
|
|
const bool bOldPause = mbIsPaused;
|
|
|
|
mpRenderContext->SaveBackground(*mpBackground, maDispPt, maDispSz, maSizePx);
|
|
|
|
mbIsPaused = false;
|
|
drawToIndex( mnActIndex );
|
|
mbIsPaused = bOldPause;
|
|
}
|
|
|
|
AnimationData* AnimationRenderer::createAnimationData() const
|
|
{
|
|
AnimationData* pDataItem = new AnimationData;
|
|
|
|
pDataItem->maOriginStartPt = maOriginPt;
|
|
pDataItem->maStartSize = maLogicalSize;
|
|
pDataItem->mpRenderContext = mpRenderContext;
|
|
pDataItem->mpRendererData = const_cast<AnimationRenderer *>(this);
|
|
pDataItem->mnRendererId = mnRendererId;
|
|
pDataItem->mbIsPaused = mbIsPaused;
|
|
|
|
return pDataItem;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|