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