1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 #include "precompiled_svx.hxx"
23 
24 #include "TextPropertyPanel.hrc"
25 #include "TextPropertyPanel.hxx"
26 #include "SvxSBFontNameBox.hxx"
27 
28 #include "svx/dialmgr.hxx"
29 
30 #include <editeng/brshitem.hxx>
31 #include <editeng/colritem.hxx>
32 #include <editeng/crsditem.hxx>
33 #include <editeng/escpitem.hxx>
34 #include <editeng/flstitem.hxx>
35 #include <editeng/fontitem.hxx>
36 #include <editeng/kernitem.hxx>
37 #include <editeng/postitem.hxx>
38 #include <editeng/shdditem.hxx>
39 #include <editeng/udlnitem.hxx>
40 #include <editeng/wghtitem.hxx>
41 #include <rtl/ref.hxx>
42 #include <sfx2/dispatch.hxx>
43 #include <sfx2/objsh.hxx>
44 #include <sfx2/viewsh.hxx>
45 #include <sfx2/sidebar/ResourceDefinitions.hrc>
46 #include <sfx2/sidebar/ControlFactory.hxx>
47 #include <sfx2/sidebar/ControllerFactory.hxx>
48 #include <sfx2/sidebar/Theme.hxx>
49 #include <sfx2/sidebar/SidebarToolBox.hxx>
50 #include "sfx2/imagemgr.hxx"
51 #include <svtools/ctrltool.hxx>
52 #include <svtools/unitconv.hxx>
53 
54 #include <vcl/gradient.hxx>
55 #include <vcl/svapp.hxx>
56 #include <vcl/toolbox.hxx>
57 #include "TextCharacterSpacingControl.hxx"
58 #include "TextCharacterSpacingPopup.hxx"
59 #include "TextUnderlineControl.hxx"
60 #include "TextUnderlinePopup.hxx"
61 #include <svx/sidebar/ColorControl.hxx>
62 #include <svx/sidebar/PopupContainer.hxx>
63 
64 #include <boost/bind.hpp>
65 
66 using namespace css;
67 using namespace cssu;
68 using ::sfx2::sidebar::Theme;
69 using ::sfx2::sidebar::ControlFactory;
70 
71 #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString)))
72 
73 namespace svx { namespace sidebar {
74 
75 #undef HAS_IA2
76 
77 
78 
79 PopupControl* TextPropertyPanel::CreateCharacterSpacingControl (PopupContainer* pParent)
80 {
81     return new TextCharacterSpacingControl(pParent, *this, mpBindings);
82 }
83 
84 PopupControl* TextPropertyPanel::CreateUnderlinePopupControl (PopupContainer* pParent)
85 {
86 	return new TextUnderlineControl(pParent, *this, mpBindings);
87 }
88 
89 namespace
90 {
91     Color GetAutomaticColor(void)
92     {
93         return COL_AUTO;
94     }
95 } // end of anonymous namespace
96 
97 long TextPropertyPanel::GetSelFontSize()
98 {
99     long nH = 240;
100     SfxMapUnit eUnit = maSpacingControl.GetCoreMetric();
101     if (mpHeightItem)
102         nH = LogicToLogic(  mpHeightItem->GetHeight(), (MapUnit)eUnit, MAP_TWIP );
103     return nH;
104 }
105 
106 
107 TextPropertyPanel* TextPropertyPanel::Create (
108     Window* pParent,
109     const cssu::Reference<css::frame::XFrame>& rxFrame,
110     SfxBindings* pBindings,
111     const ::sfx2::sidebar::EnumContext& rContext)
112 {
113     if (pParent == NULL)
114         throw lang::IllegalArgumentException(A2S("no parent Window given to TextPropertyPanel::Create"), NULL, 0);
115     if ( ! rxFrame.is())
116         throw lang::IllegalArgumentException(A2S("no XFrame given to TextPropertyPanel::Create"), NULL, 1);
117     if (pBindings == NULL)
118         throw lang::IllegalArgumentException(A2S("no SfxBindings given to TextPropertyPanel::Create"), NULL, 2);
119 
120     return new TextPropertyPanel(
121         pParent,
122         rxFrame,
123         pBindings,
124         rContext);
125 }
126 
127 
128 ::sfx2::sidebar::ControllerItem& TextPropertyPanel::GetSpaceController()
129 {
130 	return maSpacingControl;
131 }
132 
133 TextPropertyPanel::TextPropertyPanel (
134     Window* pParent,
135     const cssu::Reference<css::frame::XFrame>& rxFrame,
136     SfxBindings* pBindings,
137     const ::sfx2::sidebar::EnumContext& rContext)
138     :   Control(pParent, SVX_RES(RID_SIDEBAR_TEXT_PANEL)),
139         mpFontNameBox (new SvxSBFontNameBox(this, SVX_RES(CB_SBFONT_FONT))),
140         maFontSizeBox		(this, SVX_RES(MB_SBFONT_FONTSIZE)),
141         mpToolBoxFontBackground(ControlFactory::CreateToolBoxBackground(this)),
142         mpToolBoxFont(ControlFactory::CreateToolBox(
143                 mpToolBoxFontBackground.get(),
144                 SVX_RES(TB_FONT))),
145         mpToolBoxIncDecBackground(ControlFactory::CreateToolBoxBackground(this)),
146         mpToolBoxIncDec(ControlFactory::CreateToolBox(
147                 mpToolBoxIncDecBackground.get(),
148                 SVX_RES(TB_INCREASE_DECREASE))),
149         mpToolBoxScriptBackground(ControlFactory::CreateToolBoxBackground(this)),
150         mpToolBoxScript(ControlFactory::CreateToolBox(
151                 mpToolBoxScriptBackground.get(),
152                 SVX_RES(TB_SCRIPT))),
153         mpToolBoxScriptSwBackground(ControlFactory::CreateToolBoxBackground(this)),
154         mpToolBoxScriptSw(ControlFactory::CreateToolBox(
155                 mpToolBoxScriptSwBackground.get(),
156                 SVX_RES(TB_SCRIPT_SW))),
157         mpToolBoxSpacingBackground(ControlFactory::CreateToolBoxBackground(this)),
158         mpToolBoxSpacing(ControlFactory::CreateToolBox(
159                 mpToolBoxSpacingBackground.get(),
160                 SVX_RES(TB_SPACING))),
161         mpToolBoxFontColorBackground(ControlFactory::CreateToolBoxBackground(this)),
162         mpToolBoxFontColor(ControlFactory::CreateToolBox(
163                 mpToolBoxFontColorBackground.get(),
164                 rContext.GetApplication_DI() == sfx2::sidebar::EnumContext::Application_WriterVariants
165                     ? SVX_RES(TB_FONTCOLOR_SW)
166                     : SVX_RES(TB_FONTCOLOR),
167                 rxFrame)),
168         mpToolBoxHighlightBackground(ControlFactory::CreateToolBoxBackground(this)),
169         mpToolBoxHighlight(ControlFactory::CreateToolBox(
170                 mpToolBoxHighlightBackground.get(),
171                 SVX_RES(TB_HIGHLIGHT),
172                 rxFrame)),
173         mpFontColorUpdater(),
174         mpHighlightUpdater(),
175 
176         maFontNameControl	(SID_ATTR_CHAR_FONT,		*pBindings, *this, A2S("CharFontName"), rxFrame),
177         maFontSizeControl	(SID_ATTR_CHAR_FONTHEIGHT,	*pBindings, *this, A2S("FontHeight"),   rxFrame),
178         maWeightControl		(SID_ATTR_CHAR_WEIGHT,		*pBindings, *this, A2S("Bold"),         rxFrame),
179         maItalicControl		(SID_ATTR_CHAR_POSTURE,		*pBindings, *this, A2S("Italic"),       rxFrame),
180         maUnderlineControl	(SID_ATTR_CHAR_UNDERLINE,	*pBindings, *this, A2S("Underline"),    rxFrame),
181         maStrikeControl		(SID_ATTR_CHAR_STRIKEOUT,	*pBindings, *this, A2S("Strikeout"),    rxFrame),
182         maShadowControl		(SID_ATTR_CHAR_SHADOWED,	*pBindings, *this, A2S("Shadowed"),     rxFrame),
183         maScriptControlSw	(SID_ATTR_CHAR_ESCAPEMENT,	*pBindings, *this, A2S("Escapement"),   rxFrame),
184         maSuperScriptControl(SID_SET_SUPER_SCRIPT,		*pBindings, *this, A2S("SuperScript"),  rxFrame),
185         maSubScriptControl	(SID_SET_SUB_SCRIPT,		*pBindings, *this, A2S("SubScript"),    rxFrame),
186         maSpacingControl	(SID_ATTR_CHAR_KERNING,		*pBindings, *this, A2S("Spacing"),      rxFrame),
187         maSDFontGrow		(SID_GROW_FONT_SIZE,		*pBindings, *this, A2S("Grow"),         rxFrame),
188         maSDFontShrink		(SID_SHRINK_FONT_SIZE,		*pBindings, *this, A2S("Shrink"),       rxFrame),
189 
190         mpFontList			(NULL),
191         mbMustDelete		(false),
192         mbFocusOnFontSizeCtrl(false),
193         maCharSpacePopup(this, ::boost::bind(&TextPropertyPanel::CreateCharacterSpacingControl, this, _1)),
194         maUnderlinePopup(this, ::boost::bind(&TextPropertyPanel::CreateUnderlinePopupControl, this, _1)),
195         mxFrame(rxFrame),
196         maContext(),
197         mpBindings(pBindings)
198 {
199 	Initialize();
200 
201 	FreeResource();
202 }
203 
204 
205 
206 
207 TextPropertyPanel::~TextPropertyPanel (void)
208 {
209     if(mbMustDelete)
210         delete mpFontList;
211 
212     // Destroy the toolbox windows.
213     mpToolBoxIncDec.reset();
214     mpToolBoxFont.reset();
215     mpToolBoxFontColor.reset();
216     mpToolBoxScript.reset();
217     mpToolBoxScriptSw.reset();
218     mpToolBoxSpacing.reset();
219     mpToolBoxHighlight.reset();
220 
221     // Destroy the background windows of the toolboxes.
222     mpToolBoxIncDecBackground.reset();
223     mpToolBoxFontBackground.reset();
224     mpToolBoxFontColorBackground.reset();
225     mpToolBoxScriptBackground.reset();
226     mpToolBoxScriptSwBackground.reset();
227     mpToolBoxSpacingBackground.reset();
228     mpToolBoxHighlightBackground.reset();
229 }
230 
231 
232 
233 
234 void TextPropertyPanel::SetSpacing(long nKern)
235 {
236 	mlKerning = nKern;
237 }
238 
239 
240 void TextPropertyPanel::HandleContextChange (
241     const ::sfx2::sidebar::EnumContext aContext)
242 {
243     if (maContext == aContext)
244     {
245         // Nothing to do.
246         return;
247     }
248 
249     maContext = aContext;
250     switch (maContext.GetCombinedContext_DI())
251     {
252         case CombinedEnumContext(Application_Calc, Context_Cell):
253         case CombinedEnumContext(Application_Calc, Context_Pivot):
254             mpToolBoxScriptSw->Hide();
255             mpToolBoxHighlight->Hide();
256             mpToolBoxScript->Disable();
257             mpToolBoxSpacing->Disable();
258             break;
259 
260         case CombinedEnumContext(Application_Calc, Context_EditCell):
261         case CombinedEnumContext(Application_Calc, Context_DrawText):
262             mpToolBoxScriptSw->Hide();
263             mpToolBoxHighlight->Hide();
264             mpToolBoxScript->Enable();
265             mpToolBoxSpacing->Enable();
266             break;
267 
268         case CombinedEnumContext(Application_WriterVariants, Context_Text):
269         case CombinedEnumContext(Application_WriterVariants, Context_Table):
270             mpToolBoxScriptSw->Show();
271             mpToolBoxScript->Hide();
272             mpToolBoxHighlight->Show();
273             mpToolBoxSpacing->Show();
274             break;
275 
276         case CombinedEnumContext(Application_WriterVariants, Context_DrawText):
277         case CombinedEnumContext(Application_WriterVariants, Context_Annotation):
278             mpToolBoxScriptSw->Show();
279             mpToolBoxScript->Hide();
280             mpToolBoxSpacing->Show();
281             mpToolBoxHighlight->Hide();
282             break;
283 
284         case CombinedEnumContext(Application_DrawImpress, Context_DrawText):
285         case CombinedEnumContext(Application_DrawImpress, Context_Text):
286         case CombinedEnumContext(Application_DrawImpress, Context_Table):
287         case CombinedEnumContext(Application_DrawImpress, Context_OutlineText):
288         case CombinedEnumContext(Application_DrawImpress, Context_Draw):
289         case CombinedEnumContext(Application_DrawImpress, Context_TextObject):
290         case CombinedEnumContext(Application_DrawImpress, Context_Graphic):
291             mpToolBoxScriptSw->Hide();
292             mpToolBoxScript->Show();
293             mpToolBoxSpacing->Show();
294             mpToolBoxHighlight->Hide();
295             break;
296 
297         default:
298             break;
299     }
300 }
301 
302 
303 
304 
305 void TextPropertyPanel::DataChanged (const DataChangedEvent& rEvent)
306 {
307     (void)rEvent;
308 
309     SetupToolboxItems();
310 }
311 
312 
313 
314 
315 void TextPropertyPanel::Initialize (void)
316 {
317     //<<modify fill font list
318     SfxObjectShell* pDocSh = SfxObjectShell::Current();
319     const SfxPoolItem* pItem = NULL;
320 
321     if (pDocSh != NULL)
322         pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST );
323     if (pItem != NULL)
324         mpFontList = ( (SvxFontListItem*)pItem )->GetFontList();
325     else
326     {
327         mpFontList = new FontList( Application::GetDefaultDevice() );
328         mbMustDelete = true;
329     }
330 
331     mpFontNameBox->SetAccessibleName(mpFontNameBox->GetQuickHelpText());
332     const FontInfo aFontInfo (mpFontList->Get( String::CreateFromAscii( "" ), String::CreateFromAscii( "" )));
333     maFontSizeBox.Fill(&aFontInfo,mpFontList);
334     maFontSizeBox.SetAccessibleName(maFontSizeBox.GetQuickHelpText());
335 
336     //toolbox
337     SetupToolboxItems();
338     InitToolBoxIncDec();
339     InitToolBoxFont();
340     InitToolBoxScript();
341     InitToolBoxSpacing();
342 
343 #ifdef HAS_IA2
344     mpFontNameBox->SetAccRelationLabeledBy(&mpFontNameBox);
345     mpFontNameBox->SetMpSubEditAccLableBy(&mpFontNameBox);
346     maFontSizeBox.SetAccRelationLabeledBy(&maFontSizeBox);
347     maFontSizeBox.SetMpSubEditAccLableBy(&maFontSizeBox);
348     mpToolBoxFont.SetAccRelationLabeledBy(&mpToolBoxFont);
349     mpToolBoxIncDec.SetAccRelationLabeledBy(&mpToolBoxIncDec);
350     mpToolBoxFontColor.SetAccRelationLabeledBy(&mpToolBoxFontColor);
351     mpToolBoxScript.SetAccRelationLabeledBy(&mpToolBoxScript);
352     mpToolBoxScriptSw.SetAccRelationLabeledBy(&mpToolBoxScriptSw);
353     mpToolBoxSpacing.SetAccRelationLabeledBy(&mpToolBoxSpacing);
354     mpToolBoxHighlight.SetAccRelationLabeledBy(&mpToolBoxHighlight);
355 #endif
356 
357     //init state
358     mpHeightItem = NULL;
359     meWeight = WEIGHT_NORMAL;
360     meItalic = ITALIC_NONE;
361     mbShadow = false;
362     meStrike = STRIKEOUT_NONE;
363     mbPostureAvailable = true;
364     mbWeightAvailable = true;
365     meUnderline = UNDERLINE_NONE;
366     meUnderlineColor = COL_AUTO;
367     meEscape = SVX_ESCAPEMENT_OFF;
368     mbSuper = false;
369     mbSub = false;
370     mbKernAvailable = true;
371     mbKernLBAvailable = true;
372     mlKerning = 0;
373 
374     //set handler
375     mpFontNameBox->SetBindings(mpBindings);
376     Link aLink = LINK(this, TextPropertyPanel, FontSelHdl);
377     mpFontNameBox->SetSelectHdl(aLink);
378     aLink = LINK(this, TextPropertyPanel, FontSizeModifyHdl);
379     maFontSizeBox.SetModifyHdl(aLink);
380     aLink = LINK(this, TextPropertyPanel, FontSizeSelHdl);
381     maFontSizeBox.SetSelectHdl(aLink);
382     aLink = LINK(this, TextPropertyPanel, FontSizeLoseFocus);
383     maFontSizeBox.SetLoseFocusHdl(aLink);
384 }
385 
386 void TextPropertyPanel::EndSpacingPopupMode (void)
387 {
388     maCharSpacePopup.Hide();
389 }
390 
391 void TextPropertyPanel::EndUnderlinePopupMode (void)
392 {
393 	maUnderlinePopup.Hide();
394 }
395 
396 
397 void TextPropertyPanel::InitToolBoxFont()
398 {
399 	mpToolBoxFont->SetBackground(Wallpaper());
400 	mpToolBoxFont->SetPaintTransparent(true);
401 
402 	Size aTbxSize( mpToolBoxFont->CalcWindowSizePixel() );
403 	mpToolBoxFont->SetOutputSizePixel( aTbxSize );
404 
405 	Link aLink  = LINK(this, TextPropertyPanel, ToolboxFontSelectHandler);
406 	mpToolBoxFont->SetSelectHdl ( aLink );
407 	aLink = LINK(this, TextPropertyPanel, ToolBoxUnderlineClickHdl);
408 	mpToolBoxFont->SetDropdownClickHdl(aLink);
409 }
410 
411 
412 
413 
414 void TextPropertyPanel::InitToolBoxIncDec()
415 {
416 	Size aTbxSize( mpToolBoxIncDec->CalcWindowSizePixel() );
417 	mpToolBoxIncDec->SetOutputSizePixel( aTbxSize );
418 
419 	Link aLink = LINK(this, TextPropertyPanel, ToolboxIncDecSelectHdl);
420     mpToolBoxIncDec->SetSelectHdl ( aLink );
421 }
422 
423 
424 
425 
426 void TextPropertyPanel::InitToolBoxScript()
427 {
428 	Size aTbxSize( mpToolBoxScriptSw->CalcWindowSizePixel() );
429 	mpToolBoxScriptSw->SetOutputSizePixel( aTbxSize );
430 
431 	Link aLink = LINK(this, TextPropertyPanel, ToolBoxSwScriptSelectHdl);
432     mpToolBoxScriptSw->SetSelectHdl ( aLink );
433 
434 	aTbxSize = mpToolBoxScript->CalcWindowSizePixel() ;
435 	mpToolBoxScript->SetOutputSizePixel( aTbxSize );
436 
437 	aLink = LINK(this, TextPropertyPanel, ToolBoxScriptSelectHdl);
438     mpToolBoxScript->SetSelectHdl ( aLink );
439 }
440 void TextPropertyPanel::InitToolBoxSpacing()
441 {
442 	Size aTbxSize( mpToolBoxSpacing->CalcWindowSizePixel() );
443 	mpToolBoxSpacing->SetOutputSizePixel( aTbxSize );
444 	mpToolBoxSpacing->SetItemBits( TBI_SPACING, mpToolBoxSpacing->GetItemBits( TBI_SPACING ) | TIB_DROPDOWNONLY );
445 
446 	Link aLink = LINK(this, TextPropertyPanel, SpacingClickHdl);
447     mpToolBoxSpacing->SetDropdownClickHdl ( aLink );
448 	mpToolBoxSpacing->SetSelectHdl( aLink );
449 }
450 
451 
452 
453 
454 void TextPropertyPanel::SetupToolboxItems (void)
455 {
456     maSDFontGrow.SetupToolBoxItem(*mpToolBoxIncDec, TBI_INCREASE);
457     maSDFontShrink.SetupToolBoxItem(*mpToolBoxIncDec, TBI_DECREASE);
458 
459     maWeightControl.SetupToolBoxItem(*mpToolBoxFont, TBI_BOLD);
460     maItalicControl.SetupToolBoxItem(*mpToolBoxFont, TBI_ITALIC);
461     maUnderlineControl.SetupToolBoxItem(*mpToolBoxFont, TBI_UNDERLINE);
462     maStrikeControl.SetupToolBoxItem(*mpToolBoxFont, TBI_STRIKEOUT);
463     maShadowControl.SetupToolBoxItem(*mpToolBoxFont, TBI_SHADOWED);
464 
465     //for sw
466     maSuperScriptControl.SetupToolBoxItem(*mpToolBoxScriptSw, TBI_SUPER_SW);
467     maSubScriptControl.SetupToolBoxItem(*mpToolBoxScriptSw, TBI_SUB_SW);
468     //for sc and sd
469     maSuperScriptControl.SetupToolBoxItem(*mpToolBoxScript, TBI_SUPER);
470     maSubScriptControl.SetupToolBoxItem(*mpToolBoxScript, TBI_SUB);
471     maSpacingControl.SetupToolBoxItem(*mpToolBoxSpacing, TBI_SPACING);
472 }
473 
474 
475 
476 
477 IMPL_LINK( TextPropertyPanel, FontSelHdl, FontNameBox*, pBox )
478 {
479 	if ( !pBox->IsTravelSelect() )
480 	{
481 		if( SfxViewShell::Current() )
482 		{
483 			Window* pShellWnd = SfxViewShell::Current()->GetWindow();
484 
485 			if ( pShellWnd )
486 				pShellWnd->GrabFocus();
487 		}
488 	}
489 	return 0;
490 }
491 
492 IMPL_LINK( TextPropertyPanel, FontSizeModifyHdl, FontSizeBox*, pSizeBox )
493 {
494 	if (pSizeBox == &maFontSizeBox)
495 	{
496 		long nSize = pSizeBox->GetValue();
497 		mbFocusOnFontSizeCtrl = true;
498 
499 		float fSize = (float)nSize / 10;
500 		SfxMapUnit eUnit = maFontSizeControl.GetCoreMetric();
501 		SvxFontHeightItem aItem( CalcToUnit( fSize, eUnit ), 100, SID_ATTR_CHAR_FONTHEIGHT ) ;
502 
503 		mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_FONTHEIGHT, SFX_CALLMODE_RECORD, &aItem, 0L );
504 		mpBindings->Invalidate(SID_ATTR_CHAR_FONTHEIGHT,true,false);
505 	}
506 	return 0;
507 }
508 
509 IMPL_LINK( TextPropertyPanel, FontSizeSelHdl, FontSizeBox*, pSizeBox )
510 {
511 	if ( !pSizeBox->IsTravelSelect() )
512 	{
513 		if( SfxViewShell::Current() )
514 		{
515 			Window* pShellWnd = SfxViewShell::Current()->GetWindow();
516 
517 			if ( pShellWnd )
518 				pShellWnd->GrabFocus();
519 		}
520 	}
521 
522 	return 0;
523 }
524 
525 IMPL_LINK(TextPropertyPanel, FontSizeLoseFocus, FontSizeBox*, pSizeBox)
526 {
527 	if(pSizeBox == &maFontSizeBox)
528 	{
529 		mbFocusOnFontSizeCtrl = false;
530 	}
531 	return 0;
532 }
533 
534 IMPL_LINK(TextPropertyPanel, ToolboxFontSelectHandler, ToolBox*, pToolBox)
535 {
536     const sal_uInt16 nId = pToolBox->GetCurItemId();
537 
538     switch (nId)
539     {
540         case TBI_BOLD:
541         {
542             EndTracking();
543             if(meWeight != WEIGHT_BOLD)
544                 meWeight = WEIGHT_BOLD;
545             else
546                 meWeight = WEIGHT_NORMAL;
547             SvxWeightItem aWeightItem(meWeight, SID_ATTR_CHAR_WEIGHT);
548             mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_WEIGHT, SFX_CALLMODE_RECORD, &aWeightItem, 0L);
549             UpdateItem(SID_ATTR_CHAR_WEIGHT);
550             break;
551         }
552         case TBI_ITALIC:
553         {
554             EndTracking();
555             if(meItalic != ITALIC_NORMAL)
556                 meItalic = ITALIC_NORMAL;
557             else
558                 meItalic = ITALIC_NONE;
559             SvxPostureItem aPostureItem(meItalic, SID_ATTR_CHAR_POSTURE);
560             mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_POSTURE, SFX_CALLMODE_RECORD, &aPostureItem, 0L);
561             UpdateItem(SID_ATTR_CHAR_POSTURE);
562             break;
563         }
564         case TBI_UNDERLINE:
565         {
566             EndTracking();
567             if(meUnderline == UNDERLINE_NONE)
568             {
569                 meUnderline = UNDERLINE_SINGLE;
570                 SvxUnderlineItem aLineItem(meUnderline, SID_ATTR_CHAR_UNDERLINE);
571                 aLineItem.SetColor(meUnderlineColor);
572                 mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_UNDERLINE, SFX_CALLMODE_RECORD, &aLineItem, 0L);
573             }
574             else
575             {
576                 meUnderline = UNDERLINE_NONE;
577                 SvxUnderlineItem aLineItem(meUnderline, SID_ATTR_CHAR_UNDERLINE);
578                 mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_UNDERLINE, SFX_CALLMODE_RECORD, &aLineItem, 0L);
579             }
580             UpdateItem(SID_ATTR_CHAR_UNDERLINE);
581             break;
582         }
583         case TBI_STRIKEOUT:
584         {
585             EndTracking();
586             if(meStrike !=  STRIKEOUT_NONE && meStrike != STRIKEOUT_DONTKNOW)
587                 meStrike = STRIKEOUT_NONE;
588             else
589                 meStrike = STRIKEOUT_SINGLE;
590             SvxCrossedOutItem aStrikeItem(meStrike,SID_ATTR_CHAR_STRIKEOUT);
591             mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_STRIKEOUT, SFX_CALLMODE_RECORD, &aStrikeItem, 0L);
592             UpdateItem(SID_ATTR_CHAR_STRIKEOUT);
593             break;
594         }
595         case TBI_SHADOWED:
596         {
597             EndTracking();
598             mbShadow = !mbShadow;
599             SvxShadowedItem aShadowItem(mbShadow, SID_ATTR_CHAR_SHADOWED);
600             mpBindings->GetDispatcher()->Execute(SID_ATTR_CHAR_SHADOWED, SFX_CALLMODE_RECORD, &aShadowItem, 0L);
601             UpdateItem(SID_ATTR_CHAR_SHADOWED);
602             break;
603         }
604     }
605     return 0;
606 }
607 
608 
609 
610 
611 IMPL_LINK(TextPropertyPanel, ToolboxIncDecSelectHdl, ToolBox*, pToolBox)
612 {
613     const sal_uInt16 nId = pToolBox->GetCurItemId();
614 
615     // font size +/- enhancement in sd
616     switch (maContext.GetCombinedContext_DI())
617     {
618         case CombinedEnumContext(Application_DrawImpress, Context_DrawText):
619         case CombinedEnumContext(Application_DrawImpress, Context_Text):
620         case CombinedEnumContext(Application_DrawImpress, Context_Table):
621         case CombinedEnumContext(Application_DrawImpress, Context_OutlineText):
622         case CombinedEnumContext(Application_DrawImpress, Context_Draw):
623         case CombinedEnumContext(Application_DrawImpress, Context_TextObject):
624         case CombinedEnumContext(Application_DrawImpress, Context_Graphic):
625             if(nId == TBI_INCREASE)
626             {
627                 EndTracking();
628                 SfxVoidItem aItem(SID_GROW_FONT_SIZE);
629                 mpBindings->GetDispatcher()->Execute( SID_GROW_FONT_SIZE, SFX_CALLMODE_RECORD, &aItem, 0L );
630             }
631             else if(nId == TBI_DECREASE)
632             {
633                 EndTracking();
634                 SfxVoidItem aItem(SID_SHRINK_FONT_SIZE);
635                 mpBindings->GetDispatcher()->Execute( SID_SHRINK_FONT_SIZE, SFX_CALLMODE_RECORD, &aItem, 0L );
636             }
637             break;
638 
639         default:
640             if(nId == TBI_INCREASE)
641             {
642                 EndTracking();
643                 mbFocusOnFontSizeCtrl = false;
644                 sal_Int64 iValue = maFontSizeBox.GetValue();
645                 int iPos = maFontSizeBox.GetValuePos(iValue, FUNIT_NONE);
646                 long nSize = iValue;
647                 if(iPos != LISTBOX_ENTRY_NOTFOUND)
648                     nSize = maFontSizeBox.GetValue(iPos+1 , FUNIT_NONE);
649                 else if(iValue >= 100 && iValue < 105)
650                     nSize = 105;
651                 else if(iValue >= 105 && iValue < 110)
652                     nSize = 110;
653                 else if(iValue < 960)
654                 {
655                     nSize = (nSize / 10) * 10 + 10;
656                     while(maFontSizeBox.GetValuePos(nSize, FUNIT_NONE) == LISTBOX_ENTRY_NOTFOUND)
657                         nSize += 10;
658                 }
659                 else
660                 {
661                     nSize = iValue;
662                 }
663 
664                 float fSize = (float)nSize / 10;
665 
666                 SfxMapUnit eUnit = maFontSizeControl.GetCoreMetric();
667                 SvxFontHeightItem aItem( CalcToUnit( fSize, eUnit ), 100, SID_ATTR_CHAR_FONTHEIGHT ) ;
668 
669                 mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_FONTHEIGHT, SFX_CALLMODE_RECORD, &aItem, 0L );
670                 mpBindings->Invalidate(SID_ATTR_CHAR_FONTHEIGHT,true,false);
671                 maFontSizeBox.SetValue( nSize );
672             }
673             else if(nId == TBI_DECREASE)
674             {
675                 EndTracking();
676                 mbFocusOnFontSizeCtrl = false;
677                 sal_Int64 iValue = maFontSizeBox.GetValue();
678                 int iPos = maFontSizeBox.GetValuePos(iValue, FUNIT_NONE);
679                 long nSize = iValue;
680                 if(iPos != LISTBOX_ENTRY_NOTFOUND)
681                     nSize = maFontSizeBox.GetValue(iPos-1 , FUNIT_NONE);
682                 else if(iValue > 100 && iValue <= 105)
683                     nSize = 100;
684                 else if(iValue > 105 && iValue <= 110)
685                     nSize = 105;
686                 else if(iValue > 960)
687                 {
688                     nSize = 960;
689                 }
690                 else if(iValue > 60)
691                 {
692                     nSize = (nSize / 10) * 10 ;
693                     while(maFontSizeBox.GetValuePos(nSize, FUNIT_NONE) == LISTBOX_ENTRY_NOTFOUND)
694                         nSize -= 10;
695                 }
696                 else
697                 {
698                     nSize = iValue;
699                 }
700 
701                 float fSize = (float)nSize / 10;
702 
703                 SfxMapUnit eUnit = maFontSizeControl.GetCoreMetric();
704                 SvxFontHeightItem aItem( CalcToUnit( fSize, eUnit ), 100, SID_ATTR_CHAR_FONTHEIGHT ) ;
705 
706                 mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_FONTHEIGHT, SFX_CALLMODE_RECORD, &aItem, 0L );
707                 mpBindings->Invalidate(SID_ATTR_CHAR_FONTHEIGHT,true,false);
708                 maFontSizeBox.SetValue( nSize );
709             }
710 	}
711     UpdateItem(SID_ATTR_CHAR_FONTHEIGHT);
712 
713 	return 0;
714 }
715 
716 
717 
718 IMPL_LINK(TextPropertyPanel, ToolBoxUnderlineClickHdl, ToolBox*, pToolBox)
719 {
720 	const sal_uInt16 nId = pToolBox->GetCurItemId();
721 	OSL_ASSERT(nId == TBI_UNDERLINE);
722 	if(nId == TBI_UNDERLINE)
723 	{
724 		pToolBox->SetItemDown( nId, true );
725 		maUnderlinePopup.Rearrange(meUnderline);
726 		maUnderlinePopup.Show(*pToolBox);
727 
728 	}
729 	return 0L;
730 }
731 
732 
733 
734 
735 IMPL_LINK(TextPropertyPanel, ToolBoxSwScriptSelectHdl, ToolBox*, pToolBox)
736 {
737 	const sal_uInt16 nId = pToolBox->GetCurItemId();
738 	if( nId == TBI_SUPER_SW )
739 	{
740 		if(meEscape != SVX_ESCAPEMENT_SUPERSCRIPT)
741 		{
742 			meEscape = SVX_ESCAPEMENT_SUPERSCRIPT;
743 			SvxEscapementItem aSupItem(DFLT_ESC_SUPER, DFLT_ESC_PROP, SID_ATTR_CHAR_ESCAPEMENT);
744 			mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_ESCAPEMENT, SFX_CALLMODE_RECORD, &aSupItem, 0L );
745 		}
746 		else
747 		{
748 			meEscape = SVX_ESCAPEMENT_OFF;
749 			SvxEscapementItem aNoneItem(0, 100, SID_ATTR_CHAR_ESCAPEMENT);
750 			mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_ESCAPEMENT, SFX_CALLMODE_RECORD, &aNoneItem, 0L );
751 		}
752 	}
753 	else if(TBI_SUB_SW == nId)
754 	{
755 		if(meEscape != SVX_ESCAPEMENT_SUBSCRIPT)
756 		{
757 			meEscape = (SvxEscapement)SVX_ESCAPEMENT_SUBSCRIPT;
758 			SvxEscapementItem aSubItem(DFLT_ESC_SUB, DFLT_ESC_PROP, SID_ATTR_CHAR_ESCAPEMENT);
759 			mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_ESCAPEMENT, SFX_CALLMODE_RECORD, &aSubItem, 0L );
760 		}
761 		else
762 		{
763 			meEscape = SVX_ESCAPEMENT_OFF;
764 			SvxEscapementItem aNoneItem(0, 100, SID_ATTR_CHAR_ESCAPEMENT);
765 			mpBindings->GetDispatcher()->Execute( SID_ATTR_CHAR_ESCAPEMENT, SFX_CALLMODE_RECORD, &aNoneItem, 0L );
766 		}
767 	}
768     UpdateItem(SID_ATTR_CHAR_ESCAPEMENT);
769 
770 	return 0;
771 }
772 
773 
774 
775 
776 IMPL_LINK(TextPropertyPanel, ToolBoxScriptSelectHdl, ToolBox*, pToolBox)
777 {
778 	const sal_uInt16 nId = pToolBox->GetCurItemId();
779 	if( nId == TBI_SUPER )
780 	{
781 		mbSuper = !mbSuper;
782 		SfxBoolItem aSupItem(SID_SET_SUPER_SCRIPT, mbSuper);
783 		mpBindings->GetDispatcher()->Execute( SID_SET_SUPER_SCRIPT, SFX_CALLMODE_RECORD, &aSupItem, 0L );
784         UpdateItem(SID_SET_SUPER_SCRIPT);
785 	}
786 	else if(TBI_SUB == nId)
787 	{
788 
789 		mbSub = !mbSub;
790 		SfxBoolItem aSubItem(SID_SET_SUB_SCRIPT, mbSub );
791 		mpBindings->GetDispatcher()->Execute( SID_SET_SUB_SCRIPT, SFX_CALLMODE_RECORD, &aSubItem, 0L );
792         UpdateItem(SID_SET_SUB_SCRIPT);
793 	}
794 	return 0;
795 }
796 
797 
798 
799 
800 IMPL_LINK(TextPropertyPanel, SpacingClickHdl, ToolBox*, pToolBox)
801 {
802 	const sal_uInt16 nId = pToolBox->GetCurItemId();
803 	OSL_ASSERT(nId == TBI_SPACING);
804 	if(nId == TBI_SPACING)
805 	{
806 		pToolBox->SetItemDown( nId, true );
807 		maCharSpacePopup.Rearrange(mbKernLBAvailable,mbKernAvailable,mlKerning);
808 		maCharSpacePopup.Show(*pToolBox);
809 
810 	}
811 	return 0L;
812 }
813 
814 
815 
816 
817 void TextPropertyPanel::NotifyItemUpdate (
818     const sal_uInt16 nSID,
819     const SfxItemState eState,
820     const SfxPoolItem* pState,
821     const bool bIsEnabled)
822 {
823     switch(nSID)
824     {
825         case SID_ATTR_CHAR_FONT:
826         {
827             bool bIsControlEnabled (bIsEnabled);
828             if (  eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxFontItem) )
829             {
830                 const SvxFontItem* pFontItem = (const SvxFontItem*)pState;
831                 mpFontNameBox->SetText( pFontItem->GetFamilyName() );
832             }
833             else
834             {
835                 mpFontNameBox->SetText( String() );
836                 if (SFX_ITEM_DISABLED == eState)
837                     bIsControlEnabled = false;
838             }
839             mpFontNameBox->Enable(bIsControlEnabled);
840             break;
841         }
842         case SID_ATTR_CHAR_FONTHEIGHT:
843         {
844             bool bIsControlEnabled (bIsEnabled);
845             if (  eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxFontHeightItem) )
846             {
847                 mpHeightItem = (SvxFontHeightItem*)pState;//const SvxFontHeightItem*
848                 SfxMapUnit eUnit = maFontSizeControl.GetCoreMetric();
849                 const sal_Int64 nValue (CalcToPoint(mpHeightItem->GetHeight(), eUnit, 10 ));
850                 mpToolBoxIncDec->Enable();
851 
852                 mpToolBoxIncDec->SetItemState(TBI_INCREASE, STATE_NOCHECK);
853                 mpToolBoxIncDec->SetItemState(TBI_DECREASE, STATE_NOCHECK);
854 
855                 // For Writer we have to update the states of the
856                 // increase and decrease buttons here, because we have
857                 // no access to the slots used by Writer.
858                 switch(maContext.GetCombinedContext_DI())
859                 {
860                     case CombinedEnumContext(Application_DrawImpress, Context_DrawText):
861                     case CombinedEnumContext(Application_DrawImpress, Context_Text):
862                     case CombinedEnumContext(Application_DrawImpress, Context_Table):
863                     case CombinedEnumContext(Application_DrawImpress, Context_OutlineText):
864                     case CombinedEnumContext(Application_DrawImpress, Context_Draw):
865                     case CombinedEnumContext(Application_DrawImpress, Context_TextObject):
866                     case CombinedEnumContext(Application_DrawImpress, Context_Graphic):
867                         break;
868 
869                     default:
870                     {
871                         mpToolBoxIncDec->EnableItem(TBI_INCREASE, bIsEnabled && nValue<960);
872                         mpToolBoxIncDec->EnableItem(TBI_DECREASE, bIsEnabled && nValue>60);
873                         break;
874                     }
875                 }
876 
877                 if( mbFocusOnFontSizeCtrl )
878                     return;
879 
880                 maFontSizeBox.SetValue(nValue);
881                 maFontSizeBox.LoseFocus();
882 
883                 UpdateItem(SID_SHRINK_FONT_SIZE);
884                 UpdateItem(SID_GROW_FONT_SIZE);
885             }
886             else
887             {
888                 mpHeightItem = NULL;
889                 maFontSizeBox.SetText( String() );
890                 //increase decrease diabled when multi-seletion have different font size
891 
892                 // font size +/- enhancement in sd
893                 switch(maContext.GetCombinedContext_DI())
894                 {
895                     case CombinedEnumContext(Application_DrawImpress, Context_DrawText):
896                     case CombinedEnumContext(Application_DrawImpress, Context_Text):
897                     case CombinedEnumContext(Application_DrawImpress, Context_Table):
898                     case CombinedEnumContext(Application_DrawImpress, Context_OutlineText):
899                     case CombinedEnumContext(Application_DrawImpress, Context_Draw):
900                     case CombinedEnumContext(Application_DrawImpress, Context_TextObject):
901                     case CombinedEnumContext(Application_DrawImpress, Context_Graphic):
902                         break;
903 
904                     default:
905                         mpToolBoxIncDec->Disable();
906                 }
907                 if ( eState <= SFX_ITEM_READONLY )
908                     bIsControlEnabled = false;
909             }
910             maFontSizeBox.Enable(bIsControlEnabled);
911             break;
912         }
913 
914         case SID_ATTR_CHAR_WEIGHT:
915             mbWeightAvailable = (eState >= SFX_ITEM_DONTCARE);
916             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxWeightItem))
917             {
918                 const SvxWeightItem* pItem = (const SvxWeightItem*)pState;
919                 meWeight = (FontWeight)pItem->GetValue();
920             }
921             else
922             {
923                 meWeight = WEIGHT_NORMAL;
924             }
925             mpToolBoxFont->EnableItem(TBI_BOLD, mbWeightAvailable && bIsEnabled);
926             mpToolBoxFont->SetItemState(TBI_BOLD, meWeight==WEIGHT_BOLD ? STATE_CHECK : STATE_NOCHECK);
927             break;
928 
929         case SID_ATTR_CHAR_POSTURE:
930             mbPostureAvailable = (eState >= SFX_ITEM_DONTCARE);
931             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxPostureItem))
932             {
933                 const SvxPostureItem* pItem = (const SvxPostureItem*)pState;
934                 meItalic = (FontItalic)pItem->GetValue();
935             }
936             else
937             {
938                 meItalic = ITALIC_NONE;
939             }
940             mpToolBoxFont->EnableItem(TBI_ITALIC, mbPostureAvailable && bIsEnabled);
941             mpToolBoxFont->SetItemState(TBI_ITALIC,	meItalic==ITALIC_NORMAL ? STATE_CHECK : STATE_NOCHECK);
942             break;
943 
944         case SID_ATTR_CHAR_UNDERLINE:
945             if( eState >= SFX_ITEM_DEFAULT)
946             {
947                 if(pState->ISA(SvxUnderlineItem))
948                 {
949                     const SvxUnderlineItem* pItem = (const SvxUnderlineItem*)pState;
950                     meUnderline = (FontUnderline)pItem->GetValue();
951                     meUnderlineColor = pItem->GetColor();
952                 }
953             }
954             else
955             {
956                 meUnderline = UNDERLINE_NONE;
957             }
958             mpToolBoxFont->EnableItem(TBI_UNDERLINE, bIsEnabled);
959             mpToolBoxFont->SetItemState(TBI_UNDERLINE, meUnderline==UNDERLINE_NONE ? STATE_NOCHECK : STATE_CHECK);
960             break;
961 
962         case SID_ATTR_CHAR_SHADOWED:
963             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxShadowedItem))
964             {
965                 const SvxShadowedItem* pItem = (const SvxShadowedItem*)pState;
966                 mbShadow = pItem->GetValue();
967             }
968             else
969             {
970                 mbShadow = false;
971             }
972             mpToolBoxFont->EnableItem(TBI_SHADOWED, bIsEnabled);
973             mpToolBoxFont->SetItemState(TBI_SHADOWED, mbShadow ? STATE_CHECK : STATE_NOCHECK);
974             break;
975 
976         case SID_ATTR_CHAR_STRIKEOUT:
977             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SvxCrossedOutItem))
978             {
979                 const SvxCrossedOutItem* pItem = (const SvxCrossedOutItem*)pState;
980                 meStrike = (FontStrikeout)pItem->GetValue();
981             }
982             else
983             {
984                 meStrike = STRIKEOUT_NONE;
985             }
986             mpToolBoxFont->EnableItem(TBI_STRIKEOUT, bIsEnabled);
987             mpToolBoxFont->SetItemState(TBI_STRIKEOUT,
988                 meStrike!=STRIKEOUT_NONE && meStrike!=STRIKEOUT_DONTKNOW
989                     ? STATE_CHECK
990                     : STATE_NOCHECK);
991             break;
992 
993         case SID_ATTR_CHAR_ESCAPEMENT:
994         {
995             bool bIsItemEnabled (true);
996             if (eState == SFX_ITEM_AVAILABLE)
997             {
998                 if (pState->ISA(SvxEscapementItem))
999                 {
1000                     const SvxEscapementItem* pItem = (const SvxEscapementItem *)pState;
1001                     short nEsc = pItem->GetEsc();
1002                     if(nEsc == 0)
1003                     {
1004                         meEscape = SVX_ESCAPEMENT_OFF;
1005                         mpToolBoxScriptSw->SetItemState(TBI_SUPER_SW, STATE_NOCHECK);
1006                         mpToolBoxScriptSw->SetItemState(TBI_SUB_SW, STATE_NOCHECK);
1007                     }
1008                     else if(nEsc > 0)
1009                     {
1010                         meEscape = SVX_ESCAPEMENT_SUPERSCRIPT;
1011                         mpToolBoxScriptSw->SetItemState(TBI_SUPER_SW, STATE_CHECK);
1012                         mpToolBoxScriptSw->SetItemState(TBI_SUB_SW, STATE_NOCHECK);
1013                     }
1014                     else
1015                     {
1016                         meEscape = SVX_ESCAPEMENT_SUBSCRIPT;
1017                         mpToolBoxScriptSw->SetItemState(TBI_SUPER_SW, STATE_NOCHECK);
1018                         mpToolBoxScriptSw->SetItemState(TBI_SUB_SW, STATE_CHECK);
1019                     }
1020                 }
1021                 else
1022                 {
1023                     meEscape = SVX_ESCAPEMENT_OFF;
1024                     mpToolBoxScriptSw->SetItemState(TBI_SUPER_SW, STATE_NOCHECK);
1025                     mpToolBoxScriptSw->SetItemState(TBI_SUB_SW,	STATE_NOCHECK);
1026                 }
1027             }
1028             else if (eState == SFX_ITEM_DISABLED)
1029             {
1030                 bIsItemEnabled = false;
1031             }
1032             else
1033             {
1034                 meEscape = SVX_ESCAPEMENT_OFF;
1035             }
1036             mpToolBoxScriptSw->EnableItem(TBI_SUPER_SW, bIsItemEnabled && bIsEnabled);
1037             mpToolBoxScriptSw->EnableItem(TBI_SUB_SW, bIsItemEnabled && bIsEnabled);
1038             break;
1039         }
1040 
1041         case SID_SET_SUB_SCRIPT:
1042             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SfxBoolItem))
1043             {
1044                 const SfxBoolItem* pItem = (const SfxBoolItem*)pState;
1045                 mbSub = pItem->GetValue();
1046             }
1047             else
1048             {
1049                 mbSub = false;
1050             }
1051             mpToolBoxScript->EnableItem(TBI_SUB, bIsEnabled);
1052             mpToolBoxScript->SetItemState(TBI_SUB, mbSub ? STATE_CHECK : STATE_NOCHECK);
1053             break;
1054 
1055         case SID_SET_SUPER_SCRIPT:
1056             if( eState >= SFX_ITEM_DEFAULT && pState->ISA(SfxBoolItem))
1057             {
1058                 const SfxBoolItem* pItem = (const SfxBoolItem*)pState;
1059                 mbSuper = pItem->GetValue();
1060             }
1061             else
1062             {
1063                 mbSuper = false;
1064             }
1065             mpToolBoxScript->EnableItem(TBI_SUPER, bIsEnabled);
1066             mpToolBoxScript->SetItemState(TBI_SUPER, mbSuper ? STATE_CHECK : STATE_NOCHECK);
1067             break;
1068 
1069         case SID_ATTR_CHAR_KERNING:
1070             if ( SFX_ITEM_AVAILABLE == eState )
1071             {
1072                 mbKernLBAvailable = true;
1073 
1074                 if(pState->ISA(SvxKerningItem))
1075                 {
1076                     const SvxKerningItem* pKerningItem  = (const SvxKerningItem*)pState;
1077                     mlKerning = (long)pKerningItem->GetValue();
1078                     mbKernAvailable = true;
1079                 }
1080                 else
1081                 {
1082                     mlKerning = 0;
1083                     mbKernAvailable =false;
1084                 }
1085             }
1086             else if (SFX_ITEM_DISABLED == eState)
1087             {
1088                 mbKernLBAvailable = false;
1089                 mbKernAvailable = false;
1090                 mlKerning = 0;
1091             }
1092             else
1093             {
1094                 mbKernLBAvailable = true;
1095                 mbKernAvailable = false;
1096                 mlKerning = 0;
1097             }
1098             mpToolBoxSpacing->EnableItem(TBI_SPACING, bIsEnabled);
1099             break;
1100 
1101             // font size +/- enhancement in sd
1102         case SID_SHRINK_FONT_SIZE:
1103         case SID_GROW_FONT_SIZE:
1104             switch(maContext.GetCombinedContext_DI())
1105             {
1106                 case CombinedEnumContext(Application_DrawImpress, Context_DrawText):
1107                 case CombinedEnumContext(Application_DrawImpress, Context_Text):
1108                 case CombinedEnumContext(Application_DrawImpress, Context_Table):
1109                 case CombinedEnumContext(Application_DrawImpress, Context_OutlineText):
1110                 case CombinedEnumContext(Application_DrawImpress, Context_Draw):
1111                 case CombinedEnumContext(Application_DrawImpress, Context_TextObject):
1112                 case CombinedEnumContext(Application_DrawImpress, Context_Graphic):
1113                 {
1114                     if(eState == SFX_ITEM_DISABLED)
1115                         mpToolBoxIncDec->Disable();
1116                     else
1117                         mpToolBoxIncDec->Enable();
1118                     const sal_Int64 nSize (maFontSizeBox.GetValue());
1119                     switch(nSID)
1120                     {
1121                         case SID_GROW_FONT_SIZE:
1122                             mpToolBoxIncDec->EnableItem(TBI_INCREASE, bIsEnabled && nSize<960);
1123                             break;
1124 
1125                         case SID_SHRINK_FONT_SIZE:
1126                             mpToolBoxIncDec->EnableItem(TBI_DECREASE, bIsEnabled && nSize>60);
1127                             break;
1128 
1129                         default:
1130                             break;
1131                     }
1132                 }
1133             }
1134             break;
1135     }
1136 }
1137 
1138 
1139 
1140 
1141 void TextPropertyPanel::UpdateItem (const sal_uInt16 nSlotId)
1142 {
1143     switch (nSlotId)
1144     {
1145         case SID_ATTR_CHAR_FONT:
1146             maFontNameControl.RequestUpdate();
1147             break;
1148         case SID_ATTR_CHAR_FONTHEIGHT:
1149             maFontSizeControl.RequestUpdate();
1150             break;
1151         case SID_ATTR_CHAR_WEIGHT:
1152             maWeightControl.RequestUpdate();
1153             break;
1154         case SID_ATTR_CHAR_POSTURE:
1155             maItalicControl.RequestUpdate();
1156             break;
1157         case SID_ATTR_CHAR_UNDERLINE:
1158             maUnderlineControl.RequestUpdate();
1159             break;
1160         case SID_ATTR_CHAR_STRIKEOUT:
1161             maStrikeControl.RequestUpdate();
1162             break;
1163         case SID_ATTR_CHAR_SHADOWED:
1164             maShadowControl.RequestUpdate();
1165             break;
1166         case SID_ATTR_CHAR_ESCAPEMENT:
1167             maScriptControlSw.RequestUpdate();
1168             break;
1169         case SID_SET_SUPER_SCRIPT:
1170             maSuperScriptControl.RequestUpdate();
1171             break;
1172         case SID_SET_SUB_SCRIPT:
1173             maSubScriptControl.RequestUpdate();
1174             break;
1175         case SID_ATTR_CHAR_KERNING:
1176             maSpacingControl.RequestUpdate();
1177             break;
1178         case SID_GROW_FONT_SIZE:
1179             maSDFontGrow.RequestUpdate();
1180             break;
1181         case SID_SHRINK_FONT_SIZE:
1182             maSDFontShrink.RequestUpdate();
1183             break;
1184     }
1185 }
1186 
1187 
1188 
1189 
1190 
1191 Color& TextPropertyPanel::GetUnderlineColor()
1192 {
1193 	return meUnderlineColor;
1194 }
1195 
1196 void TextPropertyPanel::SetUnderline(FontUnderline	eUnderline)
1197 {
1198 	meUnderline = eUnderline;
1199 }
1200 
1201 
1202 
1203 } } // end of namespace svx::sidebar
1204