/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include <com/sun/star/presentation/AnimationEffect.hpp>
#include <com/sun/star/presentation/AnimationSpeed.hpp>
#define _ANIMATION //animation freischalten
#define _SV_BITMAPEX
#include <svx/xoutbmp.hxx>
#include <time.h>
#include <svl/eitem.hxx>
#include <svx/svdograf.hxx>
#include <svx/svdogrp.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/progress.hxx>
#include <vcl/msgbox.hxx>
#include "anminfo.hxx"
#include "animobjs.hxx"
#include "animobjs.hrc"
#include "anmdef.hxx"
#include "app.hrc"
#include "strings.hrc"
#include "sdresid.hxx"
#include "View.hxx"
#include "drawdoc.hxx"
#include "sdpage.hxx"
#include "res_bmp.hrc"
#include "ViewShell.hxx"
#ifndef _SV_SVAPP_HXX_
#include <vcl/svapp.hxx>
#endif
// #42894#
#include <EffectMigration.hxx>
#include <string>
#include <algorithm>
using namespace ::com::sun::star;
namespace sd {
/*************************************************************************
|* SdDisplay - Control
\************************************************************************/
SdDisplay::SdDisplay( Window* pWin, SdResId Id ) :
Control( pWin, Id ),
aScale( 1, 1 )
{
SetMapMode( MAP_PIXEL );
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
SetBackground( Wallpaper( Color( rStyles.GetFieldColor() ) ) );
}
// -----------------------------------------------------------------------
SdDisplay::~SdDisplay()
{
}
// -----------------------------------------------------------------------
void SdDisplay::SetBitmapEx( BitmapEx* pBmpEx )
{
if( pBmpEx )
{
aBitmapEx = *pBmpEx;
}
else
{
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
const Color aFillColor = rStyles.GetFieldColor();
aBitmapEx.Erase(aFillColor);
}
}
// -----------------------------------------------------------------------
void SdDisplay::Paint( const Rectangle& )
{
Point aPt;
Size aSize = GetOutputSize();
Size aBmpSize = aBitmapEx.GetBitmap().GetSizePixel();
aBmpSize.Width() = (long) ( (double) aBmpSize.Width() * (double) aScale );
aBmpSize.Height() = (long) ( (double) aBmpSize.Height() * (double) aScale );
if( aBmpSize.Width() < aSize.Width() )
aPt.X() = ( aSize.Width() - aBmpSize.Width() ) / 2;
if( aBmpSize.Height() < aSize.Height() )
aPt.Y() = ( aSize.Height() - aBmpSize.Height() ) / 2;
aBitmapEx.Draw( this, aPt, aBmpSize );
//DrawBitmap( aPt, aBmpSize, *pBitmap );
}
// -----------------------------------------------------------------------
void SdDisplay::SetScale( const Fraction& rFrac )
{
aScale = rFrac;
}
void SdDisplay::DataChanged( const DataChangedEvent& rDCEvt )
{
Control::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
{
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
SetBackground( Wallpaper( Color( rStyles.GetFieldColor() ) ) );
SetDrawMode( GetSettings().GetStyleSettings().GetHighContrastMode()
? ViewShell::OUTPUT_DRAWMODE_CONTRAST
: ViewShell::OUTPUT_DRAWMODE_COLOR );
}
}
/*************************************************************************
|* AnimationWindow - FloatingWindow
\************************************************************************/
AnimationWindow::AnimationWindow( SfxBindings* pInBindings,
SfxChildWindow *pCW, Window* pParent, const SdResId& rSdResId ) :
SfxDockingWindow ( pInBindings, pCW, pParent, rSdResId ),
aCtlDisplay ( this, SdResId( CTL_DISPLAY ) ),
aBtnFirst ( this, SdResId( BTN_FIRST ) ),
aBtnReverse ( this, SdResId( BTN_REVERSE ) ),
aBtnStop ( this, SdResId( BTN_STOP ) ),
aBtnPlay ( this, SdResId( BTN_PLAY ) ),
aBtnLast ( this, SdResId( BTN_LAST ) ),
aNumFldBitmap ( this, SdResId( NUM_FLD_BITMAP ) ),
aTimeField ( this, SdResId( TIME_FIELD ) ),
aLbLoopCount ( this, SdResId( LB_LOOP_COUNT ) ),
aGrpBitmap ( this, SdResId( GRP_BITMAP ) ),
aBtnGetOneObject ( this, SdResId( BTN_GET_ONE_OBJECT ) ),
aBtnGetAllObjects ( this, SdResId( BTN_GET_ALL_OBJECTS ) ),
aBtnRemoveBitmap ( this, SdResId( BTN_REMOVE_BITMAP ) ),
aBtnRemoveAll ( this, SdResId( BTN_REMOVE_ALL ) ),
aFtCount ( this, SdResId( FT_COUNT ) ),
aFiCount ( this, SdResId( FI_COUNT ) ),
aGrpAnimation ( this, SdResId( GRP_ANIMATION_GROUP ) ),
aRbtGroup ( this, SdResId( RBT_GROUP ) ),
aRbtBitmap ( this, SdResId( RBT_BITMAP ) ),
aFtAdjustment ( this, SdResId( FT_ADJUSTMENT ) ),
aLbAdjustment ( this, SdResId( LB_ADJUSTMENT ) ),
aBtnCreateGroup ( this, SdResId( BTN_CREATE_GROUP ) ),
pWin ( pParent ),
pBitmapEx ( NULL ),
bMovie ( sal_False ),
bAllObjects ( sal_False ),
pBindings ( pInBindings )
{
aCtlDisplay.SetAccessibleName(String (SdResId(STR_DISPLAY)));
FreeResource();
aBtnGetOneObject.SetModeImage( Image( SdResId( IMG_GET1OBJECT_H ) ), BMP_COLOR_HIGHCONTRAST );
aBtnGetAllObjects.SetModeImage( Image( SdResId( IMG_GETALLOBJECT_H ) ), BMP_COLOR_HIGHCONTRAST );
aBtnRemoveBitmap.SetModeImage( Image( SdResId( IMG_REMOVEBMP_H ) ), BMP_COLOR_HIGHCONTRAST );
aBtnRemoveAll.SetModeImage( Image( SdResId( IMG_REMOVEALLBMP_H ) ), BMP_COLOR_HIGHCONTRAST );
// neues Dokument mit Seite erzeugen
pMyDoc = new SdDrawDocument(DOCUMENT_TYPE_IMPRESS, NULL);
SdPage* pPage = (SdPage*) pMyDoc->AllocPage(sal_False);
pMyDoc->InsertPage(pPage);
pControllerItem = new AnimationControllerItem( SID_ANIMATOR_STATE, this, pBindings );
// Solange noch nicht in der Resource
aTimeField.SetFormat( TIMEF_SEC_CS );
aBtnFirst.SetClickHdl( LINK( this, AnimationWindow, ClickFirstHdl ) );
aBtnReverse.SetClickHdl( LINK( this, AnimationWindow, ClickPlayHdl ) );
aBtnStop.SetClickHdl( LINK( this, AnimationWindow, ClickStopHdl ) );
aBtnPlay.SetClickHdl( LINK( this, AnimationWindow, ClickPlayHdl ) );
aBtnLast.SetClickHdl( LINK( this, AnimationWindow, ClickLastHdl ) );
aBtnGetOneObject.SetClickHdl( LINK( this, AnimationWindow, ClickGetObjectHdl ) );
aBtnGetAllObjects.SetClickHdl( LINK( this, AnimationWindow, ClickGetObjectHdl ) );
aBtnRemoveBitmap.SetClickHdl( LINK( this, AnimationWindow, ClickRemoveBitmapHdl ) );
aBtnRemoveAll.SetClickHdl( LINK( this, AnimationWindow, ClickRemoveBitmapHdl ) );
aRbtGroup.SetClickHdl( LINK( this, AnimationWindow, ClickRbtHdl ) );
aRbtBitmap.SetClickHdl( LINK( this, AnimationWindow, ClickRbtHdl ) );
aBtnCreateGroup.SetClickHdl( LINK( this, AnimationWindow, ClickCreateGroupHdl ) );
aNumFldBitmap.SetModifyHdl( LINK( this, AnimationWindow, ModifyBitmapHdl ) );
aTimeField.SetModifyHdl( LINK( this, AnimationWindow, ModifyTimeHdl ) );
// disable 3D border
aCtlDisplay.SetBorderStyle(WINDOW_BORDER_MONO);
aDisplaySize = aCtlDisplay.GetOutputSize();
aSize = GetOutputSizePixel();
SetMinOutputSizePixel( aSize );
ResetAttrs();
// der Animator ist leer; es kann keine Animationsgruppe erstellt werden
aBtnCreateGroup.Disable();
aBtnGetOneObject.SetAccessibleRelationMemberOf( &aGrpBitmap );
aBtnGetAllObjects.SetAccessibleRelationMemberOf( &aGrpBitmap );
aBtnRemoveBitmap.SetAccessibleRelationMemberOf( &aGrpBitmap );
aBtnRemoveAll.SetAccessibleRelationMemberOf( &aGrpBitmap );
}
// -----------------------------------------------------------------------
AnimationWindow::~AnimationWindow()
{
sal_uLong i, nCount;
delete pControllerItem;
// Bitmapliste bereinigen
for( i = 0, nCount = aBmpExList.Count(); i < nCount; i++ )
delete static_cast< BitmapEx* >( aBmpExList.GetObject( i ) );
aBmpExList.Clear();
// Timeliste bereinigen
for( i = 0, nCount = aTimeList.Count(); i < nCount; i++ )
delete static_cast< Time* >( aTimeList.GetObject( i ) );
aTimeList.Clear();
// die Clones loeschen
delete pMyDoc;
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickFirstHdl, void *, EMPTYARG )
{
aBmpExList.First();
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetCurObject() );
UpdateControl( aBmpExList.GetCurPos() );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickStopHdl, void *, EMPTYARG )
{
bMovie = sal_False;
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickPlayHdl, void *, p )
{
ScopeLockGuard aGuard( maPlayLock );
bMovie = sal_True;
sal_Bool bDisableCtrls = sal_False;
sal_uLong nCount = aBmpExList.Count();
sal_Bool bReverse = p == &aBtnReverse;
// Kann spaeter schwer ermittelt werden
sal_Bool bRbtGroupEnabled = aRbtGroup.IsEnabled();
sal_Bool bBtnGetAllObjectsEnabled = aBtnGetAllObjects.IsEnabled();
sal_Bool bBtnGetOneObjectEnabled = aBtnGetOneObject.IsEnabled();
// Gesamtzeit ermitteln
Time aTime( 0 );
long nFullTime;
if( aRbtBitmap.IsChecked() )
{
for( sal_uLong i = 0; i < nCount; i++ )
aTime += *static_cast< Time* >( aTimeList.GetObject( i ) );
nFullTime = aTime.GetMSFromTime();
}
else
{
nFullTime = nCount * 100;
aTime.MakeTimeFromMS( nFullTime );
}
// StatusBarManager ab 1 Sekunde
SfxProgress* pProgress = NULL;
if( nFullTime >= 1000 )
{
bDisableCtrls = sal_True;
aBtnStop.Enable();
aBtnStop.Update();
String aStr( RTL_CONSTASCII_USTRINGPARAM( "Animator:" ) ); // Hier sollte man sich noch etwas gescheites ausdenken!
pProgress = new SfxProgress( NULL, aStr, nFullTime );
}
sal_uLong nTmpTime = 0;
long i = 0;
sal_Bool bCount = i < (long) nCount;
if( bReverse )
{
i = nCount - 1;
bCount = i >= 0;
}
while( bCount && bMovie )
{
// Um Konsistenz zwischen Liste und Anzeige zu erwirken
aBmpExList.Seek( i );
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetCurObject() );
UpdateControl( i, bDisableCtrls );
if( aRbtBitmap.IsChecked() )
{
Time* pTime = static_cast< Time* >( aTimeList.GetObject( i ) );
DBG_ASSERT( pTime, "Keine Zeit gefunden!" );
aTimeField.SetTime( *pTime );
sal_uLong nTime = pTime->GetMSFromTime();
WaitInEffect( nTime, nTmpTime, pProgress );
nTmpTime += nTime;
}
else
{
WaitInEffect( 100, nTmpTime, pProgress );
nTmpTime += 100;
}
if( bReverse )
{
i--;
if (i < 0)
{
// Terminate loop.
bCount = false;
// Move i back into valid range.
i = 0;
}
}
else
{
i++;
if (i >= (long) nCount)
{
// Terminate loop.
bCount = false;
// Move i back into valid range.
i = nCount - 1;
}
}
}
// Um die Controls wieder zu enablen
bMovie = sal_False;
if (nCount > 0)
UpdateControl(i);
if( pProgress )
{
delete pProgress;
aBtnStop.Disable();
}
aRbtGroup.Enable( bRbtGroupEnabled );
aBtnGetAllObjects.Enable( bBtnGetAllObjectsEnabled );
aBtnGetOneObject.Enable( bBtnGetOneObjectEnabled );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickLastHdl, void *, EMPTYARG )
{
aBmpExList.Last();
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetCurObject() );
UpdateControl( aBmpExList.GetCurPos() );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickRbtHdl, void *, p )
{
if( !pBitmapEx || p == &aRbtGroup || aRbtGroup.IsChecked() )
{
aTimeField.SetText( String() );
aTimeField.Enable( sal_False );
aLbLoopCount.Enable( sal_False );
}
else if( p == &aRbtBitmap || aRbtBitmap.IsChecked() )
{
sal_uLong n = static_cast<sal_uLong>(aNumFldBitmap.GetValue());
if( n > 0 )
{
Time* pTime = static_cast< Time* >( aTimeList.GetObject( n - 1 ) );
if( pTime )
aTimeField.SetTime( *pTime );
}
aTimeField.Enable();
aLbLoopCount.Enable();
}
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickGetObjectHdl, void *, pBtn )
{
bAllObjects = pBtn == &aBtnGetAllObjects;
// Code jetzt in AddObj()
SfxBoolItem aItem( SID_ANIMATOR_ADD, sal_True );
GetBindings().GetDispatcher()->Execute(
SID_ANIMATOR_ADD, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickRemoveBitmapHdl, void *, pBtn )
{
SdPage* pPage = pMyDoc->GetSdPage(0, PK_STANDARD);
SdrObject* pObject;
if( pBtn == &aBtnRemoveBitmap )
{
sal_uLong nPos = aBmpExList.GetCurPos();
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetCurObject() );
if( pBitmapEx )
{
delete pBitmapEx;
aBmpExList.Remove();
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetCurObject() );
}
Time* pTime = static_cast< Time* >( aTimeList.GetObject( nPos ) );
if( pTime )
{
delete pTime;
aTimeList.Remove( nPos );
}
pObject = pPage->GetObj( nPos );
// Durch Uebernahme der AnimatedGIFs muessen nicht unbedingt
// Objekte vorhanden sein.
if( pObject )
{
pObject = pPage->RemoveObject(nPos);
DBG_ASSERT(pObject, "Clone beim Loeschen nicht gefunden");
SdrObject::Free( pObject );
pPage->RecalcObjOrdNums();
}
}
else // Alles loeschen
{
WarningBox aWarnBox( this, WB_YES_NO, String( SdResId( STR_ASK_DELETE_ALL_PICTURES ) ) );
short nReturn = aWarnBox.Execute();
if( nReturn == RET_YES )
{
// Bitmapliste bereinigen
long nCount = aBmpExList.Count();
long i;
for( i = nCount - 1; i >= 0; i-- )
{
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetObject( i ) );
delete pBitmapEx;
pObject = pPage->GetObj( i );
if( pObject )
{
pObject = pPage->RemoveObject( i );
DBG_ASSERT(pObject, "Clone beim Loeschen nicht gefunden");
SdrObject::Free( pObject );
//pPage->RecalcObjOrdNums();
}
}
aBmpExList.Clear();
// Timeliste bereinigen
nCount = aTimeList.Count();
for( i = 0; i < nCount; i++ )
{
delete static_cast< Time* >( aTimeList.GetObject( i ) );
}
aTimeList.Clear();
}
}
// kann noch eine Animationsgruppe erstellt werden?
if (aBmpExList.Count() == 0)
{
aBtnCreateGroup.Disable();
// Falls vorher durch Uebernahme von AnimatedGIFs disabled:
//aRbtBitmap.Enable();
aRbtGroup.Enable();
}
// Zoom fuer DisplayWin berechnen und setzen
Fraction aFrac( GetScale() );
aCtlDisplay.SetScale( aFrac );
UpdateControl( aBmpExList.GetCurPos() );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ClickCreateGroupHdl, void *, EMPTYARG )
{
// Code jetzt in CreatePresObj()
SfxBoolItem aItem( SID_ANIMATOR_CREATE, sal_True );
GetBindings().GetDispatcher()->Execute(
SID_ANIMATOR_CREATE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ModifyBitmapHdl, void *, EMPTYARG )
{
sal_uLong nBmp = static_cast<sal_uLong>(aNumFldBitmap.GetValue());
if( nBmp > aBmpExList.Count() )
nBmp = aBmpExList.Count();
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetObject( nBmp - 1 ) );
// Positionieren in der Liste
aBmpExList.Seek( nBmp - 1 );
UpdateControl( nBmp - 1 );
return( 0L );
}
// -----------------------------------------------------------------------
IMPL_LINK( AnimationWindow, ModifyTimeHdl, void *, EMPTYARG )
{
sal_uLong nPos = static_cast<sal_uLong>(aNumFldBitmap.GetValue() - 1);
Time* pTime = static_cast< Time* >( aTimeList.GetObject( nPos ) );
DBG_ASSERT( pTime, "Zeit nicht gefunden!" );
*pTime = aTimeField.GetTime();
return( 0L );
}
// -----------------------------------------------------------------------
void AnimationWindow::UpdateControl( sal_uLong nListPos, sal_Bool bDisableCtrls )
{
String aString;
if( pBitmapEx )
{
BitmapEx aBmp( *pBitmapEx );
SdPage* pPage = pMyDoc->GetSdPage(0, PK_STANDARD);
SdrObject* pObject = (SdrObject*) pPage->GetObj( (sal_uLong) nListPos );
if( pObject )
{
VirtualDevice aVD;
Rectangle aObjRect( pObject->GetCurrentBoundRect() );
Size aObjSize( aObjRect.GetSize() );
Point aOrigin( Point( -aObjRect.Left(), -aObjRect.Top() ) );
MapMode aMap( aVD.GetMapMode() );
aMap.SetMapUnit( MAP_100TH_MM );
aMap.SetOrigin( aOrigin );
aVD.SetMapMode( aMap );
aVD.SetOutputSize( aObjSize );
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
aVD.SetBackground( Wallpaper( rStyles.GetFieldColor() ) );
aVD.SetDrawMode( rStyles.GetHighContrastMode()
? ViewShell::OUTPUT_DRAWMODE_CONTRAST
: ViewShell::OUTPUT_DRAWMODE_COLOR );
aVD.Erase();
pObject->SingleObjectPainter( aVD ); // #110094#-17
aBmp = BitmapEx( aVD.GetBitmap( aObjRect.TopLeft(), aObjSize ) );
}
aCtlDisplay.SetBitmapEx( &aBmp );
}
else
{
aCtlDisplay.SetBitmapEx( pBitmapEx );
}
aCtlDisplay.Invalidate();
aCtlDisplay.Update();
aFiCount.SetText( UniString::CreateFromInt32( aBmpExList.Count() ) );
if( pBitmapEx && !bMovie )
{
aNumFldBitmap.SetValue( nListPos + 1 );
// Wenn mind. 1 Objekt in der Liste ist
aBtnFirst.Enable();
aBtnReverse.Enable();
aBtnPlay.Enable();
aBtnLast.Enable();
aNumFldBitmap.Enable();
aTimeField.Enable();
aLbLoopCount.Enable();
aBtnRemoveBitmap.Enable();
aBtnRemoveAll.Enable();
}
else
{
//aFiCount.SetText( String( SdResId( STR_NULL ) ) );
// Wenn kein Objekt in der Liste ist
aBtnFirst.Enable( sal_False );
aBtnReverse.Enable( sal_False );
aBtnPlay.Enable( sal_False );
aBtnLast.Enable( sal_False );
aNumFldBitmap.Enable( sal_False );
aTimeField.Enable( sal_False );
aLbLoopCount.Enable( sal_False );
aBtnRemoveBitmap.Enable( sal_False );
aBtnRemoveAll.Enable( sal_False );
//aFtAdjustment.Enable();
//aLbAdjustment.Enable();
}
if( bMovie && bDisableCtrls )
{
aBtnGetOneObject.Enable( sal_False );
aBtnGetAllObjects.Enable( sal_False );
aRbtGroup.Enable( sal_False );
aRbtBitmap.Enable( sal_False );
aBtnCreateGroup.Enable( sal_False );
aFtAdjustment.Enable( sal_False );
aLbAdjustment.Enable( sal_False );
}
else
{
// 'Gruppenobjekt' nur dann enablen, wenn es kein Animated GIF ist
if (aBmpExList.Count() == 0)
aRbtGroup.Enable();
aRbtBitmap.Enable();
aBtnCreateGroup.Enable(aBmpExList.Count() != 0);
aFtAdjustment.Enable( sal_True );
aLbAdjustment.Enable( sal_True );
}
ClickRbtHdl( NULL );
}
// -----------------------------------------------------------------------
void AnimationWindow::ResetAttrs()
{
aRbtGroup.Check();
aLbAdjustment.SelectEntryPos( BA_CENTER );
// LoopCount
aLbLoopCount.SelectEntryPos( aLbLoopCount.GetEntryCount() - 1);
UpdateControl( 0 );
}
// -----------------------------------------------------------------------
void AnimationWindow::WaitInEffect( sal_uLong nMilliSeconds, sal_uLong nTime,
SfxProgress* pProgress ) const
{
clock_t aEnd = Time::GetSystemTicks() + nMilliSeconds;
clock_t aCurrent = Time::GetSystemTicks();
while (aCurrent < aEnd)
{
aCurrent = Time::GetSystemTicks();
if( pProgress )
pProgress->SetState( nTime + nMilliSeconds + aCurrent - aEnd );
Application::Reschedule();
if( !bMovie )
return;
}
}
// -----------------------------------------------------------------------
Fraction AnimationWindow::GetScale()
{
Fraction aFrac;
sal_uLong nPos = aBmpExList.GetCurPos();
sal_uLong nCount = aBmpExList.Count();
if( nCount > 0 )
{
aBmpSize.Width() = 0;
aBmpSize.Height() = 0;
for( sal_uLong i = 0; i < nCount; i++ )
{
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetObject( i ) );
Size aTempSize( pBitmapEx->GetBitmap().GetSizePixel() );
aBmpSize.Width() = Max( aBmpSize.Width(), aTempSize.Width() );
aBmpSize.Height() = Max( aBmpSize.Height(), aTempSize.Height() );
}
aBmpSize.Width() += 10;
aBmpSize.Height() += 10;
aFrac = Fraction( std::min( (double)aDisplaySize.Width() / (double)aBmpSize.Width(),
(double)aDisplaySize.Height() / (double)aBmpSize.Height() ) );
}
// Liste wieder auf alten Stand bringen
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetObject( nPos ) );
return( aFrac );
}
// -----------------------------------------------------------------------
void AnimationWindow::Resize()
{
//if( !IsZoomedIn() )
if ( !IsFloatingMode() ||
!GetFloatingWindow()->IsRollUp() )
{
Size aWinSize( GetOutputSizePixel() ); // vorher rSize im Resizing()
Size aDiffSize;
aDiffSize.Width() = aWinSize.Width() - aSize.Width();
aDiffSize.Height() = aWinSize.Height() - aSize.Height();
// Umgroessern des Display-Controls
aDisplaySize.Width() += aDiffSize.Width();
aDisplaySize.Height() += aDiffSize.Height();
aCtlDisplay.SetOutputSizePixel( aDisplaySize );
Point aPt;
// aPt.X() = aDiffSize.Width() / 2;
aPt.Y() = aDiffSize.Height();
// Verschieben der anderen Controls
aBtnFirst.Hide();
aBtnReverse.Hide();
aBtnStop.Hide();
aBtnPlay.Hide();
aBtnLast.Hide();
aTimeField.Hide();
aLbLoopCount.Hide();
aNumFldBitmap.Hide();
aFtCount.Hide();
aFiCount.Hide();
aBtnGetOneObject.Hide();
aBtnGetAllObjects.Hide();
aBtnRemoveBitmap.Hide();
aBtnRemoveAll.Hide();
aGrpBitmap.Hide();
aRbtGroup.Hide();
aRbtBitmap.Hide();
aFtAdjustment.Hide();
aLbAdjustment.Hide();
aBtnCreateGroup.Hide();
aGrpAnimation.Hide();
aBtnFirst.SetPosPixel( aBtnFirst.GetPosPixel() + aPt );
aBtnReverse.SetPosPixel( aBtnReverse.GetPosPixel() + aPt );
aBtnStop.SetPosPixel( aBtnStop.GetPosPixel() + aPt );
aBtnPlay.SetPosPixel( aBtnPlay.GetPosPixel() + aPt );
aBtnLast.SetPosPixel( aBtnLast.GetPosPixel() + aPt );
aNumFldBitmap.SetPosPixel( aNumFldBitmap.GetPosPixel() + aPt );
aTimeField.SetPosPixel( aTimeField.GetPosPixel() + aPt );
aLbLoopCount.SetPosPixel( aLbLoopCount.GetPosPixel() + aPt );
aFtCount.SetPosPixel( aFtCount.GetPosPixel() + aPt );
aFiCount.SetPosPixel( aFiCount.GetPosPixel() + aPt );
aRbtGroup.SetPosPixel( aRbtGroup.GetPosPixel() + aPt );
aRbtBitmap.SetPosPixel( aRbtBitmap.GetPosPixel() + aPt );
aFtAdjustment.SetPosPixel( aFtAdjustment.GetPosPixel() + aPt );
aLbAdjustment.SetPosPixel( aLbAdjustment.GetPosPixel() + aPt );
aBtnGetOneObject.SetPosPixel( aBtnGetOneObject.GetPosPixel() + aPt );
aBtnGetAllObjects.SetPosPixel( aBtnGetAllObjects.GetPosPixel() + aPt );
aBtnRemoveBitmap.SetPosPixel( aBtnRemoveBitmap.GetPosPixel() + aPt );
aBtnRemoveAll.SetPosPixel( aBtnRemoveAll.GetPosPixel() + aPt );
aBtnCreateGroup.SetPosPixel( aBtnCreateGroup.GetPosPixel() + aPt );
aGrpBitmap.SetPosPixel( aGrpBitmap.GetPosPixel() + aPt );
aGrpAnimation.SetPosPixel( aGrpAnimation.GetPosPixel() + aPt );
// Zoom fuer DisplayWin berechnen und setzen
Fraction aFrac( GetScale() );
aCtlDisplay.SetScale( aFrac );
aBtnFirst.Show();
aBtnReverse.Show();
aBtnStop.Show();
aBtnPlay.Show();
aBtnLast.Show();
aNumFldBitmap.Show();
aTimeField.Show();
aLbLoopCount.Show();
aFtCount.Show();
aFiCount.Show();
aFtAdjustment.Show();
aLbAdjustment.Show();
aBtnGetOneObject.Show();
aBtnGetAllObjects.Show();
aBtnRemoveBitmap.Show();
aBtnRemoveAll.Show();
aGrpBitmap.Show();
aRbtGroup.Show();
aRbtBitmap.Show();
aFtAdjustment.Show();
aLbAdjustment.Show();
aBtnCreateGroup.Show();
aGrpAnimation.Show();
aSize = aWinSize;
//aFltWinSize = GetSizePixel();
}
SfxDockingWindow::Resize();
}
// -----------------------------------------------------------------------
sal_Bool AnimationWindow::Close()
{
if( maPlayLock.isLocked() )
{
return sal_False;
}
else
{
SfxBoolItem aItem( SID_ANIMATION_OBJECTS, sal_False );
GetBindings().GetDispatcher()->Execute(
SID_ANIMATION_OBJECTS, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
SfxDockingWindow::Close();
return sal_True;
}
}
// -----------------------------------------------------------------------
void AnimationWindow::FillInfo( SfxChildWinInfo& rInfo ) const
{
SfxDockingWindow::FillInfo( rInfo ) ;
}
// -----------------------------------------------------------------------
void AnimationWindow::AddObj (::sd::View& rView )
{
// Texteingabemodus beenden, damit Bitmap mit
// Objekt identisch ist.
if( rView.IsTextEdit() )
rView.SdrEndTextEdit();
// Objekt(e) clonen und den/die Clone(s) in die Liste stellen
const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
sal_uLong nMarkCount = rMarkList.GetMarkCount();
SdPage* pPage = pMyDoc->GetSdPage(0, PK_STANDARD);
sal_uLong nCloneCount = pPage->GetObjCount();
if (nMarkCount > 0)
{
// Wenn es sich um EIN Animationsobjekt oder ein Gruppenobjekt
// handelt, das 'einzeln uebernommen' wurde,
// werden die einzelnen Objekte eingefuegt
sal_Bool bAnimObj = sal_False;
if( nMarkCount == 1 )
{
SdrMark* pMark = rMarkList.GetMark(0);
SdrObject* pObject = pMark->GetMarkedSdrObj();
SdAnimationInfo* pAnimInfo = rView.GetDoc()->GetAnimationInfo( pObject );
sal_uInt32 nInv = pObject->GetObjInventor();
sal_uInt16 nId = pObject->GetObjIdentifier();
// Animated Bitmap (GIF)
if( nInv == SdrInventor && nId == OBJ_GRAF && ( (SdrGrafObj*) pObject )->IsAnimated() )
{
const SdrGrafObj* pGrafObj = (SdrGrafObj*) pObject;
Graphic aGraphic( pGrafObj->GetTransformedGraphic() );
sal_uInt16 nCount = 0;
if( aGraphic.IsAnimated() )
nCount = aGraphic.GetAnimation().Count();
if( nCount > 0 )
{
const Animation aAnimation( aGraphic.GetAnimation() );
for( sal_uInt16 i = 0; i < nCount; i++ )
{
const AnimationBitmap& rAnimBmp = aAnimation.Get( i );
pBitmapEx = new BitmapEx( rAnimBmp.aBmpEx );
aBmpExList.Insert( pBitmapEx, aBmpExList.GetCurPos() + 1 );
// LoopCount
if( i == 0 )
{
long nLoopCount = aAnimation.GetLoopCount();
if( !nLoopCount ) // unendlich
aLbLoopCount.SelectEntryPos( aLbLoopCount.GetEntryCount() - 1);
else
aLbLoopCount.SelectEntry( UniString::CreateFromInt32( nLoopCount ) );
}
// Time
long nTime = rAnimBmp.nWait;
Time* pTime = new Time( 0, 0, nTime / 100, nTime % 100 );
aTimeList.Insert( pTime, aBmpExList.GetCurPos() + 1 );
// Weiterschalten der BitmapListe
aBmpExList.Next();
}
// Nachdem ein animated GIF uebernommen wurde, kann auch nur ein solches erstellt werden
aRbtBitmap.Check();
aRbtGroup.Enable( sal_False );
bAnimObj = sal_True;
}
}
else if( bAllObjects || ( pAnimInfo && pAnimInfo->mbIsMovie ) )
{
// Mehrere Objekte
SdrObjList* pObjList = ((SdrObjGroup*)pObject)->GetSubList();
for( sal_uInt16 nObject = 0; nObject < pObjList->GetObjCount(); nObject++ )
{
SdrObject* pSnapShot = (SdrObject*) pObjList->GetObj( (sal_uLong) nObject );
pBitmapEx = new BitmapEx( SdrExchangeView::GetObjGraphic( pSnapShot->GetModel(), pSnapShot ).GetBitmapEx() );
aBmpExList.Insert( pBitmapEx, aBmpExList.GetCurPos() + 1 );
// Time
Time* pTime = new Time( aTimeField.GetTime() );
aTimeList.Insert( pTime, aBmpExList.GetCurPos() + 1 );
// Clone
pPage->InsertObject( pSnapShot->Clone(), aBmpExList.GetCurPos() + 1 );
// Weiterschalten der BitmapListe
aBmpExList.Next();
}
bAnimObj = sal_True;
}
}
// Auch ein einzelnes animiertes Objekt
if( !bAnimObj && !( bAllObjects && nMarkCount > 1 ) )
{
pBitmapEx = new BitmapEx( rView.GetAllMarkedGraphic().GetBitmapEx() );
aBmpExList.Insert( pBitmapEx, aBmpExList.GetCurPos() + 1 );
// Time
Time* pTime = new Time( aTimeField.GetTime() );
aTimeList.Insert( pTime, aBmpExList.GetCurPos() + 1 );
}
// ein einzelnes Objekt
if( nMarkCount == 1 && !bAnimObj )
{
SdrMark* pMark = rMarkList.GetMark(0);
SdrObject* pObject = pMark->GetMarkedSdrObj();
SdrObject* pClone = pObject->Clone();
pPage->InsertObject(pClone, aBmpExList.GetCurPos() + 1);
}
// mehrere Objekte: die Clones zu einer Gruppe zusammenfassen
else if (nMarkCount > 1)
{
// Objekte einzeln uebernehmen
if( bAllObjects )
{
for( sal_uLong nObject= 0; nObject < nMarkCount; nObject++ )
{
// Clone
SdrObject* pObject = rMarkList.GetMark( nObject )->GetMarkedSdrObj();
pBitmapEx = new BitmapEx( SdrExchangeView::GetObjGraphic( pObject->GetModel(), pObject ).GetBitmapEx() );
aBmpExList.Insert( pBitmapEx, aBmpExList.GetCurPos() + 1 );
// Time
Time* pTime = new Time( aTimeField.GetTime() );
aTimeList.Insert( pTime, aBmpExList.GetCurPos() + 1 );
pPage->InsertObject( pObject->Clone(), aBmpExList.GetCurPos() + 1 );
aBmpExList.Next();
}
bAnimObj = sal_True; // damit nicht nochmal weitergeschaltet wird
}
else
{
SdrObjGroup* pCloneGroup = new SdrObjGroup;
SdrObjList* pObjList = pCloneGroup->GetSubList();
for (sal_uLong nObject= 0; nObject < nMarkCount; nObject++)
pObjList->InsertObject(rMarkList.GetMark(nObject)->GetMarkedSdrObj()->Clone(), LIST_APPEND);
pPage->InsertObject(pCloneGroup, aBmpExList.GetCurPos() + 1);
}
}
if( !bAnimObj )
aBmpExList.Next();
// wenn vorher nichts im Animator war und jetzt was da ist, kann eine
// Animationsgruppe erstellt werden
if (nCloneCount == 0 && aBmpExList.Count() > 0)
aBtnCreateGroup.Enable();
// Zoom fuer DisplayWin berechnen und setzen
Fraction aFrac( GetScale() );
aCtlDisplay.SetScale( aFrac );
UpdateControl( aBmpExList.GetCurPos() );
}
}
// -----------------------------------------------------------------------
void AnimationWindow::CreateAnimObj (::sd::View& rView )
{
::Window* pOutWin = static_cast< ::Window*>(rView.GetFirstOutputDevice()); // GetWin( 0 );
DBG_ASSERT( pOutWin, "Window ist nicht vorhanden!" );
// die Fentermitte ermitteln
const MapMode aMap100( MAP_100TH_MM );
Size aMaxSizeLog;
Size aMaxSizePix;
Size aTemp( pOutWin->GetOutputSizePixel() );
const Point aWindowCenter( pOutWin->PixelToLogic( Point( aTemp.Width() >> 1, aTemp.Height() >> 1 ) ) );
const OutputDevice* pDefDev = Application::GetDefaultDevice();
const sal_uLong nCount = aBmpExList.Count();
BitmapAdjustment eBA = (BitmapAdjustment) aLbAdjustment.GetSelectEntryPos();
sal_uLong i;
// Groesste Bitmap ermitteln
for( i = 0; i < nCount; i++ )
{
const BitmapEx& rBmpEx = *static_cast< BitmapEx* >( aBmpExList.GetObject( i ) );
const Graphic aGraphic( rBmpEx );
Size aTmpSizeLog;
const Size aTmpSizePix( rBmpEx.GetSizePixel() );
if ( aGraphic.GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
aTmpSizeLog = pDefDev->PixelToLogic( aGraphic.GetPrefSize(), aMap100 );
else
aTmpSizeLog = pDefDev->LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 );
aMaxSizeLog.Width() = Max( aMaxSizeLog.Width(), aTmpSizeLog.Width() );
aMaxSizeLog.Height() = Max( aMaxSizeLog.Height(), aTmpSizeLog.Height() );
aMaxSizePix.Width() = Max( aMaxSizePix.Width(), aTmpSizePix.Width() );
aMaxSizePix.Height() = Max( aMaxSizePix.Height(), aTmpSizePix.Height() );
}
SdrPageView* pPV = rView.GetSdrPageView();
if( aRbtBitmap.IsChecked() )
{
// Bitmapgruppe erzeugen (Animated GIF)
Animation aAnimation;
Point aPt;
for( i = 0; i < nCount; i++ )
{
Time* pTime = static_cast< Time* >( aTimeList.GetObject( i ) );
long nTime = pTime->Get100Sec();
nTime += pTime->GetSec() * 100;
pBitmapEx = static_cast< BitmapEx* >( aBmpExList.GetObject( i ) );
// Offset fuer die gewuenschte Ausrichtung bestimmen
const Size aBitmapSize( pBitmapEx->GetSizePixel() );
switch( eBA )
{
case BA_LEFT_UP:
break;
case BA_LEFT:
aPt.Y() = (aMaxSizePix.Height() - aBitmapSize.Height()) >> 1;
break;
case BA_LEFT_DOWN:
aPt.Y() = aMaxSizePix.Height() - aBitmapSize.Height();
break;
case BA_UP:
aPt.X() = (aMaxSizePix.Width() - aBitmapSize.Width()) >> 1;
break;
case BA_CENTER:
aPt.X() = (aMaxSizePix.Width() - aBitmapSize.Width()) >> 1;
aPt.Y() = (aMaxSizePix.Height() - aBitmapSize.Height()) >> 1;
break;
case BA_DOWN:
aPt.X() = (aMaxSizePix.Width() - aBitmapSize.Width()) >> 1;
aPt.Y() = aMaxSizePix.Height() - aBitmapSize.Height();
break;
case BA_RIGHT_UP:
aPt.X() = aMaxSizePix.Width() - aBitmapSize.Width();
break;
case BA_RIGHT:
aPt.X() = aMaxSizePix.Width() - aBitmapSize.Width();
aPt.Y() = (aMaxSizePix.Height() - aBitmapSize.Height()) >> 1;
break;
case BA_RIGHT_DOWN:
aPt.X() = aMaxSizePix.Width() - aBitmapSize.Width();
aPt.Y() = aMaxSizePix.Height() - aBitmapSize.Height();
break;
}
// LoopCount (Anzahl der Durchlaeufe) ermitteln
AnimationBitmap aAnimBmp;
long nLoopCount = 0L;
sal_uInt16 nPos = aLbLoopCount.GetSelectEntryPos();
if( nPos != LISTBOX_ENTRY_NOTFOUND && nPos != aLbLoopCount.GetEntryCount() - 1 ) // unendlich
nLoopCount = (long) aLbLoopCount.GetSelectEntry().ToInt32();
aAnimBmp.aBmpEx = *pBitmapEx;
aAnimBmp.aPosPix = aPt;
aAnimBmp.aSizePix = aBitmapSize;
aAnimBmp.nWait = nTime;
aAnimBmp.eDisposal = DISPOSE_BACK;
aAnimBmp.bUserInput = sal_False;
aAnimation.Insert( aAnimBmp );
aAnimation.SetDisplaySizePixel( aMaxSizePix );
aAnimation.SetLoopCount( nLoopCount );
}
SdrGrafObj* pGrafObj = new SdrGrafObj( Graphic( aAnimation ) );
const Point aOrg( aWindowCenter.X() - ( aMaxSizeLog.Width() >> 1 ), aWindowCenter.Y() - ( aMaxSizeLog.Height() >> 1 ) );
pGrafObj->SetLogicRect( Rectangle( aOrg, aMaxSizeLog ) );
rView.InsertObjectAtView( pGrafObj, *pPV, SDRINSERT_SETDEFLAYER);
}
else
{
// Offset fuer die gewuenschte Ausrichtung bestimmen
Size aOffset;
SdrObject * pClone = NULL;
SdPage* pPage = pMyDoc->GetSdPage(0, PK_STANDARD);
for(i = 0; i < nCount; i++)
{
pClone = pPage->GetObj(i);
Rectangle aRect( pClone->GetSnapRect() );
switch( eBA )
{
case BA_LEFT_UP:
break;
case BA_LEFT:
aOffset.Height() = (aMaxSizeLog.Height() - aRect.GetHeight()) / 2;
break;
case BA_LEFT_DOWN:
aOffset.Height() = aMaxSizeLog.Height() - aRect.GetHeight();
break;
case BA_UP:
aOffset.Width() = (aMaxSizeLog.Width() - aRect.GetWidth()) / 2;
break;
case BA_CENTER:
aOffset.Width() = (aMaxSizeLog.Width() - aRect.GetWidth()) / 2;
aOffset.Height() = (aMaxSizeLog.Height() - aRect.GetHeight()) / 2;
break;
case BA_DOWN:
aOffset.Width() = (aMaxSizeLog.Width() - aRect.GetWidth()) / 2;
aOffset.Height() = aMaxSizeLog.Height() - aRect.GetHeight();
break;
case BA_RIGHT_UP:
aOffset.Width() = aMaxSizeLog.Width() - aRect.GetWidth();
break;
case BA_RIGHT:
aOffset.Width() = aMaxSizeLog.Width() - aRect.GetWidth();
aOffset.Height() = (aMaxSizeLog.Height() - aRect.GetHeight()) / 2;
break;
case BA_RIGHT_DOWN:
aOffset.Width() = aMaxSizeLog.Width() - aRect.GetWidth();
aOffset.Height() = aMaxSizeLog.Height() - aRect.GetHeight();
break;
}
//aRect.SetPos(aWindowCenter + Point(aOffset.Width(), aOffset.Height()));
//pClone->SetSnapRect( aRect );
// SetSnapRect ist fuer Ellipsen leider nicht implementiert !!!
Point aMovePt( aWindowCenter + Point( aOffset.Width(), aOffset.Height() ) - aRect.TopLeft() );
Size aMoveSize( aMovePt.X(), aMovePt.Y() );
pClone->NbcMove( aMoveSize );
}
// #42894# Caution(!) variable pPage looks right, but it is a page from the local
// document the dialog is using (!), so get the target page from the target view
SdPage* pTargetSdPage = dynamic_cast< SdPage* >(rView.GetSdrPageView() ? rView.GetSdrPageView()->GetPage() : 0);
if(pTargetSdPage)
{
// Animationsgruppe erzeugen
SdrObjGroup* pGroup = new SdrObjGroup;
SdrObjList* pObjList = pGroup->GetSubList();
for (i = 0; i < nCount; i++)
{
// der Clone verbleibt im Animator; in die Gruppe kommt ein Clone
// des Clones
pClone = pPage->GetObj(i);
SdrObject* pCloneOfClone = pClone->Clone();
//SdrObject* pCloneOfClone = pPage->GetObj(i)->Clone();
pObjList->InsertObject(pCloneOfClone, LIST_APPEND);
}
// bis jetzt liegt die linke obere Ecke der Gruppe in der Fenstermitte;
// jetzt noch um die Haelfte der Groesse nach oben und links korrigieren
aTemp = aMaxSizeLog;
aTemp.Height() = - aTemp.Height() / 2;
aTemp.Width() = - aTemp.Width() / 2;
pGroup->NbcMove(aTemp);
// #42894# create needed SMIL stuff and move child objects to page directly (see
// comments at EffectMigration::CreateAnimatedGroup why this has to be done).
EffectMigration::CreateAnimatedGroup(*pGroup, *pTargetSdPage);
// #42894# if that worked, delete the group again
if(!pGroup->GetSubList()->GetObjCount())
{
delete pGroup;
}
}
}
ClickFirstHdl( this );
}
void AnimationWindow::DataChanged( const DataChangedEvent& rDCEvt )
{
SfxDockingWindow::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
{
UpdateControl( aBmpExList.GetCurPos() );
}
}
/*************************************************************************
|*
|* ControllerItem fuer Animator
|*
\************************************************************************/
AnimationControllerItem::AnimationControllerItem(
sal_uInt16 _nId,
AnimationWindow* pAnimWin,
SfxBindings* _pBindings)
: SfxControllerItem( _nId, *_pBindings ),
pAnimationWin( pAnimWin )
{
}
// -----------------------------------------------------------------------
void AnimationControllerItem::StateChanged( sal_uInt16 nSId,
SfxItemState eState, const SfxPoolItem* pItem )
{
if( eState >= SFX_ITEM_AVAILABLE && nSId == SID_ANIMATOR_STATE )
{
const SfxUInt16Item* pStateItem = PTR_CAST( SfxUInt16Item, pItem );
DBG_ASSERT( pStateItem, "SfxUInt16Item erwartet");
sal_uInt16 nState = pStateItem->GetValue();
pAnimationWin->aBtnGetOneObject.Enable( nState & 1 );
pAnimationWin->aBtnGetAllObjects.Enable( nState & 2 );
}
}
} // end of namespace sd