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