1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_svx.hxx" 30 #include <vcl/wrkwin.hxx> 31 #include <tools/shl.hxx> 32 #include <vcl/metaact.hxx> 33 #include <svtools/valueset.hxx> 34 #include <svl/eitem.hxx> 35 #include <sfx2/dispatch.hxx> 36 #include <svtools/colrdlg.hxx> 37 38 #define BMPMASK_PRIVATE 39 40 #include <svx/dialmgr.hxx> 41 #include <svx/bmpmask.hxx> 42 #include <svx/dialogs.hrc> 43 #include <bmpmask.hrc> 44 #include <svx/svxids.hrc> 45 46 //------------------------------------------------------------------------- 47 48 #define BMP_RESID(nId) ResId(nId, DIALOG_MGR()) 49 #define TRANSP_STRING "Transparent" 50 #define TRANSP_COL (Color( 252, 252, 252 )) 51 #define OWN_CALLMODE SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD 52 53 //------------------------------------------------------------------------- 54 55 #define TEST_COLS() \ 56 { \ 57 nR = aCol.GetRed(); nG = aCol.GetGreen(); nB = aCol.GetBlue(); \ 58 for( i = 0; i < nCount; i++ ) \ 59 { \ 60 if ( ( pMinR[i] <= nR ) && ( pMaxR[i] >= nR ) && \ 61 ( pMinG[i] <= nG ) && ( pMaxG[i] >= nG ) && \ 62 ( pMinB[i] <= nB ) && ( pMaxB[i] >= nB ) ) \ 63 { \ 64 aCol = pDstCols[i]; bReplace = sal_True; break; \ 65 } \ 66 } \ 67 } 68 69 // ------------------------------------------------------------------------- 70 71 SFX_IMPL_DOCKINGWINDOW( SvxBmpMaskChildWindow, SID_BMPMASK ) 72 73 // ------------------------------------------------------------------------- 74 75 class ColorWindow : public Control 76 { 77 Color aColor; 78 79 80 public: 81 82 ColorWindow( Window* pParent, WinBits nWinStyle ) : 83 Control( pParent, nWinStyle ), 84 aColor( COL_WHITE ) {}; 85 86 ColorWindow( Window* pParent, const ResId& rId ) : 87 Control( pParent, rId ), 88 aColor( COL_WHITE ) {}; 89 90 void SetColor( const Color& rColor ) 91 { 92 aColor = rColor; 93 Invalidate(); 94 } 95 96 virtual void Paint( const Rectangle& rRect ); 97 }; 98 99 //------------------------------------------------------------------------- 100 101 class MaskSet : public ValueSet 102 { 103 SvxBmpMask* pSvxBmpMask; 104 105 106 public: 107 MaskSet( SvxBmpMask* pParent, WinBits nWinStyle ); 108 MaskSet( SvxBmpMask* pParent, const ResId& rId ); 109 110 virtual void Select(); 111 virtual void KeyInput( const KeyEvent& rKEvt ); 112 virtual void GetFocus(); 113 114 void onEditColor(); 115 }; 116 117 //------------------------------------------------------------------------- 118 119 MaskSet::MaskSet( SvxBmpMask* pParent, WinBits nWinStyle ) : 120 ValueSet ( pParent, nWinStyle ), 121 pSvxBmpMask ( pParent ) 122 { 123 } 124 125 //------------------------------------------------------------------------- 126 127 MaskSet::MaskSet( SvxBmpMask* pParent, const ResId& rId ) : 128 ValueSet ( pParent, rId ), 129 pSvxBmpMask ( pParent ) 130 { 131 } 132 133 //------------------------------------------------------------------------- 134 135 void MaskSet::Select() 136 { 137 ValueSet::Select(); 138 139 pSvxBmpMask->onSelect( this ); 140 } 141 142 void MaskSet::GetFocus() 143 { 144 SelectItem( 1 ); 145 pSvxBmpMask->onSelect( this ); 146 } 147 148 void MaskSet::KeyInput( const KeyEvent& rKEvt ) 149 { 150 KeyCode aCode = rKEvt.GetKeyCode(); 151 152 // if the key has a modifier we don't care 153 if( aCode.GetModifier() ) 154 { 155 ValueSet::KeyInput( rKEvt ); 156 } 157 else 158 { 159 // check for keys that interests us 160 switch ( aCode.GetCode() ) 161 { 162 case KEY_SPACE: 163 onEditColor(); 164 break; 165 default: 166 ValueSet::KeyInput( rKEvt ); 167 } 168 169 } 170 } 171 172 void MaskSet::onEditColor() 173 { 174 SvColorDialog* pColorDlg = new SvColorDialog( GetParent() ); 175 176 pColorDlg->SetColor(GetItemColor(1)); 177 178 if( pColorDlg->Execute() ) 179 SetItemColor( 1, pColorDlg->GetColor() ); 180 181 delete pColorDlg; 182 } 183 184 //------------------------------------------------------------------------- 185 186 class MaskData 187 { 188 SvxBmpMask* pMask; 189 sal_Bool bIsReady; 190 sal_Bool bExecState; 191 SfxBindings& rBindings; 192 193 public: 194 MaskData( SvxBmpMask* pBmpMask, SfxBindings& rBind ); 195 196 sal_Bool IsCbxReady() const { return bIsReady; } 197 void SetExecState( sal_Bool bState ) { bExecState = bState; } 198 sal_Bool IsExecReady() const { return bExecState; } 199 200 DECL_LINK( PipetteHdl, ToolBox* pTbx ); 201 DECL_LINK( CbxHdl, CheckBox* pCbx ); 202 DECL_LINK( CbxTransHdl, CheckBox* pCbx ); 203 DECL_LINK( FocusLbHdl, ColorLB* pLb ); 204 DECL_LINK( ExecHdl, PushButton* pBtn ); 205 }; 206 207 //------------------------------------------------------------------------- 208 209 MaskData::MaskData( SvxBmpMask* pBmpMask, SfxBindings& rBind ) : 210 211 pMask ( pBmpMask ), 212 bIsReady ( sal_False ), 213 bExecState ( sal_False ), 214 rBindings ( rBind ) 215 216 { 217 } 218 219 //------------------------------------------------------------------------- 220 221 IMPL_LINK( MaskData, PipetteHdl, ToolBox*, pTbx ) 222 { 223 SfxBoolItem aBItem( SID_BMPMASK_PIPETTE, 224 pTbx->IsItemChecked( TBI_PIPETTE ) ); 225 226 rBindings.GetDispatcher()->Execute( SID_BMPMASK_PIPETTE, OWN_CALLMODE, &aBItem, 0L ); 227 228 return 0; 229 } 230 231 //------------------------------------------------------------------------- 232 233 IMPL_LINK( MaskData, CbxHdl, CheckBox*, pCbx ) 234 { 235 bIsReady = pMask->aCbx1.IsChecked() || pMask->aCbx2.IsChecked() || 236 pMask->aCbx3.IsChecked() || pMask->aCbx4.IsChecked(); 237 238 if ( bIsReady && IsExecReady() ) 239 pMask->aBtnExec.Enable(); 240 else 241 pMask->aBtnExec.Disable(); 242 243 // Wenn eine Checkbox gecheckt wurde, wird die Pipette enabled 244 if ( pCbx->IsChecked() ) 245 { 246 MaskSet* pSet = NULL; 247 248 if ( pCbx == &( pMask->aCbx1 ) ) 249 pSet = pMask->pQSet1; 250 else if ( pCbx == &( pMask->aCbx2 ) ) 251 pSet = pMask->pQSet2; 252 else if ( pCbx == &( pMask->aCbx3 ) ) 253 pSet = pMask->pQSet3; 254 else // if ( pCbx == &( pMask->aCbx4 ) ) 255 pSet = pMask->pQSet4; 256 257 pSet->SelectItem( 1 ); 258 pSet->Select(); 259 260 pMask->aTbxPipette.CheckItem( TBI_PIPETTE, sal_True ); 261 PipetteHdl( &( pMask->aTbxPipette ) ); 262 } 263 264 return 0; 265 } 266 267 //------------------------------------------------------------------------- 268 269 IMPL_LINK( MaskData, CbxTransHdl, CheckBox*, pCbx ) 270 { 271 bIsReady = pCbx->IsChecked(); 272 if ( bIsReady ) 273 { 274 pMask->pQSet1->Disable(); 275 pMask->pQSet2->Disable(); 276 pMask->pQSet3->Disable(); 277 pMask->pQSet4->Disable(); 278 pMask->pCtlPipette->Disable(); 279 pMask->aCbx1.Disable(); 280 pMask->aSp1.Disable(); 281 pMask->aCbx2.Disable(); 282 pMask->aSp2.Disable(); 283 pMask->aCbx3.Disable(); 284 pMask->aSp3.Disable(); 285 pMask->aCbx4.Disable(); 286 pMask->aSp4.Disable(); 287 pMask->aTbxPipette.Disable(); 288 289 pMask->aLbColor1.Disable(); 290 pMask->aLbColor2.Disable(); 291 pMask->aLbColor3.Disable(); 292 pMask->aLbColor4.Disable(); 293 pMask->aLbColorTrans.Enable(); 294 } 295 else 296 { 297 pMask->pQSet1->Enable(); 298 pMask->pQSet2->Enable(); 299 pMask->pQSet3->Enable(); 300 pMask->pQSet4->Enable(); 301 pMask->pCtlPipette->Enable(); 302 pMask->aCbx1.Enable(); 303 pMask->aSp1.Enable(); 304 pMask->aCbx2.Enable(); 305 pMask->aSp2.Enable(); 306 pMask->aCbx3.Enable(); 307 pMask->aSp3.Enable(); 308 pMask->aCbx4.Enable(); 309 pMask->aSp4.Enable(); 310 pMask->aTbxPipette.Enable(); 311 312 pMask->aLbColor1.Enable(); 313 pMask->aLbColor2.Enable(); 314 pMask->aLbColor3.Enable(); 315 pMask->aLbColor4.Enable(); 316 pMask->aLbColorTrans.Disable(); 317 318 bIsReady = pMask->aCbx1.IsChecked() || pMask->aCbx2.IsChecked() || 319 pMask->aCbx3.IsChecked() || pMask->aCbx4.IsChecked(); 320 } 321 322 if ( bIsReady && IsExecReady() ) 323 pMask->aBtnExec.Enable(); 324 else 325 pMask->aBtnExec.Disable(); 326 327 return 0L; 328 } 329 330 //------------------------------------------------------------------------- 331 332 IMPL_LINK( MaskData, FocusLbHdl, ColorLB*, pLb ) 333 { 334 pMask->pQSet1->SelectItem( pLb == &( pMask->aLbColor1 ) ? 1 : 0 ); 335 pMask->pQSet2->SelectItem( pLb == &( pMask->aLbColor2 ) ? 1 : 0 ); 336 pMask->pQSet3->SelectItem( pLb == &( pMask->aLbColor3 ) ? 1 : 0 ); 337 pMask->pQSet4->SelectItem( pLb == &( pMask->aLbColor4 ) ? 1 : 0 ); 338 339 return 0; 340 } 341 342 //------------------------------------------------------------------------- 343 344 IMPL_LINK( MaskData, ExecHdl, PushButton*, EMPTYARG ) 345 { 346 SfxBoolItem aBItem( SID_BMPMASK_EXEC, sal_True ); 347 rBindings.GetDispatcher()->Execute( SID_BMPMASK_EXEC, OWN_CALLMODE, &aBItem, 0L ); 348 349 return 0L; 350 } 351 352 //------------------------------------------------------------------------- 353 354 void ColorWindow::Paint( const Rectangle &/*Rect*/ ) 355 { 356 const Color& rOldLineColor = GetLineColor(); 357 const Color& rOldFillColor = GetFillColor(); 358 359 SetLineColor( aColor ); 360 SetFillColor( aColor ); 361 362 DrawRect( Rectangle( Point(), GetSizePixel() ) ); 363 364 SetLineColor( rOldLineColor ); 365 SetFillColor( rOldFillColor ); 366 } 367 368 //------------------------------------------------------------------------- 369 370 SvxBmpMaskSelectItem::SvxBmpMaskSelectItem( sal_uInt16 nId_, SvxBmpMask& rMask, 371 SfxBindings& rBindings ) : 372 SfxControllerItem ( nId_, rBindings ), 373 rBmpMask ( rMask) 374 { 375 } 376 377 //------------------------------------------------------------------------- 378 379 void SvxBmpMaskSelectItem::StateChanged( sal_uInt16 nSID, SfxItemState /*eState*/, 380 const SfxPoolItem* pItem ) 381 { 382 if ( ( nSID == SID_BMPMASK_EXEC ) && pItem ) 383 { 384 const SfxBoolItem* pStateItem = PTR_CAST( SfxBoolItem, pItem ); 385 386 DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem erwartet"); 387 388 rBmpMask.SetExecState( pStateItem->GetValue() ); 389 } 390 } 391 392 //------------------------------------------------------------------------- 393 394 SvxBmpMaskChildWindow::SvxBmpMaskChildWindow( Window* pParent_, sal_uInt16 nId, 395 SfxBindings* pBindings, 396 SfxChildWinInfo* pInfo ) : 397 SfxChildWindow( pParent_, nId ) 398 { 399 pWindow = new SvxBmpMask( pBindings, this, pParent_, 400 BMP_RESID( RID_SVXDLG_BMPMASK ) ); 401 SvxBmpMask* pDlg = (SvxBmpMask*) pWindow; 402 403 eChildAlignment = SFX_ALIGN_NOALIGNMENT; 404 405 pDlg->Initialize( pInfo ); 406 } 407 408 //------------------------------------------------------------------------- 409 410 SvxBmpMask::SvxBmpMask( SfxBindings *pBindinx, 411 SfxChildWindow *pCW, 412 Window* pParent, 413 const ResId& rResId ) : 414 SfxDockingWindow ( pBindinx, pCW, pParent, rResId ), 415 aTbxPipette ( this, BMP_RESID( TBX_PIPETTE ) ), 416 pCtlPipette ( new ColorWindow( this, BMP_RESID( WND_PIPETTE ) ) ), 417 aBtnExec ( this, BMP_RESID( BTN_EXEC ) ), 418 aGrpQ ( this, BMP_RESID( GRP_Q ) ), 419 420 aFt1 ( this, BMP_RESID ( FT_1 ) ), 421 aFt2 ( this, BMP_RESID ( FT_2 ) ), 422 aFt3 ( this, BMP_RESID ( FT_3 ) ), 423 424 aCbx1 ( this, BMP_RESID( CBX_1 ) ), 425 pQSet1 ( new MaskSet( this, BMP_RESID( QCOL_1 ) ) ), 426 aSp1 ( this, BMP_RESID( SP_1 ) ), 427 aLbColor1 ( this, BMP_RESID ( LB_1 ) ), 428 429 aCbx2 ( this, BMP_RESID( CBX_2 ) ), 430 pQSet2 ( new MaskSet( this, BMP_RESID( QCOL_2 ) ) ), 431 aSp2 ( this, BMP_RESID( SP_2 ) ), 432 aLbColor2 ( this, BMP_RESID ( LB_2 ) ), 433 434 aCbx3 ( this, BMP_RESID( CBX_3 ) ), 435 pQSet3 ( new MaskSet( this, BMP_RESID( QCOL_3 ) ) ), 436 aSp3 ( this, BMP_RESID( SP_3 ) ), 437 aLbColor3 ( this, BMP_RESID ( LB_3 ) ), 438 439 aCbx4 ( this, BMP_RESID( CBX_4 ) ), 440 pQSet4 ( new MaskSet( this, BMP_RESID( QCOL_4 ) ) ), 441 aSp4 ( this, BMP_RESID( SP_4 ) ), 442 aLbColor4 ( this, BMP_RESID ( LB_4 ) ), 443 444 pData ( new MaskData( this, *pBindinx ) ), 445 aCbxTrans ( this, BMP_RESID( CBX_TRANS ) ), 446 aLbColorTrans ( this, BMP_RESID ( LB_TRANS ) ), 447 pColTab ( NULL ), 448 aPipetteColor ( COL_WHITE ), 449 aSelItem ( SID_BMPMASK_EXEC, *this, *pBindinx ), 450 maImgPipette ( BMP_RESID ( IMG_PIPETTE ) ), 451 maImgPipetteH ( BMP_RESID ( IMG_PIPETTE_H ) ) 452 { 453 FreeResource(); 454 455 ApplyStyle(); 456 457 aTbxPipette.SetSizePixel( aTbxPipette.CalcWindowSizePixel() ); 458 aTbxPipette.SetSelectHdl( LINK( pData, MaskData, PipetteHdl ) ); 459 aBtnExec.SetClickHdl( LINK( pData, MaskData, ExecHdl ) ); 460 461 aCbx1.SetClickHdl( LINK( pData, MaskData, CbxHdl ) ); 462 aCbx2.SetClickHdl( LINK( pData, MaskData, CbxHdl ) ); 463 aCbx3.SetClickHdl( LINK( pData, MaskData, CbxHdl ) ); 464 aCbx4.SetClickHdl( LINK( pData, MaskData, CbxHdl ) ); 465 aCbxTrans.SetClickHdl( LINK( pData, MaskData, CbxTransHdl ) ); 466 467 SetAccessibleNames (); 468 469 aLbColor1.SetGetFocusHdl( LINK( pData, MaskData, FocusLbHdl ) ); 470 aLbColor2.SetGetFocusHdl( LINK( pData, MaskData, FocusLbHdl ) ); 471 aLbColor3.SetGetFocusHdl( LINK( pData, MaskData, FocusLbHdl ) ); 472 aLbColor4.SetGetFocusHdl( LINK( pData, MaskData, FocusLbHdl ) ); 473 aLbColorTrans.Disable(); 474 475 aSp1.SetValue( 10 ); 476 aSp2.SetValue( 10 ); 477 aSp3.SetValue( 10 ); 478 aSp4.SetValue( 10 ); 479 480 pQSet1->SetStyle( pQSet1->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); 481 pQSet1->SetColCount( 1 ); 482 pQSet1->SetLineCount( 1 ); 483 // pQSet1->SetExtraSpacing( 1 ); 484 pQSet1->InsertItem( 1, aPipetteColor ); 485 pQSet1->SelectItem( 1 ); 486 487 pQSet2->SetStyle( pQSet2->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); 488 pQSet2->SetColCount( 1 ); 489 pQSet2->SetLineCount( 1 ); 490 // pQSet2->SetExtraSpacing( 1 ); 491 pQSet2->InsertItem( 1, aPipetteColor ); 492 pQSet2->SelectItem( 0 ); 493 494 pQSet3->SetStyle( pQSet3->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); 495 pQSet3->SetColCount( 1 ); 496 pQSet3->SetLineCount( 1 ); 497 // pQSet3->SetExtraSpacing( 1 ); 498 pQSet3->InsertItem( 1, aPipetteColor ); 499 pQSet3->SelectItem( 0 ); 500 501 pQSet4->SetStyle( pQSet4->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); 502 pQSet4->SetColCount( 1 ); 503 pQSet4->SetLineCount( 1 ); 504 // pQSet4->SetExtraSpacing( 1 ); 505 pQSet4->InsertItem( 1, aPipetteColor ); 506 pQSet4->SelectItem( 0 ); 507 508 pQSet1->Show(); 509 pQSet2->Show(); 510 pQSet3->Show(); 511 pQSet4->Show(); 512 513 aCbx1.SetAccessibleRelationMemberOf( &aGrpQ ); 514 pQSet1->SetAccessibleRelationMemberOf( &aGrpQ ); 515 aSp1.SetAccessibleRelationMemberOf( &aGrpQ ); 516 aLbColor1.SetAccessibleRelationMemberOf( &aGrpQ ); 517 aCbx1.SetAccessibleRelationLabeledBy( &aFt1 ); 518 pQSet1->SetAccessibleRelationLabeledBy( &aFt1 ); 519 aSp1.SetAccessibleRelationLabeledBy( &aFt2 ); 520 aLbColor1.SetAccessibleRelationLabeledBy( &aFt3 ); 521 aCbx2.SetAccessibleRelationMemberOf( &aGrpQ ); 522 pQSet2->SetAccessibleRelationMemberOf( &aGrpQ ); 523 aSp2.SetAccessibleRelationMemberOf( &aGrpQ ); 524 aLbColor2.SetAccessibleRelationMemberOf( &aGrpQ ); 525 aCbx2.SetAccessibleRelationLabeledBy( &aFt1 ); 526 pQSet2->SetAccessibleRelationLabeledBy( &aFt1 ); 527 aSp2.SetAccessibleRelationLabeledBy( &aFt2 ); 528 aLbColor2.SetAccessibleRelationLabeledBy( &aFt3 ); 529 aCbx3.SetAccessibleRelationMemberOf( &aGrpQ ); 530 pQSet3->SetAccessibleRelationMemberOf( &aGrpQ ); 531 aSp3.SetAccessibleRelationMemberOf( &aGrpQ ); 532 aLbColor3.SetAccessibleRelationMemberOf( &aGrpQ ); 533 aCbx3.SetAccessibleRelationLabeledBy( &aFt1 ); 534 pQSet3->SetAccessibleRelationLabeledBy( &aFt1 ); 535 aSp3.SetAccessibleRelationLabeledBy( &aFt2 ); 536 aLbColor3.SetAccessibleRelationLabeledBy( &aFt3 ); 537 aCbx4.SetAccessibleRelationMemberOf( &aGrpQ ); 538 pQSet4->SetAccessibleRelationMemberOf( &aGrpQ ); 539 aSp4.SetAccessibleRelationMemberOf( &aGrpQ ); 540 aLbColor4.SetAccessibleRelationMemberOf( &aGrpQ ); 541 aCbx4.SetAccessibleRelationLabeledBy( &aFt1 ); 542 pQSet4->SetAccessibleRelationLabeledBy( &aFt1 ); 543 aSp4.SetAccessibleRelationLabeledBy( &aFt2 ); 544 aLbColor4.SetAccessibleRelationLabeledBy( &aFt3 ); 545 aLbColorTrans.SetAccessibleRelationLabeledBy( &aCbxTrans ); 546 aLbColorTrans.SetAccessibleRelationMemberOf( &aGrpQ ); 547 aCbxTrans.SetAccessibleRelationMemberOf( &aGrpQ ); 548 } 549 550 //------------------------------------------------------------------------- 551 552 SvxBmpMask::~SvxBmpMask() 553 { 554 delete pQSet1; 555 delete pQSet2; 556 delete pQSet3; 557 delete pQSet4; 558 delete pCtlPipette; 559 delete pData; 560 } 561 562 //------------------------------------------------------------------------- 563 564 /** is called by a MaskSet when it is selected */ 565 void SvxBmpMask::onSelect( MaskSet* pSet ) 566 { 567 // automaticaly set focus to the corresponding listbox 568 /* 569 if( pSet == pQSet1 ) 570 aLbColor1.GrabFocus(); 571 else if( pSet == pQSet2 ) 572 aLbColor2.GrabFocus(); 573 else if( pSet == pQSet2 ) 574 aLbColor3.GrabFocus(); 575 else if( pSet == pQSet2 ) 576 aLbColor4.GrabFocus(); 577 */ 578 579 // now deselect all other value sets 580 if( pSet != pQSet1 ) 581 pQSet1->SelectItem( 0 ); 582 583 if( pSet != pQSet2 ) 584 pQSet2->SelectItem( 0 ); 585 586 if( pSet != pQSet3 ) 587 pQSet3->SelectItem( 0 ); 588 589 if( pSet != pQSet4 ) 590 pQSet4->SelectItem( 0 ); 591 } 592 593 //------------------------------------------------------------------------- 594 595 sal_Bool SvxBmpMask::Close() 596 { 597 SfxBoolItem aItem2( SID_BMPMASK_PIPETTE, sal_False ); 598 GetBindings().GetDispatcher()->Execute( SID_BMPMASK_PIPETTE, OWN_CALLMODE, &aItem2, 0L ); 599 600 return SfxDockingWindow::Close(); 601 } 602 603 //------------------------------------------------------------------------- 604 605 sal_Bool SvxBmpMask::NeedsColorTable() const 606 { 607 return ( aLbColor1.GetEntryCount() == 0 ); 608 } 609 610 //------------------------------------------------------------------------- 611 612 void SvxBmpMask::SetColorTable( const XColorTable* pTable ) 613 { 614 if ( pTable && ( pTable != pColTab ) ) 615 { 616 const String aTransp( BMP_RESID( RID_SVXDLG_BMPMASK_STR_TRANSP ) ); 617 618 pColTab = pTable; 619 620 aLbColorTrans.Fill( pColTab ); 621 aLbColorTrans.SelectEntryPos( 0 ); 622 623 aLbColor1.Fill( pColTab ); 624 aLbColor1.InsertEntry( TRANSP_COL, aTransp, 0 ); 625 aLbColor1.SelectEntryPos( 0 ); 626 627 aLbColor2.Fill( pColTab ); 628 aLbColor2.InsertEntry( TRANSP_COL, aTransp, 0 ); 629 aLbColor2.SelectEntryPos( 0 ); 630 631 aLbColor3.Fill( pColTab ); 632 aLbColor3.InsertEntry( TRANSP_COL, aTransp, 0 ); 633 aLbColor3.SelectEntryPos( 0 ); 634 635 aLbColor4.Fill( pColTab ); 636 aLbColor4.InsertEntry( TRANSP_COL, aTransp, 0 ); 637 aLbColor4.SelectEntryPos( 0 ); 638 } 639 } 640 641 //------------------------------------------------------------------------- 642 643 void SvxBmpMask::SetColor( const Color& rColor ) 644 { 645 aPipetteColor = rColor; 646 pCtlPipette->SetColor( aPipetteColor ); 647 } 648 649 //------------------------------------------------------------------------- 650 651 void SvxBmpMask::PipetteClicked() 652 { 653 if( pQSet1->GetSelectItemId() == 1 ) 654 { 655 aCbx1.Check( sal_True ); 656 pData->CbxHdl( &aCbx1 ); 657 pQSet1->SetItemColor( 1, aPipetteColor ); 658 } 659 else if( pQSet2->GetSelectItemId() == 1 ) 660 { 661 aCbx2.Check( sal_True ); 662 pData->CbxHdl( &aCbx2 ); 663 pQSet2->SetItemColor( 1, aPipetteColor ); 664 } 665 else if( pQSet3->GetSelectItemId() == 1 ) 666 { 667 aCbx3.Check( sal_True ); 668 pData->CbxHdl( &aCbx3 ); 669 pQSet3->SetItemColor( 1, aPipetteColor ); 670 } 671 else if( pQSet4->GetSelectItemId() == 1 ) 672 { 673 aCbx4.Check( sal_True ); 674 pData->CbxHdl( &aCbx4 ); 675 pQSet4->SetItemColor( 1, aPipetteColor ); 676 } 677 678 aTbxPipette.CheckItem( TBI_PIPETTE, sal_False ); 679 pData->PipetteHdl( &aTbxPipette ); 680 } 681 682 //------------------------------------------------------------------------- 683 684 void SvxBmpMask::SetExecState( sal_Bool bEnable ) 685 { 686 pData->SetExecState( bEnable ); 687 688 if ( pData->IsExecReady() && pData->IsCbxReady() ) 689 aBtnExec.Enable(); 690 else 691 aBtnExec.Disable(); 692 } 693 694 //------------------------------------------------------------------------- 695 696 sal_uInt16 SvxBmpMask::InitColorArrays( Color* pSrcCols, Color* pDstCols, sal_uIntPtr* pTols ) 697 { 698 sal_uInt16 nCount = 0; 699 700 if ( aCbx1.IsChecked() ) 701 { 702 pSrcCols[nCount] = pQSet1->GetItemColor( 1 ); 703 pDstCols[nCount] = aLbColor1.GetSelectEntryColor(); 704 pTols[nCount++] = static_cast<sal_uIntPtr>(aSp1.GetValue()); 705 } 706 707 if ( aCbx2.IsChecked() ) 708 { 709 pSrcCols[nCount] = pQSet2->GetItemColor( 1 ); 710 pDstCols[nCount] = aLbColor2.GetSelectEntryColor(); 711 pTols[nCount++] = static_cast<sal_uIntPtr>(aSp2.GetValue()); 712 } 713 714 if ( aCbx3.IsChecked() ) 715 { 716 pSrcCols[nCount] = pQSet3->GetItemColor( 1 ); 717 pDstCols[nCount] = aLbColor3.GetSelectEntryColor(); 718 pTols[nCount++] = static_cast<sal_uIntPtr>(aSp3.GetValue()); 719 } 720 721 if ( aCbx4.IsChecked() ) 722 { 723 pSrcCols[nCount] = pQSet4->GetItemColor( 1 ); 724 pDstCols[nCount] = aLbColor4.GetSelectEntryColor(); 725 pTols[nCount++] = static_cast<sal_uIntPtr>(aSp4.GetValue()); 726 } 727 728 return nCount; 729 } 730 731 //------------------------------------------------------------------------- 732 733 Bitmap SvxBmpMask::ImpMask( const Bitmap& rBitmap ) 734 { 735 Bitmap aBitmap( rBitmap ); 736 Color pSrcCols[4]; 737 Color pDstCols[4]; 738 sal_uIntPtr pTols[4]; 739 const sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); 740 741 EnterWait(); 742 aBitmap.Replace( pSrcCols, pDstCols, nCount, pTols ); 743 LeaveWait(); 744 745 return aBitmap; 746 } 747 748 //------------------------------------------------------------------------- 749 750 BitmapEx SvxBmpMask::ImpMask( const BitmapEx& rBitmapEx ) 751 { 752 return BitmapEx( ImpMask( rBitmapEx.GetBitmap() ), rBitmapEx.GetMask() ); 753 } 754 755 //------------------------------------------------------------------------- 756 757 BitmapEx SvxBmpMask::ImpMaskTransparent( const BitmapEx& rBitmapEx, const Color& rColor, const long nTol ) 758 { 759 EnterWait(); 760 761 BitmapEx aBmpEx; 762 Bitmap aMask( rBitmapEx.GetBitmap().CreateMask( rColor, nTol ) ); 763 764 if( rBitmapEx.IsTransparent() ) 765 aMask.CombineSimple( rBitmapEx.GetMask(), BMP_COMBINE_OR ); 766 767 aBmpEx = BitmapEx( rBitmapEx.GetBitmap(), aMask ); 768 LeaveWait(); 769 770 return aBmpEx; 771 } 772 773 //------------------------------------------------------------------------- 774 775 Animation SvxBmpMask::ImpMask( const Animation& rAnimation ) 776 { 777 Animation aAnimation( rAnimation ); 778 Color pSrcCols[4]; 779 Color pDstCols[4]; 780 sal_uIntPtr pTols[4]; 781 InitColorArrays( pSrcCols, pDstCols, pTols ); 782 sal_uInt16 nAnimationCount = aAnimation.Count(); 783 784 for( sal_uInt16 i = 0; i < nAnimationCount; i++ ) 785 { 786 AnimationBitmap aAnimBmp( aAnimation.Get( i ) ); 787 aAnimBmp.aBmpEx = Mask( aAnimBmp.aBmpEx ).GetBitmapEx(); 788 aAnimation.Replace( aAnimBmp, i ); 789 } 790 791 return aAnimation; 792 } 793 794 //------------------------------------------------------------------------- 795 796 GDIMetaFile SvxBmpMask::ImpMask( const GDIMetaFile& rMtf ) 797 { 798 GDIMetaFile aMtf; 799 Color pSrcCols[4]; 800 Color pDstCols[4]; 801 sal_uIntPtr pTols[4]; 802 sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); 803 sal_Bool pTrans[4]; 804 805 // Falls keine Farben ausgewaehlt, kopieren wir nur das Mtf 806 if( !nCount ) 807 aMtf = rMtf; 808 else 809 { 810 Color aCol; 811 long nVal; 812 long nTol; 813 long nR; 814 long nG; 815 long nB; 816 long* pMinR = new long[nCount]; 817 long* pMaxR = new long[nCount]; 818 long* pMinG = new long[nCount]; 819 long* pMaxG = new long[nCount]; 820 long* pMinB = new long[nCount]; 821 long* pMaxB = new long[nCount]; 822 sal_uInt16 i; 823 sal_Bool bReplace; 824 825 aMtf.SetPrefSize( rMtf.GetPrefSize() ); 826 aMtf.SetPrefMapMode( rMtf.GetPrefMapMode() ); 827 828 // Farbvergleichsarrays vorbereiten 829 for( i = 0; i < nCount; i++ ) 830 { 831 nTol = ( pTols[i] * 255L ) / 100L; 832 833 nVal = ( (long) pSrcCols[i].GetRed() ); 834 pMinR[i] = Max( nVal - nTol, 0L ); 835 pMaxR[i] = Min( nVal + nTol, 255L ); 836 837 nVal = ( (long) pSrcCols[i].GetGreen() ); 838 pMinG[i] = Max( nVal - nTol, 0L ); 839 pMaxG[i] = Min( nVal + nTol, 255L ); 840 841 nVal = ( (long) pSrcCols[i].GetBlue() ); 842 pMinB[i] = Max( nVal - nTol, 0L ); 843 pMaxB[i] = Min( nVal + nTol, 255L ); 844 845 pTrans[ i ] = ( pDstCols[ i ] == TRANSP_COL ); 846 } 847 848 // Actions untersuchen und Farben ggf. ersetzen 849 for( sal_uIntPtr nAct = 0UL, nActCount = rMtf.GetActionCount(); nAct < nActCount; nAct++ ) 850 { 851 MetaAction* pAction = rMtf.GetAction( nAct ); 852 853 bReplace = sal_False; 854 855 switch( pAction->GetType() ) 856 { 857 case( META_PIXEL_ACTION ): 858 { 859 MetaPixelAction* pAct = (MetaPixelAction*) pAction; 860 861 aCol = pAct->GetColor(); 862 TEST_COLS(); 863 864 if( bReplace ) 865 pAct = new MetaPixelAction( pAct->GetPoint(), aCol ); 866 else 867 pAct->Duplicate(); 868 869 aMtf.AddAction( pAct ); 870 } 871 break; 872 873 case( META_LINECOLOR_ACTION ): 874 { 875 MetaLineColorAction* pAct = (MetaLineColorAction*) pAction; 876 877 aCol = pAct->GetColor(); 878 TEST_COLS(); 879 880 if( bReplace ) 881 pAct = new MetaLineColorAction( aCol, !pTrans[ i ] ); 882 else 883 pAct->Duplicate(); 884 885 aMtf.AddAction( pAct ); 886 } 887 break; 888 889 case( META_FILLCOLOR_ACTION ): 890 { 891 MetaFillColorAction* pAct = (MetaFillColorAction*) pAction; 892 893 aCol = pAct->GetColor(); 894 TEST_COLS(); 895 896 if( bReplace ) 897 pAct = new MetaFillColorAction( aCol, !pTrans[ i ] ); 898 else 899 pAct->Duplicate(); 900 901 aMtf.AddAction( pAct ); 902 } 903 break; 904 905 case( META_TEXTCOLOR_ACTION ): 906 { 907 MetaTextColorAction* pAct = (MetaTextColorAction*) pAction; 908 909 aCol = pAct->GetColor(); 910 TEST_COLS(); 911 912 if( bReplace ) 913 pAct = new MetaTextColorAction( aCol ); 914 else 915 pAct->Duplicate(); 916 917 aMtf.AddAction( pAct ); 918 } 919 break; 920 921 case( META_TEXTFILLCOLOR_ACTION ): 922 { 923 MetaTextFillColorAction* pAct = (MetaTextFillColorAction*) pAction; 924 925 aCol = pAct->GetColor(); 926 TEST_COLS(); 927 928 if( bReplace ) 929 pAct = new MetaTextFillColorAction( aCol, !pTrans[ i ] ); 930 else 931 pAct->Duplicate(); 932 933 aMtf.AddAction( pAct ); 934 } 935 break; 936 937 case( META_FONT_ACTION ): 938 { 939 MetaFontAction* pAct = (MetaFontAction*) pAction; 940 Font aFont( pAct->GetFont() ); 941 942 aCol = aFont.GetColor(); 943 TEST_COLS(); 944 945 if( bReplace ) 946 { 947 aFont.SetColor( aCol ); 948 pAct = new MetaFontAction( aFont ); 949 } 950 else 951 pAct->Duplicate(); 952 953 aMtf.AddAction( pAct ); 954 } 955 break; 956 957 case( META_WALLPAPER_ACTION ): 958 { 959 MetaWallpaperAction* pAct = (MetaWallpaperAction*) pAction; 960 Wallpaper aWall( pAct->GetWallpaper() ); 961 962 aCol = aWall.GetColor(); 963 TEST_COLS(); 964 965 if( bReplace ) 966 { 967 aWall.SetColor( aCol ); 968 pAct = new MetaWallpaperAction( pAct->GetRect(), aWall ); 969 } 970 else 971 pAct->Duplicate(); 972 973 aMtf.AddAction( pAct ); 974 } 975 break; 976 977 case( META_BMP_ACTION ): 978 { 979 MetaBmpAction* pAct = (MetaBmpAction*) pAction; 980 const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmap() ); 981 982 pAct = new MetaBmpAction( pAct->GetPoint(), aBmp ); 983 aMtf.AddAction( pAct ); 984 } 985 break; 986 987 case( META_BMPSCALE_ACTION ): 988 { 989 MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction; 990 const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmap() ); 991 992 pAct = new MetaBmpScaleAction( pAct->GetPoint(), pAct->GetSize(), aBmp ); 993 aMtf.AddAction( pAct ); 994 } 995 break; 996 997 case( META_BMPSCALEPART_ACTION ): 998 { 999 MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction; 1000 const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmap() ); 1001 1002 pAct = new MetaBmpScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(), 1003 pAct->GetSrcPoint(), pAct->GetSrcSize(), aBmp ); 1004 aMtf.AddAction( pAct ); 1005 } 1006 break; 1007 1008 case( META_BMPEX_ACTION ): 1009 { 1010 MetaBmpExAction* pAct = (MetaBmpExAction*) pAction; 1011 const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); 1012 1013 pAct = new MetaBmpExAction( pAct->GetPoint(), aBmpEx ); 1014 aMtf.AddAction( pAct ); 1015 } 1016 break; 1017 1018 case( META_BMPEXSCALE_ACTION ): 1019 { 1020 MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction; 1021 const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); 1022 1023 pAct = new MetaBmpExScaleAction( pAct->GetPoint(), pAct->GetSize(), aBmpEx ); 1024 aMtf.AddAction( pAct ); 1025 } 1026 break; 1027 1028 case( META_BMPEXSCALEPART_ACTION ): 1029 { 1030 MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction; 1031 const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); 1032 1033 pAct = new MetaBmpExScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(), 1034 pAct->GetSrcPoint(), pAct->GetSrcSize(), aBmpEx ); 1035 aMtf.AddAction( pAct ); 1036 } 1037 break; 1038 1039 default: 1040 { 1041 OSL_ENSURE( pAction->GetType() != META_RENDERGRAPHIC_ACTION, 1042 "META_RENDERGRAPHIC_ACTION currently not supported at masking" ); 1043 1044 pAction->Duplicate(); 1045 aMtf.AddAction( pAction ); 1046 } 1047 break; 1048 } 1049 } 1050 1051 delete[] pMinR; 1052 delete[] pMaxR; 1053 delete[] pMinG; 1054 delete[] pMaxG; 1055 delete[] pMinB; 1056 delete[] pMaxB; 1057 } 1058 1059 LeaveWait(); 1060 1061 return aMtf; 1062 } 1063 1064 //------------------------------------------------------------------------- 1065 1066 BitmapEx SvxBmpMask::ImpReplaceTransparency( const BitmapEx& rBmpEx, const Color& rColor ) 1067 { 1068 if( rBmpEx.IsTransparent() ) 1069 { 1070 Bitmap aBmp( rBmpEx.GetBitmap() ); 1071 aBmp.Replace( rBmpEx.GetMask(), rColor ); 1072 return aBmp; 1073 } 1074 else 1075 return rBmpEx; 1076 } 1077 1078 //------------------------------------------------------------------------- 1079 1080 Animation SvxBmpMask::ImpReplaceTransparency( const Animation& rAnim, const Color& rColor ) 1081 { 1082 Animation aAnimation( rAnim ); 1083 sal_uInt16 nAnimationCount = aAnimation.Count(); 1084 1085 for( sal_uInt16 i = 0; i < nAnimationCount; i++ ) 1086 { 1087 AnimationBitmap aAnimBmp( aAnimation.Get( i ) ); 1088 aAnimBmp.aBmpEx = ImpReplaceTransparency( aAnimBmp.aBmpEx, rColor ); 1089 aAnimation.Replace( aAnimBmp, i ); 1090 } 1091 1092 return aAnimation; 1093 } 1094 1095 //------------------------------------------------------------------------- 1096 1097 GDIMetaFile SvxBmpMask::ImpReplaceTransparency( const GDIMetaFile& rMtf, const Color& rColor ) 1098 { 1099 VirtualDevice aVDev; 1100 GDIMetaFile aMtf; 1101 const MapMode& rPrefMap = rMtf.GetPrefMapMode(); 1102 const Size& rPrefSize = rMtf.GetPrefSize(); 1103 const sal_uIntPtr nActionCount = rMtf.GetActionCount(); 1104 1105 aVDev.EnableOutput( sal_False ); 1106 aMtf.Record( &aVDev ); 1107 aMtf.SetPrefSize( rPrefSize ); 1108 aMtf.SetPrefMapMode( rPrefMap ); 1109 aVDev.SetLineColor( rColor ); 1110 aVDev.SetFillColor( rColor ); 1111 1112 // Actions nacheinander abspielen; zuerst 1113 // den gesamten Bereich auf die Ersatzfarbe setzen 1114 aVDev.DrawRect( Rectangle( rPrefMap.GetOrigin(), rPrefSize ) ); 1115 for ( sal_uIntPtr i = 0; i < nActionCount; i++ ) 1116 { 1117 MetaAction* pAct = rMtf.GetAction( i ); 1118 1119 pAct->Duplicate(); 1120 aMtf.AddAction( pAct ); 1121 } 1122 1123 aMtf.Stop(); 1124 aMtf.WindStart(); 1125 1126 return aMtf; 1127 } 1128 1129 //------------------------------------------------------------------------- 1130 1131 Graphic SvxBmpMask::Mask( const Graphic& rGraphic ) 1132 { 1133 Graphic aGraphic( rGraphic ); 1134 const Color aReplColor( aLbColorTrans.GetSelectEntryColor() ); 1135 1136 switch( rGraphic.GetType() ) 1137 { 1138 case( GRAPHIC_BITMAP ): 1139 { 1140 if( rGraphic.IsAnimated() ) 1141 { 1142 // Transparenz ersetzen? 1143 if ( aCbxTrans.IsChecked() ) 1144 aGraphic = ImpReplaceTransparency( rGraphic.GetAnimation(), aReplColor ); 1145 else 1146 aGraphic = ImpMask( rGraphic.GetAnimation() ); 1147 } 1148 else 1149 { 1150 // Transparenz ersetzen? 1151 if( aCbxTrans.IsChecked() ) 1152 { 1153 if( aGraphic.IsTransparent() ) 1154 { 1155 BitmapEx aBmpEx( ImpReplaceTransparency( aGraphic.GetBitmapEx(), aReplColor ) ); 1156 const Size aSize( aBmpEx.GetSizePixel() ); 1157 1158 if( aSize.Width() && aSize.Height() ) 1159 aGraphic = aBmpEx; 1160 } 1161 } 1162 else 1163 { 1164 Color pSrcCols[4]; 1165 Color pDstCols[4]; 1166 sal_uIntPtr pTols[4]; 1167 sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); 1168 1169 if( nCount ) 1170 { 1171 // erstmal alle Transparent-Farben setzen 1172 for( sal_uInt16 i = 0; i < nCount; i++ ) 1173 { 1174 // Haben wir eine Transparenzfarbe? 1175 if( pDstCols[i] == TRANSP_COL ) 1176 { 1177 BitmapEx aBmpEx( ImpMaskTransparent( aGraphic.GetBitmapEx(), 1178 pSrcCols[ i ], pTols[ i ] ) ); 1179 const Size aSize( aBmpEx.GetSizePixel() ); 1180 1181 if( aSize.Width() && aSize.Height() ) 1182 aGraphic = aBmpEx; 1183 } 1184 } 1185 1186 // jetzt noch einmal mit den normalen Farben ersetzen 1187 Bitmap aBitmap( ImpMask( aGraphic.GetBitmap() ) ); 1188 Size aSize( aBitmap.GetSizePixel() ); 1189 1190 if ( aSize.Width() && aSize.Height() ) 1191 { 1192 if ( aGraphic.IsTransparent() ) 1193 aGraphic = Graphic( BitmapEx( aBitmap, aGraphic.GetBitmapEx().GetMask() ) ); 1194 else 1195 aGraphic = aBitmap; 1196 } 1197 } 1198 } 1199 } 1200 } 1201 break; 1202 1203 case( GRAPHIC_GDIMETAFILE ): 1204 { 1205 GDIMetaFile aMtf( aGraphic.GetGDIMetaFile() ); 1206 1207 // Transparenz ersetzen? 1208 if( aCbxTrans.IsChecked() ) 1209 aMtf = ImpReplaceTransparency( aMtf, aReplColor ); 1210 else 1211 aMtf = ImpMask( aMtf ); 1212 1213 Size aSize( aMtf.GetPrefSize() ); 1214 if ( aSize.Width() && aSize.Height() ) 1215 aGraphic = Graphic( aMtf ); 1216 else 1217 aGraphic = rGraphic; 1218 } 1219 break; 1220 1221 default: 1222 aGraphic = rGraphic; 1223 break; 1224 } 1225 1226 if( aGraphic != rGraphic ) 1227 { 1228 aGraphic.SetPrefSize( rGraphic.GetPrefSize() ); 1229 aGraphic.SetPrefMapMode( rGraphic.GetPrefMapMode() ); 1230 } 1231 1232 return aGraphic; 1233 } 1234 1235 //------------------------------------------------------------------------- 1236 1237 sal_Bool SvxBmpMask::IsEyedropping() const 1238 { 1239 return aTbxPipette.IsItemChecked( TBI_PIPETTE ); 1240 } 1241 1242 void SvxBmpMask::DataChanged( const DataChangedEvent& rDCEvt ) 1243 { 1244 SfxDockingWindow::DataChanged( rDCEvt ); 1245 1246 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) ) 1247 ApplyStyle(); 1248 } 1249 1250 void SvxBmpMask::ApplyStyle() 1251 { 1252 bool bHighContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); 1253 1254 aTbxPipette.SetItemImage( TBI_PIPETTE, bHighContrast ? maImgPipetteH : maImgPipette ); 1255 } 1256 1257 1258 /** Set an accessible name for the source color check boxes. Without this 1259 the lengthy description is read. 1260 */ 1261 void SvxBmpMask::SetAccessibleNames (void) 1262 { 1263 String sSourceColor (BMP_RESID( RID_SVXDLG_BMPMASK_STR_SOURCECOLOR)); 1264 String sSourceColorN; 1265 1266 sSourceColorN = sSourceColor; 1267 sSourceColorN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 1")); 1268 aCbx1.SetAccessibleName (sSourceColorN); 1269 1270 sSourceColorN = sSourceColor; 1271 sSourceColorN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 2")); 1272 aCbx2.SetAccessibleName (sSourceColorN); 1273 1274 sSourceColorN = sSourceColor; 1275 sSourceColorN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 3")); 1276 aCbx3.SetAccessibleName (sSourceColorN); 1277 1278 sSourceColorN = sSourceColor; 1279 sSourceColorN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4")); 1280 aCbx4.SetAccessibleName (sSourceColorN); 1281 } 1282