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