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