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