?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / svx / source / tbxctrls / tbcontrl.cxx
blob94494aa3aa6d361372f3abf1a5a738a720466593
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: tbcontrl.cxx,v $
10 * $Revision: 1.84 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33
34 // include ---------------------------------------------------------------
35
36
37 #include <string> // HACK: prevent conflict between STLPORT and Workshop headers
38 #include <tools/shl.hxx>
39 #include <svtools/poolitem.hxx>
40 #include <svtools/eitem.hxx>
41 #include <vcl/toolbox.hxx>
42 #include <vcl/bmpacc.hxx>
43 #include <svtools/valueset.hxx>
44 #include <svtools/ctrlbox.hxx>
45 #include <svtools/style.hxx>
46 #include <svtools/ctrltool.hxx>
47 #include <svtools/stritem.hxx>
48 #include <svtools/pathoptions.hxx>
49 #include <sfx2/tplpitem.hxx>
50 #include <sfx2/dispatch.hxx>
51 #include <sfx2/viewsh.hxx>
52 #include <sfx2/objsh.hxx>
53 #include <sfx2/docfac.hxx>
54 #include <sfx2/templdlg.hxx>
55 #include <svtools/isethint.hxx>
56 #include <sfx2/querystatus.hxx>
57 #include <sfx2/sfxstatuslistener.hxx>
58 #include <tools/urlobj.hxx>
59 #include <sfx2/childwin.hxx>
60 #include <sfx2/viewfrm.hxx>
61 #include <svtools/fontoptions.hxx>
62 #ifndef _VCL_MNEMONIC_HXX_
63 #include <vcl/mnemonic.hxx>
64 #endif
65
66 #include <vcl/svapp.hxx>
67 #include <svtools/smplhint.hxx>
68
69 #define _SVX_TBCONTRL_CXX
70 #include <svtools/colorcfg.hxx>
71 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
72 #include <com/sun/star/lang/XServiceInfo.hpp>
73 #include <com/sun/star/beans/XPropertySet.hpp>
74 #include <com/sun/star/frame/status/ItemStatus.hpp>
75 #include <com/sun/star/frame/status/FontHeight.hpp>
76
77 #include <svx/dialogs.hrc>
78 #include <svx/svxitems.hrc>
79 #include "helpid.hrc"
80 #include "htmlmode.hxx"
81 #include <svx/xtable.hxx>
82 #include "fontitem.hxx"
83 #include <svx/fhgtitem.hxx>
84 #include <svx/brshitem.hxx>
85 #include <svx/boxitem.hxx>
86 #include <svx/colritem.hxx>
87 #include "flstitem.hxx"
88 #include "bolnitem.hxx"
89 #include "drawitem.hxx"
90 #include <svx/tbcontrl.hxx>
91 #include "dlgutil.hxx"
92 #include <svx/dialmgr.hxx>
93 #include "colorwindow.hxx"
94 #include <memory>
95
96 #include <svx/tbxcolorupdate.hxx>
97
98 // ------------------------------------------------------------------------
99
100 #define MAX_MRU_FONTNAME_ENTRIES 5
101 #define LOGICAL_EDIT_HEIGHT 12
102
103 // STATIC DATA -----------------------------------------------------------
104
105 #ifndef DELETEZ
106 #define DELETEZ(p) (delete (p), (p)=NULL)
107 #endif
108 // don't make more than 15 entries visible at once
109 #define MAX_STYLES_ENTRIES static_cast< USHORT >( 15 )
110
111 void lcl_ResizeValueSet( Window &rWin, ValueSet &rValueSet );
112 void lcl_CalcSizeValueSet( Window &rWin, ValueSet &rValueSet, const Size &aItemSize );
113 BOOL lcl_FontChangedHint( const SfxHint &rHint );
114
115 // namespaces
116 using ::rtl::OUString;
117 using namespace ::com::sun::star;
118 using namespace ::com::sun::star::uno;
119 using namespace ::com::sun::star::frame;
120 using namespace ::com::sun::star::util;
121 using namespace ::com::sun::star::beans;
122 using namespace ::com::sun::star::lang;
123
124 SFX_IMPL_TOOLBOX_CONTROL( SvxStyleToolBoxControl, SfxTemplateItem );
125 SFX_IMPL_TOOLBOX_CONTROL( SvxFontNameToolBoxControl, SvxFontItem );
126 SFX_IMPL_TOOLBOX_CONTROL( SvxFontColorToolBoxControl, SvxColorItem );
127 SFX_IMPL_TOOLBOX_CONTROL( SvxFontColorExtToolBoxControl, SvxColorItem );
128 SFX_IMPL_TOOLBOX_CONTROL( SvxColorToolBoxControl, SvxColorItem );
129 SFX_IMPL_TOOLBOX_CONTROL( SvxFrameToolBoxControl, SvxBoxItem );
130 SFX_IMPL_TOOLBOX_CONTROL( SvxFrameLineStyleToolBoxControl, SvxLineItem );
131 SFX_IMPL_TOOLBOX_CONTROL( SvxFrameLineColorToolBoxControl, SvxColorItem );
132 SFX_IMPL_TOOLBOX_CONTROL( SvxReloadControllerItem, SfxBoolItem );
133 SFX_IMPL_TOOLBOX_CONTROL( SvxSimpleUndoRedoController, SfxStringItem );
134
135 //========================================================================
136 // class SvxStyleBox_Impl -----------------------------------------------------
137 //========================================================================
138
139
140 class SvxStyleBox_Impl : public ComboBox
141 {
142 using Window::IsVisible;
143 public:
144 SvxStyleBox_Impl( Window* pParent, USHORT nSlot, const OUString& rCommand, SfxStyleFamily eFamily, const Reference< XDispatchProvider >& rDispatchProvider,
145 const Reference< XFrame >& _xFrame,const String& rClearFormatKey, const String& rMoreKey, BOOL bInSpecialMode );
146 ~SvxStyleBox_Impl();
147
148 void SetFamily( SfxStyleFamily eNewFamily );
149 inline BOOL IsVisible() { return bVisible; }
150
151 virtual long PreNotify( NotifyEvent& rNEvt );
152 virtual long Notify( NotifyEvent& rNEvt );
153 virtual void DataChanged( const DataChangedEvent& rDCEvt );
154 virtual void StateChanged( StateChangedType nStateChange );
155
156 inline void SetVisibilityListener( const Link& aVisListener ) { aVisibilityListener = aVisListener; }
157 inline void RemoveVisibilityListener() { aVisibilityListener = Link(); }
158
159 void SetDefaultStyle( const ::rtl::OUString& rDefault ) { sDefaultStyle = rDefault; }
160 DECL_STATIC_LINK( SvxStyleBox_Impl, FocusHdl_Impl, Control* );
161
162 protected:
163 virtual void Select();
164
165 private:
166 USHORT nSlotId;
167 SfxStyleFamily eStyleFamily;
168 USHORT nCurSel;
169 BOOL bRelease;
170 Size aLogicalSize;
171 Link aVisibilityListener;
172 BOOL bVisible;
173 Reference< XDispatchProvider > m_xDispatchProvider;
174 Reference< XFrame > m_xFrame;
175 OUString m_aCommand;
176 String aClearFormatKey;
177 String aMoreKey;
178 String sDefaultStyle;
179 BOOL bInSpecialMode;
180
181 void ReleaseFocus();
182 };
183
184 //========================================================================
185 // class SvxFontNameBox --------------------------------------------------
186 //========================================================================
187
188 class SvxFontNameBox_Impl : public FontNameBox
189 {
190 using Window::Update;
191 private:
192 const FontList* pFontList;
193 ::std::auto_ptr<FontList> m_aOwnFontList;
194 Font aCurFont;
195 Size aLogicalSize;
196 String aCurText;
197 USHORT nFtCount;
198 BOOL bRelease;
199 Reference< XDispatchProvider > m_xDispatchProvider;
200 Reference< XFrame > m_xFrame;
201
202 void ReleaseFocus_Impl();
203 void EnableControls_Impl();
204
205 protected:
206 virtual void Select();
207 virtual void DataChanged( const DataChangedEvent& rDCEvt );
208
209 public:
210 SvxFontNameBox_Impl( Window* pParent, const Reference< XDispatchProvider >& rDispatchProvider,const Reference< XFrame >& _xFrame
211 , WinBits nStyle = WB_SORT
212 );
213
214 void FillList();
215 void Update( const SvxFontItem* pFontItem );
216 USHORT GetListCount() { return nFtCount; }
217 void Clear() { FontNameBox::Clear(); nFtCount = 0; }
218 void Fill( const FontList* pList )
219 { FontNameBox::Fill( pList );
220 nFtCount = pList->GetFontNameCount(); }
221 virtual long PreNotify( NotifyEvent& rNEvt );
222 virtual long Notify( NotifyEvent& rNEvt );
223 virtual Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
224 inline void SetOwnFontList(::std::auto_ptr<FontList> _aOwnFontList) { m_aOwnFontList = _aOwnFontList; }
225 };
226
227 //========================================================================
228 // class SvxFrameWindow_Impl --------------------------------------------------
229 //========================================================================
230
231 // fuer den SelectHdl werden die Modifier gebraucht, also
232 // muss man sie im MouseButtonUp besorgen
233
234 class SvxFrmValueSet_Impl : public ValueSet
235 {
236 USHORT nModifier;
237 virtual void MouseButtonUp( const MouseEvent& rMEvt );
238 public:
239 SvxFrmValueSet_Impl(Window* pParent, WinBits nWinStyle)
240 : ValueSet(pParent, nWinStyle), nModifier(0) {}
241 USHORT GetModifier() const {return nModifier;}
242
243 };
244
245 void SvxFrmValueSet_Impl::MouseButtonUp( const MouseEvent& rMEvt )
246 {
247 nModifier = rMEvt.GetModifier();
248 ValueSet::MouseButtonUp(rMEvt);
249 }
250
251 class SvxFrameWindow_Impl : public SfxPopupWindow
252 {
253 using FloatingWindow::StateChanged;
254
255 private:
256 SvxFrmValueSet_Impl aFrameSet;
257 ImageList aImgList;
258 sal_Bool bParagraphMode;
259
260 #if _SOLAR__PRIVATE
261 DECL_LINK( SelectHdl, void * );
262 #endif
263
264 protected:
265 virtual void Resize();
266 virtual BOOL Close();
267 virtual Window* GetPreferredKeyInputWindow();
268 virtual void GetFocus();
269
270 public:
271 SvxFrameWindow_Impl( USHORT nId, const Reference< XFrame >& rFrame, Window* pParentWindow );
272 ~SvxFrameWindow_Impl();
273 void StartSelection();
274
275 virtual void StateChanged( USHORT nSID, SfxItemState eState,
276 const SfxPoolItem* pState );
277 virtual SfxPopupWindow* Clone() const;
278 virtual void DataChanged( const DataChangedEvent& rDCEvt );
279
280 inline BOOL IsHighContrast( void ) const;
281 };
282
283 inline BOOL SvxFrameWindow_Impl::IsHighContrast( void ) const
284 {
285 return GetDisplayBackground().GetColor().IsDark();
286 }
287
288 //========================================================================
289 // class SvxLineWindow_Impl ---------------------------------------------------
290 //========================================================================
291 class SvxLineWindow_Impl : public SfxPopupWindow
292 {
293 private:
294 ValueSet aLineSet;
295 bool m_bIsWriter;
296
297 #if _SOLAR__PRIVATE
298 void MakeLineBitmap( USHORT nNo, Bitmap& rBmp, const Size& rSize, String& rStr,
299 const ::Color& rLine, const ::Color& rBack );
300 DECL_LINK( SelectHdl, void * );
301 #endif
302
303 protected:
304 virtual void Resize();
305 virtual BOOL Close();
306 virtual Window* GetPreferredKeyInputWindow();
307 virtual void GetFocus();
308 virtual void DataChanged( const DataChangedEvent& rDCEvt );
309 void CreateBitmaps( void );
310 public:
311 SvxLineWindow_Impl( USHORT nId, const Reference< XFrame >& rFrame, Window* pParentWindow );
312
313 void StartSelection();
314 virtual SfxPopupWindow* Clone() const;
315 };
316
317 //########################################################################
318 // Hilfsklassen:
319 //========================================================================
320 // class SfxStyleControllerItem ------------------------------------------
321 //========================================================================
322 class SvxStyleToolBoxControl;
323
324 class SfxStyleControllerItem_Impl : public SfxStatusListener
325 {
326 public:
327 SfxStyleControllerItem_Impl( const Reference< XDispatchProvider >& rDispatchProvider,
328 USHORT nSlotId,
329 const rtl::OUString& rCommand,
330 SvxStyleToolBoxControl& rTbxCtl );
331
332 protected:
333 virtual void StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState );
334
335 private:
336 SvxStyleToolBoxControl& rControl;
337 };
338
339 //========================================================================
340 // class SvxStyleBox_Impl -----------------------------------------------------
341 //========================================================================
342
343 SvxStyleBox_Impl::SvxStyleBox_Impl(
344 Window* pParent,
345 USHORT nSlot,
346 const rtl::OUString& rCommand,
347 SfxStyleFamily eFamily,
348 const Reference< XDispatchProvider >& rDispatchProvider,
349 const Reference< XFrame >& _xFrame,
350 const String& rClearFormatKey,
351 const String& rMoreKey,
352 BOOL bInSpec) :
353
354 ComboBox( pParent, SVX_RES( RID_SVXTBX_STYLE ) ),
355
356 nSlotId ( nSlot ),
357 eStyleFamily( eFamily ),
358 bRelease ( TRUE ),
359 bVisible(FALSE),
360 m_xDispatchProvider( rDispatchProvider ),
361 m_xFrame(_xFrame),
362 m_aCommand ( rCommand ),
363 aClearFormatKey ( rClearFormatKey ),
364 aMoreKey ( rMoreKey ),
365 bInSpecialMode ( bInSpec )
366 {
367 aLogicalSize = PixelToLogic( GetSizePixel(), MAP_APPFONT );
368 EnableAutocomplete( TRUE );
369 }
370
371 SvxStyleBox_Impl::~SvxStyleBox_Impl()
372 {
373 }
374
375 // -----------------------------------------------------------------------
376
377 void SvxStyleBox_Impl::ReleaseFocus()
378 {
379 if ( !bRelease )
380 {
381 bRelease = TRUE;
382 return;
383 }
384 if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
385 m_xFrame->getContainerWindow()->setFocus();
386 }
387
388 // -----------------------------------------------------------------------
389
390 void SvxStyleBox_Impl::Select()
391 {
392 // Tell base class about selection so that AT get informed about it.
393 ComboBox::Select();
394
395 if ( !IsTravelSelect() )
396 {
397 String aSelEntry( GetText() );
398 bool bDoIt = true, bClear = false;
399 if( bInSpecialMode )
400 {
401 if( aSelEntry == aClearFormatKey && GetSelectEntryPos() == 0 )
402 {
403 aSelEntry = sDefaultStyle;
404 bClear = true;
405 //not only apply default style but also call 'ClearFormatting'
406 Sequence< PropertyValue > aEmptyVals;
407 SfxToolBoxControl::Dispatch( m_xDispatchProvider, String::CreateFromAscii(".uno:ResetAttributes"),
408 aEmptyVals);
409 }
410 else if( aSelEntry == aMoreKey && GetSelectEntryPos() == ( GetEntryCount() - 1 ) )
411 {
412 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
413 DBG_ASSERT( pViewFrm, "SvxStyleBox_Impl::Select(): no viewframe" );
414 pViewFrm->ShowChildWindow( SID_STYLE_DESIGNER );
415 SfxChildWindow* pChildWin = pViewFrm->GetChildWindow( SID_STYLE_DESIGNER );
416 if ( pChildWin && pChildWin->GetWindow() )
417 {
418 static_cast< SfxTemplateDialogWrapper* >( pChildWin )->SetParagraphFamily();
419 static_cast< SfxDockingWindow* >( pChildWin->GetWindow() )->AutoShow( sal_True );
420 Application::PostUserEvent(
421 STATIC_LINK( 0, SvxStyleBox_Impl, FocusHdl_Impl ), pChildWin->GetWindow() );
422 }
423 bDoIt = false;
424 }
425 }
426
427 // #i36723# after ReleaseFocus() the new entry is included into the List
428 sal_Bool bCreateNew = GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND;
429
430 /* #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
431 This instance may be deleted in the meantime (i.e. when a dialog is opened
432 while in Dispatch()), accessing members will crash in this case. */
433 ReleaseFocus();
434
435 if( bDoIt )
436 {
437 if ( bClear )
438 SetText( aSelEntry );
439 SaveValue();
440
441 Sequence< PropertyValue > aArgs( 2 );
442 aArgs[0].Value = makeAny( OUString( aSelEntry ) );
443 aArgs[1].Name = OUString::createFromAscii( "Family" );
444 aArgs[1].Value = makeAny( sal_Int16( eStyleFamily ));
445 if( bCreateNew )
446 {
447 aArgs[0].Name = OUString::createFromAscii( "Param" );
448 SfxToolBoxControl::Dispatch( m_xDispatchProvider, String::CreateFromAscii(".uno:StyleNewByExample"), aArgs);
449 }
450 else
451 {
452 aArgs[0].Name = OUString::createFromAscii( "Template" );
453 SfxToolBoxControl::Dispatch( m_xDispatchProvider, m_aCommand, aArgs );
454 }
455 }
456 }
457 }
458 // -----------------------------------------------------------------------
459
460 void SvxStyleBox_Impl::SetFamily( SfxStyleFamily eNewFamily )
461 {
462 eStyleFamily = eNewFamily;
463 }
464
465 // -----------------------------------------------------------------------
466
467 long SvxStyleBox_Impl::PreNotify( NotifyEvent& rNEvt )
468 {
469 USHORT nType = rNEvt.GetType();
470
471 if ( EVENT_MOUSEBUTTONDOWN == nType || EVENT_GETFOCUS == nType )
472 nCurSel = GetSelectEntryPos();
473 else if ( EVENT_LOSEFOCUS == nType )
474 {
475 // don't handle before our Select() is called
476 if ( !HasFocus() && !HasChildPathFocus() )
477 SetText( GetSavedValue() );
478 }
479 return ComboBox::PreNotify( rNEvt );
480 }
481
482 // -----------------------------------------------------------------------
483
484 long SvxStyleBox_Impl::Notify( NotifyEvent& rNEvt )
485 {
486 long nHandled = 0;
487
488 if ( rNEvt.GetType() == EVENT_KEYINPUT )
489 {
490 USHORT nCode = rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
491
492 switch ( nCode )
493 {
494 case KEY_RETURN:
495 case KEY_TAB:
496 {
497 if ( KEY_TAB == nCode )
498 bRelease = FALSE;
499 else
500 nHandled = 1;
501 Select();
502 break;
503 }
504
505 case KEY_ESCAPE:
506 SelectEntryPos( nCurSel );
507 ReleaseFocus();
508 nHandled = 1;
509 break;
510 }
511 }
512 return nHandled ? nHandled : ComboBox::Notify( rNEvt );
513 }
514 /* -----------------------------08.03.2002 13:03------------------------------
515
516 ---------------------------------------------------------------------------*/
517 void SvxStyleBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
518 {
519 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
520 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
521 {
522 SetSizePixel(LogicToPixel(aLogicalSize, MAP_APPFONT));
523 Size aDropSize( aLogicalSize.Width(), LOGICAL_EDIT_HEIGHT);
524 SetDropDownSizePixel(LogicToPixel(aDropSize, MAP_APPFONT));
525 }
526
527 ComboBox::DataChanged( rDCEvt );
528 }
529
530 void SvxStyleBox_Impl::StateChanged( StateChangedType nStateChange )
531 {
532 ComboBox::StateChanged( nStateChange );
533
534 if ( nStateChange == STATE_CHANGE_VISIBLE )
535 {
536 bVisible = IsReallyVisible();
537 if ( aVisibilityListener.IsSet() )
538 aVisibilityListener.Call( this );
539 }
540 else if ( nStateChange == STATE_CHANGE_INITSHOW )
541 {
542 bVisible = TRUE;
543 if ( aVisibilityListener.IsSet() )
544 aVisibilityListener.Call( this );
545 }
546 }
547
548 //--------------------------------------------------------------------
549
550 IMPL_STATIC_LINK( SvxStyleBox_Impl, FocusHdl_Impl, Control*, _pCtrl )
551 {
552 (void)pThis;
553 if ( _pCtrl )
554 _pCtrl->GrabFocus();
555 return 0;
556 }
557
558 // -----------------------------------------------------------------------
559
560 BOOL GetDocFontList_Impl( const FontList** ppFontList, SvxFontNameBox_Impl* pBox )
561 {
562 BOOL bChanged = FALSE;
563 const SfxObjectShell* pDocSh = SfxObjectShell::Current();
564 SvxFontListItem* pFontListItem = NULL;
565
566 if ( pDocSh )
567 pFontListItem =
568 (SvxFontListItem*)pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST );
569 else
570 {
571 ::std::auto_ptr<FontList> aFontList(new FontList( pBox ));
572 *ppFontList = aFontList.get();
573 pBox->SetOwnFontList(aFontList);
574 bChanged = TRUE;
575 }
576
577 if ( pFontListItem )
578 {
579 const FontList* pNewFontList = pFontListItem->GetFontList();
580 DBG_ASSERT( pNewFontList, "Doc-FontList not available!" );
581
582 // keine alte Liste, aber neue Liste
583 if ( !*ppFontList && pNewFontList )
584 {
585 // => "ubernehmen
586 *ppFontList = pNewFontList;
587 bChanged = TRUE;
588 }
589 else
590 {
591 // Vergleich der Fontlisten ist nicht vollkommen
592 // wird die Fontliste am Doc geaendert, kann man hier
593 // nur ueber die Listbox Aenderungen feststellen, weil
594 // ppFontList dabei schon upgedatet wurde
595 bChanged =
596 ( ( *ppFontList != pNewFontList ) ||
597 pBox->GetListCount() != pNewFontList->GetFontNameCount() );
598 HACK(vergleich ist unvollstaendig)
599
600 if ( bChanged )
601 *ppFontList = pNewFontList;
602 }
603
604 if ( pBox )
605 pBox->Enable();
606 }
607 else if ( pBox && ( pDocSh || ( !pDocSh && !ppFontList )))
608 {
609 // Disable box only when we have a SfxObjectShell and didn't get a font list OR
610 // we don't have a SfxObjectShell and no current font list.
611 // It's possible that we currently have no SfxObjectShell, but a current font list.
612 // See #i58471: When a user set the focus into the font name combo box and opens
613 // the help window with F1. After closing the help window, we disable the font name
614 // combo box. The SfxObjectShell::Current() method returns in that case zero. But the
615 // font list hasn't changed and therefore the combo box shouldn't be disabled!
616 pBox->Disable();
617 }
618
619 // in die FontBox ggf. auch die neue Liste f"ullen
620 if ( pBox && bChanged )
621 {
622 if ( *ppFontList )
623 pBox->Fill( *ppFontList );
624 else
625 pBox->Clear();
626 }
627 return bChanged;
628 }
629
630 //========================================================================
631 // class SvxFontNameBox_Impl --------------------------------------------------
632 //========================================================================
633
634 SvxFontNameBox_Impl::SvxFontNameBox_Impl( Window* pParent, const Reference< XDispatchProvider >& rDispatchProvider,const Reference< XFrame >& _xFrame, WinBits nStyle ) :
635
636 FontNameBox ( pParent, nStyle | WinBits( WB_DROPDOWN | WB_AUTOHSCROLL ) ),
637 pFontList ( NULL ),
638 aLogicalSize ( 75,160 ),
639 nFtCount ( 0 ),
640 bRelease ( TRUE ),
641 m_xDispatchProvider( rDispatchProvider ),
642 m_xFrame (_xFrame)
643 {
644 SetSizePixel(LogicToPixel( aLogicalSize, MAP_APPFONT ));
645 EnableControls_Impl();
646 }
647 // -----------------------------------------------------------------------
648
649 void SvxFontNameBox_Impl::FillList()
650 {
651 // alte Selektion merken, und am Ende wieder setzen
652 Selection aOldSel = GetSelection();
653 // hat sich Doc-Fontlist geaendert?
654 GetDocFontList_Impl( &pFontList, this );
655 aCurText = GetText();
656 SetSelection( aOldSel );
657 }
658
659 // -----------------------------------------------------------------------
660
661 void SvxFontNameBox_Impl::Update( const SvxFontItem* pFontItem )
662 {
663 if ( pFontItem )
664 {
665 aCurFont.SetName ( pFontItem->GetFamilyName() );
666 aCurFont.SetFamily ( pFontItem->GetFamily() );
667 aCurFont.SetStyleName ( pFontItem->GetStyleName() );
668 aCurFont.SetPitch ( pFontItem->GetPitch() );
669 aCurFont.SetCharSet ( pFontItem->GetCharSet() );
670 }
671 String aCurName = aCurFont.GetName();
672 if ( GetText() != aCurName )
673 SetText( aCurName );
674 }
675
676 // -----------------------------------------------------------------------
677
678 long SvxFontNameBox_Impl::PreNotify( NotifyEvent& rNEvt )
679 {
680 USHORT nType = rNEvt.GetType();
681
682 if ( EVENT_MOUSEBUTTONDOWN == nType || EVENT_GETFOCUS == nType )
683 {
684 EnableControls_Impl();
685 FillList();
686 }
687 return FontNameBox::PreNotify( rNEvt );
688 }
689
690 // -----------------------------------------------------------------------
691
692 long SvxFontNameBox_Impl::Notify( NotifyEvent& rNEvt )
693 {
694 long nHandled = 0;
695
696 if ( rNEvt.GetType() == EVENT_KEYINPUT )
697 {
698 USHORT nCode = rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
699
700 switch ( nCode )
701 {
702 case KEY_RETURN:
703 case KEY_TAB:
704 {
705 if ( KEY_TAB == nCode )
706 bRelease = FALSE;
707 else
708 nHandled = 1;
709 Select();
710 break;
711 }
712
713 case KEY_ESCAPE:
714 SetText( aCurText );
715 ReleaseFocus_Impl();
716 break;
717 }
718 }
719 else if ( EVENT_LOSEFOCUS == rNEvt.GetType() )
720 {
721 Window* pFocusWin = Application::GetFocusWindow();
722 if ( !HasFocus() && GetSubEdit() != pFocusWin )
723 SetText( GetSavedValue() );
724 }
725
726 return nHandled ? nHandled : FontNameBox::Notify( rNEvt );
727 }
728
729 // ---------------------------------------------------------------------------
730 void SvxFontNameBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
731 {
732 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
733 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
734 {
735 SetSizePixel(LogicToPixel(aLogicalSize, MAP_APPFONT));
736 Size aDropSize( aLogicalSize.Width(), LOGICAL_EDIT_HEIGHT);
737 SetDropDownSizePixel(LogicToPixel(aDropSize, MAP_APPFONT));
738 }
739
740 FontNameBox::DataChanged( rDCEvt );
741 }
742
743 // -----------------------------------------------------------------------
744
745 void SvxFontNameBox_Impl::ReleaseFocus_Impl()
746 {
747 if ( !bRelease )
748 {
749 bRelease = TRUE;
750 return;
751 }
752 if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
753 m_xFrame->getContainerWindow()->setFocus();
754 }
755
756 // -----------------------------------------------------------------------
757
758 void SvxFontNameBox_Impl::EnableControls_Impl()
759 {
760 SvtFontOptions aFontOpt;
761 BOOL bEnable = aFontOpt.IsFontHistoryEnabled();
762 USHORT nEntries = bEnable ? MAX_MRU_FONTNAME_ENTRIES : 0;
763 if ( GetMaxMRUCount() != nEntries )
764 {
765 // refill in the next GetFocus-Handler
766 pFontList = NULL;
767 Clear();
768 SetMaxMRUCount( nEntries );
769 }
770
771 bEnable = aFontOpt.IsFontWYSIWYGEnabled();
772 EnableWYSIWYG( bEnable );
773 EnableSymbols( bEnable );
774 }
775
776 // -----------------------------------------------------------------------
777
778 void SvxFontNameBox_Impl::Select()
779 {
780 FontNameBox::Select();
781
782 if ( !IsTravelSelect() )
783 {
784 if ( pFontList )
785 {
786 FontInfo aInfo( pFontList->Get( GetText(),
787 aCurFont.GetWeight(),
788 aCurFont.GetItalic() ) );
789 aCurFont = aInfo;
790
791 SvxFontItem aFontItem( aInfo.GetFamily(),
792 aInfo.GetName(),
793 aInfo.GetStyleName(),
794 aInfo.GetPitch(),
795 aInfo.GetCharSet(),
796 SID_ATTR_CHAR_FONT );
797
798 Any a;
799 Sequence< PropertyValue > aArgs( 1 );
800 aArgs[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "CharFontName" ));
801 aFontItem.QueryValue( a );
802 aArgs[0].Value = a;
803
804 // #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
805 // This instance may be deleted in the meantime (i.e. when a dialog is opened
806 // while in Dispatch()), accessing members will crash in this case.
807 ReleaseFocus_Impl();
808
809 SfxToolBoxControl::Dispatch( m_xDispatchProvider,
810 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CharFontName" )),
811 aArgs );
812 }
813 else
814 ReleaseFocus_Impl();
815 }
816 }
817
818 //========================================================================
819 // class SvxColorWindow_Impl --------------------------------------------------
820 //========================================================================
821 #ifndef WB_NO_DIRECTSELECT
822 #define WB_NO_DIRECTSELECT ((WinBits)0x04000000)
823 #endif
824
825 #define PALETTE_X 10
826 #define PALETTE_Y 11
827 #define PALETTE_SIZE (PALETTE_X * PALETTE_Y)
828
829 SvxColorWindow_Impl::SvxColorWindow_Impl( const OUString& rCommand,
830 USHORT nSlotId,
831 const Reference< XFrame >& rFrame,
832 const String& rWndTitle,
833 Window* pParentWindow ) :
834
835 SfxPopupWindow( nSlotId, rFrame, pParentWindow, WinBits( WB_BORDER | WB_STDFLOATWIN | WB_3DLOOK|WB_DIALOGCONTROL ) ),
836
837 theSlotId( nSlotId ),
838 aColorSet( this, WinBits( WB_ITEMBORDER | WB_NAMEFIELD | WB_3DLOOK | WB_NO_DIRECTSELECT) ),
839 maCommand( rCommand )
840
841 {
842 SfxObjectShell* pDocSh = SfxObjectShell::Current();
843 const SfxPoolItem* pItem = NULL;
844 XColorTable* pColorTable = NULL;
845 BOOL bKillTable = FALSE;
846 const Size aSize12( 13, 13 );
847
848 if ( pDocSh )
849 if ( 0 != ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) )
850 pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
851
852 if ( !pColorTable )
853 {
854 pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
855 bKillTable = TRUE;
856 }
857
858 if ( SID_ATTR_CHAR_COLOR_BACKGROUND == theSlotId || SID_BACKGROUND_COLOR == theSlotId )
859 {
860 aColorSet.SetStyle( aColorSet.GetStyle() | WB_NONEFIELD );
861 aColorSet.SetText( SVX_RESSTR( RID_SVXSTR_TRANSPARENT ) );
862 }
863 else if ( SID_ATTR_CHAR_COLOR == theSlotId || SID_ATTR_CHAR_COLOR2 == theSlotId || SID_EXTRUSION_3D_COLOR == theSlotId )
864 {
865 SfxPoolItem* pDummy;
866
867 Reference< XDispatchProvider > aDisp( GetFrame()->getController(), UNO_QUERY );
868 SfxQueryStatus aQueryStatus( aDisp,
869 SID_ATTR_AUTO_COLOR_INVALID,
870 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:AutoColorInvalid" )));
871 SfxItemState eState = aQueryStatus.QueryState( pDummy );
872 if( (SFX_ITEM_DEFAULT > eState) || ( SID_EXTRUSION_3D_COLOR == theSlotId ) )
873 {
874 aColorSet.SetStyle( aColorSet.GetStyle() | WB_NONEFIELD );
875 aColorSet.SetText( SVX_RESSTR( RID_SVXSTR_AUTOMATIC ) );
876 }
877 }
878
879 if ( pColorTable )
880 {
881 short i = 0;
882 long nCount = pColorTable->Count();
883 XColorEntry* pEntry = NULL;
884 ::Color aColWhite( COL_WHITE );
885 String aStrWhite( SVX_RES(RID_SVXITEMS_COLOR_WHITE) );
886
887 if ( nCount > PALETTE_SIZE )
888 // Show scrollbar if more than PALLETTE_SIZE colors are available
889 aColorSet.SetStyle( aColorSet.GetStyle() | WB_VSCROLL );
890
891 for ( i = 0; i < nCount; i++ )
892 {
893 pEntry = pColorTable->GetColor(i);
894 aColorSet.InsertItem( i+1, pEntry->GetColor(), pEntry->GetName() );
895 }
896
897 while ( i < PALETTE_SIZE )
898 {
899 // fill empty elements if less then PALLETTE_SIZE colors are available
900 aColorSet.InsertItem( i+1, aColWhite, aStrWhite );
901 i++;
902 }
903 }
904
905 aColorSet.SetSelectHdl( LINK( this, SvxColorWindow_Impl, SelectHdl ) );
906 aColorSet.SetColCount( PALETTE_X );
907 aColorSet.SetLineCount( PALETTE_Y );
908
909 lcl_CalcSizeValueSet( *this, aColorSet, aSize12 );
910
911 SetHelpId( HID_POPUP_COLOR );
912 aColorSet.SetHelpId( HID_POPUP_COLOR_CTRL );
913
914 SetText( rWndTitle );
915 aColorSet.Show();
916
917 AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ColorTableState" )));
918 if ( bKillTable )
919 delete pColorTable;
920 }
921
922 SvxColorWindow_Impl::~SvxColorWindow_Impl()
923 {
924 }
925
926 void SvxColorWindow_Impl::KeyInput( const KeyEvent& rKEvt )
927 {
928 aColorSet.KeyInput(rKEvt);
929 }
930
931 SfxPopupWindow* SvxColorWindow_Impl::Clone() const
932 {
933 return new SvxColorWindow_Impl( maCommand, theSlotId, GetFrame(), GetText(), GetParent() );
934 }
935
936 // -----------------------------------------------------------------------
937
938 IMPL_LINK( SvxColorWindow_Impl, SelectHdl, void *, EMPTYARG )
939 {
940 USHORT nItemId = aColorSet.GetSelectItemId();
941 SvxColorItem aColorItem( aColorSet.GetItemColor( nItemId ), theSlotId );
942
943 /* #i33380# DR 2004-09-03 Moved the following line above the Dispatch() calls.
944 This instance may be deleted in the meantime (i.e. when a dialog is opened
945 while in Dispatch()), accessing members will crash in this case. */
946 aColorSet.SetNoSelection();
947
948 if ( IsInPopupMode() )
949 EndPopupMode();
950
951 if ( !nItemId && ( SID_ATTR_CHAR_COLOR_BACKGROUND == theSlotId || SID_BACKGROUND_COLOR == theSlotId ) )
952 {
953 Sequence< PropertyValue > aArgs;
954 SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( GetFrame()->getController(), UNO_QUERY ),
955 maCommand,
956 aArgs );
957 }
958 else if ( !nItemId && (SID_ATTR_CHAR_COLOR == theSlotId || SID_ATTR_CHAR_COLOR2 == theSlotId || SID_EXTRUSION_3D_COLOR == theSlotId) )
959 {
960 SvxColorItem _aColorItem( COL_AUTO, theSlotId );
961 INetURLObject aObj( maCommand );
962
963 Any a;
964 Sequence< PropertyValue > aArgs( 1 );
965 aArgs[0].Name = aObj.GetURLPath();
966 _aColorItem.QueryValue( a );
967 aArgs[0].Value = a;
968 SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( GetFrame()->getController(), UNO_QUERY ),
969 maCommand,
970 aArgs );
971 }
972 else
973 {
974 INetURLObject aObj( maCommand );
975
976 Any a;
977 Sequence< PropertyValue > aArgs( 1 );
978 aArgs[0].Name = aObj.GetURLPath();
979 aColorItem.QueryValue( a );
980 aArgs[0].Value = a;
981 SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( GetFrame()->getController(), UNO_QUERY ),
982 maCommand,
983 aArgs );
984 }
985
986 return 0;
987 }
988
989 // -----------------------------------------------------------------------
990
991 void SvxColorWindow_Impl::Resize()
992 {
993 lcl_ResizeValueSet( *this, aColorSet);
994 }
995
996 // -----------------------------------------------------------------------
997
998 void SvxColorWindow_Impl::StartSelection()
999 {
1000 aColorSet.StartSelection();
1001 }
1002
1003 // -----------------------------------------------------------------------
1004
1005 BOOL SvxColorWindow_Impl::Close()
1006 {
1007 return SfxPopupWindow::Close();
1008 }
1009
1010 // -----------------------------------------------------------------------
1011
1012 void SvxColorWindow_Impl::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
1013 {
1014 if (( SFX_ITEM_DISABLED != eState ) && pState )
1015 {
1016 if (( nSID == SID_COLOR_TABLE ) && ( pState->ISA( SvxColorTableItem )))
1017 {
1018 XColorTable* pColorTable = pState ? ((SvxColorTableItem *)pState)->GetColorTable() : NULL;
1019
1020 if ( pColorTable )
1021 {
1022 // Die Liste der Farben (ColorTable) hat sich ge"andert:
1023 short i = 0;
1024 long nCount = pColorTable->Count();
1025 XColorEntry* pEntry = NULL;
1026 ::Color aColWhite( COL_WHITE );
1027 String aStrWhite( SVX_RES( RID_SVXITEMS_COLOR_WHITE ) );
1028
1029 // ScrollBar an oder aus
1030 WinBits nBits = aColorSet.GetStyle();
1031 if ( nCount > PALETTE_SIZE )
1032 nBits &= ~WB_VSCROLL;
1033 else
1034 nBits |= WB_VSCROLL;
1035 aColorSet.SetStyle( nBits );
1036
1037 for ( i = 0; i < nCount; ++i )
1038 {
1039 pEntry = pColorTable->GetColor(i);
1040 aColorSet.SetItemColor( i + 1, pEntry->GetColor() );
1041 aColorSet.SetItemText ( i + 1, pEntry->GetName() );
1042 }
1043
1044 while ( i < PALETTE_SIZE )
1045 {
1046 aColorSet.SetItemColor( i + 1, aColWhite );
1047 aColorSet.SetItemText ( i + 1, aStrWhite );
1048 i++;
1049 }
1050 }
1051 }
1052 }
1053 }
1054
1055 //========================================================================
1056 // class SvxFrameWindow_Impl --------------------------------------------------
1057 //========================================================================
1058
1059 SvxFrameWindow_Impl::SvxFrameWindow_Impl( USHORT nId, const Reference< XFrame >& rFrame, Window* pParentWindow ) :
1060
1061 SfxPopupWindow( nId, rFrame, pParentWindow, WinBits( WB_BORDER | WB_STDFLOATWIN | WB_3DLOOK | WB_DIALOGCONTROL ) ),
1062 aFrameSet ( this, WinBits( WB_ITEMBORDER | WB_DOUBLEBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT ) ),
1063 bParagraphMode(sal_False)
1064
1065 {
1066 BindListener();
1067 String sCommand(String::CreateFromAscii( ".uno:BorderReducedMode" ));
1068 AddStatusListener( sCommand );
1069 aImgList = ImageList( SVX_RES( IsHighContrast()? RID_SVXIL_FRAME_HC : RID_SVXIL_FRAME ) );
1070
1071 /*
1072 * 1 2 3 4
1073 * -------------------------------------
1074 * NONE LEFT RIGHT LEFTRIGHT
1075 * TOP BOTTOM TOPBOTTOM OUTER
1076 * -------------------------------------
1077 * HOR HORINNER VERINNER ALL <- kann ueber bParagraphMode
1078 * abgeschaltet werden
1079 */
1080
1081 USHORT i = 0;
1082
1083 for ( i=1; i<9; i++ )
1084 aFrameSet.InsertItem( i, aImgList.GetImage(i) );
1085
1086 //bParagraphMode should have been set in StateChanged
1087 if ( !bParagraphMode )
1088 for ( i = 9; i < 13; i++ )
1089 aFrameSet.InsertItem( i, aImgList.GetImage(i) );
1090
1091 aFrameSet.SetColCount( 4 );
1092 aFrameSet.SetSelectHdl( LINK( this, SvxFrameWindow_Impl, SelectHdl ) );
1093
1094 lcl_CalcSizeValueSet( *this, aFrameSet,Size( 20, 20 ));
1095
1096 SetHelpId( HID_POPUP_FRAME );
1097 SetText( SVX_RESSTR(RID_SVXSTR_FRAME) );
1098 aFrameSet.Show();
1099 }
1100 /*-- 22.09.2004 12:27:50---------------------------------------------------
1101
1102 -----------------------------------------------------------------------*/
1103 SvxFrameWindow_Impl::~SvxFrameWindow_Impl()
1104 {
1105 UnbindListener();
1106 }
1107
1108 SfxPopupWindow* SvxFrameWindow_Impl::Clone() const
1109 {
1110 //! HACK: wie bekomme ich den Paragraph-Mode ??
1111 return new SvxFrameWindow_Impl( GetId(), GetFrame(), GetParent() );
1112 }
1113
1114 Window* SvxFrameWindow_Impl::GetPreferredKeyInputWindow()
1115 {
1116 return &aFrameSet;
1117 }
1118
1119 void SvxFrameWindow_Impl::GetFocus()
1120 {
1121 aFrameSet.GrabFocus();
1122 }
1123
1124 void SvxFrameWindow_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1125 {
1126 SfxPopupWindow::DataChanged( rDCEvt );
1127
1128 if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
1129 {
1130 aImgList = ImageList( SVX_RES( IsHighContrast()? RID_SVXIL_FRAME_HC : RID_SVXIL_FRAME ) );
1131
1132 USHORT nNumOfItems = aFrameSet.GetItemCount();
1133
1134 for( USHORT i = 1 ; i <= nNumOfItems ; ++i )
1135 aFrameSet.SetItemImage( i, aImgList.GetImage( i ) );
1136 }
1137 }
1138 // -----------------------------------------------------------------------
1139
1140 #define FRM_VALID_LEFT 0x01
1141 #define FRM_VALID_RIGHT 0x02
1142 #define FRM_VALID_TOP 0x04
1143 #define FRM_VALID_BOTTOM 0x08
1144 #define FRM_VALID_HINNER 0x10
1145 #define FRM_VALID_VINNER 0x20
1146 #define FRM_VALID_OUTER 0x0f
1147 #define FRM_VALID_ALL 0xff
1148
1149 //
1150 // Per default bleiben ungesetzte Linien unveraendert
1151 // Mit Shift werden ungesetzte Linien zurueckgsetzt
1152 //
1153 IMPL_LINK( SvxFrameWindow_Impl, SelectHdl, void *, EMPTYARG )
1154 {
1155 ::Color aColBlack( COL_BLACK );
1156 SvxBoxItem aBorderOuter( SID_ATTR_BORDER_OUTER );
1157 SvxBoxInfoItem aBorderInner( SID_ATTR_BORDER_INNER );
1158 SvxBorderLine theDefLine;
1159 SvxBorderLine *pLeft = 0,
1160 *pRight = 0,
1161 *pTop = 0,
1162 *pBottom = 0;
1163 USHORT nSel = aFrameSet.GetSelectItemId();
1164 USHORT nModifier = aFrameSet.GetModifier();
1165 BYTE nValidFlags = 0;
1166
1167 theDefLine.SetOutWidth( DEF_LINE_WIDTH_0 );
1168 switch ( nSel )
1169 {
1170 case 1: nValidFlags |= FRM_VALID_ALL;
1171 break; // NONE
1172 case 2: pLeft = &theDefLine;
1173 nValidFlags |= FRM_VALID_LEFT;
1174 break; // LEFT
1175 case 3: pRight = &theDefLine;
1176 nValidFlags |= FRM_VALID_RIGHT;
1177 break; // RIGHT
1178 case 4: pLeft = pRight = &theDefLine;
1179 nValidFlags |= FRM_VALID_RIGHT|FRM_VALID_LEFT;
1180 break; // LEFTRIGHT
1181 case 5: pTop = &theDefLine;
1182 nValidFlags |= FRM_VALID_TOP;
1183 break; // TOP
1184 case 6: pBottom = &theDefLine;
1185 nValidFlags |= FRM_VALID_BOTTOM;
1186 break; // BOTTOM
1187 case 7: pTop = pBottom = &theDefLine;
1188 nValidFlags |= FRM_VALID_BOTTOM|FRM_VALID_TOP;
1189 break; // TOPBOTTOM
1190 case 8: pLeft = pRight = pTop = pBottom = &theDefLine;
1191 nValidFlags |= FRM_VALID_OUTER;
1192 break; // OUTER
1193
1194 // Tabelle innen:
1195 case 9: // HOR
1196 pTop = pBottom = &theDefLine;
1197 aBorderInner.SetLine( &theDefLine, BOXINFO_LINE_HORI );
1198 aBorderInner.SetLine( NULL, BOXINFO_LINE_VERT );
1199 nValidFlags |= FRM_VALID_HINNER|FRM_VALID_TOP|FRM_VALID_BOTTOM;
1200 break;
1201
1202 case 10: // HORINNER
1203 pLeft = pRight = pTop = pBottom = &theDefLine;
1204 aBorderInner.SetLine( &theDefLine, BOXINFO_LINE_HORI );
1205 aBorderInner.SetLine( NULL, BOXINFO_LINE_VERT );
1206 nValidFlags |= FRM_VALID_RIGHT|FRM_VALID_LEFT|FRM_VALID_HINNER|FRM_VALID_TOP|FRM_VALID_BOTTOM;
1207 break;
1208
1209 case 11: // VERINNER
1210 pLeft = pRight = pTop = pBottom = &theDefLine;
1211 aBorderInner.SetLine( NULL, BOXINFO_LINE_HORI );
1212 aBorderInner.SetLine( &theDefLine, BOXINFO_LINE_VERT );
1213 nValidFlags |= FRM_VALID_RIGHT|FRM_VALID_LEFT|FRM_VALID_VINNER|FRM_VALID_TOP|FRM_VALID_BOTTOM;
1214 break;
1215
1216 case 12: // ALL
1217 pLeft = pRight = pTop = pBottom = &theDefLine;
1218 aBorderInner.SetLine( &theDefLine, BOXINFO_LINE_HORI );
1219 aBorderInner.SetLine( &theDefLine, BOXINFO_LINE_VERT );
1220 nValidFlags |= FRM_VALID_ALL;
1221 break;
1222
1223 default:
1224 break;
1225 }
1226 aBorderOuter.SetLine( pLeft, BOX_LINE_LEFT );
1227 aBorderOuter.SetLine( pRight, BOX_LINE_RIGHT );
1228 aBorderOuter.SetLine( pTop, BOX_LINE_TOP );
1229 aBorderOuter.SetLine( pBottom, BOX_LINE_BOTTOM );
1230
1231 if(nModifier == KEY_SHIFT)
1232 nValidFlags |= FRM_VALID_ALL;
1233 aBorderInner.SetValid( VALID_TOP, 0 != (nValidFlags&FRM_VALID_TOP ));
1234 aBorderInner.SetValid( VALID_BOTTOM, 0 != (nValidFlags&FRM_VALID_BOTTOM ));
1235 aBorderInner.SetValid( VALID_LEFT, 0 != (nValidFlags&FRM_VALID_LEFT));
1236 aBorderInner.SetValid( VALID_RIGHT, 0 != (nValidFlags&FRM_VALID_RIGHT ));
1237 aBorderInner.SetValid( VALID_HORI, 0 != (nValidFlags&FRM_VALID_HINNER ));
1238 aBorderInner.SetValid( VALID_VERT, 0 != (nValidFlags&FRM_VALID_VINNER));
1239 aBorderInner.SetValid( VALID_DISTANCE, TRUE );
1240 aBorderInner.SetValid( VALID_DISABLE, FALSE );
1241
1242 if ( IsInPopupMode() )
1243 EndPopupMode();
1244
1245 Any a;
1246 Sequence< PropertyValue > aArgs( 2 );
1247 aArgs[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "OuterBorder" ));
1248 aBorderOuter.QueryValue( a );
1249 aArgs[0].Value = a;
1250 aArgs[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "InnerBorder" ));
1251 aBorderInner.QueryValue( a );
1252 aArgs[1].Value = a;
1253
1254 /* #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
1255 This instance may be deleted in the meantime (i.e. when a dialog is opened
1256 while in Dispatch()), accessing members will crash in this case. */
1257 aFrameSet.SetNoSelection();
1258
1259 SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( GetFrame()->getController(), UNO_QUERY ),
1260 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:SetBorderStyle" )),
1261 aArgs );
1262 return 0;
1263 }
1264
1265 // -----------------------------------------------------------------------
1266
1267 void SvxFrameWindow_Impl::Resize()
1268 {
1269 lcl_ResizeValueSet( *this, aFrameSet);
1270 }
1271
1272 // -----------------------------------------------------------------------
1273
1274 void SvxFrameWindow_Impl::StateChanged(
1275
1276 USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
1277
1278 {
1279 if ( pState && nSID == SID_BORDER_REDUCED_MODE)
1280 {
1281 const SfxBoolItem* pItem = PTR_CAST( SfxBoolItem, pState );
1282
1283 if ( pItem )
1284 {
1285 bParagraphMode = (BOOL)pItem->GetValue();
1286 //initial calls mustn't insert or remove elements
1287 if(aFrameSet.GetItemCount())
1288 {
1289 BOOL bTableMode = ( aFrameSet.GetItemCount() == 12 );
1290 BOOL bResize = FALSE;
1291
1292 if ( bTableMode && bParagraphMode )
1293 {
1294 for ( USHORT i = 9; i < 13; i++ )
1295 aFrameSet.RemoveItem(i);
1296 bResize = TRUE;
1297 }
1298 else if ( !bTableMode && !bParagraphMode )
1299 {
1300 for ( USHORT i = 9; i < 13; i++ )
1301 aFrameSet.InsertItem( i, aImgList.GetImage(i) );
1302 bResize = TRUE;
1303 }
1304
1305 if ( bResize )
1306 {
1307 lcl_CalcSizeValueSet( *this, aFrameSet,Size( 20, 20 ));
1308 }
1309 }
1310 }
1311 }
1312 SfxPopupWindow::StateChanged( nSID, eState, pState );
1313 }
1314
1315 // -----------------------------------------------------------------------
1316
1317 void SvxFrameWindow_Impl::StartSelection()
1318 {
1319 aFrameSet.StartSelection();
1320 }
1321
1322 // -----------------------------------------------------------------------
1323
1324 BOOL SvxFrameWindow_Impl::Close()
1325 {
1326 return SfxPopupWindow::Close();
1327 }
1328
1329 //========================================================================
1330 // class SvxLineWindow_Impl --------------------------------------------------
1331 //========================================================================
1332
1333 SvxLineWindow_Impl::SvxLineWindow_Impl( USHORT nId, const Reference< XFrame >& rFrame, Window* pParentWindow ) :
1334
1335 SfxPopupWindow( nId, rFrame, pParentWindow, WinBits( WB_BORDER | WB_STDFLOATWIN | WB_3DLOOK | WB_DIALOGCONTROL ) ),
1336
1337 aLineSet( this, WinBits( WB_3DLOOK | WB_ITEMBORDER | WB_DOUBLEBORDER | WB_NAMEFIELD | WB_NONEFIELD | WB_NO_DIRECTSELECT ) )
1338 {
1339 try
1340 {
1341 Reference< lang::XServiceInfo > xServices( rFrame->getController()->getModel(), UNO_QUERY_THROW );
1342 m_bIsWriter = xServices->supportsService(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextDocument")));
1343 }
1344 catch(const uno::Exception& )
1345 {
1346 }
1347 Size aBmpSize( 55, 12 );
1348 CreateBitmaps();
1349
1350 aLineSet.SetColCount( 2 );
1351 aLineSet.SetSelectHdl( LINK( this, SvxLineWindow_Impl, SelectHdl ) );
1352 aLineSet.SetText( SVX_RESSTR(STR_NONE) );
1353
1354 lcl_CalcSizeValueSet( *this, aLineSet, aBmpSize );
1355
1356 SetHelpId( HID_POPUP_LINE );
1357 SetText( SVX_RESSTR(RID_SVXSTR_FRAME_STYLE) );
1358 aLineSet.Show();
1359 }
1360
1361 SfxPopupWindow* SvxLineWindow_Impl::Clone() const
1362 {
1363 return new SvxLineWindow_Impl( GetId(), GetFrame(), GetParent() );
1364 }
1365
1366 // -----------------------------------------------------------------------
1367
1368 void SvxLineWindow_Impl::MakeLineBitmap( USHORT nNo, Bitmap& rBmp, const Size& rSize, String& rStr,
1369 const ::Color& rLineCol, const ::Color& rBackCol )
1370 {
1371 VirtualDevice aVirDev( *this );
1372 Rectangle aRect( Point(2,0), Size(rSize.Width()-4,0) );
1373
1374 // grau einfaerben und Bitmap sichern:
1375 aVirDev.SetOutputSizePixel( rSize );
1376 aVirDev.SetLineColor();
1377 aVirDev.SetFillColor( rBackCol );
1378 aVirDev.DrawRect( Rectangle( Point(0,0), rSize ) );
1379 aVirDev.SetFillColor( rLineCol );
1380
1381 sal_uInt16 nLineWidth = 0;
1382 switch ( nNo )
1383 {
1384 case 1: // DEF_LINE_WIDTH_0
1385 aRect.Top() = 6;
1386 aRect.Bottom() = 6;
1387 aVirDev.DrawRect( aRect );
1388 break;
1389
1390 case 2: // DEF_LINE_WIDTH_1
1391 aRect.Top() = 5;
1392 aRect.Bottom() = 6;
1393 aVirDev.DrawRect( aRect );
1394 nLineWidth = (USHORT) DEF_LINE_WIDTH_1/20;
1395 break;
1396
1397 case 3: // DEF_LINE_WIDTH_2
1398 aRect.Top() = 5;
1399 aRect.Bottom() = 7;
1400 aVirDev.DrawRect( aRect );
1401 nLineWidth = (USHORT) DEF_LINE_WIDTH_2/20;
1402 break;
1403
1404 case 4: // DEF_LINE_WIDTH_3
1405 aRect.Top() = 4;
1406 aRect.Bottom() = 7;
1407 aVirDev.DrawRect( aRect );
1408 aVirDev.DrawRect( Rectangle( Point(2,4), Point(37,7) ) );
1409 nLineWidth = (USHORT) DEF_LINE_WIDTH_3/20;
1410 break;
1411
1412 case 5: // DEF_LINE_WIDTH_4
1413 aRect.Top() = 4;
1414 aRect.Bottom() = 8;
1415 aVirDev.DrawRect( aRect );
1416 nLineWidth = (USHORT) DEF_LINE_WIDTH_4/20;
1417 break;
1418
1419 case 6: // DEF_DOUBLE_LINE0
1420 aRect.Top() = 5;
1421 aRect.Bottom() = 5;
1422 aVirDev.DrawRect( aRect );
1423 aRect.Top() = 7;
1424 aRect.Bottom() = 7;
1425 aVirDev.DrawRect( aRect );
1426 nLineWidth = (USHORT) (DEF_DOUBLE_LINE0_OUT+DEF_DOUBLE_LINE0_IN+DEF_DOUBLE_LINE0_DIST)/20;
1427 break;
1428
1429 case 7: // DEF_DOUBLE_LINE7
1430 aRect.Top() = 4;
1431 aRect.Bottom() = 4;
1432 aVirDev.DrawRect( aRect );
1433 aRect.Top() = 7;
1434 aRect.Bottom() = 7;
1435 aVirDev.DrawRect( aRect );
1436 nLineWidth = (USHORT) (DEF_DOUBLE_LINE7_OUT+DEF_DOUBLE_LINE7_IN+DEF_DOUBLE_LINE7_DIST)/20;
1437 break;
1438
1439 case 8: // DEF_DOUBLE_LINE1
1440 aRect.Top() = 4;
1441 aRect.Bottom() = 5;
1442 aVirDev.DrawRect( aRect );
1443 aRect.Top() = 7;
1444 aRect.Bottom() = 8;
1445 aVirDev.DrawRect( aRect );
1446 nLineWidth = (USHORT) (DEF_DOUBLE_LINE1_OUT+DEF_DOUBLE_LINE1_IN+DEF_DOUBLE_LINE1_DIST)/20;
1447 break;
1448
1449 case 9: // DEF_DOUBLE_LINE2
1450 aRect.Top() = 3;
1451 aRect.Bottom() = 5;
1452 aVirDev.DrawRect( aRect );
1453 aRect.Top() = 8;
1454 aRect.Bottom() = 10;
1455 aVirDev.DrawRect( aRect );
1456 nLineWidth = (USHORT) (DEF_DOUBLE_LINE2_OUT+DEF_DOUBLE_LINE2_IN+DEF_DOUBLE_LINE2_DIST)/20;
1457 break;
1458
1459 case 10: // DEF_DOUBLE_LINE8
1460 aRect.Top() = 3;
1461 aRect.Bottom() = 4;
1462 aVirDev.DrawRect( aRect );
1463 aRect.Top() = 7;
1464 aRect.Bottom() = 7;
1465 aVirDev.DrawRect( aRect );
1466 nLineWidth = (USHORT) (DEF_DOUBLE_LINE8_OUT+DEF_DOUBLE_LINE8_IN+DEF_DOUBLE_LINE8_DIST)/20;
1467 break;
1468
1469 case 11: // DEF_DOUBLE_LINE9
1470 aRect.Top() = 3;
1471 aRect.Bottom() = 5;
1472 aVirDev.DrawRect( aRect );
1473 aRect.Top() = 8;
1474 aRect.Bottom() = 8;
1475 aVirDev.DrawRect( aRect );
1476 nLineWidth = (USHORT) (DEF_DOUBLE_LINE9_OUT+DEF_DOUBLE_LINE9_IN+DEF_DOUBLE_LINE9_DIST)/20;
1477 break;
1478
1479 case 12: // DEF_DOUBLE_LINE10
1480 aRect.Top() = 2;
1481 aRect.Bottom() = 5;
1482 aVirDev.DrawRect( aRect );
1483 aRect.Top() = 8;
1484 aRect.Bottom() = 8;
1485 aVirDev.DrawRect( aRect );
1486 nLineWidth = (USHORT) (DEF_DOUBLE_LINE10_OUT+DEF_DOUBLE_LINE10_IN+DEF_DOUBLE_LINE10_DIST)/20;
1487 break;
1488
1489 case 13: // DEF_DOUBLE_LINE3
1490 aRect.Top() = 4;
1491 aRect.Bottom() = 5;
1492 aVirDev.DrawRect( aRect );
1493 aRect.Top() = 7;
1494 aRect.Bottom() = 7;
1495 aVirDev.DrawRect( aRect );
1496 nLineWidth = (USHORT) (DEF_DOUBLE_LINE3_OUT+DEF_DOUBLE_LINE3_IN+DEF_DOUBLE_LINE3_DIST)/20;
1497 break;
1498
1499 case 14: // DEF_DOUBLE_LINE4
1500 aRect.Top() = 4;
1501 aRect.Bottom() = 4;
1502 aVirDev.DrawRect( aRect );
1503 aRect.Top() = 6;
1504 aRect.Bottom() = 7;
1505 aVirDev.DrawRect( aRect );
1506 nLineWidth = (USHORT) (DEF_DOUBLE_LINE4_OUT+DEF_DOUBLE_LINE4_IN+DEF_DOUBLE_LINE4_DIST)/20;
1507 break;
1508
1509 case 15: // DEF_DOUBLE_LINE5
1510 aRect.Top() = 3;
1511 aRect.Bottom() = 5;
1512 aVirDev.DrawRect( aRect );
1513 aRect.Top() = 8;
1514 aRect.Bottom() = 9;
1515 aVirDev.DrawRect( aRect );
1516 nLineWidth = (USHORT) (DEF_DOUBLE_LINE5_OUT+DEF_DOUBLE_LINE5_IN+DEF_DOUBLE_LINE5_DIST)/20;
1517 break;
1518
1519 case 16: // DEF_DOUBLE_LINE6
1520 aRect.Top() = 3;
1521 aRect.Bottom() = 4;
1522 aVirDev.DrawRect( aRect );
1523 aRect.Top() = 7;
1524 aRect.Bottom() = 9;
1525 aVirDev.DrawRect( aRect );
1526 nLineWidth = (USHORT) (DEF_DOUBLE_LINE6_OUT+DEF_DOUBLE_LINE6_IN+DEF_DOUBLE_LINE6_DIST)/20;
1527 break;
1528
1529 default:
1530 break;
1531 }
1532 if ( nLineWidth )
1533 {
1534 rStr = String::CreateFromInt32( nLineWidth );
1535 rStr.AppendAscii(" pt");
1536 }
1537 rBmp = aVirDev.GetBitmap( Point(0,0), rSize );
1538 }
1539
1540 // -----------------------------------------------------------------------
1541
1542 IMPL_LINK( SvxLineWindow_Impl, SelectHdl, void *, EMPTYARG )
1543 {
1544 SvxLineItem aLineItem( SID_FRAME_LINESTYLE );
1545 USHORT n1 = 0,
1546 n2 = 0,
1547 n3 = 0;
1548 BOOL bSetLine = TRUE;
1549
1550 switch ( aLineSet.GetSelectItemId() )
1551 {
1552 case 1: n1 = DEF_LINE_WIDTH_0; break;
1553 case 2: n1 = DEF_LINE_WIDTH_1; break;
1554 case 3: n1 = DEF_LINE_WIDTH_2; break;
1555 case 4: n1 = DEF_LINE_WIDTH_3; break;
1556 case 5: n1 = DEF_LINE_WIDTH_4; break;
1557
1558 case 6: n1 = DEF_DOUBLE_LINE0_OUT;
1559 n2 = DEF_DOUBLE_LINE0_IN;
1560 n3 = DEF_DOUBLE_LINE0_DIST; break;
1561 case 7: n1 = DEF_DOUBLE_LINE7_OUT;
1562 n2 = DEF_DOUBLE_LINE7_IN;
1563 n3 = DEF_DOUBLE_LINE7_DIST; break;
1564 case 8: n1 = DEF_DOUBLE_LINE1_OUT;
1565 n2 = DEF_DOUBLE_LINE1_IN;
1566 n3 = DEF_DOUBLE_LINE1_DIST; break;
1567 case 9: n1 = DEF_DOUBLE_LINE2_OUT;
1568 n2 = DEF_DOUBLE_LINE2_IN;
1569 n3 = DEF_DOUBLE_LINE2_DIST; break;
1570 case 10: n1 = DEF_DOUBLE_LINE8_OUT;
1571 n2 = DEF_DOUBLE_LINE8_IN;
1572 n3 = DEF_DOUBLE_LINE8_DIST; break;
1573 case 11: n1 = DEF_DOUBLE_LINE9_OUT;
1574 n2 = DEF_DOUBLE_LINE9_IN;
1575 n3 = DEF_DOUBLE_LINE9_DIST; break;
1576 case 12: n1 = DEF_DOUBLE_LINE10_OUT;
1577 n2 = DEF_DOUBLE_LINE10_IN;
1578 n3 = DEF_DOUBLE_LINE10_DIST; break;
1579 case 13: n1 = DEF_DOUBLE_LINE3_OUT;
1580 n2 = DEF_DOUBLE_LINE3_IN;
1581 n3 = DEF_DOUBLE_LINE3_DIST; break;
1582 case 14: n1 = DEF_DOUBLE_LINE4_OUT;
1583 n2 = DEF_DOUBLE_LINE4_IN;
1584 n3 = DEF_DOUBLE_LINE4_DIST; break;
1585 case 15: n1 = DEF_DOUBLE_LINE5_OUT;
1586 n2 = DEF_DOUBLE_LINE5_IN;
1587 n3 = DEF_DOUBLE_LINE5_DIST; break;
1588 case 16: n1 = DEF_DOUBLE_LINE6_OUT;
1589 n2 = DEF_DOUBLE_LINE6_IN;
1590 n3 = DEF_DOUBLE_LINE6_DIST; break;
1591 case 0:
1592 default:
1593 bSetLine = FALSE;
1594 break;
1595 }
1596 if ( bSetLine )
1597 {
1598 SvxBorderLine aTmp( NULL, n1, n2, n3 );
1599 aLineItem.SetLine( &aTmp );
1600 }
1601 else
1602 aLineItem.SetLine( 0 );
1603
1604 if ( IsInPopupMode() )
1605 EndPopupMode();
1606
1607 Any a;
1608 Sequence< PropertyValue > aArgs( 1 );
1609 aArgs[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "LineStyle" ));
1610 aLineItem.QueryValue( a, m_bIsWriter ? CONVERT_TWIPS : 0 );
1611 aArgs[0].Value = a;
1612
1613 /* #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
1614 This instance may be deleted in the meantime (i.e. when a dialog is opened
1615 while in Dispatch()), accessing members will crash in this case. */
1616 aLineSet.SetNoSelection();
1617
1618 SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( GetFrame()->getController(), UNO_QUERY ),
1619 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:LineStyle" )),
1620 aArgs );
1621 return 0;
1622 }
1623
1624 // -----------------------------------------------------------------------
1625
1626 void SvxLineWindow_Impl::Resize()
1627 {
1628 lcl_ResizeValueSet( *this, aLineSet);
1629 }
1630
1631 // -----------------------------------------------------------------------
1632
1633 void SvxLineWindow_Impl::StartSelection()
1634 {
1635 aLineSet.StartSelection();
1636 }
1637
1638 // -----------------------------------------------------------------------
1639
1640 BOOL SvxLineWindow_Impl::Close()
1641 {
1642 return SfxPopupWindow::Close();
1643 }
1644
1645 // -----------------------------------------------------------------------
1646
1647 Window* SvxLineWindow_Impl::GetPreferredKeyInputWindow()
1648 {
1649 return &aLineSet;
1650 }
1651
1652 // -----------------------------------------------------------------------
1653
1654 void SvxLineWindow_Impl::GetFocus()
1655 {
1656 aLineSet.GrabFocus();
1657 }
1658
1659 void SvxLineWindow_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1660 {
1661 SfxPopupWindow::DataChanged( rDCEvt );
1662
1663 if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
1664 {
1665 CreateBitmaps();
1666 Invalidate();
1667 }
1668 }
1669
1670 void SvxLineWindow_Impl::CreateBitmaps( void )
1671 {
1672 Size aBmpSize( 55, 12 );
1673 Bitmap aBmp;
1674 String aStr;
1675
1676 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1677 svtools::ColorConfig aColorConfig;
1678 ::Color aLineCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
1679 ::Color aBackCol( rStyleSettings.GetWindowColor() );
1680 aLineSet.Clear();
1681
1682 for( USHORT i = 1 ; i < 17 ; ++i )
1683 {
1684 MakeLineBitmap( i, aBmp, aBmpSize, aStr, aLineCol, aBackCol );
1685 aLineSet.InsertItem( i, aBmp, aStr );
1686 }
1687 }
1688
1689 // -----------------------------------------------------------------------
1690
1691 //########################################################################
1692 // Hilfsklassen
1693
1694 //========================================================================
1695 // class SfxStyleControllerItem_Impl ------------------------------------------
1696 //========================================================================
1697
1698 SfxStyleControllerItem_Impl::SfxStyleControllerItem_Impl(
1699 const Reference< XDispatchProvider >& rDispatchProvider,
1700 USHORT nSlotId, // Family-ID
1701 const rtl::OUString& rCommand, // .uno: command bound to this item
1702 SvxStyleToolBoxControl& rTbxCtl ) // Controller-Instanz, dem dieses Item zugeordnet ist.
1703 : SfxStatusListener( rDispatchProvider, nSlotId, rCommand ),
1704 rControl( rTbxCtl )
1705 {
1706 }
1707
1708 // -----------------------------------------------------------------------
1709
1710 void SfxStyleControllerItem_Impl::StateChanged(
1711 USHORT, SfxItemState eState, const SfxPoolItem* pState )
1712 {
1713 switch ( GetId() )
1714 {
1715 case SID_STYLE_FAMILY1:
1716 case SID_STYLE_FAMILY2:
1717 case SID_STYLE_FAMILY3:
1718 case SID_STYLE_FAMILY4:
1719 case SID_STYLE_FAMILY5:
1720 {
1721 const USHORT nIdx = GetId() - SID_STYLE_FAMILY_START;
1722
1723 if ( SFX_ITEM_AVAILABLE == eState )
1724 {
1725 const SfxTemplateItem* pStateItem =
1726 PTR_CAST( SfxTemplateItem, pState );
1727 DBG_ASSERT( pStateItem != NULL, "SfxTemplateItem expected" );
1728 rControl.SetFamilyState( nIdx, pStateItem );
1729 }
1730 else
1731 rControl.SetFamilyState( nIdx, NULL );
1732 break;
1733 }
1734 }
1735 }
1736
1737 //########################################################################
1738
1739 //========================================================================
1740 // class SvxStyleToolBoxControl ------------------------------------------
1741 //========================================================================
1742
1743 struct SvxStyleToolBoxControl::Impl
1744 {
1745 String aClearForm;
1746 String aMore;
1747 ::std::vector< ::rtl::OUString > aDefaultStyles;
1748 BOOL bListening;
1749 BOOL bSpecModeWriter;
1750 BOOL bSpecModeCalc;
1751
1752 inline Impl( void )
1753 :aClearForm ( SVX_RESSTR( RID_SVXSTR_CLEARFORM ) )
1754 ,aMore ( SVX_RESSTR( RID_SVXSTR_MORE ) )
1755 ,bListening ( FALSE )
1756 ,bSpecModeWriter ( FALSE )
1757 ,bSpecModeCalc ( FALSE )
1758 {
1759
1760
1761 }
1762 void InitializeStyles(Reference < frame::XModel > xModel)
1763 {
1764 //now convert the default style names to the localized names
1765 try
1766 {
1767 Reference< style::XStyleFamiliesSupplier > xStylesSupplier( xModel, UNO_QUERY_THROW );
1768 Reference< lang::XServiceInfo > xServices( xModel, UNO_QUERY_THROW );
1769 bSpecModeWriter = xServices->supportsService(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextDocument")));
1770 if(bSpecModeWriter)
1771 {
1772 Reference<container::XNameAccess> xParaStyles;
1773 xStylesSupplier->getStyleFamilies()->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ParagraphStyles"))) >>=
1774 xParaStyles;
1775 static const sal_Char* aWriterStyles[] =
1776 {
1777 "Standard",
1778 "Heading 1",
1779 "Heading 2",
1780 "Heading 3",
1781 "Text body"
1782 };
1783 for( sal_uInt32 nStyle = 0; nStyle < sizeof( aWriterStyles ) / sizeof( sal_Char*); ++nStyle )
1784 {
1785 try
1786 {
1787 Reference< beans::XPropertySet > xStyle;
1788 xParaStyles->getByName( rtl::OUString::createFromAscii( aWriterStyles[nStyle] )) >>= xStyle;
1789 ::rtl::OUString sName;
1790 xStyle->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DisplayName"))) >>= sName;
1791 if( sName.getLength() )
1792 aDefaultStyles.push_back(sName);
1793 }
1794 catch( const uno::Exception& )
1795 {}
1796 }
1797
1798 }
1799 else if( 0 != (
1800 bSpecModeCalc = xServices->supportsService(::rtl::OUString(
1801 RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SpreadsheetDocument")))))
1802 {
1803 static const sal_Char* aCalcStyles[] =
1804 {
1805 "Default",
1806 "Heading 1",
1807 "Heading 2",
1808 "Result",
1809 "Result2"
1810 };
1811 Reference<container::XNameAccess> xCellStyles;
1812 xStylesSupplier->getStyleFamilies()->getByName(
1813 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellStyles"))) >>=
1814 xCellStyles;
1815 for( sal_uInt32 nStyle = 0; nStyle < sizeof( aCalcStyles ) / sizeof( sal_Char*); ++nStyle )
1816 {
1817 try
1818 {
1819 Reference< beans::XPropertySet > xStyle;
1820 xCellStyles->getByName( rtl::OUString::createFromAscii( aCalcStyles[nStyle] )) >>= xStyle;
1821 ::rtl::OUString sName;
1822 xStyle->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DisplayName")))>>= sName;
1823 if( sName.getLength() )
1824 aDefaultStyles.push_back(sName);
1825 }
1826 catch( const uno::Exception& )
1827 {}
1828 }
1829 }
1830 }
1831 catch(const uno::Exception& )
1832 {
1833 DBG_ERROR("error while initializing style names");
1834 }
1835 }
1836 };
1837
1838
1839 // mapping table from bound items. BE CAREFUL this table must be in the
1840 // same order as the uno commands bound to the slots SID_STYLE_FAMILY1..n
1841 // MAX_FAMILIES must also be correctly set!
1842 static const char* StyleSlotToStyleCommand[MAX_FAMILIES] =
1843 {
1844 ".uno:CharStyle",
1845 ".uno:ParaStyle",
1846 ".uno:FrameStyle",
1847 ".uno:PageStyle",
1848 ".uno:TemplateFamily5"
1849 };
1850
1851 SvxStyleToolBoxControl::SvxStyleToolBoxControl(
1852 USHORT nSlotId, USHORT nId, ToolBox& rTbx )
1853 : SfxToolBoxControl ( nSlotId, nId, rTbx ),
1854 pStyleSheetPool ( NULL ),
1855 nActFamily ( 0xffff ),
1856 bListening ( FALSE ),
1857 pImpl ( new Impl )
1858 {
1859 for ( USHORT i=0; i<MAX_FAMILIES; i++ )
1860 {
1861 pBoundItems[i] = 0;
1862 m_xBoundItems[i] = Reference< XComponent >();
1863 pFamilyState[i] = NULL;
1864 }
1865 }
1866
1867 // -----------------------------------------------------------------------
1868 SvxStyleToolBoxControl::~SvxStyleToolBoxControl()
1869 {
1870 }
1871
1872 // -----------------------------------------------------------------------
1873 void SAL_CALL SvxStyleToolBoxControl::initialize( const Sequence< Any >& aArguments )
1874 throw ( Exception, RuntimeException)
1875 {
1876 SfxToolBoxControl::initialize( aArguments );
1877
1878 // After initialize we should have a valid frame member where we can retrieve our
1879 // dispatch provider.
1880 if ( m_xFrame.is() )
1881 {
1882 pImpl->InitializeStyles(m_xFrame->getController()->getModel());
1883 Reference< XDispatchProvider > xDispatchProvider( m_xFrame->getController(), UNO_QUERY );
1884 for ( USHORT i=0; i<MAX_FAMILIES; i++ )
1885 {
1886 pBoundItems[i] = new SfxStyleControllerItem_Impl( xDispatchProvider,
1887 SID_STYLE_FAMILY_START + i,
1888 OUString::createFromAscii( StyleSlotToStyleCommand[i] ),
1889 *this );
1890 m_xBoundItems[i] = Reference< XComponent >( static_cast< OWeakObject* >( pBoundItems[i] ), UNO_QUERY );
1891 pFamilyState[i] = NULL;
1892 }
1893 }
1894 }
1895
1896 // XComponent
1897 void SAL_CALL SvxStyleToolBoxControl::dispose()
1898 throw (::com::sun::star::uno::RuntimeException)
1899 {
1900 SfxToolBoxControl::dispose();
1901
1902 for( USHORT i=0; i<MAX_FAMILIES; i++ )
1903 {
1904 if ( m_xBoundItems[i].is() )
1905 {
1906 try
1907 {
1908 m_xBoundItems[i]->dispose();
1909 }
1910 catch ( Exception& )
1911 {
1912 }
1913
1914 m_xBoundItems[i].clear();
1915 pBoundItems[i] = 0;
1916 }
1917 DELETEZ( pFamilyState[i] );
1918 }
1919 pStyleSheetPool = NULL;
1920 DELETEZ( pImpl );
1921 }
1922
1923 // -----------------------------------------------------------------------
1924 void SAL_CALL SvxStyleToolBoxControl::update() throw (RuntimeException)
1925 {
1926 // Do nothing, we will start binding our listener when we are visible.
1927 // See link SvxStyleToolBoxControl::VisibilityNotification.
1928 SvxStyleBox_Impl* pBox = (SvxStyleBox_Impl*)GetToolBox().GetItemWindow( GetId() );
1929 if ( pBox->IsVisible() )
1930 {
1931 for ( int i=0; i<MAX_FAMILIES; i++ )
1932 pBoundItems [i]->ReBind();
1933
1934 bindListener();
1935 }
1936 }
1937
1938 // -----------------------------------------------------------------------
1939
1940 SfxStyleFamily SvxStyleToolBoxControl::GetActFamily()
1941 {
1942 switch ( nActFamily-1 + SID_STYLE_FAMILY_START )
1943 {
1944 case SID_STYLE_FAMILY1: return SFX_STYLE_FAMILY_CHAR;
1945 case SID_STYLE_FAMILY2: return SFX_STYLE_FAMILY_PARA;
1946 case SID_STYLE_FAMILY3: return SFX_STYLE_FAMILY_FRAME;
1947 case SID_STYLE_FAMILY4: return SFX_STYLE_FAMILY_PAGE;
1948 case SID_STYLE_FAMILY5: return SFX_STYLE_FAMILY_PSEUDO;
1949 default:
1950 DBG_ERROR( "unknown style family" );
1951 break;
1952 }
1953 return SFX_STYLE_FAMILY_PARA;
1954 }
1955
1956 // -----------------------------------------------------------------------
1957
1958 void SvxStyleToolBoxControl::FillStyleBox()
1959 {
1960 SvxStyleBox_Impl* pBox = (SvxStyleBox_Impl*)GetToolBox().GetItemWindow( GetId() );
1961
1962 DBG_ASSERT( pStyleSheetPool, "StyleSheetPool not found!" );
1963 DBG_ASSERT( pBox, "Control not found!" );
1964
1965 if ( pStyleSheetPool && pBox && nActFamily!=0xffff )
1966 {
1967 const SfxStyleFamily eFamily = GetActFamily();
1968 USHORT nCount = pStyleSheetPool->Count();
1969 USHORT i = 0;
1970 SfxStyleSheetBase* pStyle = NULL;
1971 BOOL bDoFill = FALSE;
1972
1973 pStyleSheetPool->SetSearchMask( eFamily, SFXSTYLEBIT_USED );
1974
1975 //------------------------------
1976 // Ueberpruefen, ob Fill noetig:
1977 //------------------------------
1978
1979 pStyle = pStyleSheetPool->First();
1980 //!!! TODO: This condition isn't right any longer, because we always show some default entries
1981 //!!! so the list doesn't show the count
1982 if ( nCount != pBox->GetEntryCount() )
1983 {
1984 bDoFill = TRUE;
1985 }
1986 else
1987 {
1988 while ( pStyle && !bDoFill )
1989 {
1990 bDoFill = ( pBox->GetEntry(i) != pStyle->GetName() );
1991 pStyle = pStyleSheetPool->Next();
1992 i++;
1993 }
1994 }
1995
1996 if ( bDoFill )
1997 {
1998 pBox->SetUpdateMode( FALSE );
1999 pBox->Clear();
2000
2001 {
2002 USHORT _i;
2003 sal_uInt32 nCnt = pImpl->aDefaultStyles.size();
2004 bool bInsert;
2005
2006 pStyle = pStyleSheetPool->First();
2007
2008 if( pImpl->bSpecModeWriter || pImpl->bSpecModeCalc )
2009 {
2010 while ( pStyle )
2011 {
2012 // sort out default styles
2013 bInsert = true;
2014 ::rtl::OUString aName( pStyle->GetName() );
2015 for( _i = 0 ; _i < nCnt ; ++_i )
2016 {
2017 if( pImpl->aDefaultStyles[_i] == aName )
2018 {
2019 bInsert = false;
2020 break;
2021 }
2022 }
2023
2024 if( bInsert )
2025 pBox->InsertEntry( aName );
2026 pStyle = pStyleSheetPool->Next();
2027 }
2028 }
2029 else
2030 {
2031 while ( pStyle )
2032 {
2033 pBox->InsertEntry( pStyle->GetName() );
2034 pStyle = pStyleSheetPool->Next();
2035 }
2036 }
2037 }
2038
2039 if( pImpl->bSpecModeWriter || pImpl->bSpecModeCalc )
2040 {
2041 // insert default styles
2042 USHORT _i;
2043 sal_uInt32 nCnt = pImpl->aDefaultStyles.size();
2044 USHORT nPos = 1;
2045 for( _i = 0 ; _i < nCnt ; ++_i )
2046 {
2047 pBox->InsertEntry( pImpl->aDefaultStyles[_i], nPos );
2048 ++nPos;
2049 }
2050
2051 // disable sort to preserve special order
2052 WinBits nWinBits = pBox->GetStyle();
2053 nWinBits &= ~WB_SORT;
2054 pBox->SetStyle( nWinBits );
2055
2056 pBox->InsertEntry( pImpl->aClearForm, 0 );
2057 pBox->SetSeparatorPos( 0 );
2058
2059 pBox->InsertEntry( pImpl->aMore );
2060
2061 // enable sort again
2062 nWinBits |= WB_SORT;
2063 pBox->SetStyle( nWinBits );
2064 }
2065
2066 pBox->SetUpdateMode( TRUE );
2067 pBox->SetFamily( eFamily );
2068
2069 USHORT nLines = Min( pBox->GetEntryCount(), MAX_STYLES_ENTRIES );
2070 pBox->SetDropDownLineCount( nLines );
2071 }
2072 }
2073 }
2074
2075 // -----------------------------------------------------------------------
2076
2077 void SvxStyleToolBoxControl::SelectStyle( const String& rStyleName )
2078 {
2079 SvxStyleBox_Impl* pBox = (SvxStyleBox_Impl*)GetToolBox().GetItemWindow( GetId() );
2080 DBG_ASSERT( pBox, "Control not found!" );
2081
2082 if ( pBox )
2083 {
2084 // String aStrSel( pBox->GetSelectEntry() );
2085 String aStrSel( pBox->GetText() );
2086
2087 if ( rStyleName.Len() > 0 )
2088 {
2089 if ( rStyleName != aStrSel )
2090 // pBox->SelectEntry( rStyleName );
2091 pBox->SetText( rStyleName );
2092 }
2093 else
2094 pBox->SetNoSelection();
2095 pBox->SaveValue();
2096 }
2097 }
2098
2099 // -----------------------------------------------------------------------
2100
2101 void SvxStyleToolBoxControl::Update()
2102 {
2103 SfxStyleSheetBasePool* pPool = NULL;
2104 SfxObjectShell* pDocShell = SfxObjectShell::Current();
2105
2106 if ( pDocShell )
2107 pPool = pDocShell->GetStyleSheetPool();
2108
2109 USHORT i;
2110 for ( i=0; i<MAX_FAMILIES; i++ )
2111 if( pFamilyState[i] )
2112 break;
2113
2114 if ( i==MAX_FAMILIES || !pPool )
2115 {
2116 pStyleSheetPool = pPool;
2117 return;
2118 }
2119
2120 //--------------------------------------------------------------------
2121 const SfxTemplateItem* pItem = NULL;
2122
2123 if ( nActFamily == 0xffff || 0 == (pItem = pFamilyState[nActFamily-1]) )
2124 // aktueller Bereich nicht innerhalb der erlaubten Bereiche
2125 // oder Default
2126 {
2127 pStyleSheetPool = pPool;
2128 nActFamily = 2;
2129
2130 pItem = pFamilyState[nActFamily-1];
2131 if ( !pItem )
2132 {
2133 nActFamily++;
2134 pItem = pFamilyState[nActFamily-1];
2135 }
2136
2137 if ( !pItem )
2138 {
2139 DBG_WARNING( "Unknown Family" ); // can happen
2140 }
2141 }
2142 else if ( pPool != pStyleSheetPool )
2143 pStyleSheetPool = pPool;
2144
2145 FillStyleBox(); // entscheidet selbst, ob gefuellt werden muss
2146
2147 if ( pItem )
2148 SelectStyle( pItem->GetStyleName() );
2149 }
2150
2151 // -----------------------------------------------------------------------
2152
2153 void SvxStyleToolBoxControl::SetFamilyState( USHORT nIdx,
2154 const SfxTemplateItem* pItem )
2155 {
2156 DELETEZ( pFamilyState[nIdx] );
2157
2158 if ( pItem )
2159 pFamilyState[nIdx] = new SfxTemplateItem( *pItem );
2160
2161 Update();
2162 }
2163
2164 // -----------------------------------------------------------------------
2165
2166 IMPL_LINK( SvxStyleToolBoxControl, VisibilityNotification, void*, EMPTYARG )
2167 {
2168
2169 USHORT i;
2170
2171 // Call ReBind() && UnBind() according to visibility
2172 SvxStyleBox_Impl* pBox = (SvxStyleBox_Impl*)( GetToolBox().GetItemWindow( GetId() ));
2173 if ( pBox->IsVisible() && !isBound() )
2174 {
2175 for ( i=0; i<MAX_FAMILIES; i++ )
2176 pBoundItems [i]->ReBind();
2177
2178 bindListener();
2179 }
2180 else if ( !pBox->IsVisible() && isBound() )
2181 {
2182 for ( i=0; i<MAX_FAMILIES; i++ )
2183 pBoundItems[i]->UnBind();
2184 unbindListener();
2185 }
2186
2187 return 0;
2188 }
2189
2190 // -----------------------------------------------------------------------
2191
2192 void SvxStyleToolBoxControl::StateChanged(
2193
2194 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2195
2196 {
2197 USHORT nId = GetId();
2198 ToolBox& rTbx = GetToolBox();
2199 SvxStyleBox_Impl* pBox = (SvxStyleBox_Impl*)(rTbx.GetItemWindow( nId ));
2200 TriState eTri = STATE_NOCHECK;
2201
2202 DBG_ASSERT( pBox, "Control not found!" );
2203
2204 if ( SFX_ITEM_DISABLED == eState )
2205 pBox->Disable();
2206 else
2207 pBox->Enable();
2208
2209 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2210
2211 switch ( eState )
2212 {
2213 case SFX_ITEM_AVAILABLE:
2214 eTri = ((const SfxBoolItem*)pState)->GetValue()
2215 ? STATE_CHECK
2216 : STATE_NOCHECK;
2217 break;
2218
2219 case SFX_ITEM_DONTCARE:
2220 eTri = STATE_DONTKNOW;
2221 break;
2222 }
2223
2224 rTbx.SetItemState( nId, eTri );
2225
2226 if ( SFX_ITEM_DISABLED != eState )
2227 Update();
2228 }
2229
2230 // -----------------------------------------------------------------------
2231
2232 Window* SvxStyleToolBoxControl::CreateItemWindow( Window *pParent )
2233 {
2234 SvxStyleBox_Impl* pBox = new SvxStyleBox_Impl( pParent,
2235 SID_STYLE_APPLY,
2236 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:StyleApply" )),
2237 SFX_STYLE_FAMILY_PARA,
2238 Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
2239 m_xFrame,
2240 pImpl->aClearForm,
2241 pImpl->aMore,
2242 pImpl->bSpecModeWriter || pImpl->bSpecModeCalc );
2243 if( pImpl->aDefaultStyles.size())
2244 pBox->SetDefaultStyle( pImpl->aDefaultStyles[0] );
2245 // Set visibility listener to bind/unbind controller
2246 pBox->SetVisibilityListener( LINK( this, SvxStyleToolBoxControl, VisibilityNotification ));
2247
2248 return pBox;
2249 }
2250
2251 //========================================================================
2252 // class SvxFontNameToolBoxControl ---------------------------------------
2253 //========================================================================
2254
2255 SvxFontNameToolBoxControl::SvxFontNameToolBoxControl(
2256 USHORT nSlotId,
2257 USHORT nId,
2258 ToolBox& rTbx )
2259
2260 : SfxToolBoxControl( nSlotId, nId, rTbx )
2261 {
2262 }
2263
2264 // -----------------------------------------------------------------------
2265
2266 void SvxFontNameToolBoxControl::StateChanged(
2267
2268 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2269
2270 {
2271 USHORT nId = GetId();
2272 ToolBox& rTbx = GetToolBox();
2273 SvxFontNameBox_Impl* pBox = (SvxFontNameBox_Impl*)(rTbx.GetItemWindow( nId ));
2274
2275 DBG_ASSERT( pBox, "Control not found!" );
2276
2277 if ( SFX_ITEM_DISABLED == eState )
2278 {
2279 pBox->Disable();
2280 pBox->Update( (const SvxFontItem*)NULL );
2281 }
2282 else
2283 {
2284 pBox->Enable();
2285
2286 if ( SFX_ITEM_AVAILABLE == eState )
2287 {
2288 const SvxFontItem* pFontItem = dynamic_cast< const SvxFontItem* >( pState );
2289
2290 DBG_ASSERT( pFontItem, "svx::SvxFontNameToolBoxControl::StateChanged(), wrong item type!" );
2291 if( pFontItem )
2292 pBox->Update( pFontItem );
2293 }
2294 else
2295 pBox->SetText( String() );
2296 pBox->SaveValue();
2297 }
2298
2299 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2300 }
2301
2302 // -----------------------------------------------------------------------
2303
2304 Window* SvxFontNameToolBoxControl::CreateItemWindow( Window *pParent )
2305 {
2306 SvxFontNameBox_Impl* pBox = new SvxFontNameBox_Impl( pParent,
2307 Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
2308 m_xFrame,0);
2309 return pBox;
2310 }
2311
2312 //========================================================================
2313 // class SvxFontColorToolBoxControl --------------------------------------
2314 //========================================================================
2315
2316 SvxFontColorToolBoxControl::SvxFontColorToolBoxControl(
2317 USHORT nSlotId,
2318 USHORT nId,
2319 ToolBox& rTbx )
2320
2321 : SfxToolBoxControl( nSlotId, nId, rTbx ),
2322 pBtnUpdater( new ::svx::ToolboxButtonColorUpdater(
2323 nSlotId, nId, &GetToolBox(), TBX_UPDATER_MODE_CHAR_COLOR_NEW ))
2324 {
2325 rTbx.SetItemBits( nId, TIB_DROPDOWN | rTbx.GetItemBits( nId ) );
2326 }
2327
2328 // -----------------------------------------------------------------------
2329
2330 SvxFontColorToolBoxControl::~SvxFontColorToolBoxControl()
2331 {
2332 delete pBtnUpdater;
2333 }
2334
2335 // -----------------------------------------------------------------------
2336
2337 SfxPopupWindowType SvxFontColorToolBoxControl::GetPopupWindowType() const
2338 {
2339 return SFX_POPUPWINDOW_ONCLICK;
2340 }
2341
2342 // -----------------------------------------------------------------------
2343
2344 SfxPopupWindow* SvxFontColorToolBoxControl::CreatePopupWindow()
2345 {
2346 SvxColorWindow_Impl* pColorWin =
2347 new SvxColorWindow_Impl(
2348 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Color" )),
2349 SID_ATTR_CHAR_COLOR,
2350 m_xFrame,
2351 SVX_RESSTR( RID_SVXITEMS_EXTRAS_CHARCOLOR ),
2352 &GetToolBox() );
2353
2354 pColorWin->StartPopupMode( &GetToolBox(),
2355 FLOATWIN_POPUPMODE_GRABFOCUS|FLOATWIN_POPUPMODE_ALLOWTEAROFF );
2356 pColorWin->StartSelection();
2357 SetPopupWindow( pColorWin );
2358 return pColorWin;
2359 }
2360
2361 // -----------------------------------------------------------------------
2362
2363 void SvxFontColorToolBoxControl::StateChanged(
2364
2365 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2366
2367 {
2368 USHORT nId = GetId();
2369 ToolBox& rTbx = GetToolBox();
2370 const SvxColorItem* pItem = 0;
2371
2372 if ( SFX_ITEM_DONTCARE != eState )
2373 pItem = PTR_CAST( SvxColorItem, pState );
2374
2375 if ( pItem )
2376 pBtnUpdater->Update( pItem->GetValue());
2377
2378 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2379 rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
2380 }
2381
2382 //========================================================================
2383 // class SvxColorToolBoxControl --------------------------------
2384 //========================================================================
2385
2386 SvxColorToolBoxControl::SvxColorToolBoxControl( USHORT nSlotId, USHORT nId, ToolBox& rTbx ) :
2387
2388 SfxToolBoxControl( nSlotId, nId, rTbx )
2389 {
2390 if ( nSlotId == SID_BACKGROUND_COLOR )
2391 rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
2392 else
2393 rTbx.SetItemBits( nId, TIB_DROPDOWN | rTbx.GetItemBits( nId ) );
2394 rTbx.Invalidate();
2395 pBtnUpdater = new ::svx::ToolboxButtonColorUpdater( nSlotId, nId, &GetToolBox() );
2396 }
2397
2398 // -----------------------------------------------------------------------
2399
2400 SvxColorToolBoxControl::~SvxColorToolBoxControl()
2401 {
2402 delete pBtnUpdater;
2403 }
2404
2405 // -----------------------------------------------------------------------
2406
2407 SfxPopupWindowType SvxColorToolBoxControl::GetPopupWindowType() const
2408 {
2409 return SFX_POPUPWINDOW_ONCLICK;
2410 }
2411
2412 // -----------------------------------------------------------------------
2413
2414 SfxPopupWindow* SvxColorToolBoxControl::CreatePopupWindow()
2415 {
2416 USHORT nResId = GetSlotId() == SID_BACKGROUND_COLOR ?
2417 RID_SVXSTR_BACKGROUND : RID_SVXSTR_COLOR;
2418 SvxColorWindow_Impl* pColorWin = new SvxColorWindow_Impl(
2419 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:BackgroundColor" )),
2420 SID_BACKGROUND_COLOR,
2421 m_xFrame,
2422 SVX_RESSTR(nResId),
2423 &GetToolBox() );
2424
2425 pColorWin->StartPopupMode( &GetToolBox(),
2426 FLOATWIN_POPUPMODE_GRABFOCUS|FLOATWIN_POPUPMODE_ALLOWTEAROFF );
2427 pColorWin->StartSelection();
2428 SetPopupWindow( pColorWin );
2429 return pColorWin;
2430 }
2431
2432 // -----------------------------------------------------------------------
2433
2434 void SvxColorToolBoxControl::StateChanged(
2435
2436 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2437
2438 {
2439 const SvxColorItem* pItem = 0;
2440 if ( SFX_ITEM_DONTCARE != eState )
2441 pItem = PTR_CAST( SvxColorItem, pState );
2442
2443 if ( pItem )
2444 pBtnUpdater->Update( pItem->GetValue() );
2445
2446 USHORT nId = GetId();
2447 ToolBox& rTbx = GetToolBox();
2448 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2449 rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
2450 }
2451
2452 //========================================================================
2453 // class SvxFontColorExtToolBoxControl --------------------------------------
2454 //========================================================================
2455
2456 SvxFontColorExtToolBoxControl::SvxFontColorExtToolBoxControl(
2457 USHORT nSlotId,
2458 USHORT nId,
2459 ToolBox& rTbx ) :
2460
2461 SfxToolBoxControl( nSlotId, nId, rTbx ),
2462 pBtnUpdater(0)
2463 {
2464 rTbx.SetItemBits( nId, TIB_DROPDOWN | rTbx.GetItemBits( nId ) );
2465 // The following commands are available at the writer module.
2466 if ( SID_ATTR_CHAR_COLOR2 == nSlotId )
2467 addStatusListener( OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CharColorExt" )));
2468 else
2469 addStatusListener( OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CharBackgroundExt" )));
2470
2471 USHORT nMode = SID_ATTR_CHAR_COLOR2 == nSlotId
2472 ? TBX_UPDATER_MODE_CHAR_COLOR_NEW : TBX_UPDATER_MODE_CHAR_COLOR_NEW;
2473 pBtnUpdater = new ::svx::ToolboxButtonColorUpdater( nSlotId, nId, &GetToolBox(), nMode );
2474 }
2475
2476 // -----------------------------------------------------------------------
2477
2478 SvxFontColorExtToolBoxControl::~SvxFontColorExtToolBoxControl()
2479 {
2480 delete pBtnUpdater;
2481 }
2482
2483 // -----------------------------------------------------------------------
2484
2485 SfxPopupWindowType SvxFontColorExtToolBoxControl::GetPopupWindowType() const
2486 {
2487 return SFX_POPUPWINDOW_ONTIMEOUT;
2488 }
2489
2490 // -----------------------------------------------------------------------
2491
2492 SfxPopupWindow* SvxFontColorExtToolBoxControl::CreatePopupWindow()
2493 {
2494 SvxColorWindow_Impl* pColorWin =
2495 new SvxColorWindow_Impl(
2496 m_aCommandURL,
2497 GetSlotId(),
2498 m_xFrame,
2499 SVX_RESSTR( RID_SVXITEMS_EXTRAS_CHARCOLOR ),
2500 &GetToolBox() );
2501
2502 if ( GetSlotId() == SID_ATTR_CHAR_COLOR_BACKGROUND )
2503 pColorWin->SetText( SVX_RESSTR( RID_SVXSTR_EXTRAS_CHARBACKGROUND ) );
2504
2505 pColorWin->StartPopupMode( &GetToolBox(),
2506 FLOATWIN_POPUPMODE_GRABFOCUS|FLOATWIN_POPUPMODE_ALLOWTEAROFF );
2507 pColorWin->StartSelection();
2508 SetPopupWindow( pColorWin );
2509 return pColorWin;
2510 }
2511
2512 // -----------------------------------------------------------------------
2513
2514 void SvxFontColorExtToolBoxControl::StateChanged(
2515
2516 USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
2517
2518 {
2519 USHORT nId = GetId();
2520 ToolBox& rTbx = GetToolBox();
2521 const SvxColorItem* pItem = 0;
2522
2523 if ( nSID == SID_ATTR_CHAR_COLOR_EXT ||
2524 nSID == SID_ATTR_CHAR_COLOR_BACKGROUND_EXT )
2525 {
2526 if ( SFX_ITEM_DONTCARE != eState )
2527 {
2528 const SfxBoolItem* pBool = PTR_CAST( SfxBoolItem, pState );
2529 rTbx.CheckItem( nId, pBool && pBool->GetValue());
2530 }
2531 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2532 }
2533 else
2534 {
2535 if ( SFX_ITEM_DONTCARE != eState )
2536 pItem = PTR_CAST( SvxColorItem, pState );
2537
2538 if ( pItem )
2539 pBtnUpdater->Update( pItem->GetValue() );
2540 }
2541 }
2542
2543 // -----------------------------------------------------------------------
2544
2545 void SvxFontColorExtToolBoxControl::Select( BOOL )
2546 {
2547 OUString aCommand;
2548 OUString aParamName;
2549 if ( SID_ATTR_CHAR_COLOR2 == GetSlotId() )
2550 {
2551 aCommand = OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CharColorExt" ));
2552 aParamName = OUString( RTL_CONSTASCII_USTRINGPARAM( "CharColorExt" ));
2553 }
2554 else
2555 {
2556 aCommand = OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CharBackgroundExt" ));
2557 aParamName = OUString( RTL_CONSTASCII_USTRINGPARAM( "CharBackgroundExt" ));
2558 }
2559
2560 Sequence< PropertyValue > aArgs( 1 );
2561 aArgs[0].Name = aParamName;
2562 aArgs[0].Value = makeAny( GetToolBox().IsItemChecked( GetId() ));
2563 Dispatch( aCommand, aArgs );
2564 }
2565
2566 //========================================================================
2567 // class SvxFrameToolBoxControl ------------------------------------------
2568 //========================================================================
2569
2570 SvxFrameToolBoxControl::SvxFrameToolBoxControl(
2571 USHORT nSlotId,
2572 USHORT nId,
2573 ToolBox& rTbx )
2574
2575 : SfxToolBoxControl( nSlotId, nId, rTbx )
2576 {
2577 rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
2578 }
2579
2580 // -----------------------------------------------------------------------
2581
2582 SfxPopupWindowType SvxFrameToolBoxControl::GetPopupWindowType() const
2583 {
2584 return SFX_POPUPWINDOW_ONCLICK;
2585 }
2586
2587 // -----------------------------------------------------------------------
2588
2589 SfxPopupWindow* SvxFrameToolBoxControl::CreatePopupWindow()
2590 {
2591 SvxFrameWindow_Impl* pFrameWin = new SvxFrameWindow_Impl(
2592 GetSlotId(), m_xFrame, &GetToolBox() );
2593
2594 pFrameWin->StartPopupMode( &GetToolBox(), FLOATWIN_POPUPMODE_GRABFOCUS | FLOATWIN_POPUPMODE_ALLOWTEAROFF );
2595 pFrameWin->StartSelection();
2596 SetPopupWindow( pFrameWin );
2597
2598 return pFrameWin;
2599 }
2600
2601 // -----------------------------------------------------------------------
2602
2603 void SvxFrameToolBoxControl::StateChanged(
2604
2605 USHORT, SfxItemState eState, const SfxPoolItem* )
2606
2607 {
2608 USHORT nId = GetId();
2609 ToolBox& rTbx = GetToolBox();
2610
2611 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2612 rTbx.SetItemState( nId, (SFX_ITEM_DONTCARE == eState)
2613 ? STATE_DONTKNOW
2614 : STATE_NOCHECK );
2615 }
2616
2617 //========================================================================
2618 // class SvxFrameLineStyleToolBoxControl ---------------------------------
2619 //========================================================================
2620
2621 SvxFrameLineStyleToolBoxControl::SvxFrameLineStyleToolBoxControl(
2622 USHORT nSlotId,
2623 USHORT nId,
2624 ToolBox& rTbx )
2625
2626 : SfxToolBoxControl( nSlotId, nId, rTbx )
2627 {
2628 rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
2629 }
2630
2631 // -----------------------------------------------------------------------
2632
2633 SfxPopupWindowType SvxFrameLineStyleToolBoxControl::GetPopupWindowType() const
2634 {
2635 return SFX_POPUPWINDOW_ONCLICK;
2636 }
2637
2638 // -----------------------------------------------------------------------
2639
2640 SfxPopupWindow* SvxFrameLineStyleToolBoxControl::CreatePopupWindow()
2641 {
2642 SvxLineWindow_Impl* pLineWin = new SvxLineWindow_Impl( GetSlotId(), m_xFrame, &GetToolBox() );
2643 pLineWin->StartPopupMode( &GetToolBox(), TRUE );
2644 pLineWin->StartSelection();
2645 SetPopupWindow( pLineWin );
2646
2647 return pLineWin;
2648 }
2649
2650 // -----------------------------------------------------------------------
2651
2652 void SvxFrameLineStyleToolBoxControl::StateChanged(
2653
2654 USHORT , SfxItemState eState, const SfxPoolItem* )
2655 {
2656 USHORT nId = GetId();
2657 ToolBox& rTbx = GetToolBox();
2658
2659 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2660 rTbx.SetItemState( nId, (SFX_ITEM_DONTCARE == eState)
2661 ? STATE_DONTKNOW
2662 : STATE_NOCHECK );
2663 }
2664
2665 //========================================================================
2666 // class SvxFrameLineColorToolBoxControl ---------------------------------
2667 //========================================================================
2668
2669 SvxFrameLineColorToolBoxControl::SvxFrameLineColorToolBoxControl(
2670 USHORT nSlotId,
2671 USHORT nId,
2672 ToolBox& rTbx ) :
2673
2674 SfxToolBoxControl( nSlotId, nId, rTbx ),
2675 pBtnUpdater(new ::svx::ToolboxButtonColorUpdater( nSlotId, nId, &GetToolBox() ))
2676 {
2677 rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
2678 }
2679
2680 // -----------------------------------------------------------------------
2681
2682 SvxFrameLineColorToolBoxControl::~SvxFrameLineColorToolBoxControl()
2683 {
2684
2685 delete pBtnUpdater;
2686 }
2687
2688 // -----------------------------------------------------------------------
2689
2690 SfxPopupWindowType SvxFrameLineColorToolBoxControl::GetPopupWindowType() const
2691 {
2692 return SFX_POPUPWINDOW_ONCLICK;
2693 }
2694
2695 // -----------------------------------------------------------------------
2696
2697 SfxPopupWindow* SvxFrameLineColorToolBoxControl::CreatePopupWindow()
2698 {
2699 SvxColorWindow_Impl* pColorWin = new SvxColorWindow_Impl(
2700 OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:FrameLineColor" )),
2701 SID_FRAME_LINECOLOR,
2702 m_xFrame,
2703 SVX_RESSTR(RID_SVXSTR_FRAME_COLOR),
2704 &GetToolBox() );
2705
2706 pColorWin->StartPopupMode( &GetToolBox(),
2707 FLOATWIN_POPUPMODE_GRABFOCUS|FLOATWIN_POPUPMODE_ALLOWTEAROFF );
2708 pColorWin->StartSelection();
2709 SetPopupWindow( pColorWin );
2710 return pColorWin;
2711 }
2712
2713 // -----------------------------------------------------------------------
2714
2715 void SvxFrameLineColorToolBoxControl::StateChanged(
2716
2717 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2718
2719 {
2720 USHORT nId = GetId();
2721 ToolBox& rTbx = GetToolBox();
2722 rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
2723 rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
2724
2725 const SvxColorItem* pItem = 0;
2726 if ( SFX_ITEM_DONTCARE != eState )
2727 {
2728 pItem = PTR_CAST( SvxColorItem, pState );
2729 if ( pItem )
2730 pBtnUpdater->Update( pItem->GetValue());
2731 }
2732 }
2733
2734 // class SvxReloadControllerItem_Impl ------------------------------------
2735
2736 class SvxReloadControllerItem_Impl
2737 {
2738 public:
2739 Image* pNormalImage;
2740 Image* pSpecialImage;
2741
2742 SvxReloadControllerItem_Impl() :
2743 pNormalImage( new Image( SVX_RES( RID_SVX_RELOAD_NORMAL ) ) ), pSpecialImage( 0 ) {}
2744 ~SvxReloadControllerItem_Impl() { delete pNormalImage; delete pSpecialImage; }
2745
2746 Image& GetNormalImage() { return *pNormalImage; }
2747 Image& GetSpecialImage()
2748 {
2749 if ( !pSpecialImage )
2750 pSpecialImage = new Image( SVX_RES( RID_SVX_RELOAD_SPECIAL ) );
2751 return *pSpecialImage;
2752 }
2753 };
2754
2755 // -----------------------------------------------------------------------
2756
2757 SvxReloadControllerItem::SvxReloadControllerItem( USHORT nSlotId, USHORT nId, ToolBox& rTbx )
2758 : SfxToolBoxControl( nSlotId, nId, rTbx )
2759 , pImpl( new SvxReloadControllerItem_Impl )
2760 {
2761 rTbx.SetItemImage( nId, pImpl->GetNormalImage() );
2762 }
2763
2764 // -----------------------------------------------------------------------
2765
2766 SvxReloadControllerItem::~SvxReloadControllerItem()
2767 {
2768 delete pImpl;
2769 }
2770
2771 // -----------------------------------------------------------------------
2772
2773 void SvxReloadControllerItem::StateChanged(
2774 USHORT , SfxItemState eState, const SfxPoolItem* pState )
2775 {
2776 SfxBoolItem* pItem = PTR_CAST( SfxBoolItem, pState );
2777 ToolBox& rBox = GetToolBox();
2778 if( pItem )
2779 {
2780 rBox.SetItemImage( GetId(),
2781 pItem->GetValue() ? pImpl->GetSpecialImage() :
2782 pImpl->GetNormalImage() );
2783 }
2784 rBox.EnableItem( GetId(), eState != SFX_ITEM_DISABLED );
2785 }
2786
2787 //========================================================================
2788 // class SvxSimpleUndoRedoController -------------------------------------
2789 //========================================================================
2790
2791 SvxSimpleUndoRedoController::SvxSimpleUndoRedoController( USHORT nSlotId, USHORT nId, ToolBox& rTbx )
2792 :SfxToolBoxControl( nSlotId, nId, rTbx )
2793 {
2794 aDefaultText = rTbx.GetItemText( nId );
2795 }
2796
2797 // -----------------------------------------------------------------------
2798
2799 SvxSimpleUndoRedoController::~SvxSimpleUndoRedoController()
2800 {
2801 }
2802
2803 // -----------------------------------------------------------------------
2804
2805 void SvxSimpleUndoRedoController::StateChanged( USHORT, SfxItemState eState, const SfxPoolItem* pState )
2806 {
2807 SfxStringItem* pItem = PTR_CAST( SfxStringItem, pState );
2808 ToolBox& rBox = GetToolBox();
2809 if ( pItem && eState != SFX_ITEM_DISABLED )
2810 {
2811 ::rtl::OUString aNewText( MnemonicGenerator::EraseAllMnemonicChars( pItem->GetValue() ) );
2812 rBox.SetQuickHelpText( GetId(), aNewText );
2813 }
2814 if ( eState == SFX_ITEM_DISABLED )
2815 rBox.SetQuickHelpText( GetId(), aDefaultText );
2816 rBox.EnableItem( GetId(), eState != SFX_ITEM_DISABLED );
2817 }
2818
2819 //========================================================================
2820
2821 void lcl_ResizeValueSet( Window &rWin, ValueSet &rValueSet )
2822 {
2823 Size aSize = rWin.GetOutputSizePixel();
2824 aSize.Width() -= 4;
2825 aSize.Height() -= 4;
2826 rValueSet.SetPosSizePixel( Point(2,2), aSize );
2827 }
2828
2829 // -----------------------------------------------------------------------
2830
2831 void lcl_CalcSizeValueSet( Window &rWin, ValueSet &rValueSet, const Size &aItemSize )
2832 {
2833 Size aSize = rValueSet.CalcWindowSizePixel( aItemSize );
2834 aSize.Width() += 4;
2835 aSize.Height() += 4;
2836 rWin.SetOutputSizePixel( aSize );
2837 }
2838
2839 // -----------------------------------------------------------------------
2840
2841 BOOL lcl_FontChangedHint( const SfxHint &rHint )
2842 {
2843 SfxPoolItemHint *pItemHint = PTR_CAST(SfxPoolItemHint, &rHint);
2844 if ( pItemHint )
2845 {
2846 SfxPoolItem *pItem = pItemHint->GetObject();
2847 return ( pItem->Which() == SID_ATTR_CHAR_FONTLIST );
2848 }
2849 else
2850 {
2851 SfxSimpleHint* pSimpleHint = PTR_CAST(SfxSimpleHint, &rHint);
2852 return pSimpleHint && ( SFX_HINT_DATACHANGED ==
2853 ( pSimpleHint->GetId() & SFX_HINT_DATACHANGED ) );
2854 }
2855 }
2856 // -----------------------------------------------------------------------------
2857 Reference< ::com::sun::star::accessibility::XAccessible > SvxFontNameBox_Impl::CreateAccessible()
2858 {
2859 FillList();
2860 return FontNameBox::CreateAccessible();
2861 }
vba interoperability for OOo