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