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