xref: /aoo41x/main/cui/source/dialogs/colorpicker.cxx (revision ae2dc0fa)
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 // MARKER(update_precomp.py): autogen include statement, do not remove
23 #include "precompiled_cui.hxx"
24 
25 #include <com/sun/star/uno/XComponentContext.hpp>
26 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
27 #include <com/sun/star/beans/XPropertyAccess.hpp>
28 #include <com/sun/star/lang/XInitialization.hpp>
29 #include <com/sun/star/lang/XServiceInfo.hpp>
30 #include <com/sun/star/datatransfer/XTransferable.hpp>
31 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
32 #include <com/sun/star/awt/XWindow.hpp>
33 #include <cppuhelper/compbase4.hxx>
34 #include <comphelper/broadcasthelper.hxx>
35 #include <vcl/dialog.hxx>
36 #include <vcl/button.hxx>
37 #include <vcl/fixed.hxx>
38 #include <vcl/edit.hxx>
39 #include <vcl/field.hxx>
40 #include <vcl/bmpacc.hxx>
41 #include <vcl/decoview.hxx>
42 #include <vcl/sound.hxx>
43 #include <vcl/svapp.hxx>
44 #include <toolkit/helper/vclunohelper.hxx>
45 #include <sot/exchange.hxx>
46 #include <sot/formats.hxx>
47 #include <sax/tools/converter.hxx>
48 #include "dialmgr.hxx"
49 #include "colorpicker.hrc"
50 #include <cmath>
51 
52 using rtl::OUString;
53 using namespace ::com::sun::star::uno;
54 using namespace ::com::sun::star::lang;
55 using namespace ::com::sun::star::ui::dialogs;
56 using namespace ::com::sun::star::beans;
57 
58 namespace cui
59 {
60 const sal_uInt16 COLORMODE_RGB =  0x10;
61 const sal_uInt16 COLORMODE_HSV =  0x20;
62 const sal_uInt16 COLORMODE_CMYK = 0x40;
63 
64 const sal_uInt16 COLORCOMP_RED   = 0x10;
65 const sal_uInt16 COLORCOMP_GREEN = 0x11;
66 const sal_uInt16 COLORCOMP_BLUE  = 0x12;
67 
68 const sal_uInt16 COLORCOMP_HUE  = 0x20;
69 const sal_uInt16 COLORCOMP_SAT  = 0x21;
70 const sal_uInt16 COLORCOMP_BRI  = 0x22;
71 
72 const sal_uInt16 COLORCOMP_CYAN    = 0x40;
73 const sal_uInt16 COLORCOMP_YELLOW  = 0x41;
74 const sal_uInt16 COLORCOMP_MAGENTA = 0x42;
75 const sal_uInt16 COLORCOMP_KEY     = 0x43;
76 
77 // -----------------------------------------------------------------------
78 // color space conversion
79 // RGB  = 0 .. 1
80 // H    = 0 .. 360
81 // SV   = 0 .. 1
82 // CMYK = 0 .. 1
83 // -----------------------------------------------------------------------
84 
RGBtoHSV(double dR,double dG,double dB,double & dH,double & dS,double & dV)85 static void RGBtoHSV( double dR, double dG, double dB, double& dH, double& dS, double& dV )
86 {
87     // Brightness = max(R, G, B);
88     dV = std::max( dR, std::max( dG, dB ) );
89 
90     double cDelta = dV - std::min( dR, std::min( dG, dB ) );
91 
92     // Saturation = max - min / max
93     if( dV > 0 )
94         dS = cDelta / dV;
95     else
96         dS = 0.0;
97 
98     dH = 0.0;
99 
100     if( !basegfx::fTools::equalZero( dS ) )
101     {
102         if( basegfx::fTools::equal( dR, dV ) )
103         {
104             dH = ( dG - dB ) / cDelta;
105         }
106         else if( basegfx::fTools::equal( dG, dV ) )
107         {
108             dH = 2.0 + ( dB - dR ) / cDelta;
109         }
110         else if ( basegfx::fTools::equal( dB, dV ) )
111         {
112             dH = 4.0 + ( dR - dG ) / cDelta;
113         }
114         dH *= 60.0;
115 
116         if( dH < 0.0 )
117             dH += 360.0;
118     }
119 }
120 
HSVtoRGB(double dH,double dS,double dV,double & dR,double & dG,double & dB)121 static void HSVtoRGB(double dH, double dS, double dV, double& dR, double& dG, double& dB )
122 {
123     if( basegfx::fTools::equalZero( dS ) )
124     {
125         dR = dV;
126         dG = dV;
127         dB = dV;
128     }
129     else
130     {
131         if( basegfx::fTools::equal( dH, 360.0 ) )
132             dH = 0.0;
133         else
134             dH /= 60.0;
135 
136         sal_uInt16 n = (sal_uInt16) dH;
137         double f = dH - n;
138 
139         double a = dV * ( 1.0 - dS );
140         double b = dV * ( 1.0 - ( dS * f ) );
141         double c = dV * ( 1.0 - ( dS * ( 1.0 - f ) ) );
142 
143         switch( n )
144         {
145             case 0: dR = dV; dG = c;  dB = a;  break;
146             case 1: dR = b;  dG = dV; dB = a;  break;
147             case 2: dR = a;  dG = dV; dB = c;  break;
148             case 3: dR = a;  dG = b;  dB = dV; break;
149             case 4: dR = c;  dG = a;  dB = dV; break;
150             case 5: dR = dV; dG = a;  dB = b;  break;
151         }
152     }
153 }
154 
155 // -----------------------------------------------------------------------
156 
157 // CMYK values from 0 to 1
CMYKtoRGB(double fCyan,double fMagenta,double fYellow,double fKey,double & dR,double & dG,double & dB)158 static void CMYKtoRGB( double fCyan, double fMagenta, double fYellow, double fKey, double& dR, double& dG, double& dB )
159 {
160     fCyan = (fCyan * ( 1.0 - fKey )) + fKey;
161     fMagenta = (fMagenta * ( 1.0 - fKey )) + fKey;
162     fYellow = (fYellow * ( 1.0 - fKey )) + fKey;
163 
164     dR = std::max( std::min( ( 1.0 - fCyan ), 1.0), 0.0 );
165     dG = std::max( std::min( ( 1.0 - fMagenta ), 1.0), 0.0 );
166     dB = std::max( std::min( ( 1.0 - fYellow ), 1.0), 0.0 );
167 }
168 
169 // -----------------------------------------------------------------------
170 
171 // CMY results from 0 to 1
RGBtoCMYK(double dR,double dG,double dB,double & fCyan,double & fMagenta,double & fYellow,double & fKey)172 static void RGBtoCMYK( double dR, double dG, double dB, double& fCyan, double& fMagenta, double& fYellow, double& fKey )
173 {
174     fCyan = 1 - dR;
175     fMagenta = 1 - dG;
176     fYellow = 1 - dB;
177 
178     //CMYK and CMY values from 0 to 1
179     fKey = 1.0;
180     if( fCyan < fKey ) fKey = fCyan;
181     if( fMagenta < fKey ) fKey = fMagenta;
182     if( fYellow < fKey ) fKey = fYellow;
183 
184     if( basegfx::fTools::equal( fKey, 1.0 ) )
185     {
186         //Black
187        fCyan = 0.0;
188        fMagenta = 0.0;
189        fYellow = 0.0;
190     }
191     else
192     {
193        fCyan = ( fCyan - fKey ) / ( 1.0 - fKey );
194        fMagenta = ( fMagenta - fKey ) / ( 1.0 - fKey );
195        fYellow = ( fYellow - fKey ) / ( 1.0 - fKey );
196     }
197 }
198 
199 // ====================================================================
200 
201 class HexColorControl : public Edit
202 {
203 public:
204     HexColorControl( Window* pParent, const ResId& rResId );
205 
206     virtual long PreNotify( NotifyEvent& rNEvt );
207     virtual void Paste();
208 
209     void SetColor( sal_Int32 nColor );
210     sal_Int32 GetColor();
211 
212 private:
213     bool ImplProcessKeyInput( const KeyEvent& rKEv );
214 };
215 
HexColorControl(Window * pParent,const ResId & rResId)216 HexColorControl::HexColorControl( Window* pParent, const ResId& rResId )
217 : Edit( pParent, rResId )
218 {
219     SetMaxTextLen( 6 );
220 }
221 
222 // -----------------------------------------------------------------------
223 
SetColor(sal_Int32 nColor)224 void HexColorControl::SetColor( sal_Int32 nColor )
225 {
226     ::rtl::OUStringBuffer aBuffer;
227     sax::Converter::convertColor( aBuffer, nColor );
228     SetText( aBuffer.makeStringAndClear().copy(1) );
229 }
230 
231 // -----------------------------------------------------------------------
232 
GetColor()233 sal_Int32 HexColorControl::GetColor()
234 {
235     sal_Int32 nColor = -1;
236 
237     OUString aStr( RTL_CONSTASCII_USTRINGPARAM( "#" ) );
238     aStr += GetText();
239     sal_Int32 nLen = aStr.getLength();
240     if( nLen < 7 )
241     {
242         static const sal_Char* pNullStr = "000000";
243         aStr += OUString::createFromAscii( &pNullStr[nLen-1] );
244     }
245 
246     sax::Converter::convertColor( nColor, aStr );
247 
248     if( nColor == -1 )
249         SetControlBackground( Color( COL_RED ) );
250     else
251         SetControlBackground();
252 
253     return nColor;
254 }
255 
256 // -----------------------------------------------------------------------
257 
PreNotify(NotifyEvent & rNEvt)258 long HexColorControl::PreNotify( NotifyEvent& rNEvt )
259 {
260     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
261     {
262         if ( ImplProcessKeyInput( *rNEvt.GetKeyEvent() ) )
263             return 1;
264     }
265 
266     return Edit::PreNotify( rNEvt );
267 }
268 
269 // -----------------------------------------------------------------------
270 
Paste()271 void HexColorControl::Paste()
272 {
273     ::com::sun::star::uno::Reference<com::sun::star::datatransfer::clipboard::XClipboard> aClipboard(GetClipboard());
274     if ( aClipboard.is() )
275     {
276         ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xDataObj;
277 
278         const sal_uInt32 nRef = Application::ReleaseSolarMutex();
279 
280         try
281         {
282             xDataObj = aClipboard->getContents();
283         }
284         catch( const ::com::sun::star::uno::Exception& )
285         {
286         }
287 
288         Application::AcquireSolarMutex( nRef );
289 
290         if ( xDataObj.is() )
291         {
292             ::com::sun::star::datatransfer::DataFlavor aFlavor;
293             SotExchange::GetFormatDataFlavor( SOT_FORMAT_STRING, aFlavor );
294             try
295             {
296                 ::com::sun::star::uno::Any aData = xDataObj->getTransferData( aFlavor );
297                 ::rtl::OUString aText;
298                 aData >>= aText;
299 
300                 if( aText.getLength() && aText.matchAsciiL( "#", 1, 0 ) )
301                     aText = aText.copy(1);
302 
303                 if( aText.getLength() > 6 )
304                     aText = aText.copy( 0, 6 );
305 
306                 SetText( aText );
307             }
308             catch( const ::com::sun::star::uno::Exception& )
309             {
310             }
311         }
312     }
313 }
314 
315 // -----------------------------------------------------------------------
316 
ImplProcessKeyInput(const KeyEvent & rKEv)317 bool HexColorControl::ImplProcessKeyInput( const KeyEvent& rKEv )
318 {
319     const KeyCode& rKeyCode = rKEv.GetKeyCode();
320 
321     if( rKeyCode.GetGroup() == KEYGROUP_ALPHA && !rKeyCode.IsMod1() && !rKeyCode.IsMod2() )
322     {
323         if( (rKeyCode.GetCode() < KEY_A) || (rKeyCode.GetCode() > KEY_F) )
324         {
325             Sound::Beep();
326             return true;
327         }
328     }
329     else if( rKeyCode.GetGroup() == KEYGROUP_NUM )
330     {
331         if( rKeyCode.IsShift() )
332         {
333             Sound::Beep();
334             return true;
335         }
336     }
337     return false;
338 }
339 
340 // ====================================================================
341 
342 class ColorPreviewControl : public Control
343 {
344 public:
345     ColorPreviewControl( Window* pParent, const ResId& rResId );
346 
347     virtual void        Paint( const Rectangle& rRect );
348 
349     void SetColor( const Color& rColor );
350 private:
351     Color maColor;
352 };
353 
354 // -----------------------------------------------------------------------
355 
ColorPreviewControl(Window * pParent,const ResId & rResId)356 ColorPreviewControl::ColorPreviewControl( Window* pParent, const ResId& rResId )
357 : Control( pParent, rResId )
358 {
359     SetFillColor( maColor );
360     SetLineColor( maColor );
361 }
362 
363 // -----------------------------------------------------------------------
364 
SetColor(const Color & rCol)365 void ColorPreviewControl::SetColor( const Color& rCol )
366 {
367     if( rCol != maColor )
368     {
369         maColor = rCol;
370         SetFillColor( maColor );
371         SetLineColor( maColor );
372         Invalidate();
373     }
374 }
375 
376 // -----------------------------------------------------------------------
377 
Paint(const Rectangle & rRect)378 void ColorPreviewControl::Paint( const Rectangle& rRect )
379 {
380     DrawRect( rRect );
381 }
382 
383 // ====================================================================
384 
385 enum ColorMode { HUE, SATURATION, BRIGHTNESS, RED, GREEN, BLUE };
386 const ColorMode DefaultMode = HUE;
387 
388 class ColorFieldControl : public Control
389 {
390 public:
391     ColorFieldControl( Window* pParent, const ResId& rResId );
392     ~ColorFieldControl();
393 
394     virtual void        MouseMove( const MouseEvent& rMEvt );
395     virtual void        MouseButtonDown( const MouseEvent& rMEvt );
396     virtual void        MouseButtonUp( const MouseEvent& rMEvt );
397     virtual void        KeyInput( const KeyEvent& rKEvt );
398     virtual void        Paint( const Rectangle& rRect );
399     virtual void        Resize();
400 
401     void                UpdateBitmap();
402     void                ShowPosition( const Point& rPos, bool bUpdate );
403     void                UpdatePosition();
404     void                Modify();
405 
406     void                SetValues( Color aColor, ColorMode eMode, double x, double y );
407     double              GetX();
408     double              GetY();
409 
410     void                KeyMove( int dx, int dy );
411 
SetModifyHdl(Link & rLink)412     void                SetModifyHdl( Link& rLink ) { maModifyHdl = rLink; }
413 
414 private:
415     Link maModifyHdl;
416     ColorMode meMode;
417     Color maColor;
418     double mdX;
419     double mdY;
420     Point maPosition;
421     Bitmap* mpBitmap;
422     std::vector< sal_uInt8 > maRGB_Horiz;
423     std::vector< sal_uInt16 > maGrad_Horiz;
424     std::vector< sal_uInt16 > maPercent_Horiz;
425     std::vector< sal_uInt8 > maRGB_Vert;
426     std::vector< sal_uInt16 > maPercent_Vert;
427     bool mbInit;
428 };
429 
430 // -----------------------------------------------------------------------
431 
ColorFieldControl(Window * pParent,const ResId & rResId)432 ColorFieldControl::ColorFieldControl( Window* pParent, const ResId& rResId )
433 : Control( pParent, rResId )
434 , meMode( DefaultMode )
435 , mdX( -1.0 )
436 , mdY( -1.0 )
437 , mpBitmap( 0 )
438 , mbInit( false )
439 {
440     SetControlBackground();
441 }
442 
443 // -----------------------------------------------------------------------
444 
~ColorFieldControl()445 ColorFieldControl::~ColorFieldControl()
446 {
447     delete mpBitmap;
448 }
449 
450 // -----------------------------------------------------------------------
451 
UpdateBitmap()452 void ColorFieldControl::UpdateBitmap()
453 {
454     const Size aSize( GetOutputSizePixel() );
455 
456     if( mpBitmap && mpBitmap->GetSizePixel() != aSize )
457         delete mpBitmap, mpBitmap = NULL;
458 
459     const sal_Int32 nWidth = aSize.Width();
460     const sal_Int32 nHeight = aSize.Height();
461 
462     if( !mpBitmap )
463     {
464         mpBitmap = new Bitmap( aSize, 24 );
465 
466         maRGB_Horiz.resize( nWidth );
467         maGrad_Horiz.resize( nWidth );
468         maPercent_Horiz.resize( nWidth );
469 
470         sal_uInt8* pRGB = &(*maRGB_Horiz.begin());
471         sal_uInt16* pGrad = &(*maGrad_Horiz.begin());
472         sal_uInt16* pPercent = &(*maPercent_Horiz.begin());
473 
474         for( sal_Int32 x = 0; x < nWidth; x++ )
475         {
476             *pRGB++ = static_cast< sal_uInt8 >( (x * 256) / nWidth );
477             *pGrad++ = static_cast< sal_uInt16 >( (x * 359) / nWidth );
478             *pPercent++ = static_cast< sal_uInt16 >( (x * 100) / nWidth );
479         }
480 
481         maRGB_Vert.resize( nHeight );
482         maPercent_Vert.resize( nHeight );
483 
484         pRGB = &(*maRGB_Vert.begin());
485         pPercent = &(*maPercent_Vert.begin());
486 
487         sal_Int32 y = nHeight;
488         while( y-- )
489         {
490             *pRGB++ = static_cast< sal_uInt8 >( (y * 256) / nHeight );
491             *pPercent++ = static_cast< sal_uInt16 >( (y * 100) / nHeight );
492         }
493     }
494 
495     sal_uInt8* pRGB_Horiz = &(*maRGB_Horiz.begin());
496     sal_uInt16* pGrad_Horiz = &(*maGrad_Horiz.begin());
497     sal_uInt16* pPercent_Horiz = &(*maPercent_Horiz.begin());
498     sal_uInt8* pRGB_Vert = &(*maRGB_Vert.begin());
499     sal_uInt16* pPercent_Vert = &(*maPercent_Vert.begin());
500 
501     BitmapWriteAccess* pWriteAccess = mpBitmap->AcquireWriteAccess();
502     if( pWriteAccess )
503     {
504         BitmapColor aBitmapColor( maColor );
505 
506         sal_uInt16 nHue, nSat, nBri;
507         maColor.RGBtoHSB( nHue, nSat, nBri );
508 
509         // this has been unlooped for performance reason, please do not merge back!
510 
511         sal_uInt16 y = nHeight,x;
512 
513         switch( meMode )
514         {
515         case HUE:
516             while( y-- )
517             {
518                 nBri = pPercent_Vert[y];
519                 x = nWidth;
520                 while( x-- )
521                 {
522                     nSat = pPercent_Horiz[x];
523                     pWriteAccess->SetPixel( y, x, BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) ) );
524                 }
525             }
526             break;
527         case SATURATION:
528             while( y-- )
529             {
530                 nBri = pPercent_Vert[y];
531                 x = nWidth;
532                 while( x-- )
533                 {
534                     nHue = pGrad_Horiz[x];
535                     pWriteAccess->SetPixel( y, x, BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) ) );
536                 }
537             }
538             break;
539         case BRIGHTNESS:
540             while( y-- )
541             {
542                 nSat = pPercent_Vert[y];
543                 x = nWidth;
544                 while( x-- )
545                 {
546                     nHue = pGrad_Horiz[x];
547                     pWriteAccess->SetPixel( y, x, BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) ) );
548                 }
549             }
550             break;
551         case RED:
552             while( y-- )
553             {
554                 aBitmapColor.SetGreen( pRGB_Vert[y] );
555                 x = nWidth;
556                 while( x-- )
557                 {
558                     aBitmapColor.SetBlue( pRGB_Horiz[x] );
559                     pWriteAccess->SetPixel( y, x, aBitmapColor );
560                 }
561             }
562             break;
563         case GREEN:
564             while( y-- )
565             {
566                 aBitmapColor.SetRed( pRGB_Vert[y] );
567                 x = nWidth;
568                 while( x-- )
569                 {
570                     aBitmapColor.SetBlue( pRGB_Horiz[x] );
571                     pWriteAccess->SetPixel( y, x, aBitmapColor );
572                 }
573             }
574             break;
575         case BLUE:
576             while( y-- )
577             {
578                 aBitmapColor.SetGreen( pRGB_Vert[y] );
579                 x = nWidth;
580                 while( x-- )
581                 {
582                     aBitmapColor.SetRed( pRGB_Horiz[x] );
583                     pWriteAccess->SetPixel( y, x, aBitmapColor );
584                 }
585             }
586             break;
587         }
588 
589         mpBitmap->ReleaseAccess( pWriteAccess );
590     }
591 }
592 
593 // -----------------------------------------------------------------------
594 
ShowPosition(const Point & rPos,bool bUpdate)595 void ColorFieldControl::ShowPosition( const Point& rPos, bool bUpdate )
596 {
597     if( !mpBitmap )
598     {
599         UpdateBitmap();
600         Invalidate();
601     }
602 
603     const Size aSize( mpBitmap->GetSizePixel() );
604 
605     long nX = rPos.X();
606     long nY = rPos.Y();
607     if( nX < 0L )
608         nX = 0L;
609     else if( nX >= aSize.Width() )
610         nX = aSize.Width() - 1L;
611 
612     if( nY < 0L )
613         nY= 0L;
614     else if( nY >= aSize.Height() )
615         nY = aSize.Height() - 1L;
616 
617     Point aPos = maPosition;
618     maPosition.X() = nX - 5;
619     maPosition.Y() = nY - 5;
620     Invalidate( Rectangle( aPos, Size( 11, 11) ) );
621     Invalidate( Rectangle( maPosition, Size( 11, 11) ) );
622 
623     if( bUpdate )
624     {
625         mdX = (double)nX / (double)(aSize.Width()-1);
626         mdY = (double)(aSize.Height()-1-nY) / (double)(aSize.Height()-1);
627 
628         BitmapReadAccess* pReadAccess = mpBitmap->AcquireReadAccess();
629         if( pReadAccess != NULL )
630         {
631             // mpBitmap always has a bit count of 24 => use of GetPixel(...) is safe
632             maColor = pReadAccess->GetPixel( nY, nX );
633             mpBitmap->ReleaseAccess( pReadAccess );
634             pReadAccess = NULL;
635         }
636     }
637 }
638 // -----------------------------------------------------------------------
639 
MouseMove(const MouseEvent & rMEvt)640 void ColorFieldControl::MouseMove( const MouseEvent& rMEvt )
641 {
642     if( rMEvt.IsLeft() )
643     {
644         ShowPosition( rMEvt.GetPosPixel(), true );
645         Modify();
646     }
647 }
648 
649 // -----------------------------------------------------------------------
MouseButtonDown(const MouseEvent & rMEvt)650 void ColorFieldControl::MouseButtonDown( const MouseEvent& rMEvt )
651 {
652     if( rMEvt.IsLeft() && !rMEvt.IsShift() )
653     {
654         CaptureMouse();
655         ShowPosition( rMEvt.GetPosPixel(), true );
656         Modify();
657     }
658 }
659 
660 // -----------------------------------------------------------------------
MouseButtonUp(const MouseEvent &)661 void ColorFieldControl::MouseButtonUp( const MouseEvent& )
662 {
663     if( IsMouseCaptured() )
664         ReleaseMouse();
665 }
666 
667 // -----------------------------------------------------------------------
668 
KeyMove(int dx,int dy)669 void ColorFieldControl::KeyMove( int dx, int dy )
670 {
671     Size aSize( GetOutputSizePixel() );
672     Point aPos( mdX * aSize.Width(), (1.0 - mdY) * aSize.Height() );
673     aPos.X() += dx;
674     aPos.Y() += dy;
675     if( aPos.X() < 0 )
676         aPos.X() += aSize.Width();
677     else if( aPos.X() >= aSize.Width() )
678         aPos.X() -= aSize.Width();
679 
680     if( aPos.Y() < 0 )
681         aPos.Y() += aSize.Height();
682     else if( aPos.Y() >= aSize.Height() )
683         aPos.Y() -= aSize.Height();
684 
685     ShowPosition( aPos, true );
686     Modify();
687 }
688 
689 // -----------------------------------------------------------------------
690 
KeyInput(const KeyEvent & rKEvt)691 void ColorFieldControl::KeyInput( const KeyEvent& rKEvt )
692 {
693     bool   bShift = rKEvt.GetKeyCode().IsShift();
694     bool   bCtrl = rKEvt.GetKeyCode().IsMod1();
695     bool   bAlt = rKEvt.GetKeyCode().IsMod2();
696 
697     if ( !bAlt && !bShift )
698     {
699         switch( rKEvt.GetKeyCode().GetCode() )
700         {
701         case KEY_DOWN:      KeyMove(  0, bCtrl ?  5  :  1 ); return;
702         case KEY_UP:        KeyMove(  0, bCtrl ? -5  : -1 ); return;
703         case KEY_LEFT:      KeyMove( bCtrl ? -5  : -1,  0 ); return;
704         case KEY_RIGHT:     KeyMove( bCtrl ?  5  :  1,  0 ); return;
705         }
706     }
707     Control::KeyInput( rKEvt );
708 }
709 
710 // -----------------------------------------------------------------------
711 
Paint(const Rectangle & rRect)712 void ColorFieldControl::Paint( const Rectangle& rRect )
713 {
714     if( !mpBitmap )
715         UpdateBitmap();
716 
717     Bitmap aOutputBitmap( *mpBitmap );
718 
719     if( GetBitCount() <= 8 )
720         aOutputBitmap.Dither();
721 
722     DrawBitmap( rRect.TopLeft(), rRect.GetSize(), rRect.TopLeft(), rRect.GetSize(), aOutputBitmap );
723 
724     // draw circle around current color
725     if( maColor.IsDark() )
726         SetLineColor( COL_WHITE );
727     else
728         SetLineColor( COL_BLACK );
729 
730     SetFillColor();
731 
732     DrawEllipse( Rectangle( maPosition, Size( 11, 11) ) );
733 }
734 
735 // -----------------------------------------------------------------------
736 
Resize()737 void ColorFieldControl::Resize()
738 {
739     UpdateBitmap();
740     Control::Resize();
741 }
742 
743 // -----------------------------------------------------------------------
744 
Modify()745 void ColorFieldControl::Modify()
746 {
747     maModifyHdl.Call( this );
748 }
749 
750 // -----------------------------------------------------------------------
751 
SetValues(Color aColor,ColorMode eMode,double x,double y)752 void ColorFieldControl::SetValues( Color aColor, ColorMode eMode, double x, double y )
753 {
754     bool bUpdateBitmap = (maColor!= aColor) || (meMode != eMode);
755     if( bUpdateBitmap || (mdX != x) || (mdY != y) )
756     {
757         maColor = aColor;
758         meMode = eMode;
759         mdX = x;
760         mdY = y;
761 
762         if( bUpdateBitmap )
763             UpdateBitmap();
764         UpdatePosition();
765         if( bUpdateBitmap )
766             Invalidate();
767     }
768 }
769 
770 // -----------------------------------------------------------------------
771 
GetX()772 double ColorFieldControl::GetX()
773 {
774     return mdX;
775 }
776 
777 // -----------------------------------------------------------------------
778 
GetY()779 double ColorFieldControl::GetY()
780 {
781     return mdY;
782 }
783 
784 // -----------------------------------------------------------------------
785 
UpdatePosition()786 void ColorFieldControl::UpdatePosition()
787 {
788     Size aSize( GetOutputSizePixel() );
789     ShowPosition( Point( mdX * aSize.Width(), (1.0 - mdY) * aSize.Height() ), false );
790 }
791 
792 // ====================================================================
793 
794 class ColorSliderControl : public Control
795 {
796 public:
797     ColorSliderControl( Window* pParent, const ResId& rResId );
798     ~ColorSliderControl();
799 
800     virtual void        MouseMove( const MouseEvent& rMEvt );
801     virtual void        MouseButtonDown( const MouseEvent& rMEvt );
802     virtual void        MouseButtonUp( const MouseEvent& rMEvt );
803     virtual void        KeyInput( const KeyEvent& rKEvt );
804     virtual void        Paint( const Rectangle& rRect );
805     virtual void        Resize();
806 
807     void                UpdateBitmap();
808     void                ChangePosition( long nY );
809     void                Modify();
810 
811     void SetValue( const Color& rColor, ColorMode eMode, double dValue );
GetValue() const812     double GetValue() const { return mdValue; }
813 
814     void                KeyMove( int dy );
815 
SetModifyHdl(Link & rLink)816     void SetModifyHdl( Link& rLink ) { maModifyHdl = rLink; }
817 
GetLevel() const818     sal_Int16 GetLevel() const { return mnLevel; }
819 
820 private:
821     Link maModifyHdl;
822     Color maColor;
823     ColorMode meMode;
824     Bitmap* mpBitmap;
825     sal_Int16 mnLevel;
826     double mdValue;
827 };
828 
829 // -----------------------------------------------------------------------
830 
ColorSliderControl(Window * pParent,const ResId & rResId)831 ColorSliderControl::ColorSliderControl( Window* pParent, const ResId& rResId )
832 : Control( pParent, rResId )
833 , meMode( DefaultMode )
834 , mpBitmap( 0 )
835 , mnLevel( 0 )
836 , mdValue( -1.0 )
837 {
838     SetControlBackground();
839 }
840 
841 // -----------------------------------------------------------------------
842 
~ColorSliderControl()843 ColorSliderControl::~ColorSliderControl()
844 {
845     delete mpBitmap;
846 }
847 
848 // -----------------------------------------------------------------------
849 
UpdateBitmap()850 void ColorSliderControl::UpdateBitmap()
851 {
852     Size aSize( 1, GetOutputSizePixel().Height() );
853 
854     if( mpBitmap && mpBitmap->GetSizePixel() != aSize )
855         delete mpBitmap, mpBitmap = NULL;
856 
857     if( !mpBitmap )
858         mpBitmap = new Bitmap( aSize, 24 );
859 
860     BitmapWriteAccess* pWriteAccess = mpBitmap->AcquireWriteAccess();
861 
862     if( pWriteAccess )
863     {
864         const long nY = aSize.Height()-1;
865 
866         BitmapColor aBitmapColor( maColor );
867 
868         sal_uInt16 nHue, nSat, nBri;
869         maColor.RGBtoHSB( nHue, nSat, nBri );
870 
871         // this has been unlooped for performance reason, please do not merge back!
872 
873         switch( meMode )
874         {
875         case HUE:
876             nSat = 100;
877             nBri = 100;
878             for( long y = 0; y <= nY; y++ )
879             {
880                 nHue = static_cast< sal_uInt16 >( (359 * y) / nY );
881                 aBitmapColor = BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) );
882                 pWriteAccess->SetPixel( nY-y, 0, aBitmapColor );
883             }
884             break;
885 
886         case SATURATION:
887             nBri = std::max( (sal_uInt16)32, nBri );
888             for( long y = 0; y <= nY; y++ )
889             {
890                 nSat = static_cast< sal_uInt16 >( (100 * y) / nY );
891                 pWriteAccess->SetPixel( nY-y, 0, BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) ) );
892             }
893             break;
894 
895         case BRIGHTNESS:
896             for( long y = 0; y <= nY; y++ )
897             {
898                 nBri = static_cast< sal_uInt16 >( (100 * y) / nY );
899                 pWriteAccess->SetPixel( nY-y, 0, BitmapColor( Color( Color::HSBtoRGB( nHue, nSat, nBri ) ) ) );
900             }
901             break;
902 
903         case RED:
904             for( long y = 0; y <= nY; y++ )
905             {
906                 aBitmapColor.SetRed( sal_uInt8( ((long)255 * y) / nY ) );
907                 pWriteAccess->SetPixel( nY-y, 0, aBitmapColor );
908             }
909             break;
910 
911         case GREEN:
912             for( long y = 0; y <= nY; y++ )
913             {
914                 aBitmapColor.SetGreen( sal_uInt8( ((long)255 * y) / nY ) );
915                 pWriteAccess->SetPixel( nY-y, 0, aBitmapColor );
916             }
917             break;
918 
919         case BLUE:
920             for( long y = 0; y <= nY; y++ )
921             {
922                 aBitmapColor.SetBlue( sal_uInt8( ((long)255 * y) / nY ) );
923                 pWriteAccess->SetPixel( nY-y, 0, aBitmapColor );
924             }
925             break;
926         }
927 
928         mpBitmap->ReleaseAccess( pWriteAccess );
929     }
930 }
931 
932 // -----------------------------------------------------------------------
933 
ChangePosition(long nY)934 void ColorSliderControl::ChangePosition( long nY )
935 {
936     const long nHeight = GetOutputSizePixel().Height() - 1;
937 
938     if( nY < 0L )
939         nY = 0;
940     else if( nY > nHeight )
941         nY = nHeight;
942 
943     mnLevel = nY;
944     mdValue = ((double)(nHeight - nY)) / (double)nHeight;
945 }
946 
947 // -----------------------------------------------------------------------
948 
MouseMove(const MouseEvent & rMEvt)949 void ColorSliderControl::MouseMove( const MouseEvent& rMEvt )
950 {
951     if( rMEvt.IsLeft() )
952     {
953         ChangePosition( rMEvt.GetPosPixel().Y() );
954         Modify();
955     }
956 }
957 
958 // -----------------------------------------------------------------------
MouseButtonDown(const MouseEvent & rMEvt)959 void ColorSliderControl::MouseButtonDown( const MouseEvent& rMEvt )
960 {
961     if( rMEvt.IsLeft() && !rMEvt.IsShift() )
962     {
963         CaptureMouse();
964         ChangePosition( rMEvt.GetPosPixel().Y() );
965         Modify();
966     }
967 }
968 
969 // -----------------------------------------------------------------------
MouseButtonUp(const MouseEvent &)970 void ColorSliderControl::MouseButtonUp( const MouseEvent& )
971 {
972     if( IsMouseCaptured() )
973         ReleaseMouse();
974 }
975 
976 // -----------------------------------------------------------------------
977 
KeyMove(int dy)978 void ColorSliderControl::KeyMove( int dy )
979 {
980     ChangePosition( mnLevel + dy );
981     Modify();
982 }
983 
984 // -----------------------------------------------------------------------
985 
KeyInput(const KeyEvent & rKEvt)986 void ColorSliderControl::KeyInput( const KeyEvent& rKEvt )
987 {
988     if ( !rKEvt.GetKeyCode().IsMod2() && !rKEvt.GetKeyCode().IsShift() )
989     {
990         switch( rKEvt.GetKeyCode().GetCode() )
991         {
992         case KEY_DOWN:      KeyMove(  rKEvt.GetKeyCode().IsMod1() ?  5 :  1 ); return;
993         case KEY_UP:        KeyMove(  rKEvt.GetKeyCode().IsMod1() ? -5 : -1 ); return;
994         }
995     }
996 
997     Control::KeyInput( rKEvt );
998 }
999 // -----------------------------------------------------------------------
1000 
Paint(const Rectangle &)1001 void ColorSliderControl::Paint( const Rectangle& /*rRect*/ )
1002 {
1003     if( !mpBitmap )
1004         UpdateBitmap();
1005 
1006     const Size aSize( GetOutputSizePixel() );
1007 
1008     Bitmap aOutputBitmap( *mpBitmap );
1009 
1010     if( GetBitCount() <= 8 )
1011         aOutputBitmap.Dither();
1012 
1013     Point aPos;
1014     int x = aSize.Width();
1015     while( x-- )
1016     {
1017         DrawBitmap( aPos, aOutputBitmap );
1018         aPos.X() += 1;
1019     }
1020 }
1021 
1022 // -----------------------------------------------------------------------
1023 
Resize()1024 void ColorSliderControl::Resize()
1025 {
1026     UpdateBitmap();
1027     Control::Resize();
1028 }
1029 
1030 // -----------------------------------------------------------------------
1031 
Modify()1032 void ColorSliderControl::Modify()
1033 {
1034     maModifyHdl.Call( this );
1035 }
1036 
1037 // -----------------------------------------------------------------------
1038 
SetValue(const Color & rColor,ColorMode eMode,double dValue)1039 void ColorSliderControl::SetValue( const Color& rColor, ColorMode eMode, double dValue )
1040 {
1041     bool bUpdateBitmap = (rColor != maColor) || (eMode != meMode);
1042     if( bUpdateBitmap || (mdValue != dValue))
1043     {
1044         maColor = rColor;
1045         mdValue = dValue;
1046         mnLevel = (1.0-dValue) * GetOutputSizePixel().Height();
1047         meMode = eMode;
1048         if( bUpdateBitmap )
1049             UpdateBitmap();
1050         Invalidate();
1051     }
1052 }
1053 
1054 // ====================================================================
1055 
1056 const sal_uInt16 UPDATE_RGB = 0x01;
1057 const sal_uInt16 UPDATE_CMYK = 0x02;
1058 const sal_uInt16 UPDATE_HSB = 0x04;
1059 const sal_uInt16 UPDATE_COLORCHOOSER = 0x08;
1060 const sal_uInt16 UPDATE_COLORSLIDER = 0x10;
1061 const sal_uInt16 UPDATE_HEX = 0x20;
1062 const sal_uInt16 UPDATE_ALL = 0xff;
1063 
1064 class ColorPickerDialog : public ModalDialog
1065 {
1066 public:
1067     ColorPickerDialog( Window* pParent, sal_Int32 nColor, sal_Int16 nMode );
1068 
1069     void update_color( sal_uInt16 n = UPDATE_ALL );
1070 
1071     DECL_LINK( ColorModifyHdl, void * );
1072     DECL_LINK( ModeModifyHdl, void * );
1073 
1074     sal_Int32 GetColor() const;
1075 
1076     void setColorComponent( sal_uInt16 nComp, double dValue );
1077 
1078 private:
1079     Color maPreviousColor;
1080     sal_Int16 mnDialogMode;
1081     ColorMode meMode;
1082 
1083     double mdRed, mdGreen, mdBlue;
1084     double mdHue, mdSat, mdBri;
1085     double mdCyan, mdMagenta, mdYellow, mdKey;
1086 
1087 private:
1088     ColorFieldControl  maColorField;
1089     ColorSliderControl maColorSlider;
1090     ColorPreviewControl maColorPreview;
1091     ColorPreviewControl maColorPrevious;
1092 
1093     FixedImage maFISliderLeft;
1094     FixedImage maFISliderRight;
1095     Image maSliderImage;
1096 
1097 #if 0
1098     ImageButton maBtnPicker;
1099 #endif
1100 
1101     FixedLine maFLRGB;
1102 
1103     RadioButton maRBRed;
1104     RadioButton maRBGreen;
1105     RadioButton maRBBlue;
1106     RadioButton maRBHue;
1107     RadioButton maRBSaturation;
1108     RadioButton maRBBrightness;
1109 
1110     FixedText maFTRed;
1111     MetricField maMFRed;
1112     FixedText maFTGreen;
1113     MetricField maMFGreen;
1114     FixedText maFTBlue;
1115     MetricField maMFBlue;
1116     FixedText maFTHex;
1117     HexColorControl maEDHex;
1118 
1119     FixedLine maFLHSB;
1120     FixedText maFTHue;
1121     MetricField maMFHue;
1122     FixedText maFTSaturation;
1123     MetricField maMFSaturation;
1124     FixedText maFTBrightness;
1125     MetricField maMFBrightness;
1126 
1127     FixedLine maFLCMYK;
1128     FixedText maFTCyan;
1129     MetricField maMFCyan;
1130     FixedText maFTMagenta;
1131     MetricField maMFMagenta;
1132     FixedText maFTYellow;
1133     MetricField maMFYellow;
1134     FixedText maFTKey;
1135     MetricField maMFKey;
1136 
1137     FixedLine maFLBottmLine;
1138     HelpButton maBTNHelp;
1139     OKButton maBTNOk;
1140     CancelButton maBTNCancel;
1141 };
1142 
1143 // --------------------------------------------------------------------
1144 
ColorPickerDialog(Window * pParent,sal_Int32 nColor,sal_Int16 nMode)1145 ColorPickerDialog::ColorPickerDialog( Window* pParent, sal_Int32 nColor, sal_Int16 nMode )
1146 : ModalDialog( pParent, CUI_RES( RID_CUI_DIALOG_COLORPICKER ) )
1147 , maPreviousColor( nColor )
1148 , mnDialogMode( nMode )
1149 , meMode( DefaultMode )
1150 , maColorField( this, CUI_RES( CT_COLORFIELD ) )
1151 , maColorSlider( this, CUI_RES( CT_COLORSLIDER ) )
1152 , maColorPreview( this, CUI_RES( CT_PREVIEW ) )
1153 , maColorPrevious( this, CUI_RES( CT_PREVIOUS ) )
1154 , maFISliderLeft(  this, CUI_RES( CT_LEFT_SLIDER ) )
1155 , maFISliderRight( this, CUI_RES( CT_RIGHT_SLIDER ) )
1156 , maSliderImage( CUI_RES( CT_SLIDERIMG ) )
1157 #if 0
1158 , maBtnPicker( this, CUI_RES( PB_PICKER ) )
1159 #endif
1160 , maFLRGB( this, CUI_RES( FL_RGB ) )
1161 , maRBRed( this, CUI_RES( CT_RED ) )
1162 , maRBGreen( this, CUI_RES( CT_GREEN ) )
1163 , maRBBlue( this, CUI_RES( CT_BLUE ) )
1164 , maRBHue( this, CUI_RES( CT_HUE ) )
1165 , maRBSaturation( this, CUI_RES( CT_SATURATION ) )
1166 , maRBBrightness( this, CUI_RES( CT_BRIGHTNESS ) )
1167 , maFTRed( this, CUI_RES( CT_RED ) )
1168 , maMFRed( this, CUI_RES( CT_RED ) )
1169 , maFTGreen( this, CUI_RES( CT_GREEN ) )
1170 , maMFGreen( this, CUI_RES( CT_GREEN ) )
1171 , maFTBlue( this, CUI_RES( CT_BLUE ) )
1172 , maMFBlue( this, CUI_RES( CT_BLUE ) )
1173 , maFTHex( this, CUI_RES( CT_HEX ) )
1174 , maEDHex( this, CUI_RES( CT_HEX ) )
1175 , maFLHSB( this, CUI_RES( FL_HSB ) )
1176 , maFTHue( this, CUI_RES( CT_HUE ) )
1177 , maMFHue( this, CUI_RES( CT_HUE ) )
1178 , maFTSaturation( this, CUI_RES( CT_SATURATION ) )
1179 , maMFSaturation( this, CUI_RES( CT_SATURATION ) )
1180 , maFTBrightness( this, CUI_RES( CT_BRIGHTNESS ) )
1181 , maMFBrightness( this, CUI_RES( CT_BRIGHTNESS ) )
1182 , maFLCMYK( this, CUI_RES( FL_CMYK ) )
1183 , maFTCyan( this, CUI_RES( CT_CYAN ) )
1184 , maMFCyan( this, CUI_RES( CT_CYAN ) )
1185 , maFTMagenta( this, CUI_RES( CT_MAGENTA ) )
1186 , maMFMagenta( this, CUI_RES( CT_MAGENTA ) )
1187 , maFTYellow( this, CUI_RES( CT_YELLOW ) )
1188 , maMFYellow( this, CUI_RES( CT_YELLOW ) )
1189 , maFTKey( this, CUI_RES( CT_KEY ) )
1190 , maMFKey( this, CUI_RES( CT_KEY ) )
1191 
1192 , maFLBottmLine( this, CUI_RES( FT_BOTTOMLINE ) )
1193 , maBTNHelp( this, CUI_RES( BTN_HELP ) )
1194 , maBTNOk( this, CUI_RES( BTN_OK ) )
1195 , maBTNCancel( this, CUI_RES( BTN_CANCEL ) )
1196 {
1197     FreeResource();
1198 
1199     String sUnitText( (sal_Unicode) 0xb0 );
1200 
1201     maMFHue.SetCustomUnitText( sUnitText );
1202 
1203     Link aLink( LINK( this, ColorPickerDialog, ColorModifyHdl ) );
1204     maColorField.SetModifyHdl( aLink );
1205     maColorSlider.SetModifyHdl( aLink );
1206 
1207     maMFRed.SetModifyHdl( aLink );
1208     maMFGreen.SetModifyHdl( aLink );
1209     maMFBlue.SetModifyHdl( aLink );
1210 
1211     maMFCyan.SetModifyHdl( aLink );
1212     maMFMagenta.SetModifyHdl( aLink );
1213     maMFYellow.SetModifyHdl( aLink );
1214     maMFKey.SetModifyHdl( aLink );
1215 
1216     maMFHue.SetModifyHdl( aLink );
1217     maMFSaturation.SetModifyHdl( aLink );
1218     maMFBrightness.SetModifyHdl( aLink );
1219 
1220     maEDHex.SetModifyHdl( aLink );
1221 
1222     aLink = LINK( this, ColorPickerDialog, ModeModifyHdl );
1223     maRBRed.SetToggleHdl( aLink );
1224     maRBGreen.SetToggleHdl( aLink );
1225     maRBBlue.SetToggleHdl( aLink );
1226     maRBHue.SetToggleHdl( aLink );
1227     maRBSaturation.SetToggleHdl( aLink );
1228     maRBBrightness.SetToggleHdl( aLink );
1229 
1230     Image aSliderImage( maSliderImage );
1231 
1232     maFISliderLeft.SetImage( aSliderImage );
1233 
1234     BitmapEx aTmpBmp( maSliderImage.GetBitmapEx() );
1235     aTmpBmp.Mirror( BMP_MIRROR_HORZ );
1236     maFISliderRight.SetImage( Image( aTmpBmp  ) );
1237 
1238     Size aSize( maSliderImage.GetSizePixel() );
1239     maFISliderLeft.SetSizePixel( aSize );
1240     maFISliderRight.SetSizePixel( aSize );
1241 
1242     Point aPos( maColorSlider.GetPosPixel() );
1243 
1244     aPos.X() -= aSize.Width();
1245     aPos.Y() -= aSize.Height() / 2;
1246     maFISliderLeft.SetPosPixel( aPos );
1247 
1248     aPos.X() += aSize.Width() + maColorSlider.GetSizePixel().Width();
1249     maFISliderRight.SetPosPixel( aPos );
1250 
1251     Color aColor( nColor );
1252 
1253     // modify
1254     if( mnDialogMode == 2 )
1255     {
1256         maColorPreview.SetSizePixel( maColorPrevious.GetSizePixel() );
1257         maColorPrevious.SetColor( aColor );
1258         maColorPrevious.Show( true );
1259     }
1260 
1261     mdRed = ((double)aColor.GetRed()) / 255.0;
1262     mdGreen = ((double)aColor.GetGreen()) / 255.0;
1263     mdBlue = ((double)aColor.GetBlue()) / 255.0;
1264 
1265     RGBtoHSV( mdRed, mdGreen, mdBlue, mdHue, mdSat, mdBri );
1266     RGBtoCMYK( mdRed, mdGreen, mdBlue, mdCyan, mdMagenta, mdYellow, mdKey );
1267 
1268     update_color();
1269 }
1270 
1271 // --------------------------------------------------------------------
1272 
toInt(double dValue,double bRange)1273 static int toInt( double dValue, double bRange )
1274 {
1275     return static_cast< int >( std::floor((dValue * bRange) + 0.5 ) );
1276 }
1277 
GetColor() const1278 sal_Int32 ColorPickerDialog::GetColor() const
1279 {
1280     return Color( toInt(mdRed,255.0), toInt(mdGreen,255.0), toInt(mdBlue,255.0) ).GetColor();
1281 }
1282 
update_color(sal_uInt16 n)1283 void ColorPickerDialog::update_color( sal_uInt16 n )
1284 {
1285     sal_uInt8 nRed = toInt(mdRed,255.0);
1286     sal_uInt8 nGreen = toInt(mdGreen,255.0);
1287     sal_uInt8 nBlue = toInt(mdBlue,255.0);
1288 
1289     Color aColor( nRed, nGreen, nBlue );
1290 
1291     if( n & UPDATE_RGB ) // update RGB
1292     {
1293         maMFRed.SetValue( nRed );
1294         maMFGreen.SetValue( nGreen );
1295         maMFBlue.SetValue( nBlue );
1296     }
1297 
1298     if( n & UPDATE_CMYK ) // update CMYK
1299     {
1300         maMFCyan.SetValue( toInt( mdCyan, 100.0 ) );
1301         maMFMagenta.SetValue( toInt( mdMagenta, 100.0 ) );
1302         maMFYellow.SetValue( toInt( mdYellow, 100.0 ) );
1303         maMFKey.SetValue( toInt( mdKey, 100.0 ) );
1304     }
1305 
1306     if( n & UPDATE_HSB ) // update HSB
1307     {
1308         maMFHue.SetValue( toInt( mdHue, 1.0 ) );
1309         maMFSaturation.SetValue( toInt( mdSat, 100.0 ) );
1310         maMFBrightness.SetValue( toInt( mdBri, 100.0 ) );
1311     }
1312 
1313     if( n & UPDATE_COLORCHOOSER ) // update Color Chooser 1
1314     {
1315         switch( meMode )
1316         {
1317         case HUE:           maColorField.SetValues( aColor, meMode, mdSat, mdBri ); break;
1318         case SATURATION:    maColorField.SetValues( aColor, meMode, mdHue / 360.0, mdBri ); break;
1319         case BRIGHTNESS:    maColorField.SetValues( aColor, meMode, mdHue / 360.0, mdSat ); break;
1320         case RED:           maColorField.SetValues( aColor, meMode, mdBlue, mdGreen ); break;
1321         case GREEN:         maColorField.SetValues( aColor, meMode, mdBlue, mdRed ); break;
1322         case BLUE:          maColorField.SetValues( aColor, meMode, mdRed, mdGreen ); break;
1323         }
1324     }
1325 
1326     if( n & UPDATE_COLORSLIDER ) // update Color Chooser 2
1327     {
1328         switch( meMode )
1329         {
1330         case HUE:           maColorSlider.SetValue( aColor, meMode, mdHue / 360.0 ); break;
1331         case SATURATION:    maColorSlider.SetValue( aColor, meMode, mdSat ); break;
1332         case BRIGHTNESS:    maColorSlider.SetValue( aColor, meMode, mdBri ); break;
1333         case RED:           maColorSlider.SetValue( aColor, meMode, mdRed ); break;
1334         case GREEN:         maColorSlider.SetValue( aColor, meMode, mdGreen ); break;
1335         case BLUE:          maColorSlider.SetValue( aColor, meMode, mdBlue ); break;
1336         }
1337     }
1338 
1339     if( n & UPDATE_HEX ) // update hex
1340     {
1341         maEDHex.SetColor( aColor.GetColor()  );
1342     }
1343 
1344     {
1345         Point aPos( 0, maColorSlider.GetLevel() + maColorSlider.GetPosPixel().Y() - 1 );
1346 
1347         aPos.X() = maFISliderLeft.GetPosPixel().X();
1348         if( aPos != maFISliderLeft.GetPosPixel() )
1349         {
1350             maFISliderLeft.SetPosPixel( aPos );
1351 
1352             aPos.X() = maFISliderRight.GetPosPixel().X();
1353             maFISliderRight.SetPosPixel( aPos );
1354         }
1355     }
1356 
1357     maColorPreview.SetColor( aColor );
1358 }
1359 
1360 // --------------------------------------------------------------------
1361 
IMPL_LINK(ColorPickerDialog,ColorModifyHdl,void *,p)1362 IMPL_LINK( ColorPickerDialog, ColorModifyHdl, void *, p )
1363 {
1364     sal_uInt16 n = 0;
1365 
1366     if( p == &maColorField )
1367     {
1368         double x = maColorField.GetX();
1369         double y = maColorField.GetY();
1370 
1371         switch( meMode )
1372         {
1373         case HUE:           mdSat = x; setColorComponent( COLORCOMP_BRI, y ); break;
1374         case SATURATION:    mdHue = x * 360.0; setColorComponent( COLORCOMP_BRI, y ); break;
1375         case BRIGHTNESS:    mdHue = x * 360.0; setColorComponent( COLORCOMP_SAT, y ); break;
1376         case RED:           mdBlue = x; setColorComponent( COLORCOMP_GREEN, y ); break;
1377         case GREEN:         mdBlue = x; setColorComponent( COLORCOMP_RED, y ); break;
1378         case BLUE:          mdRed = x; setColorComponent( COLORCOMP_GREEN, y ); break;
1379         }
1380 
1381         n = UPDATE_ALL&~(UPDATE_COLORCHOOSER);
1382     }
1383     else if( p == &maColorSlider )
1384     {
1385         double dValue = maColorSlider.GetValue();
1386         switch( meMode )
1387         {
1388         case HUE:           setColorComponent( COLORCOMP_HUE, dValue * 360.0 ); break;
1389         case SATURATION:    setColorComponent( COLORCOMP_SAT, dValue ); break;
1390         case BRIGHTNESS:    setColorComponent( COLORCOMP_BRI, dValue ); break;
1391         case RED:           setColorComponent( COLORCOMP_RED, dValue ); break;
1392         case GREEN:         setColorComponent( COLORCOMP_GREEN, dValue ); break;
1393         case BLUE:          setColorComponent( COLORCOMP_BLUE, dValue ); break;
1394         }
1395 
1396         n = UPDATE_ALL&~(UPDATE_COLORSLIDER);
1397     }
1398     else if( p == &maMFRed )
1399     {
1400         setColorComponent( COLORCOMP_RED, ((double)maMFRed.GetValue()) / 255.0 );
1401         n = UPDATE_ALL&~(UPDATE_RGB);
1402     }
1403     else if( p == &maMFGreen )
1404     {
1405         setColorComponent( COLORCOMP_GREEN, ((double)maMFGreen.GetValue()) / 255.0 );
1406         n = UPDATE_ALL&~(UPDATE_RGB);
1407     }
1408     else if( p == &maMFBlue )
1409     {
1410         setColorComponent( COLORCOMP_BLUE, ((double)maMFBlue.GetValue()) / 255.0 );
1411         n = UPDATE_ALL&~(UPDATE_RGB);
1412     }
1413     else if( p == &maMFHue )
1414     {
1415         setColorComponent( COLORCOMP_HUE, (double)maMFHue.GetValue() );
1416         n = UPDATE_ALL&~(UPDATE_HSB);
1417     }
1418     else if( p == &maMFSaturation )
1419     {
1420         setColorComponent( COLORCOMP_SAT, ((double)maMFSaturation.GetValue()) / 100.0 );
1421         n = UPDATE_ALL&~(UPDATE_HSB);
1422     }
1423     else if( p == &maMFBrightness )
1424     {
1425         setColorComponent( COLORCOMP_BRI, ((double)maMFBrightness.GetValue()) / 100.0 );
1426         n = UPDATE_ALL&~(UPDATE_HSB);
1427     }
1428     else if( p == &maMFCyan )
1429     {
1430         setColorComponent( COLORCOMP_CYAN, ((double)maMFCyan.GetValue()) / 100.0 );
1431         n = UPDATE_ALL&~(UPDATE_CMYK);
1432     }
1433     else if( p == &maMFMagenta )
1434     {
1435         setColorComponent( COLORCOMP_MAGENTA, ((double)maMFMagenta.GetValue()) / 100.0 );
1436         n = UPDATE_ALL&~(UPDATE_CMYK);
1437     }
1438     else if( p == &maMFYellow )
1439     {
1440         setColorComponent( COLORCOMP_YELLOW, ((double)maMFYellow.GetValue()) / 100.0 );
1441         n = UPDATE_ALL&~(UPDATE_CMYK);
1442     }
1443     else if( p == &maMFKey )
1444     {
1445         setColorComponent( COLORCOMP_KEY, ((double)maMFKey.GetValue()) / 100.0 );
1446         n = UPDATE_ALL&~(UPDATE_CMYK);
1447     }
1448     else if( p == &maEDHex )
1449     {
1450         sal_Int32 nColor = maEDHex.GetColor();
1451 
1452         if( nColor != -1 )
1453         {
1454             Color aColor( nColor );
1455 
1456             if( aColor != GetColor() )
1457             {
1458                 // #121251# green and blue were wrongly taken
1459                 mdRed = ((double)aColor.GetRed()) / 255.0;
1460                 mdGreen = ((double)aColor.GetGreen()) / 255.0;
1461                 mdBlue = ((double)aColor.GetBlue()) / 255.0;
1462 
1463                 RGBtoHSV( mdRed, mdGreen, mdBlue, mdHue, mdSat, mdBri );
1464                 RGBtoCMYK( mdRed, mdGreen, mdBlue, mdCyan, mdMagenta, mdYellow, mdKey );
1465                 n = UPDATE_ALL&~(UPDATE_HEX);
1466             }
1467         }
1468     }
1469 
1470     if( n )
1471         update_color( n );
1472 
1473     return 0;
1474 }
1475 
1476 // --------------------------------------------------------------------
1477 
IMPL_LINK(ColorPickerDialog,ModeModifyHdl,void *,EMPTYARG)1478 IMPL_LINK( ColorPickerDialog, ModeModifyHdl, void *, EMPTYARG )
1479 {
1480     ColorMode eMode = HUE;
1481 
1482     if( maRBRed.IsChecked() )
1483     {
1484         eMode = RED;
1485     }
1486     else if( maRBGreen.IsChecked() )
1487     {
1488         eMode = GREEN;
1489     }
1490     else if( maRBBlue.IsChecked() )
1491     {
1492         eMode = BLUE;
1493     }
1494     else if( maRBSaturation.IsChecked() )
1495     {
1496         eMode = SATURATION;
1497     }
1498     else if( maRBBrightness.IsChecked() )
1499     {
1500         eMode = BRIGHTNESS;
1501     }
1502 
1503     if( meMode != eMode )
1504     {
1505         meMode = eMode;
1506         update_color( UPDATE_COLORCHOOSER | UPDATE_COLORSLIDER );
1507     }
1508 
1509     return 0;
1510 }
1511 
1512 // --------------------------------------------------------------------
1513 
setColorComponent(sal_uInt16 nComp,double dValue)1514 void ColorPickerDialog::setColorComponent( sal_uInt16 nComp, double dValue )
1515 {
1516     switch( nComp )
1517     {
1518     case COLORCOMP_RED:     mdRed = dValue; break;
1519     case COLORCOMP_GREEN:   mdGreen = dValue; break;
1520     case COLORCOMP_BLUE:    mdBlue = dValue; break;
1521     case COLORCOMP_HUE:     mdHue = dValue; break;
1522     case COLORCOMP_SAT:     mdSat = dValue; break;
1523     case COLORCOMP_BRI:     mdBri = dValue; break;
1524     case COLORCOMP_CYAN:    mdCyan = dValue; break;
1525     case COLORCOMP_YELLOW:  mdYellow = dValue; break;
1526     case COLORCOMP_MAGENTA: mdMagenta = dValue; break;
1527     case COLORCOMP_KEY:     mdKey = dValue; break;
1528     }
1529 
1530     if( nComp & COLORMODE_RGB )
1531     {
1532         RGBtoHSV( mdRed, mdGreen, mdBlue, mdHue, mdSat, mdBri );
1533         RGBtoCMYK( mdRed, mdGreen, mdBlue, mdCyan, mdMagenta, mdYellow, mdKey );
1534     }
1535     else if( nComp & COLORMODE_HSV )
1536     {
1537         HSVtoRGB( mdHue, mdSat, mdBri, mdRed, mdGreen, mdBlue );
1538         RGBtoCMYK( mdRed, mdGreen, mdBlue, mdCyan, mdMagenta, mdYellow, mdKey );
1539     }
1540     else
1541     {
1542         CMYKtoRGB( mdCyan, mdMagenta, mdYellow, mdKey, mdRed, mdGreen, mdBlue );
1543         RGBtoHSV( mdRed, mdGreen, mdBlue, mdHue, mdSat, mdBri );
1544     }
1545 }
1546 
1547 // --------------------------------------------------------------------
1548 
1549 typedef ::cppu::WeakComponentImplHelper4< XServiceInfo, XExecutableDialog, XInitialization, XPropertyAccess > ColorPickerBase;
1550 
1551 class ColorPicker : protected ::comphelper::OBaseMutex,    // Struct for right initalization of mutex member! Must be first of baseclasses.
1552                     public ColorPickerBase
1553 {
1554 public:
1555     ColorPicker( Reference< XComponentContext > const & xContext );
1556 
1557     // XInitialization
1558     virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) throw (Exception, RuntimeException);
1559 
1560     // XInitialization
1561     virtual OUString SAL_CALL getImplementationName(  ) throw (RuntimeException);
1562     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (RuntimeException);
1563     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw (RuntimeException);
1564 
1565     // XPropertyAccess
1566     virtual Sequence< PropertyValue > SAL_CALL getPropertyValues(  ) throw (RuntimeException);
1567     virtual void SAL_CALL setPropertyValues( const Sequence< PropertyValue >& aProps ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException);
1568 
1569     // XExecutableDialog
1570     virtual void SAL_CALL setTitle( const OUString& aTitle ) throw (RuntimeException);
1571     virtual sal_Int16 SAL_CALL execute(  ) throw (RuntimeException);
1572 
1573 private:
1574     Reference< XComponentContext > mxContext;
1575     OUString msTitle;
1576     const OUString msColorKey;
1577     const OUString msModeKey;
1578     sal_Int32 mnColor;
1579     sal_Int16 mnMode;
1580     Reference< ::com::sun::star::awt::XWindow > mxParent;
1581 };
1582 
1583 // --------------------------------------------------------------------
1584 
ColorPicker_getImplementationName()1585 OUString SAL_CALL ColorPicker_getImplementationName()
1586 {
1587     return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.cui.ColorPicker" ) );
1588 }
1589 
1590 // --------------------------------------------------------------------
1591 
ColorPicker_createInstance(Reference<XComponentContext> const & xContext)1592 Reference< XInterface > SAL_CALL ColorPicker_createInstance( Reference< XComponentContext > const & xContext ) SAL_THROW( (Exception) )
1593 {
1594     return static_cast<XWeak*>( new ColorPicker( xContext ) );
1595 }
1596 
1597 // --------------------------------------------------------------------
1598 
ColorPicker_getSupportedServiceNames()1599 Sequence< OUString > SAL_CALL ColorPicker_getSupportedServiceNames() throw( RuntimeException )
1600 {
1601     Sequence< OUString > seq(1);
1602     seq[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.dialogs.ColorPicker" ) );
1603     return seq;
1604 }
1605 
1606 // --------------------------------------------------------------------
1607 
ColorPicker(Reference<XComponentContext> const & xContext)1608 ColorPicker::ColorPicker( Reference< XComponentContext > const & xContext )
1609 : ColorPickerBase( m_aMutex )
1610 , mxContext( xContext )
1611 , msColorKey( RTL_CONSTASCII_USTRINGPARAM( "Color" ) )
1612 , msModeKey( RTL_CONSTASCII_USTRINGPARAM( "Mode" ) )
1613 , mnColor( 0 )
1614 , mnMode( 0 )
1615 {
1616 }
1617 
1618 // --------------------------------------------------------------------
1619 
1620 // XInitialization
initialize(const Sequence<Any> & aArguments)1621 void SAL_CALL ColorPicker::initialize( const Sequence< Any >& aArguments ) throw (Exception, RuntimeException)
1622 {
1623     if( aArguments.getLength() == 1 )
1624     {
1625         aArguments[0] >>= mxParent;
1626     }
1627 }
1628 
1629 // --------------------------------------------------------------------
1630 
1631 // XInitialization
getImplementationName()1632 OUString SAL_CALL ColorPicker::getImplementationName(  ) throw (RuntimeException)
1633 {
1634     return ColorPicker_getImplementationName();
1635 }
1636 
1637 // --------------------------------------------------------------------
1638 
supportsService(const OUString & sServiceName)1639 sal_Bool SAL_CALL ColorPicker::supportsService( const OUString& sServiceName ) throw (RuntimeException)
1640 {
1641     return sServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.ui.dialogs.ColorPicker" ) );
1642 }
1643 
1644 // --------------------------------------------------------------------
1645 
getSupportedServiceNames()1646 Sequence< OUString > SAL_CALL ColorPicker::getSupportedServiceNames(  ) throw (RuntimeException)
1647 {
1648     return ColorPicker_getSupportedServiceNames();
1649 }
1650 
1651 // --------------------------------------------------------------------
1652 
1653 // XPropertyAccess
getPropertyValues()1654 Sequence< PropertyValue > SAL_CALL ColorPicker::getPropertyValues(  ) throw (RuntimeException)
1655 {
1656     Sequence< PropertyValue > props(1);
1657     props[0].Name = msColorKey;
1658     props[0].Value <<= mnColor;
1659     return props;
1660 }
1661 
1662 // --------------------------------------------------------------------
1663 
setPropertyValues(const Sequence<PropertyValue> & aProps)1664 void SAL_CALL ColorPicker::setPropertyValues( const Sequence< PropertyValue >& aProps ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1665 {
1666     for( sal_Int32 n = 0; n < aProps.getLength(); n++ )
1667     {
1668         if( aProps[n].Name.equals( msColorKey ) )
1669         {
1670             aProps[n].Value >>= mnColor;
1671         }
1672         else if( aProps[n].Name.equals( msModeKey ) )
1673         {
1674             aProps[n].Value >>= mnMode;
1675         }
1676     }
1677 }
1678 
1679 // --------------------------------------------------------------------
1680 
1681 // XExecutableDialog
setTitle(const OUString & sTitle)1682 void SAL_CALL ColorPicker::setTitle( const OUString& sTitle ) throw (RuntimeException)
1683 {
1684     msTitle = sTitle;
1685 }
1686 
1687 // --------------------------------------------------------------------
1688 
execute()1689 sal_Int16 SAL_CALL ColorPicker::execute(  ) throw (RuntimeException)
1690 {
1691     ColorPickerDialog aDlg( VCLUnoHelper::GetWindow( mxParent ), mnColor, mnMode );
1692     sal_Int16 ret = aDlg.Execute();
1693     if( ret )
1694         mnColor = aDlg.GetColor();
1695 
1696     return ret;
1697 }
1698 
1699 // --------------------------------------------------------------------
1700 
1701 }
1702 
1703 // eof
1704