| /************************************************************** |
| * |
| * 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/EffectNodeType.hpp> |
| #include <com/sun/star/animations/Timing.hpp> |
| #include <com/sun/star/animations/Event.hpp> |
| #include <com/sun/star/animations/EventTrigger.hpp> |
| #include <com/sun/star/animations/AnimationFill.hpp> |
| #include <com/sun/star/presentation/TextAnimationType.hpp> |
| #include <com/sun/star/animations/ValuePair.hpp> |
| #include <com/sun/star/awt/FontSlant.hpp> |
| #include <com/sun/star/awt/FontWeight.hpp> |
| #include <com/sun/star/awt/FontUnderline.hpp> |
| #include <com/sun/star/drawing/XDrawPage.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/media/XManager.hpp> |
| #include <com/sun/star/media/XPlayer.hpp> |
| |
| #ifndef BOOST_SHARED_PTR_HPP_INCLUDED |
| #include <boost/shared_ptr.hpp> |
| #endif |
| |
| #ifndef _UNOTOOLS_PROCESSFACTORY_HXX |
| #include <comphelper/processfactory.hxx> |
| #endif |
| #include <unotools/pathoptions.hxx> |
| #include <vcl/tabctrl.hxx> |
| #include <vcl/tabpage.hxx> |
| #include <vcl/menubtn.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/fixed.hxx> |
| #include <vcl/lstbox.hxx> |
| #include <vcl/field.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <vcl/decoview.hxx> |
| #include <vcl/combobox.hxx> |
| #include <vcl/menu.hxx> |
| #include <svtools/ctrlbox.hxx> |
| #include <svtools/ctrltool.hxx> |
| #include <sfx2/objsh.hxx> |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| #include <svx/dialmgr.hxx> |
| #include <editeng/flstitem.hxx> |
| #include <svx/drawitem.hxx> |
| |
| #include <svx/xtable.hxx> |
| #include <svx/gallery.hxx> |
| |
| #ifndef _SVX_DIALOGS_HRC |
| #include <svx/dialogs.hrc> |
| #endif |
| #include "sdresid.hxx" |
| |
| #include "glob.hrc" |
| #include "CustomAnimationDialog.hxx" |
| #ifndef _SD_CUSTOMANIMATIONDIALOG_HRC |
| #include "CustomAnimationDialog.hrc" |
| #endif |
| #ifndef _SD_CUSTOMANIMATION_HRC |
| #include "CustomAnimation.hrc" |
| #endif |
| #include "STLPropertySet.hxx" |
| |
| #include <avmedia/mediawindow.hxx> |
| |
| #include "filedlg.hxx" |
| #include "strings.hrc" |
| #include "helpids.h" |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::animations; |
| using namespace ::com::sun::star::presentation; |
| |
| using ::rtl::OUString; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::uno::UNO_QUERY_THROW; |
| using ::com::sun::star::uno::Any; |
| using ::com::sun::star::uno::makeAny; |
| using ::com::sun::star::uno::Sequence; |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::Exception; |
| using ::com::sun::star::drawing::XShape; |
| using ::com::sun::star::drawing::XDrawPage; |
| using ::com::sun::star::beans::XPropertySet; |
| |
| namespace sd { |
| |
| extern void fillRepeatComboBox( ComboBox* pBox ); |
| extern void fillDurationComboBox( ComboBox* pBox ); |
| extern OUString getShapeDescription( const Reference< XShape >& xShape, bool bWithText = true ); |
| extern OUString getPropertyName( sal_Int32 nPropertyType ); |
| |
| // ==================================================================== |
| |
| class PresetPropertyBox : public PropertySubControl |
| { |
| public: |
| PresetPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const OUString& aPresetId, const Link& rModifyHdl ); |
| ~PresetPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& rPresetId ); |
| virtual Control* getControl(); |
| |
| private: |
| std::map< sal_uInt16, rtl::OUString > maPropertyValues; |
| ListBox* mpControl; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| PresetPropertyBox::PresetPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const OUString& aPresetId, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| { |
| mpControl = new ListBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN ); |
| mpControl->SetDropDownLineCount( 10 ); |
| mpControl->SetSelectHdl( rModifyHdl ); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_PRESETPROPERTYBOX ); |
| |
| setValue( rValue, aPresetId ); |
| |
| } |
| |
| void PresetPropertyBox::setValue( const Any& rValue, const OUString& rPresetId ) |
| { |
| if( mpControl ) |
| { |
| mpControl->Clear(); |
| |
| const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets(); |
| CustomAnimationPresetPtr pDescriptor = rPresets.getEffectDescriptor( rPresetId ); |
| if( pDescriptor.get() ) |
| { |
| |
| OUString aPropertyValue; |
| rValue >>= aPropertyValue; |
| |
| UStringList aSubTypes( pDescriptor->getSubTypes() ); |
| UStringList::iterator aIter( aSubTypes.begin() ); |
| const UStringList::iterator aEnd( aSubTypes.end() ); |
| |
| mpControl->Enable( aIter != aEnd ); |
| |
| while( aIter != aEnd ) |
| { |
| sal_uInt16 nPos = mpControl->InsertEntry( rPresets.getUINameForProperty( (*aIter) ) ); |
| if( (*aIter) == aPropertyValue ) |
| mpControl->SelectEntryPos( nPos ); |
| maPropertyValues[nPos] = (*aIter++); |
| } |
| } |
| else |
| { |
| mpControl->Enable( sal_False ); |
| } |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| PresetPropertyBox::~PresetPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any PresetPropertyBox::getValue() |
| { |
| return makeAny( maPropertyValues[mpControl->GetSelectEntryPos()] ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* PresetPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class ColorPropertyBox : public PropertySubControl |
| { |
| public: |
| ColorPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| ~ColorPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& rPresetId ); |
| virtual Control* getControl(); |
| |
| private: |
| ColorListBox* mpControl; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| ColorPropertyBox::ColorPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| { |
| mpControl = new ColorListBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN ); |
| mpControl->SetDropDownLineCount( 10 ); |
| mpControl->SetSelectHdl( rModifyHdl ); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_COLORPROPERTYBOX ); |
| |
| SfxObjectShell* pDocSh = SfxObjectShell::Current(); |
| DBG_ASSERT( pDocSh, "DocShell not found!" ); |
| XColorListSharedPtr aColorTable; |
| const SfxPoolItem* pItem = NULL; |
| |
| if ( pDocSh && ( ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) != 0) ) |
| aColorTable = static_cast< const SvxColorTableItem* >(pItem)->GetColorTable(); |
| |
| if ( !aColorTable.get() ) |
| { |
| aColorTable = XPropertyListFactory::CreateSharedXColorList(SvtPathOptions().GetPalettePath()); |
| } |
| |
| sal_Int32 nColor = 0; |
| rValue >>= nColor; |
| |
| for ( long i = 0; i < aColorTable->Count(); i++ ) |
| { |
| XColorEntry* pEntry = aColorTable->GetColor(i); |
| sal_uInt16 nPos = mpControl->InsertEntry( pEntry->GetColor(), pEntry->GetName() ); |
| if( pEntry->GetColor().GetRGBColor() == (sal_uInt32)nColor ) |
| mpControl->SelectEntryPos( nPos ); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| ColorPropertyBox::~ColorPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void ColorPropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpControl ) |
| { |
| sal_Int32 nColor = 0; |
| rValue >>= nColor; |
| |
| mpControl->SetNoSelection(); |
| mpControl->SelectEntryPos( mpControl->GetEntryPos( (Color)nColor ) ); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any ColorPropertyBox::getValue() |
| { |
| return makeAny( (sal_Int32)mpControl->GetSelectEntryColor().GetRGBColor() ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* ColorPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class FontPropertyBox : public PropertySubControl |
| { |
| public: |
| FontPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| virtual ~FontPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& rPresetId ); |
| |
| virtual Control* getControl(); |
| |
| private: |
| FontNameBox* mpControl; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| FontPropertyBox::FontPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| { |
| mpControl = new FontNameBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN ); |
| mpControl->SetDropDownLineCount( 10 ); |
| mpControl->SetSelectHdl( rModifyHdl ); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_FONTPROPERTYBOX ); |
| |
| SfxObjectShell* pDocSh = SfxObjectShell::Current(); |
| const SfxPoolItem* pItem; |
| |
| const FontList* pFontList = 0; |
| bool bMustDelete = false; |
| |
| if ( pDocSh && ( (pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST ) ) != 0) ) |
| pFontList = ( (SvxFontListItem*)pItem )->GetFontList(); |
| |
| if(!pFontList) |
| { |
| pFontList = new FontList( Application::GetDefaultDevice(), NULL, sal_False ); |
| bMustDelete = true; |
| } |
| |
| mpControl->Fill( pFontList ); |
| |
| if( bMustDelete ) |
| delete pFontList; |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void FontPropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpControl ) |
| { |
| OUString aFontName; |
| rValue >>= aFontName; |
| mpControl->SetText( aFontName ); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| FontPropertyBox::~FontPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any FontPropertyBox::getValue() |
| { |
| OUString aFontName( mpControl->GetText() ); |
| return makeAny( aFontName ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* FontPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class DropdownMenuBox : public Edit |
| { |
| public: |
| DropdownMenuBox( Window* pParent, Edit* pSubControl, PopupMenu* pMenu ); |
| ~DropdownMenuBox(); |
| |
| void Resize(); |
| long PreNotify( NotifyEvent& rNEvt ); |
| |
| void SetMenuSelectHdl( const Link& rLink ) { mpDropdownButton->SetSelectHdl( rLink ); } |
| |
| private: |
| Edit* mpSubControl; |
| MenuButton* mpDropdownButton; |
| PopupMenu* mpMenu; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| DropdownMenuBox::DropdownMenuBox( Window* pParent, Edit* pSubControl, PopupMenu* pMenu ) |
| : Edit( pParent, WB_BORDER|WB_TABSTOP| WB_DIALOGCONTROL ), |
| mpSubControl(pSubControl),mpDropdownButton(0),mpMenu(pMenu) |
| { |
| mpDropdownButton = new MenuButton( this, WB_NOLIGHTBORDER | WB_RECTSTYLE | WB_NOTABSTOP); |
| mpDropdownButton->SetSymbol(SYMBOL_SPIN_DOWN); |
| mpDropdownButton->Show(); |
| mpDropdownButton->SetPopupMenu( pMenu ); |
| |
| SetSubEdit( mpSubControl ); |
| mpSubControl->SetParent( this ); |
| mpSubControl->Show(); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| DropdownMenuBox::~DropdownMenuBox() |
| { |
| SetSubEdit( 0 ); |
| delete mpSubControl; |
| delete mpDropdownButton; |
| delete mpMenu; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void DropdownMenuBox::Resize() |
| { |
| Size aOutSz = GetOutputSizePixel(); |
| |
| long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize(); |
| nSBWidth = CalcZoom( nSBWidth ); |
| mpSubControl->SetPosSizePixel( 0, 1, aOutSz.Width() - nSBWidth, aOutSz.Height()-2 ); |
| mpDropdownButton->SetPosSizePixel( aOutSz.Width() - nSBWidth, 0, nSBWidth, aOutSz.Height() ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| long DropdownMenuBox::PreNotify( NotifyEvent& rNEvt ) |
| { |
| long nResult=sal_True; |
| |
| sal_uInt16 nSwitch=rNEvt.GetType(); |
| if (nSwitch==EVENT_KEYINPUT) |
| { |
| const KeyCode& aKeyCode=rNEvt.GetKeyEvent()->GetKeyCode(); |
| sal_uInt16 nKey=aKeyCode.GetCode(); |
| |
| if (nKey==KEY_DOWN && aKeyCode.IsMod2()) |
| { |
| mpDropdownButton->KeyInput( *rNEvt.GetKeyEvent() ); |
| } |
| else |
| { |
| nResult=Edit::PreNotify(rNEvt); |
| } |
| } |
| else |
| nResult=Edit::PreNotify(rNEvt); |
| |
| return nResult; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| class CharHeightPropertyBox : public PropertySubControl |
| { |
| public: |
| CharHeightPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| virtual ~CharHeightPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& ); |
| |
| virtual Control* getControl(); |
| |
| DECL_LINK( implMenuSelectHdl, MenuButton* ); |
| |
| private: |
| DropdownMenuBox* mpControl; |
| PopupMenu* mpMenu; |
| MetricField* mpMetric; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| CharHeightPropertyBox::CharHeightPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| { |
| mpMetric = new MetricField( pParent, WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER); |
| mpMetric->SetUnit( FUNIT_PERCENT ); |
| mpMetric->SetMin( 0 ); |
| mpMetric->SetMax( 1000 ); |
| |
| mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_FONTSIZE_POPUP ) ); |
| mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu ); |
| mpControl->SetMenuSelectHdl( LINK( this, CharHeightPropertyBox, implMenuSelectHdl )); |
| mpControl->SetModifyHdl( rModifyHdl ); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_CHARHEIGHTPROPERTYBOX ); |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| CharHeightPropertyBox::~CharHeightPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( CharHeightPropertyBox, implMenuSelectHdl, MenuButton*, pPb ) |
| { |
| long nValue = 100; |
| switch( pPb->GetCurItemId() ) |
| { |
| case CM_SIZE_25: nValue = 25; break; |
| case CM_SIZE_50: nValue = 50; break; |
| case CM_SIZE_150: nValue = 150; break; |
| case CM_SIZE_400: nValue = 400; break; |
| } |
| mpMetric->SetValue( nValue ); |
| mpMetric->Modify(); |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void CharHeightPropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpMetric ) |
| { |
| double fValue = 0.0; |
| rValue >>= fValue; |
| mpMetric->SetValue( (long)(fValue * 100.0) ); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any CharHeightPropertyBox::getValue() |
| { |
| return makeAny( (double)((double)mpMetric->GetValue() / 100.0) ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* CharHeightPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class TransparencyPropertyBox : public PropertySubControl |
| { |
| public: |
| TransparencyPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| ~TransparencyPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& rPresetId ); |
| |
| virtual Control* getControl(); |
| |
| DECL_LINK( implMenuSelectHdl, MenuButton* ); |
| DECL_LINK( implModifyHdl, Control* ); |
| |
| void updateMenu(); |
| |
| private: |
| DropdownMenuBox* mpControl; |
| PopupMenu* mpMenu; |
| MetricField* mpMetric; |
| Link maModifyHdl; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| TransparencyPropertyBox::TransparencyPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| , maModifyHdl( rModifyHdl ) |
| { |
| mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER); |
| mpMetric->SetUnit( FUNIT_PERCENT ); |
| mpMetric->SetMin( 0 ); |
| mpMetric->SetMax( 100 ); |
| |
| mpMenu = new PopupMenu(); |
| for( sal_uInt16 i = 25; i < 101; i += 25 ) |
| { |
| String aStr( String::CreateFromInt32( i ) ); |
| aStr += sal_Unicode('%'); |
| mpMenu->InsertItem( i, aStr ); |
| } |
| |
| mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu ); |
| mpControl->SetMenuSelectHdl( LINK( this, TransparencyPropertyBox, implMenuSelectHdl )); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_TRANSPARENCYPROPERTYBOX ); |
| |
| Link aLink( LINK( this, TransparencyPropertyBox, implModifyHdl ) ); |
| mpControl->SetModifyHdl( aLink ); |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| TransparencyPropertyBox::~TransparencyPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TransparencyPropertyBox::updateMenu() |
| { |
| sal_Int64 nValue = mpMetric->GetValue(); |
| for( sal_uInt16 i = 25; i < 101; i += 25 ) |
| mpMenu->CheckItem( i, nValue == i ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( TransparencyPropertyBox, implModifyHdl, Control*, EMPTYARG ) |
| { |
| updateMenu(); |
| maModifyHdl.Call(mpMetric); |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( TransparencyPropertyBox, implMenuSelectHdl, MenuButton*, pPb ) |
| { |
| if( pPb->GetCurItemId() != mpMetric->GetValue() ) |
| { |
| mpMetric->SetValue( pPb->GetCurItemId() ); |
| mpMetric->Modify(); |
| } |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TransparencyPropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpMetric ) |
| { |
| double fValue = 0.0; |
| rValue >>= fValue; |
| long nValue = (long)(fValue * 100); |
| mpMetric->SetValue( nValue ); |
| updateMenu(); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any TransparencyPropertyBox::getValue() |
| { |
| return makeAny( (double)((double)mpMetric->GetValue()) / 100.0 ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* TransparencyPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| class RotationPropertyBox : public PropertySubControl |
| { |
| public: |
| RotationPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| ~RotationPropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& ); |
| |
| virtual Control* getControl(); |
| |
| DECL_LINK( implMenuSelectHdl, MenuButton* ); |
| DECL_LINK( implModifyHdl, Control* ); |
| |
| void updateMenu(); |
| |
| private: |
| DropdownMenuBox* mpControl; |
| PopupMenu* mpMenu; |
| MetricField* mpMetric; |
| Link maModifyHdl; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| RotationPropertyBox::RotationPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| , maModifyHdl( rModifyHdl ) |
| { |
| mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER); |
| mpMetric->SetUnit( FUNIT_CUSTOM ); |
| mpMetric->SetCustomUnitText( OUString( sal_Unicode(0xb0)) ); // degree sign |
| mpMetric->SetMin( -10000 ); |
| mpMetric->SetMax( 10000 ); |
| |
| mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_ROTATION_POPUP ) ); |
| mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu ); |
| mpControl->SetMenuSelectHdl( LINK( this, RotationPropertyBox, implMenuSelectHdl )); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_ROTATIONPROPERTYBOX ); |
| |
| Link aLink( LINK( this, RotationPropertyBox, implModifyHdl ) ); |
| mpControl->SetModifyHdl( aLink ); |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| RotationPropertyBox::~RotationPropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void RotationPropertyBox::updateMenu() |
| { |
| sal_Int64 nValue = mpMetric->GetValue(); |
| bool bDirection = nValue >= 0; |
| nValue = (nValue < 0 ? -nValue : nValue); |
| |
| mpMenu->CheckItem( CM_QUARTER_SPIN, nValue == 90 ); |
| mpMenu->CheckItem( CM_HALF_SPIN, nValue == 180 ); |
| mpMenu->CheckItem( CM_FULL_SPIN, nValue == 360 ); |
| mpMenu->CheckItem( CM_TWO_SPINS, nValue == 720 ); |
| |
| mpMenu->CheckItem( CM_CLOCKWISE, bDirection ); |
| mpMenu->CheckItem( CM_COUNTERCLOCKWISE, !bDirection ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( RotationPropertyBox, implModifyHdl, Control*, EMPTYARG ) |
| { |
| updateMenu(); |
| maModifyHdl.Call(mpMetric); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( RotationPropertyBox, implMenuSelectHdl, MenuButton*, pPb ) |
| { |
| sal_Int64 nValue = mpMetric->GetValue(); |
| bool bDirection = nValue >= 0; |
| nValue = (nValue < 0 ? -nValue : nValue); |
| |
| switch( pPb->GetCurItemId() ) |
| { |
| case CM_QUARTER_SPIN: nValue = 90; break; |
| case CM_HALF_SPIN: nValue = 180; break; |
| case CM_FULL_SPIN: nValue = 360; break; |
| case CM_TWO_SPINS: nValue = 720; break; |
| |
| case CM_CLOCKWISE: bDirection = true; break; |
| case CM_COUNTERCLOCKWISE: bDirection = false; break; |
| |
| } |
| |
| if( !bDirection ) |
| nValue = -nValue; |
| |
| if( nValue != mpMetric->GetValue() ) |
| { |
| mpMetric->SetValue( nValue ); |
| mpMetric->Modify(); |
| } |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void RotationPropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpMetric ) |
| { |
| double fValue = 0.0; |
| rValue >>= fValue; |
| long nValue = (long)(fValue); |
| mpMetric->SetValue( nValue ); |
| updateMenu(); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any RotationPropertyBox::getValue() |
| { |
| return makeAny( (double)((double)mpMetric->GetValue()) ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* RotationPropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| class ScalePropertyBox : public PropertySubControl |
| { |
| public: |
| ScalePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| ~ScalePropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& ); |
| |
| virtual Control* getControl(); |
| |
| DECL_LINK( implMenuSelectHdl, MenuButton* ); |
| DECL_LINK( implModifyHdl, Control* ); |
| |
| void updateMenu(); |
| |
| private: |
| DropdownMenuBox* mpControl; |
| PopupMenu* mpMenu; |
| MetricField* mpMetric; |
| Link maModifyHdl; |
| int mnDirection; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| ScalePropertyBox::ScalePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| , maModifyHdl( rModifyHdl ) |
| { |
| mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER); |
| mpMetric->SetUnit( FUNIT_PERCENT ); |
| mpMetric->SetMin( 0 ); |
| mpMetric->SetMax( 10000 ); |
| |
| mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_SCALE_POPUP ) ); |
| mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu ); |
| mpControl->SetMenuSelectHdl( LINK( this, ScalePropertyBox, implMenuSelectHdl )); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_SCALEPROPERTYBOX ); |
| |
| Link aLink( LINK( this, ScalePropertyBox, implModifyHdl ) ); |
| mpControl->SetModifyHdl( aLink ); |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| ScalePropertyBox::~ScalePropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void ScalePropertyBox::updateMenu() |
| { |
| sal_Int64 nValue = mpMetric->GetValue(); |
| |
| mpMenu->CheckItem( 25, nValue == 25 ); |
| mpMenu->CheckItem( 50, nValue == 50 ); |
| mpMenu->CheckItem( 150, nValue == 150 ); |
| mpMenu->CheckItem( 400, nValue == 400 ); |
| |
| mpMenu->CheckItem( CM_HORIZONTAL, mnDirection == 1 ); |
| mpMenu->CheckItem( CM_VERTICAL, mnDirection == 2 ); |
| mpMenu->CheckItem( CM_BOTH, mnDirection == 3 ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( ScalePropertyBox, implModifyHdl, Control*, EMPTYARG ) |
| { |
| updateMenu(); |
| maModifyHdl.Call(mpMetric); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( ScalePropertyBox, implMenuSelectHdl, MenuButton*, pPb ) |
| { |
| sal_Int64 nValue = mpMetric->GetValue(); |
| |
| int nDirection = mnDirection; |
| |
| switch( pPb->GetCurItemId() ) |
| { |
| case CM_HORIZONTAL: nDirection = 1; break; |
| case CM_VERTICAL: nDirection = 2; break; |
| case CM_BOTH: nDirection = 3; break; |
| |
| default: |
| nValue = pPb->GetCurItemId(); |
| } |
| |
| bool bModified = false; |
| |
| if( nDirection != mnDirection ) |
| { |
| mnDirection = nDirection; |
| bModified = true; |
| } |
| |
| if( nValue != mpMetric->GetValue() ) |
| { |
| mpMetric->SetValue( nValue ); |
| bModified = true; |
| } |
| |
| if( bModified ) |
| { |
| mpMetric->Modify(); |
| updateMenu(); |
| } |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void ScalePropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| if( mpMetric ) |
| { |
| ValuePair aValues; |
| rValue >>= aValues; |
| |
| double fValue1 = 0.0; |
| double fValue2 = 0.0; |
| |
| aValues.First >>= fValue1; |
| aValues.Second >>= fValue2; |
| |
| if( fValue2 == 0.0 ) |
| mnDirection = 1; |
| else if( fValue1 == 0.0 ) |
| mnDirection = 2; |
| else |
| mnDirection = 3; |
| |
| long nValue; |
| if( fValue1 ) |
| nValue = (long)(fValue1 * 100.0); |
| else |
| nValue = (long)(fValue2 * 100.0); |
| mpMetric->SetValue( nValue ); |
| updateMenu(); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any ScalePropertyBox::getValue() |
| { |
| double fValue1 = (double)((double)mpMetric->GetValue() / 100.0); |
| double fValue2 = fValue1; |
| |
| if( mnDirection == 1 ) |
| fValue2 = 0.0; |
| else if( mnDirection == 2 ) |
| fValue1 = 0.0; |
| |
| ValuePair aValues; |
| aValues.First <<= fValue1; |
| aValues.Second <<= fValue2; |
| |
| return makeAny( aValues ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* ScalePropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class FontStylePropertyBox : public PropertySubControl |
| { |
| public: |
| FontStylePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ); |
| ~FontStylePropertyBox(); |
| |
| virtual Any getValue(); |
| virtual void setValue( const Any& rValue, const OUString& ); |
| |
| virtual Control* getControl(); |
| |
| DECL_LINK( implMenuSelectHdl, MenuButton* ); |
| |
| void update(); |
| |
| private: |
| DropdownMenuBox* mpControl; |
| PopupMenu* mpMenu; |
| Edit* mpEdit; |
| Link maModifyHdl; |
| |
| float mfFontWeight; |
| awt::FontSlant meFontSlant; |
| sal_Int16 mnFontUnderline; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| FontStylePropertyBox::FontStylePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl ) |
| : PropertySubControl( nControlType ) |
| , maModifyHdl( rModifyHdl ) |
| { |
| mpEdit = new Edit( pParent, WB_TABSTOP|WB_IGNORETAB|WB_NOBORDER|WB_READONLY); |
| mpEdit->SetText( String( SdResId( STR_CUSTOMANIMATION_SAMPLE ) ) ); |
| |
| mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_FONTSTYLE_POPUP ) ); |
| mpControl = new DropdownMenuBox( pParent, mpEdit, mpMenu ); |
| mpControl->SetMenuSelectHdl( LINK( this, FontStylePropertyBox, implMenuSelectHdl )); |
| mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_FONTSTYLEPROPERTYBOX ); |
| |
| OUString aPresetId; |
| setValue( rValue, aPresetId ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| FontStylePropertyBox::~FontStylePropertyBox() |
| { |
| delete mpControl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void FontStylePropertyBox::update() |
| { |
| // update menu |
| mpMenu->CheckItem( CM_BOLD, mfFontWeight == awt::FontWeight::BOLD ); |
| mpMenu->CheckItem( CM_ITALIC, meFontSlant == awt::FontSlant_ITALIC); |
| mpMenu->CheckItem( CM_UNDERLINED, mnFontUnderline != awt::FontUnderline::NONE ); |
| |
| // update sample edit |
| Font aFont( mpEdit->GetFont() ); |
| aFont.SetWeight( mfFontWeight == awt::FontWeight::BOLD ? WEIGHT_BOLD : WEIGHT_NORMAL ); |
| aFont.SetItalic( meFontSlant == awt::FontSlant_ITALIC ? ITALIC_NORMAL : ITALIC_NONE ); |
| aFont.SetUnderline( mnFontUnderline == awt::FontUnderline::NONE ? UNDERLINE_NONE : UNDERLINE_SINGLE ); |
| mpEdit->SetFont( aFont ); |
| mpEdit->Invalidate(); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( FontStylePropertyBox, implMenuSelectHdl, MenuButton*, pPb ) |
| { |
| switch( pPb->GetCurItemId() ) |
| { |
| case CM_BOLD: |
| if( mfFontWeight == awt::FontWeight::BOLD ) |
| mfFontWeight = awt::FontWeight::NORMAL; |
| else |
| mfFontWeight = awt::FontWeight::BOLD; |
| break; |
| case CM_ITALIC: |
| if( meFontSlant == awt::FontSlant_ITALIC ) |
| meFontSlant = awt::FontSlant_NONE; |
| else |
| meFontSlant = awt::FontSlant_ITALIC; |
| break; |
| case CM_UNDERLINED: |
| if( mnFontUnderline == awt::FontUnderline::SINGLE ) |
| mnFontUnderline = awt::FontUnderline::NONE; |
| else |
| mnFontUnderline = awt::FontUnderline::SINGLE; |
| break; |
| default: |
| return 0; |
| } |
| |
| update(); |
| maModifyHdl.Call(mpEdit); |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void FontStylePropertyBox::setValue( const Any& rValue, const OUString& ) |
| { |
| Sequence<Any> aValues; |
| rValue >>= aValues; |
| |
| aValues[0] >>= mfFontWeight; |
| aValues[1] >>= meFontSlant; |
| aValues[2] >>= mnFontUnderline; |
| |
| update(); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Any FontStylePropertyBox::getValue() |
| { |
| Sequence<Any> aValues(3); |
| aValues[0] <<= mfFontWeight; |
| aValues[1] <<= meFontSlant; |
| aValues[2] <<= mnFontUnderline; |
| return makeAny( aValues ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Control* FontStylePropertyBox::getControl() |
| { |
| return mpControl; |
| } |
| |
| // ==================================================================== |
| |
| class CustomAnimationEffectTabPage : public TabPage |
| { |
| public: |
| CustomAnimationEffectTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet ); |
| ~CustomAnimationEffectTabPage(); |
| |
| void update( STLPropertySet* pSet ); |
| DECL_LINK( implSelectHdl, Control* ); |
| |
| private: |
| void updateControlStates(); |
| void fillSoundListBox(); |
| void clearSoundListBox(); |
| sal_Int32 getSoundObject( const String& rStr ); |
| void openSoundFileDialog(); |
| void onSoundPreview(); |
| |
| private: |
| List maSoundList; |
| sal_Bool mbHasText; |
| const STLPropertySet* mpSet; |
| |
| FixedLine* mpFLSettings; |
| FixedText* mpFTProperty1; |
| PropertyControl* mpLBProperty1; |
| FixedText* mpFTProperty2; |
| PropertyControl* mpLBProperty2; |
| CheckBox* mpCBSmoothStart; |
| CheckBox* mpCBSmoothEnd; |
| CheckBox* mpCBAutoRestart; |
| |
| FixedLine* mpFLPlay; |
| RadioButton* mpRBFromStart; |
| RadioButton* mpRBFromLast; |
| RadioButton* mpRBFromTime; |
| MetricField* mpMFStartTime; |
| FixedLine* mpFLStop; |
| RadioButton* mpRBStopOnClick; |
| RadioButton* mpRBStopOnNextSlide; |
| RadioButton* mpRBStopAfterSlides; |
| MetricField* mpMFStopAfterSlides; |
| |
| FixedLine* mpFLEnhancements; |
| FixedText* mpFTSound; |
| ListBox* mpLBSound; |
| PushButton* mpPBSoundPreview; |
| FixedText* mpFTAfterEffect; |
| ListBox* mpLBAfterEffect; |
| FixedText* mpFTDimColor; |
| ColorListBox* mpCLBDimColor; |
| FixedText* mpFTTextAnim; |
| ListBox* mpLBTextAnim; |
| MetricField* mpMFTextDelay; |
| FixedText* mpFTTextDelay; |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::media::XPlayer > mxPlayer; |
| }; |
| |
| |
| static void move_down( Control* pControl, int nOffsetX, int nOffsetY ) |
| { |
| Point aPos( pControl->GetPosPixel() ); |
| aPos.X() += nOffsetX; |
| aPos.Y() += nOffsetY; |
| pControl->SetPosPixel( aPos ); |
| } |
| |
| CustomAnimationEffectTabPage::CustomAnimationEffectTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet ) |
| : TabPage( pParent, rResId ), mbHasText( sal_False ), mpSet(pSet ) |
| { |
| mpFLSettings = new FixedLine( this, SdResId( FL_SETTINGS ) ); |
| mpFTProperty1 = new FixedText( this, SdResId( FT_PROPERTY_1 ) ); |
| mpLBProperty1 = new PropertyControl( this, SdResId( LB_PROPERTY_1 ) ); |
| mpFTProperty2 = new FixedText( this, SdResId( FT_PROPERTY_2 ) ); |
| mpLBProperty2 = new PropertyControl( this, SdResId( LB_PROPERTY_2 ) ); |
| mpCBSmoothStart = new CheckBox( this, SdResId( CB_SMOOTH_START ) ); |
| mpCBSmoothEnd = new CheckBox( this, SdResId( CB_SMOOTH_END ) ); |
| mpCBAutoRestart = new CheckBox( this, SdResId( CB_AUTORESTART ) ); |
| /* |
| mpFLPlay = new FixedLine( this, SdResId( FL_PLAY ) ); |
| mpRBFromStart = new RadioButton( this, SdResId( RB_FROM_START ) ); |
| mpRBFromLast = new RadioButton( this, SdResId( RB_FROM_LAST ) ); |
| mpRBFromTime = new RadioButton( this, SdResId( RB_FROM_TIME ) ); |
| mpMFStartTime = new MetricField( this, SdResId( MF_START_TIME ) ); |
| mpFLStop = new FixedLine( this, SdResId( FL_STOP ) ); |
| mpRBStopOnClick = new RadioButton( this, SdResId( RB_STOP_ON_CLICK ) ); |
| mpRBStopOnNextSlide = new RadioButton( this, SdResId( RB_STOP_ON_NEXT_SLIDE ) ); |
| mpRBStopAfterSlides = new RadioButton( this, SdResId( RB_STOP_AFTER_N_SLIDES ) ); |
| mpMFStopAfterSlides = new MetricField( this, SdResId( MF_STOP_AFTER_SLIDES ) ); |
| */ |
| mpFLEnhancements = new FixedLine( this, SdResId( FL_ENHANCEMENTS ) ); |
| mpFTSound = new FixedText( this, SdResId( FT_SOUND ) ); |
| mpLBSound = new ListBox( this, SdResId( LB_SOUND ) ); |
| mpPBSoundPreview = new PushButton( this, SdResId( PB_SOUND_PREVIEW ) ); |
| mpFTAfterEffect = new FixedText( this, SdResId( FT_AFTER_EFFECT ) ); |
| mpLBAfterEffect = new ListBox( this, SdResId( LB_AFTER_EFFECT ) ); |
| mpFTDimColor = new FixedText( this, SdResId( FT_DIMCOLOR ) ); |
| mpCLBDimColor = new ColorListBox( this, SdResId( CLB_DIMCOLOR ) ); |
| mpFTTextAnim = new FixedText( this, SdResId( FT_TEXT_ANIM ) ); |
| mpLBTextAnim = new ListBox( this, SdResId( LB_TEXT_ANIM ) ); |
| mpMFTextDelay = new MetricField( this, SdResId( MF_TEXT_DELAY ) ); |
| mpFTTextDelay = new FixedText( this, SdResId( FT_TEXT_DELAY ) ); |
| |
| FreeResource(); |
| |
| // fill the soundbox |
| fillSoundListBox(); |
| |
| mpLBSound->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) ); |
| |
| mpPBSoundPreview->SetClickHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) ); |
| mpPBSoundPreview->SetSymbol( SYMBOL_PLAY ); |
| |
| // fill the color box |
| SfxObjectShell* pDocSh = SfxObjectShell::Current(); |
| DBG_ASSERT( pDocSh, "DocShell not found!" ); |
| XColorListSharedPtr aColorTable; |
| const SfxPoolItem* pItem = NULL; |
| |
| if ( pDocSh && ( (pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) != 0 ) ) |
| aColorTable = static_cast< const SvxColorTableItem* >(pItem)->GetColorTable(); |
| |
| if ( !aColorTable.get() ) |
| { |
| aColorTable = XPropertyListFactory::CreateSharedXColorList(SvtPathOptions().GetPalettePath()); |
| } |
| |
| mpCLBDimColor->SetUpdateMode( sal_False ); |
| |
| for ( long i = 0; i < aColorTable->Count(); i++ ) |
| { |
| XColorEntry* pEntry = aColorTable->GetColor(i); |
| mpCLBDimColor->InsertEntry( pEntry->GetColor(), pEntry->GetName() ); |
| } |
| |
| mpCLBDimColor->SetUpdateMode( sal_True ); |
| |
| // |
| // init settings controls |
| // |
| |
| int nOffsetY = 0; |
| int nOffsetX = 0; |
| |
| Size aSpace( LogicToPixel( Size( 3, 3 ), MAP_APPFONT ) ); |
| |
| // only show settings if all selected effects have the same preset-id |
| if( pSet->getPropertyState( nHandlePresetId ) != STLPropertyState_AMBIGUOUS ) |
| { |
| OUString aPresetId; |
| pSet->getPropertyValue( nHandlePresetId ) >>= aPresetId; |
| |
| // |
| // property 1 |
| // |
| |
| if( pSet->getPropertyState( nHandleProperty1Type ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Int32 nType = 0; |
| pSet->getPropertyValue( nHandleProperty1Type ) >>= nType; |
| |
| if( nType != nPropertyTypeNone ) |
| { |
| // set ui name for property at fixed text |
| OUString aPropertyName( getPropertyName( nType ) ); |
| |
| if( aPropertyName.getLength() ) |
| { |
| mpFTProperty1->Show(); |
| mpLBProperty1->Show(); |
| |
| nOffsetY += mpLBProperty1->GetSizePixel().Height() + aSpace.Height(); |
| |
| mpFTProperty1->SetText( aPropertyName ); |
| } |
| |
| // get property value |
| const Any aValue( pSet->getPropertyValue( nHandleProperty1Value ) ); |
| |
| Link aModifyLink; |
| // create property sub control |
| mpLBProperty1->setSubControl( PropertySubControl::create( nType, this, aValue, aPresetId, aModifyLink )); |
| } |
| } |
| |
| mpFTProperty1->Enable( mpLBProperty1->IsEnabled() ); |
| |
| // |
| // accelerate & deccelerate |
| // |
| |
| if( pSet->getPropertyState( nHandleAccelerate ) == STLPropertyState_DIRECT ) |
| { |
| mpCBSmoothStart->Show(); |
| mpCBSmoothEnd->Show(); |
| |
| move_down( mpCBSmoothStart, nOffsetX, nOffsetY ); |
| move_down( mpCBSmoothEnd, nOffsetX, nOffsetY ); |
| |
| nOffsetY += mpCBSmoothStart->GetSizePixel().Height() + aSpace.Height(); |
| |
| double fTemp = 0.0; |
| pSet->getPropertyValue( nHandleAccelerate ) >>= fTemp; |
| mpCBSmoothStart->Check( fTemp > 0.0 ); |
| |
| pSet->getPropertyValue( nHandleDecelerate ) >>= fTemp; |
| mpCBSmoothEnd->Check( fTemp > 0.0 ); |
| } |
| |
| // |
| // auto reverse |
| // |
| |
| |
| if( nOffsetY ) |
| { |
| nOffsetY += mpFLSettings->GetSizePixel().Height() + aSpace.Height(); |
| mpFLSettings->Show(); |
| |
| mpFLEnhancements->Show(); |
| move_down( mpFLEnhancements, nOffsetX, nOffsetY ); |
| |
| nOffsetY += mpFLEnhancements->GetSizePixel().Height() + aSpace.Height(); |
| |
| nOffsetX = 2* aSpace.Width(); |
| } |
| } |
| |
| if( (nOffsetY != 0) || (nOffsetX != 0) ) |
| { |
| move_down( mpFTSound, nOffsetX, nOffsetY ); |
| move_down( mpLBSound, nOffsetX, nOffsetY ); |
| move_down( mpPBSoundPreview, nOffsetX, nOffsetY ); |
| move_down( mpFTAfterEffect, nOffsetX, nOffsetY ); |
| move_down( mpLBAfterEffect, nOffsetX, nOffsetY ); |
| move_down( mpFTDimColor, nOffsetX, nOffsetY ); |
| move_down( mpCLBDimColor, nOffsetX, nOffsetY ); |
| move_down( mpFTTextAnim, nOffsetX, nOffsetY ); |
| move_down( mpLBTextAnim, nOffsetX, nOffsetY ); |
| move_down( mpMFTextDelay, nOffsetX, nOffsetY ); |
| move_down( mpFTTextDelay, nOffsetX, nOffsetY ); |
| } |
| |
| // |
| // init after effect controls |
| // |
| |
| mpLBAfterEffect->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) ); |
| mpLBTextAnim->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) ); |
| |
| if( (pSet->getPropertyState( nHandleHasAfterEffect ) != STLPropertyState_AMBIGUOUS) && |
| (pSet->getPropertyState( nHandleAfterEffectOnNextEffect ) != STLPropertyState_AMBIGUOUS) && |
| (pSet->getPropertyState( nHandleDimColor ) != STLPropertyState_AMBIGUOUS)) |
| { |
| sal_Bool bHasAfterEffect = sal_False; |
| pSet->getPropertyValue( nHandleHasAfterEffect ) >>= bHasAfterEffect; |
| |
| sal_uInt16 nPos = 0; |
| if( bHasAfterEffect ) |
| { |
| nPos++; |
| |
| sal_Bool bAfterEffectOnNextClick = sal_False; |
| pSet->getPropertyValue( nHandleAfterEffectOnNextEffect ) >>= bAfterEffectOnNextClick; |
| Any aDimColor( pSet->getPropertyValue( nHandleDimColor ) ); |
| |
| if( aDimColor.hasValue() ) |
| { |
| sal_Int32 nColor = 0; |
| aDimColor >>= nColor; |
| Color aColor( nColor ); |
| sal_uInt16 nColorPos = mpCLBDimColor->GetEntryPos( aColor ); |
| if ( LISTBOX_ENTRY_NOTFOUND != nColorPos ) |
| mpCLBDimColor->SelectEntryPos( nColorPos ); |
| else |
| mpCLBDimColor->SelectEntryPos( |
| mpCLBDimColor->InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) ); |
| } |
| else |
| { |
| nPos++; |
| if( bAfterEffectOnNextClick ) |
| nPos++; |
| } |
| } |
| |
| mpLBAfterEffect->SelectEntryPos( nPos ); |
| } |
| |
| if( pSet->getPropertyState( nHandleHasText ) != STLPropertyState_AMBIGUOUS ) |
| pSet->getPropertyValue( nHandleHasText ) >>= mbHasText; |
| |
| if( mbHasText ) |
| { |
| if( pSet->getPropertyState( nHandleIterateType ) != STLPropertyState_AMBIGUOUS) |
| { |
| sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND; |
| |
| sal_Int32 nIterateType = 0; |
| pSet->getPropertyValue( nHandleIterateType ) >>= nIterateType; |
| switch( nIterateType ) |
| { |
| case TextAnimationType::BY_PARAGRAPH: nPos = 0; break; |
| case TextAnimationType::BY_WORD: nPos = 1; break; |
| case TextAnimationType::BY_LETTER: nPos = 2; break; |
| } |
| |
| mpLBTextAnim->SelectEntryPos( nPos ); |
| } |
| |
| if( pSet->getPropertyState( nHandleIterateInterval ) ) |
| { |
| double fIterateInterval = 0.0; |
| pSet->getPropertyValue( nHandleIterateInterval ) >>= fIterateInterval; |
| mpMFTextDelay->SetValue( (long)(fIterateInterval*10) ); |
| } |
| } |
| else |
| { |
| mpFTTextAnim->Enable( sal_False ); |
| mpLBTextAnim->Enable( sal_False ); |
| mpMFTextDelay->Enable( sal_False ); |
| mpFTTextDelay->Enable( sal_False ); |
| |
| } |
| |
| if( pSet->getPropertyState( nHandleSoundURL ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_uInt16 nPos = 0; |
| |
| const Any aValue( pSet->getPropertyValue( nHandleSoundURL ) ); |
| |
| if( aValue.getValueType() == ::getCppuType((const sal_Bool*)0) ) |
| { |
| nPos = 1; |
| } |
| else |
| { |
| OUString aSoundURL; |
| aValue >>= aSoundURL; |
| |
| if( aSoundURL.getLength() ) |
| { |
| const String aTmp( aSoundURL ); |
| |
| sal_uLong i; |
| for( i = 0; i < maSoundList.Count(); i++ ) |
| { |
| String* pString = (String*)maSoundList.GetObject( i ); |
| if( *pString == aTmp ) |
| { |
| nPos = (sal_uInt16)i+2; |
| break; |
| } |
| } |
| |
| if( nPos == 0 ) |
| { |
| nPos = (sal_uInt16)maSoundList.Count()+2; |
| maSoundList.Insert( new String( aTmp ), LIST_APPEND ); |
| INetURLObject aURL( aTmp ); |
| nPos = mpLBSound->InsertEntry( aURL.GetBase(), nPos ); |
| } |
| } |
| } |
| |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| mpLBSound->SelectEntryPos( nPos ); |
| } |
| |
| updateControlStates(); |
| |
| Size aSize( GetSizePixel() ); |
| aSize.Height() += mpMFTextDelay->GetPosPixel().X() + GetSizePixel().Height() + aSpace.Height(); |
| SetSizePixel( aSize ); |
| } |
| |
| CustomAnimationEffectTabPage::~CustomAnimationEffectTabPage() |
| { |
| clearSoundListBox(); |
| |
| delete mpFLSettings; |
| delete mpFTProperty1; |
| delete mpLBProperty1; |
| delete mpFTProperty2; |
| delete mpLBProperty2; |
| delete mpCBSmoothStart; |
| delete mpCBSmoothEnd; |
| delete mpCBAutoRestart; |
| |
| delete mpFLEnhancements; |
| delete mpFTSound; |
| delete mpLBSound; |
| delete mpPBSoundPreview; |
| delete mpFTAfterEffect; |
| delete mpLBAfterEffect; |
| delete mpFTDimColor; |
| delete mpCLBDimColor; |
| delete mpFTTextAnim; |
| delete mpLBTextAnim; |
| delete mpMFTextDelay; |
| delete mpFTTextDelay; |
| } |
| |
| void CustomAnimationEffectTabPage::updateControlStates() |
| { |
| sal_uInt16 nPos = mpLBAfterEffect->GetSelectEntryPos(); |
| mpCLBDimColor->Enable( nPos == 1 ); |
| mpFTDimColor->Enable( nPos == 1 ); |
| |
| if( mbHasText ) |
| { |
| nPos = mpLBTextAnim->GetSelectEntryPos(); |
| mpMFTextDelay->Enable( nPos != 0 ); |
| mpFTTextDelay->Enable( nPos != 0 ); |
| } |
| |
| nPos = mpLBSound->GetSelectEntryPos(); |
| mpPBSoundPreview->Enable( nPos >= 2 ); |
| } |
| |
| IMPL_LINK( CustomAnimationEffectTabPage, implSelectHdl, Control*, pControl ) |
| { |
| if( pControl == mpLBAfterEffect ) |
| { |
| sal_uInt16 nPos = static_cast<ListBox*>( mpLBAfterEffect )->GetSelectEntryPos(); |
| if( nPos == 1 ) |
| { |
| if( mpCLBDimColor->GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND ) |
| mpCLBDimColor->SelectEntryPos(0); |
| } |
| } |
| else if( pControl == mpLBTextAnim ) |
| { |
| if( mpMFTextDelay->GetValue() == 0 ) |
| mpMFTextDelay->SetValue( 100 ); |
| } |
| else if( pControl == mpLBSound ) |
| { |
| sal_uInt16 nPos = mpLBSound->GetSelectEntryPos(); |
| if( nPos == (mpLBSound->GetEntryCount() - 1) ) |
| { |
| openSoundFileDialog(); |
| } |
| } |
| else if( pControl == mpPBSoundPreview ) |
| { |
| onSoundPreview(); |
| } |
| |
| updateControlStates(); |
| return 0; |
| } |
| |
| void CustomAnimationEffectTabPage::update( STLPropertySet* pSet ) |
| { |
| if( mpLBProperty1->getSubControl() ) |
| { |
| Any aNewValue( mpLBProperty1->getSubControl()->getValue() ); |
| Any aOldValue; |
| if( mpSet->getPropertyState( nHandleProperty1Value ) != STLPropertyState_AMBIGUOUS) |
| aOldValue = mpSet->getPropertyValue( nHandleProperty1Value ); |
| |
| if( aOldValue != aNewValue ) |
| pSet->setPropertyValue( nHandleProperty1Value, aNewValue ); |
| } |
| |
| if( mpLBProperty2->getSubControl() ) |
| { |
| Any aNewValue( mpLBProperty2->getSubControl()->getValue() ); |
| Any aOldValue; |
| if( mpSet->getPropertyState( nHandleProperty2Value ) != STLPropertyState_AMBIGUOUS) |
| aOldValue = mpSet->getPropertyValue( nHandleProperty2Value ); |
| |
| if( aOldValue != aNewValue ) |
| pSet->setPropertyValue( nHandleProperty2Value, aNewValue ); |
| } |
| |
| if( mpCBSmoothStart->IsVisible() ) |
| { |
| // set selected value for accelerate if different then in original set |
| |
| double fTemp = mpCBSmoothStart->IsChecked() ? 0.5 : 0.0; |
| |
| double fOldTemp = 0.0; |
| if(mpSet->getPropertyState( nHandleAccelerate ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleAccelerate ) >>= fOldTemp; |
| else |
| fOldTemp = -2.0; |
| |
| if( fOldTemp != fTemp ) |
| pSet->setPropertyValue( nHandleAccelerate, makeAny( fTemp ) ); |
| |
| // set selected value for decelerate if different then in original set |
| fTemp = mpCBSmoothEnd->IsChecked() ? 0.5 : 0.0; |
| |
| if(mpSet->getPropertyState( nHandleDecelerate ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleDecelerate ) >>= fOldTemp; |
| else |
| fOldTemp = -2.0; |
| |
| if( fOldTemp != fTemp ) |
| pSet->setPropertyValue( nHandleDecelerate, makeAny( fTemp ) ); |
| } |
| |
| sal_uInt16 nPos = mpLBAfterEffect->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| sal_Bool bAfterEffect = nPos != 0; |
| |
| sal_Bool bOldAfterEffect = sal_False; |
| |
| if(mpSet->getPropertyState( nHandleHasAfterEffect ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleHasAfterEffect ) >>= bOldAfterEffect; |
| else |
| bOldAfterEffect = !bAfterEffect; |
| |
| if( bOldAfterEffect != bAfterEffect ) |
| pSet->setPropertyValue( nHandleHasAfterEffect, makeAny( bAfterEffect ) ); |
| |
| Any aDimColor; |
| if( nPos == 1 ) |
| { |
| Color aSelectedColor; |
| if ( mpCLBDimColor->GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND ) |
| aSelectedColor = mpCLBDimColor->GetSelectEntryColor(); |
| |
| aDimColor = makeAny( makeAny( (sal_Int32)aSelectedColor.GetRGBColor() ) ); |
| } |
| |
| if( (mpSet->getPropertyState( nHandleDimColor ) == STLPropertyState_AMBIGUOUS) || |
| (mpSet->getPropertyValue( nHandleDimColor ) != aDimColor) ) |
| pSet->setPropertyValue( nHandleDimColor, makeAny( aDimColor ) ); |
| |
| sal_Bool bAfterEffectOnNextEffect = nPos != 2 ? sal_True : sal_False; |
| sal_Bool bOldAfterEffectOnNextEffect = !bAfterEffectOnNextEffect; |
| |
| if( mpSet->getPropertyState( nHandleAfterEffectOnNextEffect ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleAfterEffectOnNextEffect ) >>= bOldAfterEffectOnNextEffect; |
| |
| if( bAfterEffectOnNextEffect != bOldAfterEffectOnNextEffect ) |
| pSet->setPropertyValue( nHandleAfterEffectOnNextEffect, makeAny( bAfterEffectOnNextEffect ) ); |
| } |
| |
| // --- |
| |
| nPos = mpLBTextAnim->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| sal_Int16 nIterateType; |
| |
| switch( nPos ) |
| { |
| case 1: nIterateType = TextAnimationType::BY_WORD; break; |
| case 2: nIterateType = TextAnimationType::BY_LETTER; break; |
| default: |
| nIterateType = TextAnimationType::BY_PARAGRAPH; |
| } |
| |
| sal_Int16 nOldIterateType = nIterateType-1; |
| |
| if(mpSet->getPropertyState( nHandleIterateType ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleIterateType ) >>= nOldIterateType; |
| |
| if( nIterateType != nOldIterateType ) |
| pSet->setPropertyValue( nHandleIterateType, makeAny( nIterateType ) ); |
| } |
| |
| // --- |
| |
| { |
| double fIterateInterval = static_cast< double >( mpMFTextDelay->GetValue() ) / 10; |
| double fOldIterateInterval = -1.0; |
| |
| if( mpSet->getPropertyState( nHandleIterateInterval ) != STLPropertyState_AMBIGUOUS ) |
| mpSet->getPropertyValue( nHandleIterateInterval ) >>= fOldIterateInterval; |
| |
| if( fIterateInterval != fOldIterateInterval ) |
| pSet->setPropertyValue( nHandleIterateInterval, makeAny( fIterateInterval ) ); |
| } |
| |
| nPos = mpLBSound->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| Any aNewSoundURL, aOldSoundURL( makeAny( (sal_Int32) 0 ) ); |
| |
| if( nPos == 0 ) |
| { |
| // 0 means no sound, so leave any empty |
| } |
| else if( nPos == 1 ) |
| { |
| // this means stop sound |
| aNewSoundURL = makeAny( (sal_Bool)sal_True ); |
| } |
| else |
| { |
| OUString aSoundURL( *(String*)maSoundList.GetObject( nPos-2 ) ); |
| aNewSoundURL = makeAny( aSoundURL ); |
| } |
| |
| if( mpSet->getPropertyState( nHandleSoundURL ) != STLPropertyState_AMBIGUOUS ) |
| mpSet->getPropertyValue( nHandleSoundURL ) >>= aOldSoundURL; |
| |
| if( aNewSoundURL != aOldSoundURL ) |
| pSet->setPropertyValue( nHandleSoundURL, aNewSoundURL ); |
| } |
| } |
| |
| void CustomAnimationEffectTabPage::fillSoundListBox() |
| { |
| GalleryExplorer::FillObjList( GALLERY_THEME_SOUNDS, maSoundList ); |
| GalleryExplorer::FillObjList( GALLERY_THEME_USERSOUNDS, maSoundList ); |
| |
| mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_NO_SOUND ) ) ); |
| mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_STOP_PREVIOUS_SOUND ) ) ); |
| for( sal_uLong i = 0; i < maSoundList.Count(); i++ ) |
| { |
| String* pString = (String*)maSoundList.GetObject( i ); |
| INetURLObject aURL( *pString ); |
| mpLBSound->InsertEntry( aURL.GetBase() ); |
| } |
| mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_BROWSE_SOUND ) ) ); |
| } |
| |
| void CustomAnimationEffectTabPage::clearSoundListBox() |
| { |
| const sal_uInt32 nCount = maSoundList.Count(); |
| sal_uInt32 i; |
| for( i = 0; i < nCount; i++ ) |
| delete (String*)maSoundList.GetObject( i ); |
| maSoundList.Clear(); |
| |
| mpLBSound->Clear(); |
| } |
| |
| sal_Int32 CustomAnimationEffectTabPage::getSoundObject( const String& rStr ) |
| { |
| String aStrIn( rStr ); |
| aStrIn.ToLowerAscii(); |
| |
| sal_uInt32 i; |
| const sal_uInt32 nCount = maSoundList.Count(); |
| for( i = 0; i < nCount; i++ ) |
| { |
| String aTmpStr( *(String*)maSoundList.GetObject( i ) ); |
| aTmpStr.ToLowerAscii(); |
| |
| if( aTmpStr == aStrIn ) |
| return i+2; |
| } |
| |
| return -1; |
| } |
| |
| void CustomAnimationEffectTabPage::openSoundFileDialog() |
| { |
| SdOpenSoundFileDialog aFileDialog; |
| |
| String aFile( SvtPathOptions().GetGraphicPath() ); |
| aFileDialog.SetPath( aFile ); |
| |
| bool bValidSoundFile = false; |
| bool bQuitLoop = false; |
| long nPos = 0; |
| |
| while( !bQuitLoop && (aFileDialog.Execute() == ERRCODE_NONE) ) |
| { |
| aFile = aFileDialog.GetPath(); |
| nPos = getSoundObject( aFile ); |
| |
| if( nPos < 0 ) // not in Soundliste |
| { |
| // try to insert in Gallery |
| if( GalleryExplorer::InsertURL( GALLERY_THEME_USERSOUNDS, aFile ) ) |
| { |
| clearSoundListBox(); |
| fillSoundListBox(); |
| |
| nPos = getSoundObject( aFile ); |
| DBG_ASSERT( nPos >= 0, "sd::CustomAnimationEffectTabPage::openSoundFileDialog(), Recently inserted sound not in list!" ); |
| |
| bValidSoundFile=true; |
| bQuitLoop=true; |
| } |
| else |
| { |
| String aStrWarning(SdResId(STR_WARNING_NOSOUNDFILE)); |
| String aStr; aStr += sal_Unicode('%'); |
| aStrWarning.SearchAndReplace( aStr , aFile ); |
| WarningBox aWarningBox( NULL, WB_3DLOOK | WB_RETRY_CANCEL, aStrWarning ); |
| aWarningBox.SetModalInputMode (sal_True); |
| bQuitLoop = aWarningBox.Execute()==RET_RETRY ? sal_False : sal_True; |
| |
| bValidSoundFile=false; |
| } |
| } |
| else |
| { |
| bValidSoundFile=true; |
| bQuitLoop=true; |
| } |
| } |
| |
| if( !bValidSoundFile ) |
| nPos = 0; |
| |
| mpLBSound->SelectEntryPos( (sal_uInt16) nPos ); |
| } |
| |
| void CustomAnimationEffectTabPage::onSoundPreview() |
| { |
| const sal_uInt16 nPos = mpLBSound->GetSelectEntryPos(); |
| |
| if( nPos >= 2 ) try |
| { |
| const OUString aSoundURL( *(String*)maSoundList.GetObject( nPos-2 ) ); |
| mxPlayer.set( avmedia::MediaWindow::createPlayer( aSoundURL ), uno::UNO_QUERY_THROW ); |
| mxPlayer->start(); |
| } |
| catch( uno::Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR("CustomAnimationEffectTabPage::onSoundPreview(), exception caught!" ); |
| } |
| } |
| |
| class CustomAnimationDurationTabPage : public TabPage |
| { |
| public: |
| CustomAnimationDurationTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet ); |
| ~CustomAnimationDurationTabPage(); |
| |
| void update( STLPropertySet* pSet ); |
| |
| DECL_LINK( implControlHdl, Control* ); |
| |
| private: |
| const STLPropertySet* mpSet; |
| |
| boost::shared_ptr< FixedText > mpFTStart; |
| boost::shared_ptr< ListBox > mpLBStart; |
| boost::shared_ptr< FixedText > mpFTStartDelay; |
| boost::shared_ptr< MetricField > mpMFStartDelay; |
| boost::shared_ptr< FixedText > mpFTDuration; |
| boost::shared_ptr< ComboBox > mpCBDuration; |
| boost::shared_ptr< FixedText > mpFTRepeat; |
| boost::shared_ptr< ComboBox > mpCBRepeat; |
| boost::shared_ptr< CheckBox > mpCBXRewind; |
| boost::shared_ptr< FixedLine > mpFLTrigger; |
| boost::shared_ptr< RadioButton > mpRBClickSequence; |
| boost::shared_ptr< RadioButton > mpRBInteractive; |
| boost::shared_ptr< ListBox > mpLBTrigger; |
| }; |
| |
| CustomAnimationDurationTabPage::CustomAnimationDurationTabPage(Window* pParent, const ResId& rResId, const STLPropertySet* pSet) |
| : TabPage( pParent, rResId ), mpSet( pSet ) |
| { |
| mpFTStart.reset( new FixedText( this, SdResId( FT_START ) ) ); |
| mpLBStart.reset( new ListBox( this, SdResId( LB_START ) ) ); |
| mpFTStartDelay.reset( new FixedText( this, SdResId( FT_START_DELAY ) ) ); |
| mpMFStartDelay.reset( new MetricField( this, SdResId( MF_START_DELAY ) ) ); |
| mpFTDuration.reset( new FixedText( this, SdResId( FT_DURATION ) ) ); |
| mpCBDuration.reset( new ComboBox( this, SdResId( CB_DURATION ) ) ); |
| mpFTRepeat.reset( new FixedText( this, SdResId( FT_REPEAT ) ) ); |
| mpCBRepeat.reset( new ComboBox( this, SdResId( CB_REPEAT ) ) ); |
| mpCBXRewind.reset( new CheckBox( this, SdResId( CBX_REWIND ) ) ); |
| mpFLTrigger.reset( new FixedLine( this, SdResId( FL_TRIGGER ) ) ); |
| mpRBClickSequence.reset( new RadioButton( this, SdResId( RB_CLICKSEQUENCE ) ) ); |
| mpRBInteractive.reset( new RadioButton( this, SdResId( RB_INTERACTIVE ) ) ); |
| mpLBTrigger.reset( new ListBox( this, SdResId( LB_TRIGGER ) ) ); |
| |
| fillRepeatComboBox( mpCBRepeat.get() ); |
| fillDurationComboBox( mpCBDuration.get() ); |
| |
| FreeResource(); |
| |
| mpRBClickSequence->SetClickHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) ); |
| mpRBClickSequence->SetClickHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) ); |
| mpLBTrigger->SetSelectHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) ); |
| |
| if( pSet->getPropertyState( nHandleStart ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Int16 nStart = 0; |
| pSet->getPropertyValue( nHandleStart ) >>= nStart; |
| sal_uInt16 nPos = 0; |
| switch( nStart ) |
| { |
| case EffectNodeType::WITH_PREVIOUS: nPos = 1; break; |
| case EffectNodeType::AFTER_PREVIOUS: nPos = 2; break; |
| } |
| mpLBStart->SelectEntryPos( nPos ); |
| } |
| |
| if( pSet->getPropertyState( nHandleBegin ) != STLPropertyState_AMBIGUOUS ) |
| { |
| double fBegin = 0.0; |
| pSet->getPropertyValue( nHandleBegin ) >>= fBegin; |
| mpMFStartDelay->SetValue( (long)(fBegin*10) ); |
| } |
| |
| if( pSet->getPropertyState( nHandleDuration ) != STLPropertyState_AMBIGUOUS ) |
| { |
| double fDuration = 0.0; |
| pSet->getPropertyValue( nHandleDuration ) >>= fDuration; |
| |
| if( fDuration == 0.001 ) |
| { |
| mpFTDuration->Disable(); |
| mpCBDuration->Disable(); |
| mpFTRepeat->Disable(); |
| mpCBRepeat->Disable(); |
| mpCBXRewind->Disable(); |
| } |
| else |
| { |
| sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND; |
| |
| if( fDuration == 5.0 ) |
| nPos = 0; |
| else if( fDuration == 3.0 ) |
| nPos = 1; |
| else if( fDuration == 2.0 ) |
| nPos = 2; |
| else if( fDuration == 1.0 ) |
| nPos = 3; |
| else if( fDuration == 0.5 ) |
| nPos = 4; |
| |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| mpCBDuration->SelectEntryPos( nPos ); |
| else |
| mpCBDuration->SetText( String::CreateFromDouble( fDuration ) ); |
| } |
| } |
| |
| if( pSet->getPropertyState( nHandleRepeat ) != STLPropertyState_AMBIGUOUS ) |
| { |
| Any aRepeatCount( pSet->getPropertyValue( nHandleRepeat ) ); |
| if( (aRepeatCount.getValueType() == ::getCppuType((const double*)0)) || !aRepeatCount.hasValue() ) |
| { |
| double fRepeat = 0.0; |
| if( aRepeatCount.hasValue() ) |
| aRepeatCount >>= fRepeat; |
| |
| sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND; |
| |
| if( fRepeat == 0 ) |
| nPos = 0; |
| else if( fRepeat == 2.0 ) |
| nPos = 1; |
| else if( fRepeat == 3.0 ) |
| nPos = 2; |
| else if( fRepeat == 4.0 ) |
| nPos = 3; |
| else if( fRepeat == 5.0 ) |
| nPos = 4; |
| else if( fRepeat == 10.0 ) |
| nPos = 5; |
| |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| mpCBRepeat->SelectEntryPos( nPos ); |
| else |
| mpCBRepeat->SetText( String::CreateFromDouble( fRepeat ) ); |
| } |
| else if( aRepeatCount.getValueType() == ::getCppuType((const Timing*)0) ) |
| { |
| Any aEnd; |
| if( pSet->getPropertyState( nHandleEnd ) != STLPropertyState_AMBIGUOUS ) |
| aEnd = pSet->getPropertyValue( nHandleEnd ); |
| |
| mpCBRepeat->SelectEntryPos( aEnd.hasValue() ? 6 : 7 ); |
| } |
| } |
| |
| if( pSet->getPropertyState( nHandleRewind ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Int16 nFill = 0; |
| if( pSet->getPropertyValue( nHandleRewind ) >>= nFill ) |
| { |
| mpCBXRewind->Check( (nFill == AnimationFill::REMOVE) ? sal_True : sal_False ); |
| } |
| else |
| { |
| mpCBXRewind->SetState( STATE_DONTKNOW ); |
| } |
| } |
| |
| Reference< XShape > xTrigger; |
| |
| if( pSet->getPropertyState( nHandleTrigger ) != STLPropertyState_AMBIGUOUS ) |
| { |
| pSet->getPropertyValue( nHandleTrigger ) >>= xTrigger; |
| |
| mpRBInteractive->Check( xTrigger.is() ); |
| mpRBClickSequence->Check( !xTrigger.is() ); |
| } |
| |
| Reference< XDrawPage > xCurrentPage; |
| pSet->getPropertyValue( nHandleCurrentPage ) >>= xCurrentPage; |
| if( xCurrentPage.is() ) |
| { |
| const OUString aStrIsEmptyPresObj( RTL_CONSTASCII_USTRINGPARAM( "IsEmptyPresentationObject" ) ); |
| |
| sal_Int32 nShape, nCount = xCurrentPage->getCount(); |
| for( nShape = 0; nShape < nCount; nShape++ ) |
| { |
| Reference< XShape > xShape( xCurrentPage->getByIndex( nShape ), UNO_QUERY ); |
| |
| if( !xShape.is() ) |
| continue; |
| |
| Reference< XPropertySet > xSet( xShape, UNO_QUERY ); |
| if( xSet.is() && xSet->getPropertySetInfo()->hasPropertyByName( aStrIsEmptyPresObj ) ) |
| { |
| sal_Bool bIsEmpty = sal_False; |
| xSet->getPropertyValue( aStrIsEmptyPresObj ) >>= bIsEmpty; |
| if( bIsEmpty ) |
| continue; |
| } |
| |
| String aDescription( getShapeDescription( xShape, true ) ); |
| sal_uInt16 nPos = mpLBTrigger->InsertEntry( aDescription ); |
| |
| mpLBTrigger->SetEntryData( nPos, (void*)nShape ); |
| if( xShape == xTrigger ) |
| mpLBTrigger->SelectEntryPos( nPos ); |
| } |
| } |
| } |
| |
| CustomAnimationDurationTabPage::~CustomAnimationDurationTabPage() |
| { |
| } |
| |
| IMPL_LINK( CustomAnimationDurationTabPage, implControlHdl, Control*, pControl ) |
| { |
| if( pControl == mpLBTrigger.get() ) |
| { |
| mpRBClickSequence->Check( sal_False ); |
| mpRBInteractive->Check( sal_True ); |
| } |
| |
| return 0; |
| } |
| |
| void CustomAnimationDurationTabPage::update( STLPropertySet* pSet ) |
| { |
| sal_uInt16 nPos = mpLBStart->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| sal_Int16 nStart; |
| sal_Int16 nOldStart = -1; |
| |
| switch( nPos ) |
| { |
| case 1: nStart = EffectNodeType::WITH_PREVIOUS; break; |
| case 2: nStart = EffectNodeType::AFTER_PREVIOUS; break; |
| default: |
| nStart = EffectNodeType::ON_CLICK; break; |
| } |
| |
| if(mpSet->getPropertyState( nHandleStart ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleStart ) >>= nOldStart; |
| |
| if( nStart != nOldStart ) |
| pSet->setPropertyValue( nHandleStart, makeAny( nStart ) ); |
| } |
| |
| // --- |
| |
| { |
| double fBegin = static_cast<double>( mpMFStartDelay->GetValue()) / 10.0; |
| double fOldBegin = -1.0; |
| |
| if( mpSet->getPropertyState( nHandleBegin ) != STLPropertyState_AMBIGUOUS ) |
| mpSet->getPropertyValue( nHandleBegin ) >>= fOldBegin; |
| |
| if( fBegin != fOldBegin ) |
| pSet->setPropertyValue( nHandleBegin, makeAny( fBegin ) ); |
| } |
| |
| // --- |
| |
| nPos = mpCBRepeat->GetSelectEntryPos(); |
| if( (nPos != LISTBOX_ENTRY_NOTFOUND) || (mpCBRepeat->GetText().Len() != 0) ) |
| { |
| Any aRepeatCount; |
| Any aEnd; |
| |
| switch( nPos ) |
| { |
| case 0: |
| break; |
| case 6: |
| { |
| Event aEvent; |
| aEvent.Trigger = EventTrigger::ON_NEXT; |
| aEvent.Repeat = 0; |
| aEnd <<= aEvent; |
| } |
| // ATTENTION: FALL THROUGH INTENDED! |
| case 7: |
| aRepeatCount <<= Timing_INDEFINITE; |
| break; |
| default: |
| { |
| String aText( mpCBRepeat->GetText() ); |
| if( aText.Len() ) |
| aRepeatCount <<= aText.ToDouble(); |
| } |
| } |
| |
| Any aOldRepeatCount( aRepeatCount ); |
| if( mpSet->getPropertyState( nHandleRepeat ) != STLPropertyState_AMBIGUOUS ) |
| aOldRepeatCount = mpSet->getPropertyValue( nHandleRepeat ); |
| |
| if( aRepeatCount != aOldRepeatCount ) |
| pSet->setPropertyValue( nHandleRepeat, aRepeatCount ); |
| |
| Any aOldEnd( aEnd ); |
| if( mpSet->getPropertyState( nHandleEnd ) != STLPropertyState_AMBIGUOUS ) |
| aOldEnd = mpSet->getPropertyValue( nHandleEnd ); |
| |
| if( aEnd != aOldEnd ) |
| pSet->setPropertyValue( nHandleEnd, aEnd ); |
| } |
| |
| // --- |
| |
| double fDuration = -1.0; |
| nPos = mpCBDuration->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| fDuration = *static_cast< const double * >( mpCBDuration->GetEntryData(nPos) ); |
| } |
| else |
| { |
| String aText( mpCBDuration->GetText() ); |
| if( aText.Len() ) |
| { |
| fDuration = aText.ToDouble(); |
| } |
| } |
| |
| if( fDuration != -1.0 ) |
| { |
| double fOldDuration = -1; |
| |
| if( mpSet->getPropertyState( nHandleDuration ) != STLPropertyState_AMBIGUOUS ) |
| mpSet->getPropertyValue( nHandleDuration ) >>= fOldDuration; |
| |
| if( fDuration != fOldDuration ) |
| pSet->setPropertyValue( nHandleDuration, makeAny( fDuration ) ); |
| } |
| |
| // --- |
| |
| if( mpCBXRewind->GetState() != STATE_DONTKNOW ) |
| { |
| sal_Int16 nFill = mpCBXRewind->IsChecked() ? AnimationFill::REMOVE : AnimationFill::HOLD; |
| |
| bool bSet = true; |
| |
| if( mpSet->getPropertyState( nHandleRewind ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Int16 nOldFill = 0; |
| mpSet->getPropertyValue( nHandleRewind ) >>= nOldFill; |
| bSet = nFill != nOldFill; |
| } |
| |
| if( bSet ) |
| pSet->setPropertyValue( nHandleRewind, makeAny( nFill ) ); |
| } |
| |
| Reference< XShape > xTrigger; |
| |
| if( mpRBInteractive->IsChecked() ) |
| { |
| nPos = mpLBTrigger->GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| sal_Int32 nShape = (sal_Int32)(sal_IntPtr)mpLBTrigger->GetEntryData( nPos ); |
| |
| Reference< XDrawPage > xCurrentPage; |
| mpSet->getPropertyValue( nHandleCurrentPage ) >>= xCurrentPage; |
| |
| if( xCurrentPage.is() && (nShape >= 0) && (nShape < xCurrentPage->getCount()) ) |
| xCurrentPage->getByIndex( nShape ) >>= xTrigger; |
| } |
| } |
| |
| |
| if( xTrigger.is() || mpRBClickSequence->IsChecked() ) |
| { |
| Any aNewValue( makeAny( xTrigger ) ); |
| Any aOldValue; |
| |
| if( mpSet->getPropertyState( nHandleTrigger ) != STLPropertyState_AMBIGUOUS ) |
| aOldValue = mpSet->getPropertyValue( nHandleTrigger ); |
| |
| if( aNewValue != aOldValue ) |
| pSet->setPropertyValue( nHandleTrigger, aNewValue ); |
| } |
| } |
| |
| class CustomAnimationTextAnimTabPage : public TabPage |
| { |
| public: |
| CustomAnimationTextAnimTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet ); |
| |
| void update( STLPropertySet* pSet ); |
| |
| void updateControlStates(); |
| DECL_LINK( implSelectHdl, Control* ); |
| |
| private: |
| FixedText maFTGroupText; |
| ListBox maLBGroupText; |
| CheckBox maCBXGroupAuto; |
| MetricField maMFGroupAuto; |
| CheckBox maCBXAnimateForm; |
| CheckBox maCBXReverse; |
| |
| const STLPropertySet* mpSet; |
| |
| bool mbHasVisibleShapes; |
| }; |
| |
| CustomAnimationTextAnimTabPage::CustomAnimationTextAnimTabPage(Window* pParent, const ResId& rResId, const STLPropertySet* pSet) |
| : TabPage( pParent, rResId ), |
| maFTGroupText( this, SdResId( FT_GROUP_TEXT ) ), |
| maLBGroupText( this, SdResId( LB_GROUP_TEXT ) ), |
| maCBXGroupAuto( this, SdResId( CBX_GROUP_AUTO ) ), |
| maMFGroupAuto( this, SdResId( MF_GROUP_AUTO ) ), |
| maCBXAnimateForm( this, SdResId( CBX_ANIMATE_FORM ) ), |
| maCBXReverse( this, SdResId( CBX_REVERSE ) ), |
| mpSet( pSet ), |
| mbHasVisibleShapes(true) |
| { |
| FreeResource(); |
| |
| maLBGroupText.SetSelectHdl( LINK( this, CustomAnimationTextAnimTabPage, implSelectHdl ) ); |
| |
| if( pSet->getPropertyState( nHandleTextGrouping ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Int32 nTextGrouping = 0; |
| if( pSet->getPropertyValue( nHandleTextGrouping ) >>= nTextGrouping ) |
| maLBGroupText.SelectEntryPos( (sal_uInt16)(nTextGrouping + 1) ); |
| } |
| |
| if( pSet->getPropertyState( nHandleHasVisibleShape ) != STLPropertyState_AMBIGUOUS ) |
| pSet->getPropertyValue( nHandleHasVisibleShape ) >>= mbHasVisibleShapes; |
| |
| if( pSet->getPropertyState( nHandleTextGroupingAuto ) != STLPropertyState_AMBIGUOUS ) |
| { |
| double fTextGroupingAuto = 0.0; |
| if( pSet->getPropertyValue( nHandleTextGroupingAuto ) >>= fTextGroupingAuto ) |
| { |
| maCBXGroupAuto.Check( fTextGroupingAuto >= 0.0 ); |
| if( fTextGroupingAuto >= 0.0 ) |
| maMFGroupAuto.SetValue( (long)(fTextGroupingAuto*10) ); |
| } |
| } |
| else |
| { |
| maCBXGroupAuto.SetState( STATE_DONTKNOW ); |
| } |
| |
| maCBXAnimateForm.SetState( STATE_DONTKNOW ); |
| if( pSet->getPropertyState( nHandleAnimateForm ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Bool bAnimateForm = sal_False; |
| if( pSet->getPropertyValue( nHandleAnimateForm ) >>= bAnimateForm ) |
| { |
| maCBXAnimateForm.Check( bAnimateForm ); |
| } |
| } |
| else |
| { |
| maCBXAnimateForm.Enable( sal_False ); |
| } |
| |
| maCBXReverse.SetState( STATE_DONTKNOW ); |
| if( pSet->getPropertyState( nHandleTextReverse ) != STLPropertyState_AMBIGUOUS ) |
| { |
| sal_Bool bTextReverse = sal_False; |
| if( pSet->getPropertyValue( nHandleTextReverse ) >>= bTextReverse ) |
| { |
| maCBXReverse.Check( bTextReverse ); |
| } |
| } |
| |
| if( pSet->getPropertyState( nHandleMaxParaDepth ) == STLPropertyState_DIRECT ) |
| { |
| sal_Int32 nMaxParaDepth = 0; |
| pSet->getPropertyValue( nHandleMaxParaDepth ) >>= nMaxParaDepth; |
| nMaxParaDepth += 1; |
| |
| sal_Int32 nPos = 6; |
| while( (nPos > 2) && (nPos > nMaxParaDepth) ) |
| { |
| maLBGroupText.RemoveEntry( (sal_uInt16)nPos ); |
| nPos--; |
| } |
| } |
| |
| updateControlStates(); |
| } |
| |
| void CustomAnimationTextAnimTabPage::update( STLPropertySet* pSet ) |
| { |
| sal_uInt16 nPos = maLBGroupText.GetSelectEntryPos(); |
| if( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| sal_Int32 nTextGrouping = nPos - 1; |
| sal_Int32 nOldGrouping = -2; |
| |
| if(mpSet->getPropertyState( nHandleTextGrouping ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleTextGrouping ) >>= nOldGrouping; |
| |
| if( nTextGrouping != nOldGrouping ) |
| pSet->setPropertyValue( nHandleTextGrouping, makeAny( nTextGrouping ) ); |
| } |
| |
| if( nPos > 0 ) |
| { |
| sal_Bool bTextReverse = maCBXReverse.IsChecked(); |
| sal_Bool bOldTextReverse = !bTextReverse; |
| |
| if(mpSet->getPropertyState( nHandleTextReverse ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleTextReverse ) >>= bOldTextReverse; |
| |
| if( bTextReverse != bOldTextReverse ) |
| pSet->setPropertyValue( nHandleTextReverse, makeAny( bTextReverse ) ); |
| |
| if( nPos > 1 ) |
| { |
| double fTextGroupingAuto = maCBXGroupAuto.IsChecked() ? maMFGroupAuto.GetValue() / 10.0 : -1.0; |
| double fOldTextGroupingAuto = -2.0; |
| |
| if(mpSet->getPropertyState( nHandleTextGroupingAuto ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleTextGroupingAuto ) >>= fOldTextGroupingAuto; |
| |
| if( fTextGroupingAuto != fOldTextGroupingAuto ) |
| pSet->setPropertyValue( nHandleTextGroupingAuto, makeAny( fTextGroupingAuto ) ); |
| } |
| } |
| //bug 120049 |
| //[crash] Aoo crash when modify the "Random effects" animation effect's trigger condition to "Start effect on click of" . |
| //If this control is disabled, we should ignore its value |
| if (maCBXAnimateForm.IsEnabled()) |
| { |
| sal_Bool bAnimateForm = maCBXAnimateForm.IsChecked(); |
| sal_Bool bOldAnimateForm = !bAnimateForm; |
| |
| if(mpSet->getPropertyState( nHandleAnimateForm ) != STLPropertyState_AMBIGUOUS) |
| mpSet->getPropertyValue( nHandleAnimateForm ) >>= bOldAnimateForm; |
| |
| if( bAnimateForm != bOldAnimateForm ) |
| pSet->setPropertyValue( nHandleAnimateForm, makeAny( bAnimateForm ) ); |
| } |
| } |
| |
| void CustomAnimationTextAnimTabPage::updateControlStates() |
| { |
| sal_uInt16 nPos = maLBGroupText.GetSelectEntryPos(); |
| |
| maCBXGroupAuto.Enable( nPos > 1 ); |
| maMFGroupAuto.Enable( nPos > 1 ); |
| maCBXReverse.Enable( nPos > 0 ); |
| |
| if( !mbHasVisibleShapes && nPos > 0 ) |
| { |
| maCBXAnimateForm.Check(sal_False); |
| maCBXAnimateForm.Enable(sal_False); |
| } |
| else |
| { |
| maCBXAnimateForm.Enable(sal_True); |
| } |
| } |
| |
| IMPL_LINK( CustomAnimationTextAnimTabPage, implSelectHdl, Control*, EMPTYARG ) |
| { |
| updateControlStates(); |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| CustomAnimationDialog::CustomAnimationDialog( Window* pParent, STLPropertySet* pSet, sal_uInt16 nPage /* = 0 */ ) |
| : TabDialog( pParent, SdResId( DLG_CUSTOMANIMATION ) ), mpSet( pSet ), mpResultSet( 0 ) |
| { |
| mpTabControl = new TabControl( this, SdResId( 1 ) ); |
| mpOKButton = new OKButton(this, SdResId( 1 ) ) ; |
| mpCancelButton = new CancelButton(this, SdResId( 1 ) ); |
| mpHelpButton = new HelpButton(this, SdResId( 1 ) ); |
| |
| FreeResource(); |
| |
| mpEffectTabPage = new CustomAnimationEffectTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_EFFECT ), mpSet ); |
| mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_EFFECT, mpEffectTabPage ); |
| mpDurationTabPage = new CustomAnimationDurationTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_DURATION ), mpSet ); |
| mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_DURATION, mpDurationTabPage ); |
| |
| sal_Bool bHasText = sal_False; |
| if( pSet->getPropertyState( nHandleHasText ) != STLPropertyState_AMBIGUOUS ) |
| pSet->getPropertyValue( nHandleHasText ) >>= bHasText; |
| |
| if( bHasText ) |
| { |
| mpTextAnimTabPage = new CustomAnimationTextAnimTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_TEXT ), mpSet ); |
| mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_TEXT, mpTextAnimTabPage ); |
| } |
| else |
| { |
| mpTextAnimTabPage = 0; |
| mpTabControl->RemovePage( RID_TP_CUSTOMANIMATION_TEXT ); |
| } |
| |
| if( nPage ) |
| mpTabControl->SelectTabPage( nPage ); |
| } |
| |
| CustomAnimationDialog::~CustomAnimationDialog() |
| { |
| delete mpEffectTabPage; |
| delete mpDurationTabPage; |
| delete mpTextAnimTabPage; |
| |
| delete mpTabControl; |
| delete mpOKButton; |
| delete mpCancelButton; |
| delete mpHelpButton; |
| |
| delete mpSet; |
| delete mpResultSet; |
| } |
| |
| STLPropertySet* CustomAnimationDialog::getResultSet() |
| { |
| if( mpResultSet ) |
| delete mpResultSet; |
| |
| mpResultSet = createDefaultSet(); |
| |
| mpEffectTabPage->update( mpResultSet ); |
| mpDurationTabPage->update( mpResultSet ); |
| if( mpTextAnimTabPage ) |
| mpTextAnimTabPage->update( mpResultSet ); |
| |
| return mpResultSet; |
| } |
| |
| STLPropertySet* CustomAnimationDialog::createDefaultSet() |
| { |
| Any aEmpty; |
| |
| STLPropertySet* pSet = new STLPropertySet(); |
| pSet->setPropertyDefaultValue( nHandleMaxParaDepth, makeAny( (sal_Int32)-1 ) ); |
| |
| pSet->setPropertyDefaultValue( nHandleHasAfterEffect, makeAny( (sal_Bool)sal_False ) ); |
| pSet->setPropertyDefaultValue( nHandleAfterEffectOnNextEffect, makeAny( (sal_Bool)sal_False ) ); |
| pSet->setPropertyDefaultValue( nHandleDimColor, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleIterateType, makeAny( (sal_Int16)0 ) ); |
| pSet->setPropertyDefaultValue( nHandleIterateInterval, makeAny( (double)0.0 ) ); |
| |
| pSet->setPropertyDefaultValue( nHandleStart, makeAny( (sal_Int16)EffectNodeType::ON_CLICK ) ); |
| pSet->setPropertyDefaultValue( nHandleBegin, makeAny( (double)0.0 ) ); |
| pSet->setPropertyDefaultValue( nHandleDuration, makeAny( (double)2.0 ) ); |
| pSet->setPropertyDefaultValue( nHandleRepeat, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleRewind, makeAny( AnimationFill::HOLD ) ); |
| |
| pSet->setPropertyDefaultValue( nHandleEnd, aEmpty ); |
| |
| pSet->setPropertyDefaultValue( nHandlePresetId, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleProperty1Type, makeAny( nPropertyTypeNone ) ); |
| pSet->setPropertyDefaultValue( nHandleProperty1Value, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleProperty2Type, makeAny( nPropertyTypeNone ) ); |
| pSet->setPropertyDefaultValue( nHandleProperty2Value, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleAccelerate, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleDecelerate, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleAutoReverse, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleTrigger, aEmpty ); |
| |
| pSet->setPropertyDefaultValue( nHandleHasText, makeAny( sal_False ) ); |
| pSet->setPropertyDefaultValue( nHandleHasVisibleShape, makeAny( sal_False ) ); |
| pSet->setPropertyDefaultValue( nHandleTextGrouping, makeAny( (sal_Int32)-1 ) ); |
| pSet->setPropertyDefaultValue( nHandleAnimateForm, makeAny( sal_True ) ); |
| pSet->setPropertyDefaultValue( nHandleTextGroupingAuto, makeAny( (double)-1.0 ) ); |
| pSet->setPropertyDefaultValue( nHandleTextReverse, makeAny( sal_False ) ); |
| |
| pSet->setPropertyDefaultValue( nHandleCurrentPage, aEmpty ); |
| |
| pSet->setPropertyDefaultValue( nHandleSoundURL, aEmpty ); |
| pSet->setPropertyDefaultValue( nHandleSoundVolumne, makeAny( (double)1.0) ); |
| pSet->setPropertyDefaultValue( nHandleSoundEndAfterSlide, makeAny( (sal_Int32)0 ) ); |
| |
| pSet->setPropertyDefaultValue( nHandleCommand, makeAny( (sal_Int16)0 ) ); |
| return pSet; |
| } |
| |
| PropertyControl::PropertyControl( Window* pParent, const ResId& rResId ) |
| : ListBox( pParent, rResId ), mpSubControl(0) |
| { |
| } |
| |
| PropertyControl::~PropertyControl() |
| { |
| if( mpSubControl ) |
| delete mpSubControl; |
| } |
| |
| void PropertyControl::setSubControl( PropertySubControl* pSubControl ) |
| { |
| if( mpSubControl && mpSubControl != pSubControl ) |
| delete mpSubControl; |
| |
| mpSubControl = pSubControl; |
| |
| Control* pControl = pSubControl ? pSubControl->getControl() : 0; |
| |
| if( pControl ) |
| { |
| pControl->SetPosSizePixel( GetPosPixel(), GetSizePixel() ); |
| pControl->SetZOrder( this, WINDOW_ZORDER_BEFOR ); |
| pControl->Show(); |
| Hide(); |
| } |
| else |
| { |
| Show(); |
| } |
| } |
| |
| void PropertyControl::Resize() |
| { |
| Control* pControl = mpSubControl ? mpSubControl->getControl() : 0; |
| if( pControl ) |
| pControl->SetPosSizePixel( GetPosPixel(), GetSizePixel() ); |
| ListBox::Resize(); |
| } |
| |
| // ==================================================================== |
| |
| PropertySubControl::~PropertySubControl() |
| { |
| } |
| |
| PropertySubControl* PropertySubControl::create( sal_Int32 nType, Window* pParent, const Any& rValue, const OUString& rPresetId, const Link& rModifyHdl ) |
| { |
| PropertySubControl* pSubControl = NULL; |
| switch( nType ) |
| { |
| case nPropertyTypeDirection: |
| case nPropertyTypeSpokes: |
| case nPropertyTypeZoom: |
| pSubControl = new PresetPropertyBox( nType, pParent, rValue, rPresetId, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeColor: |
| case nPropertyTypeFillColor: |
| case nPropertyTypeFirstColor: |
| case nPropertyTypeCharColor: |
| case nPropertyTypeLineColor: |
| pSubControl = new ColorPropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeFont: |
| pSubControl = new FontPropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeCharHeight: |
| pSubControl = new CharHeightPropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeRotate: |
| pSubControl = new RotationPropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeTransparency: |
| pSubControl = new TransparencyPropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeScale: |
| pSubControl = new ScalePropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| |
| case nPropertyTypeCharDecoration: |
| pSubControl = new FontStylePropertyBox( nType, pParent, rValue, rModifyHdl ); |
| break; |
| } |
| |
| return pSubControl; |
| } |
| |
| } |