1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 #include <com/sun/star/presentation/EffectNodeType.hpp>
27 #include <com/sun/star/animations/Timing.hpp>
28 #include <com/sun/star/animations/Event.hpp>
29 #include <com/sun/star/animations/EventTrigger.hpp>
30 #include <com/sun/star/animations/AnimationFill.hpp>
31 #include <com/sun/star/presentation/TextAnimationType.hpp>
32 #include <com/sun/star/animations/ValuePair.hpp>
33 #include <com/sun/star/awt/FontSlant.hpp>
34 #include <com/sun/star/awt/FontWeight.hpp>
35 #include <com/sun/star/awt/FontUnderline.hpp>
36 #include <com/sun/star/drawing/XDrawPage.hpp>
37 #include <com/sun/star/beans/XPropertySet.hpp>
38 #include <com/sun/star/media/XManager.hpp>
39 #include <com/sun/star/media/XPlayer.hpp>
40 
41 #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
42 #include <boost/shared_ptr.hpp>
43 #endif
44 
45 #ifndef _UNOTOOLS_PROCESSFACTORY_HXX
46 #include <comphelper/processfactory.hxx>
47 #endif
48 #include <unotools/pathoptions.hxx>
49 #include <vcl/tabctrl.hxx>
50 #include <vcl/tabpage.hxx>
51 #include <vcl/menubtn.hxx>
52 #include <vcl/svapp.hxx>
53 #include <vcl/fixed.hxx>
54 #include <vcl/lstbox.hxx>
55 #include <vcl/field.hxx>
56 #include <vcl/msgbox.hxx>
57 #include <vcl/decoview.hxx>
58 #include <vcl/combobox.hxx>
59 #include <vcl/menu.hxx>
60 #include <svtools/ctrlbox.hxx>
61 #include <svtools/ctrltool.hxx>
62 #include <sfx2/objsh.hxx>
63 
64 #ifndef _SVX_SVXIDS_HRC
65 #include <svx/svxids.hrc>
66 #endif
67 #include <svx/dialmgr.hxx>
68 #include <editeng/flstitem.hxx>
69 #include <svx/drawitem.hxx>
70 
71 #include <svx/xtable.hxx>
72 #include <svx/gallery.hxx>
73 
74 #ifndef _SVX_DIALOGS_HRC
75 #include <svx/dialogs.hrc>
76 #endif
77 #include "sdresid.hxx"
78 
79 #include "glob.hrc"
80 #include "CustomAnimationDialog.hxx"
81 #ifndef _SD_CUSTOMANIMATIONDIALOG_HRC
82 #include "CustomAnimationDialog.hrc"
83 #endif
84 #ifndef _SD_CUSTOMANIMATION_HRC
85 #include "CustomAnimation.hrc"
86 #endif
87 #include "STLPropertySet.hxx"
88 
89 #include <avmedia/mediawindow.hxx>
90 
91 #include "filedlg.hxx"
92 #include "strings.hrc"
93 #include "helpids.h"
94 
95 using namespace ::com::sun::star;
96 using namespace ::com::sun::star::animations;
97 using namespace ::com::sun::star::presentation;
98 
99 using ::rtl::OUString;
100 using ::com::sun::star::uno::UNO_QUERY;
101 using ::com::sun::star::uno::UNO_QUERY_THROW;
102 using ::com::sun::star::uno::Any;
103 using ::com::sun::star::uno::makeAny;
104 using ::com::sun::star::uno::Sequence;
105 using ::com::sun::star::uno::Reference;
106 using ::com::sun::star::uno::Exception;
107 using ::com::sun::star::drawing::XShape;
108 using ::com::sun::star::drawing::XDrawPage;
109 using ::com::sun::star::beans::XPropertySet;
110 
111 namespace sd {
112 
113 extern void fillRepeatComboBox( ComboBox* pBox );
114 extern void fillDurationComboBox( ComboBox* pBox );
115 extern OUString getShapeDescription( const Reference< XShape >& xShape, bool bWithText = true );
116 extern OUString getPropertyName( sal_Int32 nPropertyType );
117 
118 // ====================================================================
119 
120 class PresetPropertyBox  : public PropertySubControl
121 {
122 public:
123 	PresetPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const OUString& aPresetId, const Link& rModifyHdl );
124 	~PresetPropertyBox();
125 
126 	virtual Any getValue();
127 	virtual void setValue( const Any& rValue, const OUString& rPresetId );
128 	virtual Control* getControl();
129 
130 private:
131 	std::map< sal_uInt16, rtl::OUString > maPropertyValues;
132 	ListBox* mpControl;
133 };
134 
135 // --------------------------------------------------------------------
136 
137 PresetPropertyBox::PresetPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const OUString& aPresetId, const Link& rModifyHdl )
138 : PropertySubControl( nControlType )
139 {
140 	mpControl = new ListBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN );
141 	mpControl->SetDropDownLineCount( 10 );
142 	mpControl->SetSelectHdl( rModifyHdl );
143 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_PRESETPROPERTYBOX );
144 
145 	setValue( rValue, aPresetId );
146 
147 }
148 
149 void PresetPropertyBox::setValue( const Any& rValue, const OUString& rPresetId )
150 {
151 	if( mpControl )
152 	{
153 		mpControl->Clear();
154 
155 		const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets();
156 		CustomAnimationPresetPtr pDescriptor = rPresets.getEffectDescriptor( rPresetId );
157 		if( pDescriptor.get() )
158 		{
159 
160 			OUString aPropertyValue;
161 			rValue >>= aPropertyValue;
162 
163 			UStringList aSubTypes( pDescriptor->getSubTypes() );
164 			UStringList::iterator aIter( aSubTypes.begin() );
165 			const UStringList::iterator aEnd( aSubTypes.end() );
166 
167 			mpControl->Enable( aIter != aEnd );
168 
169 			while( aIter != aEnd )
170 			{
171 				sal_uInt16 nPos = mpControl->InsertEntry( rPresets.getUINameForProperty( (*aIter) ) );
172 				if( (*aIter) == aPropertyValue )
173 					mpControl->SelectEntryPos( nPos );
174 				maPropertyValues[nPos] = (*aIter++);
175 			}
176 		}
177 		else
178 		{
179 			mpControl->Enable( sal_False );
180 		}
181 	}
182 }
183 
184 // --------------------------------------------------------------------
185 
186 PresetPropertyBox::~PresetPropertyBox()
187 {
188 	delete mpControl;
189 }
190 
191 // --------------------------------------------------------------------
192 
193 Any PresetPropertyBox::getValue()
194 {
195 	return makeAny( maPropertyValues[mpControl->GetSelectEntryPos()] );
196 }
197 
198 // --------------------------------------------------------------------
199 
200 Control* PresetPropertyBox::getControl()
201 {
202 	return mpControl;
203 }
204 
205 // ====================================================================
206 
207 class ColorPropertyBox  : public PropertySubControl
208 {
209 public:
210 	ColorPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
211 	~ColorPropertyBox();
212 
213 	virtual Any getValue();
214 	virtual void setValue( const Any& rValue, const OUString& rPresetId  );
215 	virtual Control* getControl();
216 
217 private:
218 	ColorListBox* mpControl;
219 };
220 
221 // --------------------------------------------------------------------
222 
223 ColorPropertyBox::ColorPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
224 : PropertySubControl( nControlType )
225 {
226 	mpControl = new ColorListBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN );
227 	mpControl->SetDropDownLineCount( 10 );
228 	mpControl->SetSelectHdl( rModifyHdl );
229 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_COLORPROPERTYBOX );
230 
231 	SfxObjectShell* pDocSh = SfxObjectShell::Current();
232 	DBG_ASSERT( pDocSh, "DocShell not found!" );
233 	XColorTable* pColorTable = NULL;
234 	bool bKillTable = false;
235 	const SfxPoolItem* pItem = NULL;
236 
237 	if ( pDocSh && ( ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) != 0) )
238 		pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
239 
240 	if ( !pColorTable )
241 	{
242 		pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
243 		bKillTable = sal_True;
244 	}
245 
246 	sal_Int32 nColor = 0;
247 	rValue >>= nColor;
248 
249 	for ( long i = 0; i < pColorTable->Count(); i++ )
250 	{
251 		XColorEntry* pEntry = pColorTable->GetColor(i);
252 		sal_uInt16 nPos = mpControl->InsertEntry( pEntry->GetColor(), pEntry->GetName() );
253 		if( pEntry->GetColor().GetRGBColor() == (sal_uInt32)nColor )
254 			mpControl->SelectEntryPos( nPos );
255 	}
256 
257 	if ( bKillTable )
258 		delete pColorTable;
259 }
260 
261 // --------------------------------------------------------------------
262 
263 ColorPropertyBox::~ColorPropertyBox()
264 {
265 	delete mpControl;
266 }
267 
268 // --------------------------------------------------------------------
269 
270 void ColorPropertyBox::setValue( const Any& rValue, const OUString& )
271 {
272 	if( mpControl )
273 	{
274 		sal_Int32 nColor = 0;
275 		rValue >>= nColor;
276 
277 		mpControl->SetNoSelection();
278 		mpControl->SelectEntryPos( mpControl->GetEntryPos( (Color)nColor ) );
279 	}
280 }
281 
282 // --------------------------------------------------------------------
283 
284 Any ColorPropertyBox::getValue()
285 {
286 	return makeAny( (sal_Int32)mpControl->GetSelectEntryColor().GetRGBColor() );
287 }
288 
289 // --------------------------------------------------------------------
290 
291 Control* ColorPropertyBox::getControl()
292 {
293 	return mpControl;
294 }
295 
296 // ====================================================================
297 
298 class FontPropertyBox : public PropertySubControl
299 {
300 public:
301 	FontPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
302 	virtual ~FontPropertyBox();
303 
304 	virtual Any getValue();
305 	virtual void setValue( const Any& rValue, const OUString& rPresetId  );
306 
307 	virtual Control* getControl();
308 
309 private:
310 	FontNameBox* mpControl;
311 };
312 
313 // --------------------------------------------------------------------
314 
315 FontPropertyBox::FontPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
316 : PropertySubControl( nControlType )
317 {
318 	mpControl = new FontNameBox( pParent, WB_BORDER|WB_TABSTOP|WB_DROPDOWN );
319 	mpControl->SetDropDownLineCount( 10 );
320 	mpControl->SetSelectHdl( rModifyHdl );
321 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_FONTPROPERTYBOX );
322 
323 	SfxObjectShell* pDocSh = SfxObjectShell::Current();
324 	const SfxPoolItem* pItem;
325 
326 	const FontList* pFontList = 0;
327 	bool bMustDelete = false;
328 
329     if ( pDocSh && ( (pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST ) ) != 0) )
330         pFontList = ( (SvxFontListItem*)pItem )->GetFontList();
331 
332 	if(!pFontList)
333 	{
334         pFontList = new FontList( Application::GetDefaultDevice(), NULL, sal_False );
335 		bMustDelete = true;
336 	}
337 
338 	mpControl->Fill( pFontList );
339 
340 	if( bMustDelete )
341 		delete pFontList;
342 
343 	OUString aPresetId;
344 	setValue( rValue, aPresetId );
345 }
346 
347 // --------------------------------------------------------------------
348 
349 void FontPropertyBox::setValue( const Any& rValue, const OUString& )
350 {
351 	if( mpControl )
352 	{
353 		OUString aFontName;
354 		rValue >>= aFontName;
355 		mpControl->SetText( aFontName );
356 	}
357 }
358 
359 // --------------------------------------------------------------------
360 
361 FontPropertyBox::~FontPropertyBox()
362 {
363 	delete mpControl;
364 }
365 
366 // --------------------------------------------------------------------
367 
368 Any FontPropertyBox::getValue()
369 {
370 	OUString aFontName( mpControl->GetText() );
371 	return makeAny( aFontName );
372 }
373 
374 // --------------------------------------------------------------------
375 
376 Control* FontPropertyBox::getControl()
377 {
378 	return mpControl;
379 }
380 
381 // ====================================================================
382 
383 class DropdownMenuBox : public Edit
384 {
385 public:
386 	DropdownMenuBox( Window* pParent, Edit* pSubControl, PopupMenu* pMenu );
387 	~DropdownMenuBox();
388 
389 	void Resize();
390 	long PreNotify( NotifyEvent& rNEvt );
391 
392 	void SetMenuSelectHdl( const Link& rLink ) { mpDropdownButton->SetSelectHdl( rLink ); }
393 
394 private:
395 	Edit* mpSubControl;
396 	MenuButton* mpDropdownButton;
397 	PopupMenu* mpMenu;
398 };
399 
400 // --------------------------------------------------------------------
401 
402 DropdownMenuBox::DropdownMenuBox( Window* pParent, Edit* pSubControl, PopupMenu* pMenu )
403 :	Edit( pParent, WB_BORDER|WB_TABSTOP| WB_DIALOGCONTROL ),
404 	mpSubControl(pSubControl),mpDropdownButton(0),mpMenu(pMenu)
405 {
406 	mpDropdownButton = new MenuButton( this, WB_NOLIGHTBORDER | WB_RECTSTYLE | WB_NOTABSTOP);
407 	mpDropdownButton->SetSymbol(SYMBOL_SPIN_DOWN);
408 	mpDropdownButton->Show();
409 	mpDropdownButton->SetPopupMenu( pMenu );
410 
411 	SetSubEdit( mpSubControl );
412 	mpSubControl->SetParent( this );
413 	mpSubControl->Show();
414 }
415 
416 // --------------------------------------------------------------------
417 
418 DropdownMenuBox::~DropdownMenuBox()
419 {
420 	SetSubEdit( 0 );
421 	delete mpSubControl;
422 	delete mpDropdownButton;
423 	delete mpMenu;
424 }
425 
426 // --------------------------------------------------------------------
427 
428 void DropdownMenuBox::Resize()
429 {
430 	Size aOutSz = GetOutputSizePixel();
431 
432 	long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
433 	nSBWidth = CalcZoom( nSBWidth );
434 	mpSubControl->SetPosSizePixel( 0, 1, aOutSz.Width() - nSBWidth, aOutSz.Height()-2 );
435 	mpDropdownButton->SetPosSizePixel( aOutSz.Width() - nSBWidth, 0, nSBWidth, aOutSz.Height() );
436 }
437 
438 // --------------------------------------------------------------------
439 
440 long DropdownMenuBox::PreNotify( NotifyEvent& rNEvt )
441 {
442 	long nResult=sal_True;
443 
444 	sal_uInt16 nSwitch=rNEvt.GetType();
445 	if (nSwitch==EVENT_KEYINPUT)
446 	{
447 		const KeyCode& aKeyCode=rNEvt.GetKeyEvent()->GetKeyCode();
448 		sal_uInt16 nKey=aKeyCode.GetCode();
449 
450 		if (nKey==KEY_DOWN && aKeyCode.IsMod2())
451 		{
452 			mpDropdownButton->KeyInput( *rNEvt.GetKeyEvent() );
453 		}
454 		else
455 		{
456 			nResult=Edit::PreNotify(rNEvt);
457 		}
458 	}
459 	else
460 		nResult=Edit::PreNotify(rNEvt);
461 
462 	return nResult;
463 }
464 
465 // --------------------------------------------------------------------
466 
467 class CharHeightPropertyBox : public PropertySubControl
468 {
469 public:
470 	CharHeightPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
471 	virtual ~CharHeightPropertyBox();
472 
473 	virtual Any getValue();
474 	virtual void setValue( const Any& rValue, const OUString& );
475 
476 	virtual Control* getControl();
477 
478 	DECL_LINK( implMenuSelectHdl, MenuButton* );
479 
480 private:
481 	DropdownMenuBox* mpControl;
482 	PopupMenu* mpMenu;
483 	MetricField* mpMetric;
484 };
485 
486 // --------------------------------------------------------------------
487 
488 CharHeightPropertyBox::CharHeightPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
489 : PropertySubControl( nControlType )
490 {
491 	mpMetric = new MetricField( pParent, WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER);
492 	mpMetric->SetUnit( FUNIT_PERCENT );
493 	mpMetric->SetMin( 0 );
494 	mpMetric->SetMax( 1000 );
495 
496 	mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_FONTSIZE_POPUP ) );
497 	mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu );
498 	mpControl->SetMenuSelectHdl( LINK( this, CharHeightPropertyBox, implMenuSelectHdl ));
499 	mpControl->SetModifyHdl( rModifyHdl );
500 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_CHARHEIGHTPROPERTYBOX );
501 
502 	OUString aPresetId;
503 	setValue( rValue, aPresetId );
504 }
505 
506 // --------------------------------------------------------------------
507 
508 CharHeightPropertyBox::~CharHeightPropertyBox()
509 {
510 	delete mpControl;
511 }
512 
513 // --------------------------------------------------------------------
514 
515 IMPL_LINK( CharHeightPropertyBox, implMenuSelectHdl, MenuButton*, pPb )
516 {
517 	long nValue = 100;
518 	switch( pPb->GetCurItemId() )
519 	{
520 	case CM_SIZE_25: nValue = 25; break;
521 	case CM_SIZE_50: nValue = 50; break;
522 	case CM_SIZE_150: nValue = 150; break;
523 	case CM_SIZE_400: nValue = 400; break;
524 	}
525 	mpMetric->SetValue( nValue );
526 	mpMetric->Modify();
527 	return 0;
528 }
529 
530 // --------------------------------------------------------------------
531 
532 void CharHeightPropertyBox::setValue( const Any& rValue, const OUString& )
533 {
534 	if( mpMetric )
535 	{
536 		double fValue = 0.0;
537 		rValue >>= fValue;
538 		mpMetric->SetValue( (long)(fValue * 100.0) );
539 	}
540 }
541 
542 // --------------------------------------------------------------------
543 
544 Any CharHeightPropertyBox::getValue()
545 {
546 	return makeAny( (double)((double)mpMetric->GetValue() / 100.0) );
547 }
548 
549 // --------------------------------------------------------------------
550 
551 Control* CharHeightPropertyBox::getControl()
552 {
553 	return mpControl;
554 }
555 
556 // ====================================================================
557 
558 class TransparencyPropertyBox : public PropertySubControl
559 {
560 public:
561 	TransparencyPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
562 	~TransparencyPropertyBox();
563 
564 	virtual Any getValue();
565 	virtual void setValue( const Any& rValue, const OUString& rPresetId  );
566 
567 	virtual Control* getControl();
568 
569 	DECL_LINK( implMenuSelectHdl, MenuButton* );
570 	DECL_LINK( implModifyHdl, Control* );
571 
572 	void updateMenu();
573 
574 private:
575 	DropdownMenuBox* mpControl;
576 	PopupMenu* mpMenu;
577 	MetricField* mpMetric;
578 	Link maModifyHdl;
579 };
580 
581 // --------------------------------------------------------------------
582 
583 TransparencyPropertyBox::TransparencyPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
584 : PropertySubControl( nControlType )
585 , maModifyHdl( rModifyHdl )
586 {
587 	mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER);
588 	mpMetric->SetUnit( FUNIT_PERCENT );
589 	mpMetric->SetMin( 0 );
590 	mpMetric->SetMax( 100 );
591 
592 	mpMenu = new PopupMenu();
593 	for( sal_uInt16 i = 25; i < 101; i += 25 )
594 	{
595 		String aStr( String::CreateFromInt32( i ) );
596 		aStr += sal_Unicode('%');
597 		mpMenu->InsertItem( i, aStr );
598 	}
599 
600 	mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu );
601 	mpControl->SetMenuSelectHdl( LINK( this, TransparencyPropertyBox, implMenuSelectHdl ));
602 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_TRANSPARENCYPROPERTYBOX );
603 
604 	Link aLink( LINK( this, TransparencyPropertyBox, implModifyHdl ) );
605 	mpControl->SetModifyHdl( aLink );
606 
607 	OUString aPresetId;
608 	setValue( rValue, aPresetId  );
609 }
610 
611 // --------------------------------------------------------------------
612 
613 TransparencyPropertyBox::~TransparencyPropertyBox()
614 {
615 	delete mpControl;
616 }
617 
618 // --------------------------------------------------------------------
619 
620 void TransparencyPropertyBox::updateMenu()
621 {
622 	sal_Int64 nValue = mpMetric->GetValue();
623 	for( sal_uInt16 i = 25; i < 101; i += 25 )
624 		mpMenu->CheckItem( i, nValue == i );
625 }
626 
627 // --------------------------------------------------------------------
628 
629 IMPL_LINK( TransparencyPropertyBox, implModifyHdl, Control*, EMPTYARG )
630 {
631 	updateMenu();
632 	maModifyHdl.Call(mpMetric);
633 
634 	return 0;
635 }
636 
637 // --------------------------------------------------------------------
638 
639 IMPL_LINK( TransparencyPropertyBox, implMenuSelectHdl, MenuButton*, pPb )
640 {
641 	if( pPb->GetCurItemId() != mpMetric->GetValue() )
642 	{
643 		mpMetric->SetValue( pPb->GetCurItemId() );
644 		mpMetric->Modify();
645 	}
646 
647 	return 0;
648 }
649 
650 // --------------------------------------------------------------------
651 
652 void TransparencyPropertyBox::setValue( const Any& rValue, const OUString& )
653 {
654 	if( mpMetric )
655 	{
656 		double fValue = 0.0;
657 		rValue >>= fValue;
658 		long nValue = (long)(fValue * 100);
659 		mpMetric->SetValue( nValue );
660 		updateMenu();
661 	}
662 }
663 
664 // --------------------------------------------------------------------
665 
666 Any TransparencyPropertyBox::getValue()
667 {
668 	return makeAny( (double)((double)mpMetric->GetValue()) / 100.0 );
669 }
670 
671 // --------------------------------------------------------------------
672 
673 Control* TransparencyPropertyBox::getControl()
674 {
675 	return mpControl;
676 }
677 
678 // --------------------------------------------------------------------
679 
680 class RotationPropertyBox : public PropertySubControl
681 {
682 public:
683 	RotationPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
684 	~RotationPropertyBox();
685 
686 	virtual Any getValue();
687 	virtual void setValue( const Any& rValue, const OUString& );
688 
689 	virtual Control* getControl();
690 
691 	DECL_LINK( implMenuSelectHdl, MenuButton* );
692 	DECL_LINK( implModifyHdl, Control* );
693 
694 	void updateMenu();
695 
696 private:
697 	DropdownMenuBox* mpControl;
698 	PopupMenu* mpMenu;
699 	MetricField* mpMetric;
700 	Link maModifyHdl;
701 };
702 
703 // --------------------------------------------------------------------
704 
705 RotationPropertyBox::RotationPropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
706 : PropertySubControl( nControlType )
707 , maModifyHdl( rModifyHdl )
708 {
709 	mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER);
710 	mpMetric->SetUnit( FUNIT_CUSTOM );
711 	mpMetric->SetCustomUnitText( OUString( sal_Unicode(0xb0)) ); // degree sign
712 	mpMetric->SetMin( -10000 );
713 	mpMetric->SetMax( 10000 );
714 
715 	mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_ROTATION_POPUP ) );
716 	mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu );
717 	mpControl->SetMenuSelectHdl( LINK( this, RotationPropertyBox, implMenuSelectHdl ));
718 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_ROTATIONPROPERTYBOX );
719 
720 	Link aLink( LINK( this, RotationPropertyBox, implModifyHdl ) );
721 	mpControl->SetModifyHdl( aLink );
722 
723 	OUString aPresetId;
724 	setValue( rValue, aPresetId );
725 }
726 
727 // --------------------------------------------------------------------
728 
729 RotationPropertyBox::~RotationPropertyBox()
730 {
731 	delete mpControl;
732 }
733 
734 // --------------------------------------------------------------------
735 
736 void RotationPropertyBox::updateMenu()
737 {
738 	sal_Int64 nValue = mpMetric->GetValue();
739 	bool bDirection = nValue >= 0;
740 	nValue = (nValue < 0 ? -nValue : nValue);
741 
742 	mpMenu->CheckItem( CM_QUARTER_SPIN, nValue == 90 );
743 	mpMenu->CheckItem( CM_HALF_SPIN, nValue == 180 );
744 	mpMenu->CheckItem( CM_FULL_SPIN, nValue == 360 );
745 	mpMenu->CheckItem( CM_TWO_SPINS, nValue == 720 );
746 
747 	mpMenu->CheckItem( CM_CLOCKWISE, bDirection );
748 	mpMenu->CheckItem( CM_COUNTERCLOCKWISE, !bDirection );
749 }
750 
751 // --------------------------------------------------------------------
752 
753 IMPL_LINK( RotationPropertyBox, implModifyHdl, Control*, EMPTYARG )
754 {
755 	updateMenu();
756 	maModifyHdl.Call(mpMetric);
757 
758 	return 0;
759 }
760 
761 IMPL_LINK( RotationPropertyBox, implMenuSelectHdl, MenuButton*, pPb )
762 {
763 	sal_Int64 nValue = mpMetric->GetValue();
764 	bool bDirection = nValue >= 0;
765 	nValue = (nValue < 0 ? -nValue : nValue);
766 
767 	switch( pPb->GetCurItemId() )
768 	{
769 	case CM_QUARTER_SPIN: nValue = 90; break;
770 	case CM_HALF_SPIN: nValue = 180; break;
771 	case CM_FULL_SPIN: nValue = 360; break;
772 	case CM_TWO_SPINS: nValue = 720; break;
773 
774 	case CM_CLOCKWISE: bDirection = true; break;
775 	case CM_COUNTERCLOCKWISE: bDirection = false; break;
776 
777 	}
778 
779 	if( !bDirection )
780 		nValue = -nValue;
781 
782 	if( nValue != mpMetric->GetValue() )
783 	{
784 		mpMetric->SetValue( nValue );
785 		mpMetric->Modify();
786 	}
787 
788 	return 0;
789 }
790 
791 // --------------------------------------------------------------------
792 
793 void RotationPropertyBox::setValue( const Any& rValue, const OUString& )
794 {
795 	if( mpMetric )
796 	{
797 		double fValue = 0.0;
798 		rValue >>= fValue;
799 		long nValue = (long)(fValue);
800 		mpMetric->SetValue( nValue );
801 		updateMenu();
802 	}
803 }
804 
805 // --------------------------------------------------------------------
806 
807 Any RotationPropertyBox::getValue()
808 {
809 	return makeAny( (double)((double)mpMetric->GetValue()) );
810 }
811 
812 // --------------------------------------------------------------------
813 
814 Control* RotationPropertyBox::getControl()
815 {
816 	return mpControl;
817 }
818 
819 // --------------------------------------------------------------------
820 
821 class ScalePropertyBox : public PropertySubControl
822 {
823 public:
824 	ScalePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
825 	~ScalePropertyBox();
826 
827 	virtual Any getValue();
828 	virtual void setValue( const Any& rValue, const OUString& );
829 
830 	virtual Control* getControl();
831 
832 	DECL_LINK( implMenuSelectHdl, MenuButton* );
833 	DECL_LINK( implModifyHdl, Control* );
834 
835 	void updateMenu();
836 
837 private:
838 	DropdownMenuBox* mpControl;
839 	PopupMenu* mpMenu;
840 	MetricField* mpMetric;
841 	Link maModifyHdl;
842 	int mnDirection;
843 };
844 
845 // --------------------------------------------------------------------
846 
847 ScalePropertyBox::ScalePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
848 : PropertySubControl( nControlType )
849 , maModifyHdl( rModifyHdl )
850 {
851 	mpMetric = new MetricField( pParent ,WB_TABSTOP|WB_IGNORETAB| WB_NOBORDER);
852 	mpMetric->SetUnit( FUNIT_PERCENT );
853 	mpMetric->SetMin( 0 );
854 	mpMetric->SetMax( 10000 );
855 
856 	mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_SCALE_POPUP ) );
857 	mpControl = new DropdownMenuBox( pParent, mpMetric, mpMenu );
858 	mpControl->SetMenuSelectHdl( LINK( this, ScalePropertyBox, implMenuSelectHdl ));
859 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_SCALEPROPERTYBOX );
860 
861 	Link aLink( LINK( this, ScalePropertyBox, implModifyHdl ) );
862 	mpControl->SetModifyHdl( aLink );
863 
864 	OUString aPresetId;
865 	setValue( rValue, aPresetId );
866 }
867 
868 // --------------------------------------------------------------------
869 
870 ScalePropertyBox::~ScalePropertyBox()
871 {
872 	delete mpControl;
873 }
874 
875 // --------------------------------------------------------------------
876 
877 void ScalePropertyBox::updateMenu()
878 {
879 	sal_Int64 nValue = mpMetric->GetValue();
880 
881 	mpMenu->CheckItem( 25, nValue == 25 );
882 	mpMenu->CheckItem( 50, nValue == 50 );
883 	mpMenu->CheckItem( 150, nValue == 150 );
884 	mpMenu->CheckItem( 400, nValue == 400 );
885 
886 	mpMenu->CheckItem( CM_HORIZONTAL, mnDirection == 1 );
887 	mpMenu->CheckItem( CM_VERTICAL, mnDirection == 2 );
888 	mpMenu->CheckItem( CM_BOTH, mnDirection == 3 );
889 }
890 
891 // --------------------------------------------------------------------
892 
893 IMPL_LINK( ScalePropertyBox, implModifyHdl, Control*, EMPTYARG )
894 {
895 	updateMenu();
896 	maModifyHdl.Call(mpMetric);
897 
898 	return 0;
899 }
900 
901 IMPL_LINK( ScalePropertyBox, implMenuSelectHdl, MenuButton*, pPb )
902 {
903 	sal_Int64 nValue = mpMetric->GetValue();
904 
905 	int nDirection = mnDirection;
906 
907 	switch( pPb->GetCurItemId() )
908 	{
909 	case CM_HORIZONTAL: nDirection = 1; break;
910 	case CM_VERTICAL: nDirection = 2; break;
911 	case CM_BOTH: nDirection = 3; break;
912 
913 	default:
914 		nValue = pPb->GetCurItemId();
915 	}
916 
917 	bool bModified = false;
918 
919 	if( nDirection != mnDirection )
920 	{
921 		mnDirection = nDirection;
922 		bModified = true;
923 	}
924 
925 	if( nValue != mpMetric->GetValue() )
926 	{
927 		mpMetric->SetValue( nValue );
928 		bModified = true;
929 	}
930 
931 	if( bModified )
932 	{
933 		mpMetric->Modify();
934 		updateMenu();
935 	}
936 
937 	return 0;
938 }
939 
940 // --------------------------------------------------------------------
941 
942 void ScalePropertyBox::setValue( const Any& rValue, const OUString& )
943 {
944 	if( mpMetric )
945 	{
946 		ValuePair aValues;
947 		rValue >>= aValues;
948 
949 		double fValue1 = 0.0;
950 		double fValue2 = 0.0;
951 
952 		aValues.First >>= fValue1;
953 		aValues.Second >>= fValue2;
954 
955 		if( fValue2 == 0.0 )
956 			mnDirection = 1;
957 		else if( fValue1 == 0.0 )
958 			mnDirection = 2;
959 		else
960 			mnDirection = 3;
961 
962 		long nValue;
963 		if( fValue1 )
964 			nValue = (long)(fValue1 * 100.0);
965 		else
966 			nValue = (long)(fValue2 * 100.0);
967 		mpMetric->SetValue( nValue );
968 		updateMenu();
969 	}
970 }
971 
972 // --------------------------------------------------------------------
973 
974 Any ScalePropertyBox::getValue()
975 {
976 	double fValue1 = (double)((double)mpMetric->GetValue() / 100.0);
977 	double fValue2 = fValue1;
978 
979 	if( mnDirection == 1 )
980 		fValue2 = 0.0;
981 	else if( mnDirection == 2 )
982 		fValue1 = 0.0;
983 
984 	ValuePair aValues;
985 	aValues.First <<= fValue1;
986 	aValues.Second <<= fValue2;
987 
988 	return makeAny( aValues );
989 }
990 
991 // --------------------------------------------------------------------
992 
993 Control* ScalePropertyBox::getControl()
994 {
995 	return mpControl;
996 }
997 
998 // ====================================================================
999 
1000 class FontStylePropertyBox : public PropertySubControl
1001 {
1002 public:
1003 	FontStylePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl );
1004 	~FontStylePropertyBox();
1005 
1006 	virtual Any getValue();
1007 	virtual void setValue( const Any& rValue, const OUString& );
1008 
1009 	virtual Control* getControl();
1010 
1011 	DECL_LINK( implMenuSelectHdl, MenuButton* );
1012 
1013 	void update();
1014 
1015 private:
1016 	DropdownMenuBox* mpControl;
1017 	PopupMenu* mpMenu;
1018 	Edit* mpEdit;
1019 	Link maModifyHdl;
1020 
1021 	float mfFontWeight;
1022 	awt::FontSlant meFontSlant;
1023 	sal_Int16 mnFontUnderline;
1024 };
1025 
1026 // --------------------------------------------------------------------
1027 
1028 FontStylePropertyBox::FontStylePropertyBox( sal_Int32 nControlType, Window* pParent, const Any& rValue, const Link& rModifyHdl )
1029 : PropertySubControl( nControlType )
1030 , maModifyHdl( rModifyHdl )
1031 {
1032 	mpEdit = new Edit( pParent, WB_TABSTOP|WB_IGNORETAB|WB_NOBORDER|WB_READONLY);
1033 	mpEdit->SetText( String( SdResId( STR_CUSTOMANIMATION_SAMPLE ) ) );
1034 
1035 	mpMenu = new PopupMenu(SdResId( RID_CUSTOMANIMATION_FONTSTYLE_POPUP ) );
1036 	mpControl = new DropdownMenuBox( pParent, mpEdit, mpMenu );
1037 	mpControl->SetMenuSelectHdl( LINK( this, FontStylePropertyBox, implMenuSelectHdl ));
1038 	mpControl->SetHelpId( HID_SD_CUSTOMANIMATIONPANE_FONTSTYLEPROPERTYBOX );
1039 
1040 	OUString aPresetId;
1041 	setValue( rValue, aPresetId );
1042 }
1043 
1044 // --------------------------------------------------------------------
1045 
1046 FontStylePropertyBox::~FontStylePropertyBox()
1047 {
1048 	delete mpControl;
1049 }
1050 
1051 // --------------------------------------------------------------------
1052 
1053 void FontStylePropertyBox::update()
1054 {
1055 	// update menu
1056 	mpMenu->CheckItem( CM_BOLD, mfFontWeight == awt::FontWeight::BOLD );
1057 	mpMenu->CheckItem( CM_ITALIC, meFontSlant == awt::FontSlant_ITALIC);
1058 	mpMenu->CheckItem( CM_UNDERLINED, mnFontUnderline != awt::FontUnderline::NONE );
1059 
1060 	// update sample edit
1061 	Font aFont( mpEdit->GetFont() );
1062 	aFont.SetWeight( mfFontWeight == awt::FontWeight::BOLD ? WEIGHT_BOLD : WEIGHT_NORMAL );
1063 	aFont.SetItalic( meFontSlant == awt::FontSlant_ITALIC ? ITALIC_NORMAL : ITALIC_NONE  );
1064 	aFont.SetUnderline( mnFontUnderline == awt::FontUnderline::NONE ? UNDERLINE_NONE : UNDERLINE_SINGLE );
1065 	mpEdit->SetFont( aFont );
1066 	mpEdit->Invalidate();
1067 }
1068 
1069 // --------------------------------------------------------------------
1070 
1071 IMPL_LINK( FontStylePropertyBox, implMenuSelectHdl, MenuButton*, pPb )
1072 {
1073 	switch( pPb->GetCurItemId() )
1074 	{
1075 	case CM_BOLD:
1076 		if( mfFontWeight == awt::FontWeight::BOLD )
1077 			mfFontWeight = awt::FontWeight::NORMAL;
1078 		else
1079 			mfFontWeight = awt::FontWeight::BOLD;
1080 		break;
1081 	case CM_ITALIC:
1082 		if( meFontSlant == awt::FontSlant_ITALIC )
1083 			meFontSlant = awt::FontSlant_NONE;
1084 		else
1085 			meFontSlant = awt::FontSlant_ITALIC;
1086 		break;
1087 	case CM_UNDERLINED:
1088 		if( mnFontUnderline == awt::FontUnderline::SINGLE )
1089 			mnFontUnderline = awt::FontUnderline::NONE;
1090 		else
1091 			mnFontUnderline = awt::FontUnderline::SINGLE;
1092 		break;
1093 	default:
1094 		return 0;
1095 	}
1096 
1097 	update();
1098 	maModifyHdl.Call(mpEdit);
1099 
1100 	return 0;
1101 }
1102 
1103 // --------------------------------------------------------------------
1104 
1105 void FontStylePropertyBox::setValue( const Any& rValue, const OUString& )
1106 {
1107 	Sequence<Any> aValues;
1108 	rValue >>= aValues;
1109 
1110 	aValues[0] >>= mfFontWeight;
1111 	aValues[1] >>= meFontSlant;
1112 	aValues[2] >>= mnFontUnderline;
1113 
1114 	update();
1115 }
1116 
1117 // --------------------------------------------------------------------
1118 
1119 Any FontStylePropertyBox::getValue()
1120 {
1121 	Sequence<Any> aValues(3);
1122 	aValues[0] <<= mfFontWeight;
1123 	aValues[1] <<= meFontSlant;
1124 	aValues[2] <<= mnFontUnderline;
1125 	return makeAny( aValues );
1126 }
1127 
1128 // --------------------------------------------------------------------
1129 
1130 Control* FontStylePropertyBox::getControl()
1131 {
1132 	return mpControl;
1133 }
1134 
1135 // ====================================================================
1136 
1137 class CustomAnimationEffectTabPage : public TabPage
1138 {
1139 public:
1140 	CustomAnimationEffectTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet );
1141 	~CustomAnimationEffectTabPage();
1142 
1143 	void update( STLPropertySet* pSet );
1144 	DECL_LINK( implSelectHdl, Control* );
1145 
1146 private:
1147 	void updateControlStates();
1148 	void fillSoundListBox();
1149 	void clearSoundListBox();
1150 	sal_Int32 getSoundObject( const String& rStr );
1151 	void openSoundFileDialog();
1152 	void onSoundPreview();
1153 
1154 private:
1155 	List maSoundList;
1156 	sal_Bool mbHasText;
1157 	const STLPropertySet* mpSet;
1158 
1159 	FixedLine*		mpFLSettings;
1160 	FixedText*		mpFTProperty1;
1161 	PropertyControl* mpLBProperty1;
1162 	FixedText*		mpFTProperty2;
1163 	PropertyControl* mpLBProperty2;
1164 	CheckBox*		mpCBSmoothStart;
1165 	CheckBox*		mpCBSmoothEnd;
1166 	CheckBox*		mpCBAutoRestart;
1167 
1168 	FixedLine*		mpFLPlay;
1169 	RadioButton*	mpRBFromStart;
1170 	RadioButton*	mpRBFromLast;
1171 	RadioButton*	mpRBFromTime;
1172 	MetricField*	mpMFStartTime;
1173 	FixedLine*		mpFLStop;
1174 	RadioButton*	mpRBStopOnClick;
1175 	RadioButton*	mpRBStopOnNextSlide;
1176 	RadioButton*	mpRBStopAfterSlides;
1177 	MetricField*	mpMFStopAfterSlides;
1178 
1179 	FixedLine*		mpFLEnhancements;
1180 	FixedText*		mpFTSound;
1181 	ListBox*		mpLBSound;
1182 	PushButton*		mpPBSoundPreview;
1183 	FixedText*		mpFTAfterEffect;
1184 	ListBox*		mpLBAfterEffect;
1185 	FixedText*		mpFTDimColor;
1186 	ColorListBox*	mpCLBDimColor;
1187 	FixedText*		mpFTTextAnim;
1188 	ListBox*		mpLBTextAnim;
1189 	MetricField*	mpMFTextDelay;
1190 	FixedText*		mpFTTextDelay;
1191 
1192 	::com::sun::star::uno::Reference< ::com::sun::star::media::XPlayer > mxPlayer;
1193 };
1194 
1195 
1196 static void move_down( Control* pControl, int nOffsetX, int nOffsetY )
1197 {
1198 	Point aPos( pControl->GetPosPixel() );
1199 	aPos.X() += nOffsetX;
1200 	aPos.Y() += nOffsetY;
1201 	pControl->SetPosPixel( aPos );
1202 }
1203 
1204 CustomAnimationEffectTabPage::CustomAnimationEffectTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet )
1205 : TabPage( pParent, rResId ), mbHasText( sal_False ), mpSet(pSet )
1206 {
1207 	mpFLSettings = new FixedLine( this, SdResId( FL_SETTINGS ) );
1208 	mpFTProperty1 = new FixedText( this, SdResId( FT_PROPERTY_1 ) );
1209 	mpLBProperty1 = new PropertyControl( this, SdResId( LB_PROPERTY_1 ) );
1210 	mpFTProperty2 = new FixedText( this, SdResId( FT_PROPERTY_2 ) );
1211 	mpLBProperty2 = new PropertyControl( this, SdResId( LB_PROPERTY_2 ) );
1212 	mpCBSmoothStart = new CheckBox( this, SdResId( CB_SMOOTH_START ) );
1213 	mpCBSmoothEnd = new CheckBox( this, SdResId( CB_SMOOTH_END ) );
1214 	mpCBAutoRestart = new CheckBox( this, SdResId( CB_AUTORESTART ) );
1215 /*
1216 	mpFLPlay = new FixedLine( this, SdResId( FL_PLAY ) );
1217 	mpRBFromStart = new RadioButton( this, SdResId( RB_FROM_START ) );
1218 	mpRBFromLast = new RadioButton( this, SdResId( RB_FROM_LAST ) );
1219 	mpRBFromTime = new RadioButton( this, SdResId( RB_FROM_TIME ) );
1220 	mpMFStartTime = new MetricField( this, SdResId( MF_START_TIME ) );
1221 	mpFLStop = new FixedLine( this, SdResId( FL_STOP ) );
1222 	mpRBStopOnClick = new RadioButton( this, SdResId( RB_STOP_ON_CLICK ) );
1223 	mpRBStopOnNextSlide = new RadioButton( this, SdResId( RB_STOP_ON_NEXT_SLIDE ) );
1224 	mpRBStopAfterSlides = new RadioButton( this, SdResId( RB_STOP_AFTER_N_SLIDES ) );
1225 	mpMFStopAfterSlides = new MetricField( this, SdResId( MF_STOP_AFTER_SLIDES ) );
1226 */
1227 	mpFLEnhancements = new FixedLine( this, SdResId( FL_ENHANCEMENTS ) );
1228 	mpFTSound = new FixedText( this, SdResId( FT_SOUND ) );
1229 	mpLBSound = new ListBox( this, SdResId( LB_SOUND ) );
1230 	mpPBSoundPreview = new PushButton( this, SdResId( PB_SOUND_PREVIEW ) );
1231 	mpFTAfterEffect = new FixedText( this, SdResId( FT_AFTER_EFFECT ) );
1232 	mpLBAfterEffect = new ListBox( this, SdResId( LB_AFTER_EFFECT ) );
1233 	mpFTDimColor = new FixedText( this, SdResId( FT_DIMCOLOR ) );
1234 	mpCLBDimColor = new ColorListBox( this, SdResId( CLB_DIMCOLOR ) );
1235 	mpFTTextAnim = new FixedText( this, SdResId( FT_TEXT_ANIM ) );
1236 	mpLBTextAnim = new ListBox( this, SdResId( LB_TEXT_ANIM ) );
1237 	mpMFTextDelay = new MetricField( this, SdResId( MF_TEXT_DELAY ) );
1238 	mpFTTextDelay = new FixedText( this, SdResId( FT_TEXT_DELAY ) );
1239 
1240 	FreeResource();
1241 
1242 	// fill the soundbox
1243 	fillSoundListBox();
1244 
1245 	mpLBSound->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) );
1246 
1247 	mpPBSoundPreview->SetClickHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) );
1248 	mpPBSoundPreview->SetSymbol( SYMBOL_PLAY );
1249 
1250 	// fill the color box
1251 	SfxObjectShell* pDocSh = SfxObjectShell::Current();
1252 	DBG_ASSERT( pDocSh, "DocShell not found!" );
1253 	XColorTable* pColorTable = NULL;
1254 	bool bKillTable = false;
1255 	const SfxPoolItem* pItem = NULL;
1256 
1257 	if ( pDocSh && ( (pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) != 0 ) )
1258 		pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
1259 
1260 	if ( !pColorTable )
1261 	{
1262 		pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
1263 		bKillTable = sal_True;
1264 	}
1265 
1266     mpCLBDimColor->SetUpdateMode( sal_False );
1267 
1268     for ( long i = 0; i < pColorTable->Count(); i++ )
1269 	{
1270 		XColorEntry* pEntry = pColorTable->GetColor(i);
1271         mpCLBDimColor->InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1272 	}
1273 
1274     mpCLBDimColor->SetUpdateMode( sal_True );
1275 
1276 	if ( bKillTable )
1277 		delete pColorTable;
1278 
1279 	//
1280 	// init settings controls
1281 	//
1282 
1283 	int nOffsetY = 0;
1284 	int nOffsetX = 0;
1285 
1286 	Size aSpace( LogicToPixel( Size( 3, 3 ), MAP_APPFONT ) );
1287 
1288 	// only show settings if all selected effects have the same preset-id
1289 	if( pSet->getPropertyState( nHandlePresetId ) != STLPropertyState_AMBIGUOUS )
1290 	{
1291 		OUString aPresetId;
1292 		pSet->getPropertyValue( nHandlePresetId ) >>= aPresetId;
1293 
1294 		//
1295 		// property 1
1296 		//
1297 
1298 		if( pSet->getPropertyState( nHandleProperty1Type ) != STLPropertyState_AMBIGUOUS )
1299 		{
1300 			sal_Int32 nType = 0;
1301 			pSet->getPropertyValue( nHandleProperty1Type ) >>= nType;
1302 
1303 			if( nType != nPropertyTypeNone )
1304 			{
1305 				// set ui name for property at fixed text
1306 				OUString aPropertyName( getPropertyName( nType ) );
1307 
1308 				if( aPropertyName.getLength() )
1309 				{
1310 					mpFTProperty1->Show();
1311 					mpLBProperty1->Show();
1312 
1313 					nOffsetY += mpLBProperty1->GetSizePixel().Height() + aSpace.Height();
1314 
1315 					mpFTProperty1->SetText( aPropertyName );
1316 				}
1317 
1318 				// get property value
1319 				const Any aValue( pSet->getPropertyValue( nHandleProperty1Value ) );
1320 
1321 				Link aModifyLink;
1322 				// create property sub control
1323 				mpLBProperty1->setSubControl( PropertySubControl::create( nType, this, aValue, aPresetId, aModifyLink ));
1324 			}
1325 		}
1326 
1327 		mpFTProperty1->Enable( mpLBProperty1->IsEnabled() );
1328 
1329 		//
1330 		// accelerate & deccelerate
1331 		//
1332 
1333 		if( pSet->getPropertyState( nHandleAccelerate ) == STLPropertyState_DIRECT )
1334 		{
1335 			mpCBSmoothStart->Show();
1336 			mpCBSmoothEnd->Show();
1337 
1338 			move_down( mpCBSmoothStart, nOffsetX, nOffsetY );
1339 			move_down( mpCBSmoothEnd, nOffsetX, nOffsetY );
1340 
1341 			nOffsetY += mpCBSmoothStart->GetSizePixel().Height() + aSpace.Height();
1342 
1343 			double fTemp = 0.0;
1344 			pSet->getPropertyValue( nHandleAccelerate ) >>= fTemp;
1345 			mpCBSmoothStart->Check( fTemp > 0.0 );
1346 
1347 			pSet->getPropertyValue( nHandleDecelerate ) >>= fTemp;
1348 			mpCBSmoothEnd->Check( fTemp > 0.0 );
1349 		}
1350 
1351 		//
1352 		// auto reverse
1353 		//
1354 
1355 
1356 		if( nOffsetY )
1357 		{
1358 			nOffsetY += mpFLSettings->GetSizePixel().Height() + aSpace.Height();
1359 			mpFLSettings->Show();
1360 
1361 			mpFLEnhancements->Show();
1362 			move_down( mpFLEnhancements, nOffsetX, nOffsetY );
1363 
1364 			nOffsetY += mpFLEnhancements->GetSizePixel().Height() + aSpace.Height();
1365 
1366 			nOffsetX = 2* aSpace.Width();
1367 		}
1368 	}
1369 
1370 	if( (nOffsetY != 0) || (nOffsetX != 0) )
1371 	{
1372 		move_down( mpFTSound, nOffsetX, nOffsetY );
1373 		move_down( mpLBSound, nOffsetX, nOffsetY );
1374 		move_down( mpPBSoundPreview, nOffsetX, nOffsetY );
1375 		move_down( mpFTAfterEffect, nOffsetX, nOffsetY );
1376 		move_down( mpLBAfterEffect, nOffsetX, nOffsetY );
1377 		move_down( mpFTDimColor, nOffsetX, nOffsetY );
1378 		move_down( mpCLBDimColor, nOffsetX, nOffsetY );
1379 		move_down( mpFTTextAnim, nOffsetX, nOffsetY );
1380 		move_down( mpLBTextAnim, nOffsetX, nOffsetY );
1381 		move_down( mpMFTextDelay, nOffsetX, nOffsetY );
1382 		move_down( mpFTTextDelay, nOffsetX, nOffsetY );
1383 	}
1384 
1385 	//
1386 	// init after effect controls
1387 	//
1388 
1389     mpLBAfterEffect->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) );
1390     mpLBTextAnim->SetSelectHdl( LINK( this, CustomAnimationEffectTabPage, implSelectHdl ) );
1391 
1392 	if( (pSet->getPropertyState( nHandleHasAfterEffect ) != STLPropertyState_AMBIGUOUS) &&
1393 		(pSet->getPropertyState( nHandleAfterEffectOnNextEffect ) != STLPropertyState_AMBIGUOUS) &&
1394 		(pSet->getPropertyState( nHandleDimColor ) != STLPropertyState_AMBIGUOUS))
1395 	{
1396 		sal_Bool bHasAfterEffect = sal_False;
1397 		pSet->getPropertyValue( nHandleHasAfterEffect ) >>= bHasAfterEffect;
1398 
1399 		sal_uInt16 nPos = 0;
1400 		if( bHasAfterEffect )
1401 		{
1402 			nPos++;
1403 
1404 			sal_Bool bAfterEffectOnNextClick = sal_False;
1405 			pSet->getPropertyValue( nHandleAfterEffectOnNextEffect ) >>= bAfterEffectOnNextClick;
1406 			Any aDimColor( pSet->getPropertyValue( nHandleDimColor ) );
1407 
1408 			if( aDimColor.hasValue() )
1409 			{
1410 				sal_Int32 nColor = 0;
1411 				aDimColor >>= nColor;
1412 				Color aColor( nColor );
1413 	            sal_uInt16 nColorPos = mpCLBDimColor->GetEntryPos( aColor );
1414 				if ( LISTBOX_ENTRY_NOTFOUND != nColorPos )
1415 					mpCLBDimColor->SelectEntryPos( nColorPos );
1416 				else
1417                     mpCLBDimColor->SelectEntryPos(
1418                         mpCLBDimColor->InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
1419 			}
1420 			else
1421 			{
1422 				nPos++;
1423 				if( bAfterEffectOnNextClick )
1424 					nPos++;
1425 			}
1426 		}
1427 
1428 		mpLBAfterEffect->SelectEntryPos( nPos );
1429 	}
1430 
1431 	if( pSet->getPropertyState( nHandleHasText ) != STLPropertyState_AMBIGUOUS )
1432 		pSet->getPropertyValue( nHandleHasText ) >>= mbHasText;
1433 
1434 	if( mbHasText )
1435 	{
1436 		if( pSet->getPropertyState( nHandleIterateType ) != STLPropertyState_AMBIGUOUS)
1437 		{
1438 			sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND;
1439 
1440 			sal_Int32 nIterateType = 0;
1441 			pSet->getPropertyValue( nHandleIterateType ) >>= nIterateType;
1442 			switch( nIterateType )
1443 			{
1444 			case TextAnimationType::BY_PARAGRAPH:	nPos = 0; break;
1445 			case TextAnimationType::BY_WORD:		nPos = 1; break;
1446 			case TextAnimationType::BY_LETTER:		nPos = 2; break;
1447 			}
1448 
1449 			mpLBTextAnim->SelectEntryPos( nPos );
1450 		}
1451 
1452 		if( pSet->getPropertyState( nHandleIterateInterval ) )
1453 		{
1454 			double fIterateInterval = 0.0;
1455 			pSet->getPropertyValue( nHandleIterateInterval ) >>= fIterateInterval;
1456 			mpMFTextDelay->SetValue( (long)(fIterateInterval*10) );
1457 		}
1458 	}
1459 	else
1460 	{
1461 		mpFTTextAnim->Enable( sal_False );
1462 		mpLBTextAnim->Enable( sal_False );
1463 		mpMFTextDelay->Enable( sal_False );
1464 		mpFTTextDelay->Enable( sal_False );
1465 
1466 	}
1467 
1468 	if( pSet->getPropertyState( nHandleSoundURL ) != STLPropertyState_AMBIGUOUS )
1469 	{
1470 		sal_uInt16 nPos = 0;
1471 
1472 		const Any aValue( pSet->getPropertyValue( nHandleSoundURL ) );
1473 
1474 		if( aValue.getValueType() == ::getCppuType((const sal_Bool*)0) )
1475 		{
1476 			nPos = 1;
1477 		}
1478 		else
1479 		{
1480 			OUString aSoundURL;
1481 			aValue >>= aSoundURL;
1482 
1483 			if( aSoundURL.getLength() )
1484 			{
1485 				const String aTmp( aSoundURL );
1486 
1487 				sal_uLong i;
1488 				for( i = 0; i < maSoundList.Count(); i++ )
1489 				{
1490 					String* pString = (String*)maSoundList.GetObject( i );
1491 					if( *pString == aTmp )
1492 					{
1493 						nPos = (sal_uInt16)i+2;
1494 						break;
1495 					}
1496 				}
1497 
1498 				if( nPos == 0 )
1499 				{
1500 					nPos = (sal_uInt16)maSoundList.Count()+2;
1501 					maSoundList.Insert( new String( aTmp ), LIST_APPEND );
1502 					INetURLObject aURL( aTmp );
1503 					nPos = mpLBSound->InsertEntry( aURL.GetBase(), nPos );
1504 				}
1505 			}
1506 		}
1507 
1508 		if( nPos != LISTBOX_ENTRY_NOTFOUND )
1509 			mpLBSound->SelectEntryPos( nPos );
1510 	}
1511 
1512 	updateControlStates();
1513 
1514 	Size aSize( GetSizePixel() );
1515 	aSize.Height() += mpMFTextDelay->GetPosPixel().X() + GetSizePixel().Height() + aSpace.Height();
1516 	SetSizePixel( aSize );
1517 }
1518 
1519 CustomAnimationEffectTabPage::~CustomAnimationEffectTabPage()
1520 {
1521 	clearSoundListBox();
1522 
1523 	delete mpFLSettings;
1524 	delete mpFTProperty1;
1525 	delete mpLBProperty1;
1526 	delete mpFTProperty2;
1527 	delete mpLBProperty2;
1528 	delete mpCBSmoothStart;
1529 	delete mpCBSmoothEnd;
1530 	delete mpCBAutoRestart;
1531 
1532 	delete mpFLEnhancements;
1533 	delete mpFTSound;
1534 	delete mpLBSound;
1535 	delete mpPBSoundPreview;
1536 	delete mpFTAfterEffect;
1537 	delete mpLBAfterEffect;
1538 	delete mpFTDimColor;
1539 	delete mpCLBDimColor;
1540 	delete mpFTTextAnim;
1541 	delete mpLBTextAnim;
1542 	delete mpMFTextDelay;
1543 	delete mpFTTextDelay;
1544 }
1545 
1546 void CustomAnimationEffectTabPage::updateControlStates()
1547 {
1548 	sal_uInt16 nPos = mpLBAfterEffect->GetSelectEntryPos();
1549 	mpCLBDimColor->Enable( nPos == 1 );
1550 	mpFTDimColor->Enable( nPos == 1 );
1551 
1552 	if( mbHasText )
1553 	{
1554 		nPos = mpLBTextAnim->GetSelectEntryPos();
1555 		mpMFTextDelay->Enable( nPos != 0 );
1556 		mpFTTextDelay->Enable( nPos != 0 );
1557 	}
1558 
1559 	nPos = mpLBSound->GetSelectEntryPos();
1560 	mpPBSoundPreview->Enable( nPos >= 2 );
1561 }
1562 
1563 IMPL_LINK( CustomAnimationEffectTabPage, implSelectHdl, Control*, pControl )
1564 {
1565 	if( pControl == mpLBAfterEffect )
1566 	{
1567 		sal_uInt16 nPos = static_cast<ListBox*>( mpLBAfterEffect )->GetSelectEntryPos();
1568 		if( nPos == 1 )
1569 		{
1570 			if( mpCLBDimColor->GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND )
1571 				mpCLBDimColor->SelectEntryPos(0);
1572 		}
1573 	}
1574 	else if( pControl == mpLBTextAnim )
1575 	{
1576 		if( mpMFTextDelay->GetValue() == 0 )
1577 			mpMFTextDelay->SetValue( 100 );
1578 	}
1579 	else if( pControl == mpLBSound )
1580 	{
1581 		sal_uInt16 nPos = mpLBSound->GetSelectEntryPos();
1582 		if( nPos == (mpLBSound->GetEntryCount() - 1) )
1583 		{
1584 			openSoundFileDialog();
1585 		}
1586 	}
1587 	else if( pControl == mpPBSoundPreview )
1588 	{
1589 		onSoundPreview();
1590 	}
1591 
1592 	updateControlStates();
1593 	return 0;
1594 }
1595 
1596 void CustomAnimationEffectTabPage::update( STLPropertySet* pSet )
1597 {
1598 	if( mpLBProperty1->getSubControl() )
1599 	{
1600 		Any aNewValue( mpLBProperty1->getSubControl()->getValue() );
1601 		Any aOldValue;
1602 		if( mpSet->getPropertyState( nHandleProperty1Value ) != STLPropertyState_AMBIGUOUS)
1603 			aOldValue = mpSet->getPropertyValue( nHandleProperty1Value );
1604 
1605 		if( aOldValue != aNewValue )
1606 			pSet->setPropertyValue( nHandleProperty1Value, aNewValue );
1607 	}
1608 
1609 	if( mpLBProperty2->getSubControl() )
1610 	{
1611 		Any aNewValue( mpLBProperty2->getSubControl()->getValue() );
1612 		Any aOldValue;
1613 		if( mpSet->getPropertyState( nHandleProperty2Value ) != STLPropertyState_AMBIGUOUS)
1614 			aOldValue = mpSet->getPropertyValue( nHandleProperty2Value );
1615 
1616 		if( aOldValue != aNewValue )
1617 			pSet->setPropertyValue( nHandleProperty2Value, aNewValue );
1618 	}
1619 
1620 	if( mpCBSmoothStart->IsVisible() )
1621 	{
1622 		// set selected value for accelerate if different then in original set
1623 
1624 		double fTemp = mpCBSmoothStart->IsChecked() ? 0.5 : 0.0;
1625 
1626 		double fOldTemp = 0.0;
1627 		if(mpSet->getPropertyState( nHandleAccelerate ) != STLPropertyState_AMBIGUOUS)
1628 			mpSet->getPropertyValue( nHandleAccelerate ) >>= fOldTemp;
1629 		else
1630 			fOldTemp = -2.0;
1631 
1632 		if( fOldTemp != fTemp )
1633 			pSet->setPropertyValue( nHandleAccelerate, makeAny( fTemp ) );
1634 
1635 		// set selected value for decelerate if different then in original set
1636 		fTemp = mpCBSmoothEnd->IsChecked() ? 0.5 : 0.0;
1637 
1638 		if(mpSet->getPropertyState( nHandleDecelerate ) != STLPropertyState_AMBIGUOUS)
1639 			mpSet->getPropertyValue( nHandleDecelerate ) >>= fOldTemp;
1640 		else
1641 			fOldTemp = -2.0;
1642 
1643 		if( fOldTemp != fTemp )
1644 			pSet->setPropertyValue( nHandleDecelerate, makeAny( fTemp ) );
1645 	}
1646 
1647 	sal_uInt16 nPos = mpLBAfterEffect->GetSelectEntryPos();
1648 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
1649 	{
1650 		sal_Bool bAfterEffect = nPos != 0;
1651 
1652 		sal_Bool bOldAfterEffect = sal_False;
1653 
1654 		if(mpSet->getPropertyState( nHandleHasAfterEffect ) != STLPropertyState_AMBIGUOUS)
1655 			mpSet->getPropertyValue( nHandleHasAfterEffect ) >>= bOldAfterEffect;
1656 		else
1657 			bOldAfterEffect = !bAfterEffect;
1658 
1659 		if( bOldAfterEffect != bAfterEffect )
1660 			pSet->setPropertyValue( nHandleHasAfterEffect, makeAny( bAfterEffect ) );
1661 
1662 		Any aDimColor;
1663 		if( nPos == 1 )
1664 		{
1665 			Color aSelectedColor;
1666 			if ( mpCLBDimColor->GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND )
1667 				aSelectedColor = mpCLBDimColor->GetSelectEntryColor();
1668 
1669 			aDimColor = makeAny( makeAny( (sal_Int32)aSelectedColor.GetRGBColor() ) );
1670 		}
1671 
1672 		if( (mpSet->getPropertyState( nHandleDimColor ) == STLPropertyState_AMBIGUOUS) ||
1673 			(mpSet->getPropertyValue( nHandleDimColor ) != aDimColor) )
1674 			pSet->setPropertyValue( nHandleDimColor, makeAny( aDimColor ) );
1675 
1676 		sal_Bool bAfterEffectOnNextEffect = nPos != 2 ? sal_True : sal_False;
1677 		sal_Bool bOldAfterEffectOnNextEffect = !bAfterEffectOnNextEffect;
1678 
1679 		if( mpSet->getPropertyState( nHandleAfterEffectOnNextEffect ) != STLPropertyState_AMBIGUOUS)
1680 			mpSet->getPropertyValue( nHandleAfterEffectOnNextEffect ) >>= bOldAfterEffectOnNextEffect;
1681 
1682 		if( bAfterEffectOnNextEffect != bOldAfterEffectOnNextEffect )
1683 			pSet->setPropertyValue( nHandleAfterEffectOnNextEffect, makeAny( bAfterEffectOnNextEffect ) );
1684 	}
1685 
1686 	// ---
1687 
1688 	nPos = mpLBTextAnim->GetSelectEntryPos();
1689 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
1690 	{
1691 		sal_Int16 nIterateType;
1692 
1693 		switch( nPos )
1694 		{
1695 		case 1: nIterateType = TextAnimationType::BY_WORD; break;
1696 		case 2: nIterateType = TextAnimationType::BY_LETTER; break;
1697 		default:
1698 			nIterateType = TextAnimationType::BY_PARAGRAPH;
1699 		}
1700 
1701 		sal_Int16 nOldIterateType = nIterateType-1;
1702 
1703 		if(mpSet->getPropertyState( nHandleIterateType ) != STLPropertyState_AMBIGUOUS)
1704 			mpSet->getPropertyValue( nHandleIterateType ) >>= nOldIterateType;
1705 
1706 		if( nIterateType != nOldIterateType )
1707 			pSet->setPropertyValue( nHandleIterateType, makeAny( nIterateType ) );
1708 	}
1709 
1710 	// ---
1711 
1712 	{
1713 		double fIterateInterval = static_cast< double >( mpMFTextDelay->GetValue() ) / 10;
1714 		double fOldIterateInterval = -1.0;
1715 
1716 		if( mpSet->getPropertyState( nHandleIterateInterval ) != STLPropertyState_AMBIGUOUS )
1717 			mpSet->getPropertyValue( nHandleIterateInterval ) >>= fOldIterateInterval;
1718 
1719 		if( fIterateInterval != fOldIterateInterval )
1720 			pSet->setPropertyValue( nHandleIterateInterval, makeAny( fIterateInterval ) );
1721 	}
1722 
1723 	nPos = mpLBSound->GetSelectEntryPos();
1724 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
1725 	{
1726 		Any aNewSoundURL, aOldSoundURL( makeAny( (sal_Int32) 0 ) );
1727 
1728 		if( nPos == 0 )
1729 		{
1730 			// 0 means no sound, so leave any empty
1731 		}
1732 		else if( nPos == 1 )
1733 		{
1734 			// this means stop sound
1735 			aNewSoundURL = makeAny( (sal_Bool)sal_True );
1736 		}
1737 		else
1738 		{
1739 			OUString aSoundURL( *(String*)maSoundList.GetObject( nPos-2 ) );
1740 			aNewSoundURL = makeAny( aSoundURL );
1741 		}
1742 
1743 		if( mpSet->getPropertyState( nHandleSoundURL ) != STLPropertyState_AMBIGUOUS )
1744 			mpSet->getPropertyValue( nHandleSoundURL  ) >>= aOldSoundURL;
1745 
1746 		if( aNewSoundURL != aOldSoundURL )
1747 			pSet->setPropertyValue( nHandleSoundURL, aNewSoundURL );
1748 	}
1749 }
1750 
1751 void CustomAnimationEffectTabPage::fillSoundListBox()
1752 {
1753 	GalleryExplorer::FillObjList( GALLERY_THEME_SOUNDS, maSoundList );
1754 	GalleryExplorer::FillObjList( GALLERY_THEME_USERSOUNDS, maSoundList );
1755 
1756 	mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_NO_SOUND ) ) );
1757 	mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_STOP_PREVIOUS_SOUND ) ) );
1758 	for( sal_uLong i = 0; i < maSoundList.Count(); i++ )
1759 	{
1760 		String* pString = (String*)maSoundList.GetObject( i );
1761 		INetURLObject aURL( *pString );
1762 		mpLBSound->InsertEntry( aURL.GetBase() );
1763 	}
1764 	mpLBSound->InsertEntry( String( SdResId( STR_CUSTOMANIMATION_BROWSE_SOUND ) ) );
1765 }
1766 
1767 void CustomAnimationEffectTabPage::clearSoundListBox()
1768 {
1769 	const sal_uInt32 nCount = maSoundList.Count();
1770 	sal_uInt32 i;
1771 	for( i = 0; i < nCount; i++ )
1772 		delete (String*)maSoundList.GetObject( i );
1773 	maSoundList.Clear();
1774 
1775 	mpLBSound->Clear();
1776 }
1777 
1778 sal_Int32 CustomAnimationEffectTabPage::getSoundObject( const String& rStr )
1779 {
1780 	String aStrIn( rStr );
1781 	aStrIn.ToLowerAscii();
1782 
1783 	sal_uInt32 i;
1784 	const sal_uInt32 nCount = maSoundList.Count();
1785 	for( i = 0; i < nCount; i++ )
1786 	{
1787 		String aTmpStr( *(String*)maSoundList.GetObject( i ) );
1788 		aTmpStr.ToLowerAscii();
1789 
1790 		if( aTmpStr == aStrIn )
1791 			return i+2;
1792 	}
1793 
1794 	return -1;
1795 }
1796 
1797 void CustomAnimationEffectTabPage::openSoundFileDialog()
1798 {
1799 	SdOpenSoundFileDialog	aFileDialog;
1800 
1801 	String aFile( SvtPathOptions().GetGraphicPath() );
1802 	aFileDialog.SetPath( aFile );
1803 
1804 	bool bValidSoundFile = false;
1805 	bool bQuitLoop = false;
1806 	long nPos = 0;
1807 
1808 	while( !bQuitLoop && (aFileDialog.Execute() == ERRCODE_NONE) )
1809 	{
1810 		aFile = aFileDialog.GetPath();
1811 		nPos = getSoundObject( aFile );
1812 
1813 		if( nPos < 0 ) // not in Soundliste
1814 		{
1815 			// try to insert in Gallery
1816 			if( GalleryExplorer::InsertURL( GALLERY_THEME_USERSOUNDS, aFile, SGA_FORMAT_SOUND ) )
1817 			{
1818 				clearSoundListBox();
1819 				fillSoundListBox();
1820 
1821 				nPos = getSoundObject( aFile );
1822 				DBG_ASSERT( nPos >= 0, "sd::CustomAnimationEffectTabPage::openSoundFileDialog(), Recently inserted sound not in list!" );
1823 
1824 				bValidSoundFile=true;
1825 				bQuitLoop=true;
1826 			}
1827 			else
1828 			{
1829 				String aStrWarning(SdResId(STR_WARNING_NOSOUNDFILE));
1830 				String aStr; aStr += sal_Unicode('%');
1831 				aStrWarning.SearchAndReplace( aStr , aFile );
1832 				WarningBox aWarningBox( NULL, WB_3DLOOK | WB_RETRY_CANCEL, aStrWarning );
1833 				aWarningBox.SetModalInputMode (sal_True);
1834 				bQuitLoop = aWarningBox.Execute()==RET_RETRY ? sal_False : sal_True;
1835 
1836 				bValidSoundFile=false;
1837 			}
1838 		}
1839 		else
1840 		{
1841 			bValidSoundFile=true;
1842 			bQuitLoop=true;
1843 		}
1844 	}
1845 
1846 	if( !bValidSoundFile )
1847 		nPos = 0;
1848 
1849 	mpLBSound->SelectEntryPos( (sal_uInt16) nPos );
1850 }
1851 
1852 void CustomAnimationEffectTabPage::onSoundPreview()
1853 {
1854 	const sal_uInt16 nPos = mpLBSound->GetSelectEntryPos();
1855 
1856 	if( nPos >= 2 ) try
1857     {
1858 		const OUString aSoundURL( *(String*)maSoundList.GetObject( nPos-2 ) );
1859                 mxPlayer.set( avmedia::MediaWindow::createPlayer( aSoundURL ), uno::UNO_QUERY_THROW );
1860 		mxPlayer->start();
1861 	}
1862     catch( uno::Exception& e )
1863     {
1864 		(void)e;
1865         DBG_ERROR("CustomAnimationEffectTabPage::onSoundPreview(), exception caught!" );
1866     }
1867 }
1868 
1869 class CustomAnimationDurationTabPage : public TabPage
1870 {
1871 public:
1872 	CustomAnimationDurationTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet );
1873 	~CustomAnimationDurationTabPage();
1874 
1875 	void update( STLPropertySet* pSet );
1876 
1877 	DECL_LINK( implControlHdl, Control* );
1878 
1879 private:
1880 	const STLPropertySet* mpSet;
1881 
1882 	boost::shared_ptr< FixedText > mpFTStart;
1883 	boost::shared_ptr< ListBox > mpLBStart;
1884 	boost::shared_ptr< FixedText > mpFTStartDelay;
1885 	boost::shared_ptr< MetricField > mpMFStartDelay;
1886 	boost::shared_ptr< FixedText > mpFTDuration;
1887 	boost::shared_ptr< ComboBox > mpCBDuration;
1888 	boost::shared_ptr< FixedText > mpFTRepeat;
1889 	boost::shared_ptr< ComboBox > mpCBRepeat;
1890 	boost::shared_ptr< CheckBox > mpCBXRewind;
1891 	boost::shared_ptr< FixedLine > mpFLTrigger;
1892 	boost::shared_ptr< RadioButton > mpRBClickSequence;
1893 	boost::shared_ptr< RadioButton > mpRBInteractive;
1894 	boost::shared_ptr< ListBox > mpLBTrigger;
1895 };
1896 
1897 CustomAnimationDurationTabPage::CustomAnimationDurationTabPage(Window* pParent, const ResId& rResId, const STLPropertySet* pSet)
1898 : TabPage( pParent, rResId ), mpSet( pSet )
1899 {
1900 	mpFTStart.reset( new FixedText( this, SdResId( FT_START ) ) );
1901 	mpLBStart.reset( new ListBox( this, SdResId( LB_START ) ) );
1902 	mpFTStartDelay.reset( new FixedText( this, SdResId( FT_START_DELAY ) ) );
1903 	mpMFStartDelay.reset( new MetricField( this, SdResId( MF_START_DELAY ) ) );
1904 	mpFTDuration.reset( new FixedText( this, SdResId( FT_DURATION ) ) );
1905 	mpCBDuration.reset( new ComboBox( this, SdResId( CB_DURATION ) ) );
1906 	mpFTRepeat.reset( new FixedText( this, SdResId( FT_REPEAT ) ) );
1907 	mpCBRepeat.reset( new ComboBox( this, SdResId( CB_REPEAT ) ) );
1908 	mpCBXRewind.reset( new CheckBox( this, SdResId( CBX_REWIND ) ) );
1909 	mpFLTrigger.reset( new FixedLine( this, SdResId( FL_TRIGGER ) ) );
1910 	mpRBClickSequence.reset( new RadioButton( this, SdResId( RB_CLICKSEQUENCE ) ) );
1911 	mpRBInteractive.reset( new RadioButton( this, SdResId( RB_INTERACTIVE ) ) );
1912 	mpLBTrigger.reset( new ListBox( this, SdResId( LB_TRIGGER ) ) );
1913 
1914 	fillRepeatComboBox( mpCBRepeat.get() );
1915 	fillDurationComboBox( mpCBDuration.get() );
1916 
1917 	FreeResource();
1918 
1919     mpRBClickSequence->SetClickHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) );
1920     mpRBClickSequence->SetClickHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) );
1921     mpLBTrigger->SetSelectHdl( LINK( this, CustomAnimationDurationTabPage, implControlHdl ) );
1922 
1923 	if( pSet->getPropertyState( nHandleStart ) != STLPropertyState_AMBIGUOUS )
1924 	{
1925 		sal_Int16 nStart = 0;
1926 		pSet->getPropertyValue( nHandleStart ) >>= nStart;
1927 		sal_uInt16 nPos = 0;
1928 		switch( nStart )
1929 		{
1930 			case EffectNodeType::WITH_PREVIOUS:		nPos = 1; break;
1931 			case EffectNodeType::AFTER_PREVIOUS:	nPos = 2; break;
1932 		}
1933 		mpLBStart->SelectEntryPos( nPos );
1934 	}
1935 
1936 	if( pSet->getPropertyState( nHandleBegin ) != STLPropertyState_AMBIGUOUS )
1937 	{
1938 		double fBegin = 0.0;
1939 		pSet->getPropertyValue( nHandleBegin ) >>= fBegin;
1940 		mpMFStartDelay->SetValue( (long)(fBegin*10) );
1941 	}
1942 
1943 	if( pSet->getPropertyState( nHandleDuration ) != STLPropertyState_AMBIGUOUS )
1944 	{
1945 		double fDuration = 0.0;
1946 		pSet->getPropertyValue( nHandleDuration ) >>= fDuration;
1947 
1948 		if( fDuration == 0.001 )
1949 		{
1950 			mpFTDuration->Disable();
1951 			mpCBDuration->Disable();
1952 			mpFTRepeat->Disable();
1953 			mpCBRepeat->Disable();
1954 			mpCBXRewind->Disable();
1955 		}
1956 		else
1957 		{
1958 			sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND;
1959 
1960 			if( fDuration == 5.0 )
1961 				nPos = 0;
1962 			else if( fDuration == 3.0 )
1963 				nPos = 1;
1964 			else if( fDuration == 2.0 )
1965 				nPos = 2;
1966 			else if( fDuration == 1.0 )
1967 				nPos = 3;
1968 			else if( fDuration == 0.5 )
1969 				nPos = 4;
1970 
1971 			if( nPos != LISTBOX_ENTRY_NOTFOUND )
1972 				mpCBDuration->SelectEntryPos( nPos );
1973 			else
1974 				mpCBDuration->SetText( String::CreateFromDouble( fDuration ) );
1975 		}
1976 	}
1977 
1978 	if( pSet->getPropertyState( nHandleRepeat ) != STLPropertyState_AMBIGUOUS )
1979 	{
1980 		Any aRepeatCount( pSet->getPropertyValue( nHandleRepeat ) );
1981 		if( (aRepeatCount.getValueType() == ::getCppuType((const double*)0)) || !aRepeatCount.hasValue() )
1982 		{
1983 			double fRepeat = 0.0;
1984 			if( aRepeatCount.hasValue() )
1985 				aRepeatCount >>= fRepeat;
1986 
1987 			sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND;
1988 
1989 			if( fRepeat == 0 )
1990 				nPos = 0;
1991 			else if( fRepeat == 2.0 )
1992 				nPos = 1;
1993 			else if( fRepeat == 3.0 )
1994 				nPos = 2;
1995 			else if( fRepeat == 4.0 )
1996 				nPos = 3;
1997 			else if( fRepeat == 5.0 )
1998 				nPos = 4;
1999 			else if( fRepeat == 10.0 )
2000 				nPos = 5;
2001 
2002 			if( nPos != LISTBOX_ENTRY_NOTFOUND )
2003 				mpCBRepeat->SelectEntryPos( nPos );
2004 			else
2005 				mpCBRepeat->SetText( String::CreateFromDouble( fRepeat ) );
2006 		}
2007 		else if( aRepeatCount.getValueType() == ::getCppuType((const Timing*)0) )
2008 		{
2009 			Any aEnd;
2010 			if( pSet->getPropertyState( nHandleEnd ) != STLPropertyState_AMBIGUOUS )
2011 				aEnd = pSet->getPropertyValue( nHandleEnd );
2012 
2013 			mpCBRepeat->SelectEntryPos( aEnd.hasValue() ? 6 : 7 );
2014 		}
2015 	}
2016 
2017 	if( pSet->getPropertyState( nHandleRewind ) != STLPropertyState_AMBIGUOUS )
2018 	{
2019 		sal_Int16 nFill = 0;
2020 		if( pSet->getPropertyValue( nHandleRewind ) >>= nFill )
2021 		{
2022 			mpCBXRewind->Check( (nFill == AnimationFill::REMOVE) ? sal_True : sal_False );
2023 		}
2024 		else
2025 		{
2026 			mpCBXRewind->SetState( STATE_DONTKNOW );
2027 		}
2028 	}
2029 
2030 	Reference< XShape > xTrigger;
2031 
2032 	if( pSet->getPropertyState( nHandleTrigger ) != STLPropertyState_AMBIGUOUS )
2033 	{
2034 		pSet->getPropertyValue( nHandleTrigger ) >>= xTrigger;
2035 
2036 		mpRBInteractive->Check( xTrigger.is() );
2037 		mpRBClickSequence->Check( !xTrigger.is() );
2038 	}
2039 
2040 	Reference< XDrawPage > xCurrentPage;
2041 	pSet->getPropertyValue( nHandleCurrentPage ) >>= xCurrentPage;
2042 	if( xCurrentPage.is() )
2043 	{
2044 		const OUString aStrIsEmptyPresObj( RTL_CONSTASCII_USTRINGPARAM( "IsEmptyPresentationObject" ) );
2045 
2046 		sal_Int32 nShape, nCount = xCurrentPage->getCount();
2047 		for( nShape = 0; nShape < nCount; nShape++ )
2048 		{
2049 			Reference< XShape > xShape( xCurrentPage->getByIndex( nShape ), UNO_QUERY );
2050 
2051 			if( !xShape.is() )
2052 				continue;
2053 
2054 			Reference< XPropertySet > xSet( xShape, UNO_QUERY );
2055 			if( xSet.is() && xSet->getPropertySetInfo()->hasPropertyByName( aStrIsEmptyPresObj ) )
2056 			{
2057 				sal_Bool bIsEmpty = sal_False;
2058 				xSet->getPropertyValue( aStrIsEmptyPresObj ) >>= bIsEmpty;
2059 				if( bIsEmpty )
2060 					continue;
2061 			}
2062 
2063 			String aDescription( getShapeDescription( xShape, true ) );
2064 			sal_uInt16 nPos = mpLBTrigger->InsertEntry( aDescription );
2065 
2066 			mpLBTrigger->SetEntryData( nPos, (void*)nShape );
2067 			if( xShape == xTrigger )
2068 				mpLBTrigger->SelectEntryPos( nPos );
2069 		}
2070 	}
2071 }
2072 
2073 CustomAnimationDurationTabPage::~CustomAnimationDurationTabPage()
2074 {
2075 }
2076 
2077 IMPL_LINK( CustomAnimationDurationTabPage, implControlHdl, Control*, pControl )
2078 {
2079 	if( pControl == mpLBTrigger.get() )
2080 	{
2081 		mpRBClickSequence->Check( sal_False );
2082 		mpRBInteractive->Check( sal_True );
2083 	}
2084 
2085 	return 0;
2086 }
2087 
2088 void CustomAnimationDurationTabPage::update( STLPropertySet* pSet )
2089 {
2090 	sal_uInt16 nPos = mpLBStart->GetSelectEntryPos();
2091 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
2092 	{
2093 		sal_Int16 nStart;
2094 		sal_Int16 nOldStart = -1;
2095 
2096 		switch( nPos )
2097 		{
2098 		case 1: nStart = EffectNodeType::WITH_PREVIOUS; break;
2099 		case 2: nStart = EffectNodeType::AFTER_PREVIOUS; break;
2100 		default:
2101 			nStart = EffectNodeType::ON_CLICK; break;
2102 		}
2103 
2104 		if(mpSet->getPropertyState( nHandleStart ) != STLPropertyState_AMBIGUOUS)
2105 			mpSet->getPropertyValue( nHandleStart ) >>= nOldStart;
2106 
2107 		if( nStart != nOldStart )
2108 			pSet->setPropertyValue( nHandleStart, makeAny( nStart ) );
2109 	}
2110 
2111 	// ---
2112 
2113 	{
2114 		double fBegin = static_cast<double>( mpMFStartDelay->GetValue()) / 10.0;
2115 		double fOldBegin = -1.0;
2116 
2117 		if( mpSet->getPropertyState( nHandleBegin ) != STLPropertyState_AMBIGUOUS )
2118 			mpSet->getPropertyValue( nHandleBegin ) >>= fOldBegin;
2119 
2120 		if( fBegin != fOldBegin )
2121 			pSet->setPropertyValue( nHandleBegin, makeAny( fBegin ) );
2122 	}
2123 
2124 	// ---
2125 
2126 	nPos = mpCBRepeat->GetSelectEntryPos();
2127 	if( (nPos != LISTBOX_ENTRY_NOTFOUND) || (mpCBRepeat->GetText().Len() != 0) )
2128 	{
2129 		Any aRepeatCount;
2130 		Any aEnd;
2131 
2132 		switch( nPos )
2133 		{
2134 		case 0:
2135 			break;
2136 		case 6:
2137 			{
2138 				Event aEvent;
2139 				aEvent.Trigger = EventTrigger::ON_NEXT;
2140 				aEvent.Repeat = 0;
2141 				aEnd <<= aEvent;
2142 			}
2143 			// ATTENTION: FALL THROUGH INTENDED!
2144 		case 7:
2145 			aRepeatCount <<= Timing_INDEFINITE;
2146 			break;
2147 		default:
2148 			{
2149 				String aText( mpCBRepeat->GetText() );
2150 				if( aText.Len() )
2151 					aRepeatCount <<= aText.ToDouble();
2152 			}
2153 		}
2154 
2155 		Any aOldRepeatCount( aRepeatCount );
2156 		if( mpSet->getPropertyState( nHandleRepeat ) != STLPropertyState_AMBIGUOUS )
2157 			aOldRepeatCount = mpSet->getPropertyValue( nHandleRepeat );
2158 
2159 		if( aRepeatCount != aOldRepeatCount )
2160 			pSet->setPropertyValue( nHandleRepeat, aRepeatCount );
2161 
2162 		Any aOldEnd( aEnd );
2163 		if( mpSet->getPropertyState( nHandleEnd ) != STLPropertyState_AMBIGUOUS )
2164 			aOldEnd = mpSet->getPropertyValue( nHandleEnd );
2165 
2166 		if( aEnd != aOldEnd )
2167 			pSet->setPropertyValue( nHandleEnd, aEnd );
2168 	}
2169 
2170 	// ---
2171 
2172 	double fDuration = -1.0;
2173 	nPos = mpCBDuration->GetSelectEntryPos();
2174 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
2175 	{
2176 		fDuration = *static_cast< const double * >( mpCBDuration->GetEntryData(nPos) );
2177 	}
2178 	else
2179 	{
2180 		String aText( mpCBDuration->GetText() );
2181 		if( aText.Len() )
2182 		{
2183 			fDuration = aText.ToDouble();
2184 		}
2185 	}
2186 
2187 	if( fDuration != -1.0 )
2188 	{
2189 		double fOldDuration = -1;
2190 
2191 		if( mpSet->getPropertyState( nHandleDuration ) != STLPropertyState_AMBIGUOUS )
2192 			mpSet->getPropertyValue( nHandleDuration ) >>= fOldDuration;
2193 
2194 		if( fDuration != fOldDuration )
2195 			pSet->setPropertyValue( nHandleDuration, makeAny( fDuration ) );
2196 	}
2197 
2198 	// ---
2199 
2200 	if( mpCBXRewind->GetState() != STATE_DONTKNOW )
2201 	{
2202 		sal_Int16 nFill = mpCBXRewind->IsChecked() ? AnimationFill::REMOVE : AnimationFill::HOLD;
2203 
2204 		bool bSet = true;
2205 
2206 		if( mpSet->getPropertyState( nHandleRewind ) != STLPropertyState_AMBIGUOUS )
2207 		{
2208 			sal_Int16 nOldFill = 0;
2209 			mpSet->getPropertyValue( nHandleRewind ) >>= nOldFill;
2210 			bSet = nFill != nOldFill;
2211 		}
2212 
2213 		if( bSet )
2214 			pSet->setPropertyValue( nHandleRewind, makeAny( nFill ) );
2215 	}
2216 
2217 	Reference< XShape > xTrigger;
2218 
2219 	if( mpRBInteractive->IsChecked() )
2220 	{
2221 		nPos = mpLBTrigger->GetSelectEntryPos();
2222 		if( nPos != LISTBOX_ENTRY_NOTFOUND )
2223 		{
2224 			sal_Int32 nShape = (sal_Int32)(sal_IntPtr)mpLBTrigger->GetEntryData( nPos );
2225 
2226 			Reference< XDrawPage > xCurrentPage;
2227 			mpSet->getPropertyValue( nHandleCurrentPage ) >>= xCurrentPage;
2228 
2229 			if( xCurrentPage.is() && (nShape >= 0) && (nShape < xCurrentPage->getCount()) )
2230 				xCurrentPage->getByIndex( nShape ) >>= xTrigger;
2231 		}
2232 	}
2233 
2234 
2235 	if( xTrigger.is() || mpRBClickSequence->IsChecked() )
2236 	{
2237 		Any aNewValue( makeAny( xTrigger ) );
2238 		Any aOldValue;
2239 
2240 		if( mpSet->getPropertyState( nHandleTrigger ) != STLPropertyState_AMBIGUOUS )
2241 			aOldValue = mpSet->getPropertyValue( nHandleTrigger );
2242 
2243 		if( aNewValue != aOldValue )
2244 			pSet->setPropertyValue( nHandleTrigger, aNewValue );
2245 	}
2246 }
2247 
2248 class CustomAnimationTextAnimTabPage : public TabPage
2249 {
2250 public:
2251 	CustomAnimationTextAnimTabPage( Window* pParent, const ResId& rResId, const STLPropertySet* pSet );
2252 
2253 	void update( STLPropertySet* pSet );
2254 
2255 	void updateControlStates();
2256 	DECL_LINK( implSelectHdl, Control* );
2257 
2258 private:
2259 	FixedText	maFTGroupText;
2260 	ListBox		maLBGroupText;
2261 	CheckBox	maCBXGroupAuto;
2262 	MetricField	maMFGroupAuto;
2263 	CheckBox	maCBXAnimateForm;
2264 	CheckBox	maCBXReverse;
2265 
2266 	const STLPropertySet* mpSet;
2267 
2268 	bool mbHasVisibleShapes;
2269 };
2270 
2271 CustomAnimationTextAnimTabPage::CustomAnimationTextAnimTabPage(Window* pParent, const ResId& rResId, const STLPropertySet* pSet)
2272 :	TabPage( pParent, rResId ),
2273 	maFTGroupText( this, SdResId( FT_GROUP_TEXT ) ),
2274 	maLBGroupText( this, SdResId( LB_GROUP_TEXT ) ),
2275 	maCBXGroupAuto( this, SdResId( CBX_GROUP_AUTO ) ),
2276 	maMFGroupAuto( this, SdResId( MF_GROUP_AUTO ) ),
2277 	maCBXAnimateForm( this, SdResId( CBX_ANIMATE_FORM ) ),
2278 	maCBXReverse( this, SdResId( CBX_REVERSE ) ),
2279 	mpSet( pSet ),
2280 	mbHasVisibleShapes(true)
2281 {
2282 	FreeResource();
2283 
2284 	maLBGroupText.SetSelectHdl( LINK( this, CustomAnimationTextAnimTabPage, implSelectHdl ) );
2285 
2286 	if( pSet->getPropertyState( nHandleTextGrouping ) != STLPropertyState_AMBIGUOUS )
2287 	{
2288 		sal_Int32 nTextGrouping = 0;
2289 		if( pSet->getPropertyValue( nHandleTextGrouping ) >>= nTextGrouping )
2290 			maLBGroupText.SelectEntryPos( (sal_uInt16)(nTextGrouping + 1) );
2291 	}
2292 
2293 	if( pSet->getPropertyState( nHandleHasVisibleShape ) != STLPropertyState_AMBIGUOUS )
2294 		pSet->getPropertyValue( nHandleHasVisibleShape ) >>= mbHasVisibleShapes;
2295 
2296 	if( pSet->getPropertyState( nHandleTextGroupingAuto ) != STLPropertyState_AMBIGUOUS )
2297 	{
2298 		double fTextGroupingAuto = 0.0;
2299 		if( pSet->getPropertyValue( nHandleTextGroupingAuto ) >>= fTextGroupingAuto )
2300 		{
2301 			maCBXGroupAuto.Check( fTextGroupingAuto >= 0.0 );
2302 			if( fTextGroupingAuto >= 0.0 )
2303 				maMFGroupAuto.SetValue( (long)(fTextGroupingAuto*10) );
2304 		}
2305 	}
2306 	else
2307 	{
2308 		maCBXGroupAuto.SetState( STATE_DONTKNOW );
2309 	}
2310 
2311 	maCBXAnimateForm.SetState( STATE_DONTKNOW );
2312 	if( pSet->getPropertyState( nHandleAnimateForm ) != STLPropertyState_AMBIGUOUS )
2313 	{
2314 		sal_Bool bAnimateForm = sal_False;
2315 		if( pSet->getPropertyValue( nHandleAnimateForm ) >>= bAnimateForm )
2316 		{
2317 			maCBXAnimateForm.Check( bAnimateForm );
2318 		}
2319 	}
2320 	else
2321 	{
2322 		maCBXAnimateForm.Enable( sal_False );
2323 	}
2324 
2325 	maCBXReverse.SetState( STATE_DONTKNOW );
2326 	if( pSet->getPropertyState( nHandleTextReverse ) != STLPropertyState_AMBIGUOUS )
2327 	{
2328 		sal_Bool bTextReverse = sal_False;
2329 		if( pSet->getPropertyValue( nHandleTextReverse ) >>= bTextReverse )
2330 		{
2331 			maCBXReverse.Check( bTextReverse );
2332 		}
2333 	}
2334 
2335 	if( pSet->getPropertyState( nHandleMaxParaDepth ) == STLPropertyState_DIRECT )
2336 	{
2337 		sal_Int32 nMaxParaDepth = 0;
2338 		pSet->getPropertyValue( nHandleMaxParaDepth ) >>= nMaxParaDepth;
2339 		nMaxParaDepth += 1;
2340 
2341 		sal_Int32 nPos = 6;
2342 		while( (nPos > 2) && (nPos > nMaxParaDepth) )
2343 		{
2344 			maLBGroupText.RemoveEntry( (sal_uInt16)nPos );
2345 			nPos--;
2346 		}
2347 	}
2348 
2349 	updateControlStates();
2350 }
2351 
2352 void CustomAnimationTextAnimTabPage::update( STLPropertySet* pSet )
2353 {
2354 	sal_uInt16 nPos = maLBGroupText.GetSelectEntryPos();
2355 	if( nPos != LISTBOX_ENTRY_NOTFOUND )
2356 	{
2357 		sal_Int32 nTextGrouping = nPos - 1;
2358 		sal_Int32 nOldGrouping = -2;
2359 
2360 		if(mpSet->getPropertyState( nHandleTextGrouping ) != STLPropertyState_AMBIGUOUS)
2361 			mpSet->getPropertyValue( nHandleTextGrouping ) >>= nOldGrouping;
2362 
2363 		if( nTextGrouping != nOldGrouping )
2364 			pSet->setPropertyValue( nHandleTextGrouping, makeAny( nTextGrouping ) );
2365 	}
2366 
2367 	if( nPos > 0 )
2368 	{
2369 		sal_Bool bTextReverse = maCBXReverse.IsChecked();
2370 		sal_Bool bOldTextReverse = !bTextReverse;
2371 
2372 		if(mpSet->getPropertyState( nHandleTextReverse ) != STLPropertyState_AMBIGUOUS)
2373 			mpSet->getPropertyValue( nHandleTextReverse ) >>= bOldTextReverse;
2374 
2375 		if( bTextReverse != bOldTextReverse )
2376 			pSet->setPropertyValue( nHandleTextReverse, makeAny( bTextReverse ) );
2377 
2378 		if( nPos > 1 )
2379 		{
2380 			double fTextGroupingAuto = maCBXGroupAuto.IsChecked() ? maMFGroupAuto.GetValue() / 10.0 : -1.0;
2381 			double fOldTextGroupingAuto = -2.0;
2382 
2383 			if(mpSet->getPropertyState( nHandleTextGroupingAuto ) != STLPropertyState_AMBIGUOUS)
2384 				mpSet->getPropertyValue( nHandleTextGroupingAuto ) >>= fOldTextGroupingAuto;
2385 
2386 			if( fTextGroupingAuto != fOldTextGroupingAuto )
2387 				pSet->setPropertyValue( nHandleTextGroupingAuto, makeAny( fTextGroupingAuto ) );
2388 		}
2389 	}
2390 
2391 	sal_Bool bAnimateForm = maCBXAnimateForm.IsChecked();
2392 	sal_Bool bOldAnimateForm = !bAnimateForm;
2393 
2394 	if(mpSet->getPropertyState( nHandleAnimateForm ) != STLPropertyState_AMBIGUOUS)
2395 		mpSet->getPropertyValue( nHandleAnimateForm ) >>= bOldAnimateForm;
2396 
2397 	if( bAnimateForm != bOldAnimateForm )
2398 		pSet->setPropertyValue( nHandleAnimateForm, makeAny( bAnimateForm ) );
2399 }
2400 
2401 void CustomAnimationTextAnimTabPage::updateControlStates()
2402 {
2403 	sal_uInt16 nPos = maLBGroupText.GetSelectEntryPos();
2404 
2405 	maCBXGroupAuto.Enable( nPos > 1 );
2406 	maMFGroupAuto.Enable( nPos > 1 );
2407 	maCBXReverse.Enable( nPos > 0 );
2408 
2409 	if( !mbHasVisibleShapes && nPos > 0 )
2410 	{
2411 		maCBXAnimateForm.Check(sal_False);
2412 		maCBXAnimateForm.Enable(sal_False);
2413 	}
2414 	else
2415 	{
2416 		maCBXAnimateForm.Enable(sal_True);
2417 	}
2418 }
2419 
2420 IMPL_LINK( CustomAnimationTextAnimTabPage, implSelectHdl, Control*, EMPTYARG )
2421 {
2422 	updateControlStates();
2423 	return 0;
2424 }
2425 
2426 // --------------------------------------------------------------------
2427 
2428 CustomAnimationDialog::CustomAnimationDialog( Window* pParent, STLPropertySet* pSet, sal_uInt16 nPage /* = 0 */  )
2429 : TabDialog( pParent, SdResId( DLG_CUSTOMANIMATION ) ), mpSet( pSet ), mpResultSet( 0 )
2430 {
2431 	mpTabControl = new TabControl( this, SdResId( 1 ) );
2432 	mpOKButton = new OKButton(this, SdResId( 1 ) ) ;
2433 	mpCancelButton = new CancelButton(this, SdResId( 1 ) );
2434 	mpHelpButton = new HelpButton(this, SdResId( 1 ) );
2435 
2436 	FreeResource();
2437 
2438 	mpEffectTabPage = new CustomAnimationEffectTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_EFFECT ), mpSet );
2439 	mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_EFFECT, mpEffectTabPage );
2440 	mpDurationTabPage = new CustomAnimationDurationTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_DURATION ), mpSet );
2441 	mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_DURATION, mpDurationTabPage );
2442 
2443 	sal_Bool bHasText = sal_False;
2444 	if( pSet->getPropertyState( nHandleHasText ) != STLPropertyState_AMBIGUOUS )
2445 		pSet->getPropertyValue( nHandleHasText ) >>= bHasText;
2446 
2447 	if( bHasText )
2448 	{
2449 		mpTextAnimTabPage = new CustomAnimationTextAnimTabPage( mpTabControl, SdResId( RID_TP_CUSTOMANIMATION_TEXT ), mpSet );
2450 		mpTabControl->SetTabPage( RID_TP_CUSTOMANIMATION_TEXT, mpTextAnimTabPage );
2451 	}
2452 	else
2453 	{
2454 		mpTextAnimTabPage = 0;
2455 		mpTabControl->RemovePage( RID_TP_CUSTOMANIMATION_TEXT );
2456 	}
2457 
2458 	if( nPage )
2459 		mpTabControl->SelectTabPage( nPage );
2460 }
2461 
2462 CustomAnimationDialog::~CustomAnimationDialog()
2463 {
2464 	delete mpEffectTabPage;
2465 	delete mpDurationTabPage;
2466 	delete mpTextAnimTabPage;
2467 
2468 	delete mpTabControl;
2469 	delete mpOKButton;
2470 	delete mpCancelButton;
2471 	delete mpHelpButton;
2472 
2473 	delete mpSet;
2474 	delete mpResultSet;
2475 }
2476 
2477 STLPropertySet* CustomAnimationDialog::getResultSet()
2478 {
2479 	if( mpResultSet )
2480 		delete mpResultSet;
2481 
2482 	mpResultSet = createDefaultSet();
2483 
2484 	mpEffectTabPage->update( mpResultSet );
2485 	mpDurationTabPage->update( mpResultSet );
2486 	if( mpTextAnimTabPage )
2487 		mpTextAnimTabPage->update( mpResultSet );
2488 
2489 	return mpResultSet;
2490 }
2491 
2492 STLPropertySet* CustomAnimationDialog::createDefaultSet()
2493 {
2494 	Any aEmpty;
2495 
2496 	STLPropertySet* pSet = new STLPropertySet();
2497 	pSet->setPropertyDefaultValue( nHandleMaxParaDepth, makeAny( (sal_Int32)-1 ) );
2498 
2499 	pSet->setPropertyDefaultValue( nHandleHasAfterEffect, makeAny( (sal_Bool)sal_False ) );
2500 	pSet->setPropertyDefaultValue( nHandleAfterEffectOnNextEffect, makeAny( (sal_Bool)sal_False ) );
2501 	pSet->setPropertyDefaultValue( nHandleDimColor, aEmpty );
2502 	pSet->setPropertyDefaultValue( nHandleIterateType, makeAny( (sal_Int16)0 ) );
2503 	pSet->setPropertyDefaultValue( nHandleIterateInterval, makeAny( (double)0.0 ) );
2504 
2505 	pSet->setPropertyDefaultValue( nHandleStart, makeAny( (sal_Int16)EffectNodeType::ON_CLICK ) );
2506 	pSet->setPropertyDefaultValue( nHandleBegin, makeAny( (double)0.0 ) );
2507 	pSet->setPropertyDefaultValue( nHandleDuration, makeAny( (double)2.0 ) );
2508 	pSet->setPropertyDefaultValue( nHandleRepeat, aEmpty );
2509 	pSet->setPropertyDefaultValue( nHandleRewind, makeAny( AnimationFill::HOLD ) );
2510 
2511 	pSet->setPropertyDefaultValue( nHandleEnd, aEmpty );
2512 
2513 	pSet->setPropertyDefaultValue( nHandlePresetId, aEmpty );
2514 	pSet->setPropertyDefaultValue( nHandleProperty1Type, makeAny( nPropertyTypeNone ) );
2515 	pSet->setPropertyDefaultValue( nHandleProperty1Value, aEmpty );
2516 	pSet->setPropertyDefaultValue( nHandleProperty2Type, makeAny( nPropertyTypeNone ) );
2517 	pSet->setPropertyDefaultValue( nHandleProperty2Value, aEmpty );
2518 	pSet->setPropertyDefaultValue( nHandleAccelerate, aEmpty );
2519 	pSet->setPropertyDefaultValue( nHandleDecelerate, aEmpty );
2520 	pSet->setPropertyDefaultValue( nHandleAutoReverse, aEmpty );
2521 	pSet->setPropertyDefaultValue( nHandleTrigger, aEmpty );
2522 
2523 	pSet->setPropertyDefaultValue( nHandleHasText, makeAny( sal_False ) );
2524 	pSet->setPropertyDefaultValue( nHandleHasVisibleShape, makeAny( sal_False ) );
2525 	pSet->setPropertyDefaultValue( nHandleTextGrouping, makeAny( (sal_Int32)-1 ) );
2526 	pSet->setPropertyDefaultValue( nHandleAnimateForm, makeAny( sal_True ) );
2527 	pSet->setPropertyDefaultValue( nHandleTextGroupingAuto, makeAny( (double)-1.0 ) );
2528 	pSet->setPropertyDefaultValue( nHandleTextReverse, makeAny( sal_False ) );
2529 
2530 	pSet->setPropertyDefaultValue( nHandleCurrentPage, aEmpty );
2531 
2532 	pSet->setPropertyDefaultValue( nHandleSoundURL, aEmpty );
2533 	pSet->setPropertyDefaultValue( nHandleSoundVolumne, makeAny( (double)1.0) );
2534 	pSet->setPropertyDefaultValue( nHandleSoundEndAfterSlide, makeAny( (sal_Int32)0 ) );
2535 
2536 	pSet->setPropertyDefaultValue( nHandleCommand, makeAny( (sal_Int16)0 ) );
2537 	return pSet;
2538 }
2539 
2540 PropertyControl::PropertyControl( Window* pParent, const ResId& rResId )
2541 : ListBox( pParent, rResId ), mpSubControl(0)
2542 {
2543 }
2544 
2545 PropertyControl::~PropertyControl()
2546 {
2547 	if( mpSubControl )
2548 		delete mpSubControl;
2549 }
2550 
2551 void PropertyControl::setSubControl( PropertySubControl* pSubControl )
2552 {
2553 	if( mpSubControl && mpSubControl != pSubControl )
2554 		delete mpSubControl;
2555 
2556 	mpSubControl = pSubControl;
2557 
2558 	Control* pControl = pSubControl ? pSubControl->getControl() : 0;
2559 
2560 	if( pControl )
2561 	{
2562 		pControl->SetPosSizePixel( GetPosPixel(), GetSizePixel() );
2563 		pControl->SetZOrder( this, WINDOW_ZORDER_BEFOR );
2564 		pControl->Show();
2565 		Hide();
2566 	}
2567 	else
2568 	{
2569 		Show();
2570 	}
2571 }
2572 
2573 void PropertyControl::Resize()
2574 {
2575 	Control* pControl = mpSubControl ? mpSubControl->getControl() : 0;
2576 	if( pControl )
2577 		pControl->SetPosSizePixel( GetPosPixel(), GetSizePixel() );
2578 	ListBox::Resize();
2579 }
2580 
2581 // ====================================================================
2582 
2583 PropertySubControl::~PropertySubControl()
2584 {
2585 }
2586 
2587 PropertySubControl* PropertySubControl::create( sal_Int32 nType, Window* pParent, const Any& rValue, const OUString& rPresetId, const Link& rModifyHdl )
2588 {
2589 	PropertySubControl* pSubControl = NULL;
2590 	switch( nType )
2591 	{
2592 	case nPropertyTypeDirection:
2593 	case nPropertyTypeSpokes:
2594 	case nPropertyTypeZoom:
2595 		pSubControl = new PresetPropertyBox( nType, pParent, rValue, rPresetId, rModifyHdl );
2596 		break;
2597 
2598 	case nPropertyTypeColor:
2599 	case nPropertyTypeFillColor:
2600 	case nPropertyTypeFirstColor:
2601 	case nPropertyTypeCharColor:
2602 	case nPropertyTypeLineColor:
2603 		pSubControl = new ColorPropertyBox( nType, pParent, rValue, rModifyHdl );
2604 		break;
2605 
2606 	case nPropertyTypeFont:
2607 		pSubControl = new FontPropertyBox( nType, pParent, rValue, rModifyHdl );
2608 		break;
2609 
2610 	case nPropertyTypeCharHeight:
2611 		pSubControl = new CharHeightPropertyBox( nType, pParent, rValue, rModifyHdl );
2612 		break;
2613 
2614 	case nPropertyTypeRotate:
2615 		pSubControl = new RotationPropertyBox( nType, pParent, rValue, rModifyHdl );
2616 		break;
2617 
2618 	case nPropertyTypeTransparency:
2619 		pSubControl = new TransparencyPropertyBox( nType, pParent, rValue, rModifyHdl );
2620 		break;
2621 
2622 	case nPropertyTypeScale:
2623 		pSubControl = new ScalePropertyBox( nType, pParent, rValue, rModifyHdl );
2624 		break;
2625 
2626 	case nPropertyTypeCharDecoration:
2627 		pSubControl = new FontStylePropertyBox( nType, pParent, rValue, rModifyHdl );
2628 		break;
2629 	}
2630 
2631 	return pSubControl;
2632 }
2633 
2634 }
2635