4 * by ]d : Original idea and basic initial code
5 * Pascal Hofstee : Code for wheeldrawing and calculating
7 * Primary coder of this Color Panel.
8 * Alban Hertroys : Optimizations for algorithms for color-
9 * wheel. Also custom ColorPalettes and
10 * magnifying glass. Secondary coder ;)
11 * Alfredo K. Kojima : For pointing out memory-allocation
12 * problems and similair code-issues
13 * Marco van Hylckama-Vlieg : For once again doing the artwork ;-)
19 * - Look at further optimization of colorWheel matrix calculation.
20 * It appears to be rather symmetric in angles of 60 degrees,
21 * while it is optimized in angles of 90 degrees.
22 * - Custom color-lists and custom colors in custom color-lists.
27 #include "../src/config.h"
33 #include <sys/types.h>
38 /* BUG There's something fishy with shaped windows */
41 #define SHAPE_WAS_DEFINED
48 #include <X11/extensions/shape.h>
53 # define PATH_MAX 1024
57 char *WMColorPanelColorChangedNotification
= "WMColorPanelColorChangedNotification";
62 #define NO_MEMORY_ERR "Color Panel: Could not allocate memory"
63 #define NO_FILE_ERR "Color Panel: Could not find file"
64 #define X_ERR "Color Panel: X failed request"
68 * Bitmaps for magnifying glass cursor
72 #define Cursor_x_hot 11
73 #define Cursor_y_hot 11
74 #define Cursor_width 32
75 #define Cursor_height 32
76 static unsigned char Cursor_bits
[] = {
77 0x00,0x7e,0x00,0x00,0xc0,0x81,0x03,0x00,0x20,0x00,0x04,0x00,0x10,0x00,0x08,
78 0x00,0x08,0x00,0x10,0x00,0x04,0x00,0x20,0x00,0x02,0x00,0x40,0x00,0x02,0x00,
79 0x40,0x00,0x02,0x00,0x40,0x00,0x01,0x42,0x80,0x00,0x01,0x24,0x80,0x00,0x01,
80 0x00,0x80,0x00,0x01,0x00,0x80,0x00,0x01,0x24,0x80,0x00,0x01,0x42,0x80,0x00,
81 0x02,0x00,0x40,0x00,0x02,0x00,0x40,0x00,0x02,0x00,0x40,0x00,0x04,0x00,0x20,
82 0x00,0x08,0x00,0x50,0x00,0x10,0x00,0x88,0x00,0x20,0x00,0x5c,0x01,0xc0,0x81,
83 0x3b,0x02,0x00,0x7e,0x70,0x05,0x00,0x00,0xe0,0x08,0x00,0x00,0xc0,0x15,0x00,
84 0x00,0x80,0x23,0x00,0x00,0x00,0x57,0x00,0x00,0x00,0x8e,0x00,0x00,0x00,0x5c,
85 0x00,0x00,0x00,0xb8,0x00,0x00,0x00,0x70};
87 /* Cursor shape-mask */
88 #define Cursor_shape_width 32
89 #define Cursor_shape_height 32
90 static unsigned char Cursor_shape_bits
[] = {
91 0x00,0x7e,0x00,0x00,0xc0,0x81,0x03,0x00,0x20,0x00,0x04,0x00,0x10,0x00,0x08,
92 0x00,0x08,0x00,0x10,0x00,0x04,0x00,0x20,0x00,0x02,0x00,0x40,0x00,0x02,0x00,
93 0x40,0x00,0x02,0x00,0x40,0x00,0x01,0x42,0x80,0x00,0x01,0x24,0x80,0x00,0x01,
94 0x00,0x80,0x00,0x01,0x00,0x80,0x00,0x01,0x24,0x80,0x00,0x01,0x42,0x80,0x00,
95 0x02,0x00,0x40,0x00,0x02,0x00,0x40,0x00,0x02,0x00,0x40,0x00,0x04,0x00,0x20,
96 0x00,0x08,0x00,0x70,0x00,0x10,0x00,0xf8,0x00,0x20,0x00,0xfc,0x01,0xc0,0x81,
97 0xfb,0x03,0x00,0x7e,0xf0,0x07,0x00,0x00,0xe0,0x0f,0x00,0x00,0xc0,0x1f,0x00,
98 0x00,0x80,0x3f,0x00,0x00,0x00,0x7f,0x00,0x00,0x00,0xfe,0x00,0x00,0x00,0xfc,
99 0x00,0x00,0x00,0xf8,0x00,0x00,0x00,0x70};
101 /* Clip-mask for magnified pixels */
102 #define Cursor_mask_width 24
103 #define Cursor_mask_height 24
104 static unsigned char Cursor_mask_bits
[] = {
105 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0xc0, 0xff, 0x03, 0xe0, 0xff, 0x07,
106 0xf0, 0xff, 0x0f, 0xf8, 0xff, 0x1f, 0xfc, 0xff, 0x3f, 0xfc, 0xff, 0x3f,
107 0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xfe, 0xff, 0x7f, 0xfe, 0xff, 0x7f,
108 0xfe, 0xff, 0x7f, 0xfe, 0xff, 0x7f, 0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f,
109 0xfc, 0xff, 0x3f, 0xfc, 0xff, 0x3f, 0xf8, 0xff, 0x1f, 0xf0, 0xff, 0x0f,
110 0xe0, 0xff, 0x07, 0xc0, 0xff, 0x03, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00};
113 typedef struct MovingView
{
114 WMView
*view
; /* The view this is all about */
115 XImage
*image
; /* What's under the view */
116 XImage
*dirtyRect
; /* Storage of overlapped image area */
117 Pixmap magPix
; /* Magnified part of pixmap */
118 RColor color
; /* Color of a pixel in the image */
119 int x
, y
; /* Position of view */
122 typedef struct CPColor
{
123 RColor rgb
; /* The RGB values of the color */
124 RHSVColor hsv
; /* The HSV values of the color */
125 enum { /* Which one was last set ? */
133 typedef struct WheelMatrix
{
134 unsigned int width
, height
; /* Size of the colorwheel */
135 unsigned char *data
[3]; /* Wheel data (R,G,B) */
136 unsigned char values
[256]; /* Precalculated values R,G & B = 0-255 */
139 typedef struct W_ColorPanel
{
147 WMColorWell
*colorWell
;
148 WMButton
*magnifyBtn
;
150 WMButton
*slidersBtn
;
151 WMButton
*customPaletteBtn
;
152 WMButton
*colorListBtn
;
154 /* Magnifying Glass */
155 MovingView
*magnifyGlass
;
157 /* ColorWheel Panel */
159 WMSlider
*wheelBrightnessS
;
164 WMFrame
*seperatorFrm
;
169 /* Gray Scale Panel */
173 WMSlider
*grayBrightnessS
;
174 WMTextField
*grayBrightnessT
;
175 WMButton
*grayPresetBtn
[7];
184 WMTextField
*rgbRedT
;
185 WMTextField
*rgbGreenT
;
186 WMTextField
*rgbBlueT
;
193 WMSlider
*cmykMagentaS
;
194 WMSlider
*cmykYellowS
;
195 WMSlider
*cmykBlackS
;
196 WMTextField
*cmykCyanT
;
197 WMTextField
*cmykMagentaT
;
198 WMTextField
*cmykYellowT
;
199 WMTextField
*cmykBlackT
;
204 WMSlider
*hsbSaturationS
;
205 WMSlider
*hsbBrightnessS
;
206 WMTextField
*hsbHueT
;
207 WMTextField
*hsbSaturationT
;
208 WMTextField
*hsbBrightnessT
;
210 /* Custom Palette Panel*/
211 WMFrame
*customPaletteFrm
;
212 WMPopUpButton
*customPaletteHistoryBtn
;
213 WMFrame
*customPaletteContentFrm
;
214 WMPopUpButton
*customPaletteMenuBtn
;
215 WMView
*customPaletteContentView
;
217 /* Color List Panel */
218 WMFrame
*colorListFrm
;
219 WMPopUpButton
*colorListHistoryBtn
;
220 WMList
*colorListContentLst
;
221 WMPopUpButton
*colorListColorMenuBtn
;
222 WMPopUpButton
*colorListListMenuBtn
;
224 /* Look-Up Tables and Images */
225 wheelMatrix
*wheelMtrx
;
228 Pixmap selectionBackImg
;
229 RImage
*customPaletteImg
;
232 /* Common Data Fields */
233 CPColor color
; /* Current color */
234 WMColorPanelMode mode
; /* Current color selection mode */
235 WMColorPanelMode slidersmode
; /* Current color sel. mode sliders panel */
236 WMColorPanelMode lastChanged
; /* Panel that last changed the color */
237 int colx
, coly
; /* (x,y) of sel.-marker in WheelMode */
238 int palx
, paly
; /* (x,y) of sel.-marker in
240 float palXRatio
, palYRatio
; /* Ratios in x & y between
244 char *configurationPath
;
247 unsigned int continuous
:1;
248 unsigned int dragging
:1;
257 CPmenuNewFromClipboard
258 } customPaletteMenuItem
;
269 #define colorWheelSize 150
270 #define customPaletteWidth 182
271 #define customPaletteHeight 106
272 #define knobThickness 8
274 #define SPECTRUM_WIDTH 511
275 #define SPECTRUM_HEIGHT 360
277 #define COLORWHEEL_PART 1
278 #define CUSTOMPALETTE_PART 2
282 #define RGBTXT "/usr/X11R6/lib/X11/rgb.txt"
285 #define MAX_LENGTH 1024
287 static int fetchFile(char* toPath
, char *imageSrcFile
,
288 char *imageDestFileName
);
289 char *generateNewFilename(char *curName
);
290 void convertCPColor(CPColor
*color
);
291 RColor
ulongToRColor(WMScreen
*scr
, unsigned long value
);
292 unsigned char getShift(unsigned char value
);
294 static void modeButtonCallback(WMWidget
*w
, void *data
);
295 static int getPickerPart(W_ColorPanel
*panel
, int x
, int y
);
296 static void readConfiguration(W_ColorPanel
*panel
);
297 static void readXColors(W_ColorPanel
*panel
);
299 static void closeWindowCallback(WMWidget
*w
, void *data
);
301 static Cursor
magnifyGrabPointer(W_ColorPanel
*panel
);
302 static WMPoint
magnifyInitialize(W_ColorPanel
*panel
);
303 static void magnifyPutCursor(WMWidget
*w
, void *data
);
304 static Pixmap
magnifyCreatePixmap(WMColorPanel
*panel
);
305 static void magnifyGetImageStored(W_ColorPanel
*panel
, int x1
, int y1
,
307 static XImage
* magnifyGetImage(WMScreen
*scr
, XImage
*image
, int x
, int y
,
310 static wheelMatrix
* wheelCreateMatrix(unsigned int width
, unsigned int height
);
311 static void wheelDestroyMatrix(wheelMatrix
*matrix
);
312 static void wheelInitMatrix(W_ColorPanel
*panel
);
313 static void wheelCalculateValues(W_ColorPanel
*panel
, int maxvalue
);
314 static void wheelRender(W_ColorPanel
*panel
);
315 static Bool
wheelInsideColorWheel(W_ColorPanel
*panel
, unsigned long ofs
);
316 static void wheelPaint(W_ColorPanel
*panel
);
318 static void wheelHandleEvents(XEvent
*event
, void *data
);
319 static void wheelHandleActionEvents(XEvent
*event
, void *data
);
320 static void wheelBrightnessSliderCallback(WMWidget
*w
, void *data
);
321 static void wheelUpdateSelection(W_ColorPanel
*panel
);
322 static void wheelUndrawSelection(W_ColorPanel
*panel
);
324 static void wheelPositionSelection(W_ColorPanel
*panel
, int x
, int y
);
325 static void wheelPositionSelectionOutBounds(W_ColorPanel
*panel
, int x
, int y
);
326 static void wheelUpdateBrightnessGradientFromLocation (W_ColorPanel
*panel
);
327 static void wheelUpdateBrightnessGradient(W_ColorPanel
*panel
, CPColor topColor
);
329 static void grayBrightnessSliderCallback(WMWidget
*w
, void *data
);
330 static void grayPresetButtonCallback(WMWidget
*w
, void *data
);
331 static void grayBrightnessTextFieldCallback(void *observerData
,
332 WMNotification
*notification
);
334 static void rgbSliderCallback(WMWidget
*w
, void *data
);
335 static void rgbTextFieldCallback(void *observerData
,
336 WMNotification
*notification
);
338 static void cmykSliderCallback(WMWidget
*w
, void *data
);
339 static void cmykTextFieldCallback(void *observerData
,
340 WMNotification
*notification
);
342 static void hsbSliderCallback(WMWidget
*w
, void *data
);
343 static void hsbTextFieldCallback(void *observerData
,
344 WMNotification
*notification
);
345 static void hsbUpdateBrightnessGradient(W_ColorPanel
*panel
);
346 static void hsbUpdateSaturationGradient(W_ColorPanel
*panel
);
347 static void hsbUpdateHueGradient(W_ColorPanel
*panel
);
349 static void customRenderSpectrum(W_ColorPanel
*panel
);
350 static void customSetPalette(W_ColorPanel
*panel
);
351 static void customPaletteHandleEvents(XEvent
*event
, void *data
);
352 static void customPaletteHandleActionEvents(XEvent
*event
, void *data
);
353 static void customPalettePositionSelection(W_ColorPanel
*panel
, int x
, int y
);
354 static void customPalettePositionSelectionOutBounds(W_ColorPanel
*panel
,
356 static void customPaletteMenuCallback(WMWidget
*w
, void *data
);
357 static void customPaletteHistoryCallback(WMWidget
*w
, void *data
);
359 static void customPaletteMenuNewFromFile(W_ColorPanel
*panel
);
360 static void customPaletteMenuRename(W_ColorPanel
*panel
);
361 static void customPaletteMenuRemove(W_ColorPanel
*panel
);
363 static void colorListPaintItem(WMList
*lPtr
, int index
, Drawable d
, char *text
,
364 int state
, WMRect
*rect
);
365 static void colorListSelect(WMWidget
*w
, void *data
);
366 static void colorListColorMenuCallback(WMWidget
*w
, void *data
);
367 static void colorListListMenuCallback(WMWidget
*w
, void *data
);
368 static void colorListListMenuNew(W_ColorPanel
*panel
);
370 static void wheelInit(W_ColorPanel
*panel
);
371 static void grayInit(W_ColorPanel
*panel
);
372 static void rgbInit(W_ColorPanel
*panel
);
373 static void cmykInit(W_ColorPanel
*panel
);
374 static void hsbInit(W_ColorPanel
*panel
);
379 WMSetColorPanelAction(WMColorPanel
*panel
, WMAction2
*action
, void *data
)
381 panel
->action
= action
;
382 panel
->clientData
= data
;
386 makeColorPanel(WMScreen
*scrPtr
, char *name
)
393 WMColor
*textcolor
, *graybuttoncolor
;
395 GC bgc
= WMColorGC(scrPtr
->black
);
396 GC wgc
= WMColorGC(scrPtr
->white
);
399 panel
= wmalloc(sizeof(WMColorPanel
));
400 memset(panel
, 0, sizeof(WMColorPanel
));
402 panel
->color
.rgb
.red
= 0;
403 panel
->color
.rgb
.green
= 0;
404 panel
->color
.rgb
.blue
= 0;
405 panel
->color
.hsv
.hue
= 0;
406 panel
->color
.hsv
.saturation
= 0;
407 panel
->color
.hsv
.value
= 0;
408 panel
->color
.set
= cpNone
; /* Color has not been set yet */
410 panel
->font8
= WMSystemFontOfSize(scrPtr
, 8);
411 panel
->font12
= WMSystemFontOfSize(scrPtr
, 12);
413 panel
->win
= WMCreateWindowWithStyle(scrPtr
, name
,
414 WMTitledWindowMask
| WMClosableWindowMask
| WMResizableWindowMask
);
415 WMResizeWidget(panel
->win
, PWIDTH
, PHEIGHT
);
416 WMSetWindowTitle(panel
->win
, "Colors");
417 WMSetWindowCloseAction(panel
->win
, closeWindowCallback
, panel
);
420 /* Set Default ColorPanel Mode(s) */
421 panel
->mode
= WMWheelModeColorPanel
;
422 panel
->lastChanged
= 0;
423 panel
->slidersmode
= WMRGBModeColorPanel
;
424 panel
->configurationPath
= wstrappend(wusergnusteppath(),
427 /* Some General Purpose Widgets */
428 panel
->colorWell
= WMCreateColorWell(panel
->win
);
429 WMResizeWidget(panel
->colorWell
, 134, 36);
430 WSetColorWellBordered(panel
->colorWell
, False
);
431 WMMoveWidget(panel
->colorWell
, 56, 4);
433 panel
->magnifyBtn
= WMCreateCustomButton(panel
->win
,
434 WBBStateLightMask
|WBBStateChangeMask
);
435 WMResizeWidget(panel
->magnifyBtn
, 46, 36);
436 WMMoveWidget(panel
->magnifyBtn
, 6,4);
437 WMSetButtonAction(panel
->magnifyBtn
, magnifyPutCursor
, panel
);
438 WMSetButtonImagePosition(panel
->magnifyBtn
, WIPImageOnly
);
439 WMSetButtonImage(panel
->magnifyBtn
, scrPtr
->magnifyIcon
);
441 panel
->wheelBtn
= WMCreateCustomButton(panel
->win
,
442 WBBStateLightMask
|WBBStateChangeMask
);
443 WMResizeWidget(panel
->wheelBtn
, 46, 32);
444 WMMoveWidget(panel
->wheelBtn
, 6, 44);
445 WMSetButtonAction(panel
->wheelBtn
, modeButtonCallback
, panel
);
446 WMSetButtonImagePosition(panel
->wheelBtn
, WIPImageOnly
);
447 WMSetButtonImage(panel
->wheelBtn
, scrPtr
->wheelIcon
);
449 panel
->slidersBtn
= WMCreateCustomButton(panel
->win
,
450 WBBStateLightMask
|WBBStateChangeMask
);
451 WMResizeWidget(panel
->slidersBtn
, 46, 32);
452 WMMoveWidget(panel
->slidersBtn
, 52, 44);
453 WMSetButtonAction(panel
->slidersBtn
, modeButtonCallback
, panel
);
454 WMSetButtonImagePosition(panel
->slidersBtn
, WIPImageOnly
);
455 WMSetButtonImage(panel
->slidersBtn
, scrPtr
->rgbIcon
);
457 panel
->customPaletteBtn
= WMCreateCustomButton(panel
->win
,
458 WBBStateLightMask
|WBBStateChangeMask
);
459 WMResizeWidget(panel
->customPaletteBtn
, 46, 32);
460 WMMoveWidget(panel
->customPaletteBtn
, 98, 44);
461 WMSetButtonAction(panel
->customPaletteBtn
, modeButtonCallback
, panel
);
462 WMSetButtonImagePosition(panel
->customPaletteBtn
, WIPImageOnly
);
463 WMSetButtonImage(panel
->customPaletteBtn
, scrPtr
->customPaletteIcon
);
465 panel
->colorListBtn
= WMCreateCustomButton(panel
->win
,
466 WBBStateLightMask
|WBBStateChangeMask
);
467 WMResizeWidget(panel
->colorListBtn
, 46, 32);
468 WMMoveWidget(panel
->colorListBtn
, 144, 44);
469 WMSetButtonAction(panel
->colorListBtn
, modeButtonCallback
, panel
);
470 WMSetButtonImagePosition(panel
->colorListBtn
, WIPImageOnly
);
471 WMSetButtonImage(panel
->colorListBtn
, scrPtr
->colorListIcon
);
473 /* Let's Group some of them together */
474 WMGroupButtons(panel
->wheelBtn
, panel
->slidersBtn
);
475 WMGroupButtons(panel
->wheelBtn
, panel
->customPaletteBtn
);
476 WMGroupButtons(panel
->wheelBtn
, panel
->colorListBtn
);
478 /* Widgets for the ColorWheel Panel */
479 panel
->wheelFrm
= WMCreateFrame(panel
->win
);
480 WMSetFrameRelief(panel
->wheelFrm
, WRFlat
);
481 WMResizeWidget(panel
->wheelFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26);
482 WMMoveWidget(panel
->wheelFrm
, 5, 80);
484 panel
->wheelView
= W_CreateView(W_VIEW(panel
->wheelFrm
));
485 /* XXX Can we create a view ? */
486 W_ResizeView(panel
->wheelView
, colorWheelSize
+4, colorWheelSize
+4);
487 W_MoveView(panel
->wheelView
, 0, 0);
489 /* Create an event handler to handle expose/click events in ColorWheel */
490 WMCreateEventHandler(panel
->wheelView
,
491 ButtonPressMask
|ButtonReleaseMask
|EnterWindowMask
|
492 LeaveWindowMask
|ButtonMotionMask
, wheelHandleActionEvents
, panel
);
494 WMCreateEventHandler(panel
->wheelView
, ExposureMask
, wheelHandleEvents
,
497 panel
->wheelBrightnessS
= WMCreateSlider(panel
->wheelFrm
);
498 WMResizeWidget(panel
->wheelBrightnessS
, 16, 153);
499 WMMoveWidget(panel
->wheelBrightnessS
, 5+colorWheelSize
+14, 1);
500 WMSetSliderMinValue(panel
->wheelBrightnessS
, 0);
501 WMSetSliderMaxValue(panel
->wheelBrightnessS
, 255);
502 WMSetSliderAction(panel
->wheelBrightnessS
, wheelBrightnessSliderCallback
,
504 WMSetSliderKnobThickness(panel
->wheelBrightnessS
, knobThickness
);
506 panel
->wheelMtrx
= wheelCreateMatrix(colorWheelSize
+4, colorWheelSize
+4);
507 wheelInitMatrix(panel
);
510 /* Widgets for the Slider Panels */
511 panel
->slidersFrm
= WMCreateFrame(panel
->win
);
512 WMSetFrameRelief(panel
->slidersFrm
, WRFlat
);
513 WMResizeWidget(panel
->slidersFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26);
514 WMMoveWidget(panel
->slidersFrm
, 4, 80);
516 panel
->seperatorFrm
= WMCreateFrame(panel
->slidersFrm
);
517 WMSetFrameRelief(panel
->seperatorFrm
, WRPushed
);
518 WMResizeWidget(panel
->seperatorFrm
, PWIDTH
- 8, 2);
519 WMMoveWidget(panel
->seperatorFrm
, 0, 1);
521 panel
->grayBtn
= WMCreateCustomButton(panel
->slidersFrm
,
522 WBBStateLightMask
|WBBStateChangeMask
);
523 WMResizeWidget(panel
->grayBtn
, 46, 24);
524 WMMoveWidget(panel
->grayBtn
, 1, 8);
525 WMSetButtonAction(panel
->grayBtn
, modeButtonCallback
, panel
);
526 WMSetButtonImagePosition(panel
->grayBtn
, WIPImageOnly
);
527 WMSetButtonImage(panel
->grayBtn
, scrPtr
->grayIcon
);
529 panel
->rgbBtn
= WMCreateCustomButton(panel
->slidersFrm
,
530 WBBStateLightMask
|WBBStateChangeMask
);
531 WMResizeWidget(panel
->rgbBtn
, 46, 24);
532 WMMoveWidget(panel
->rgbBtn
, 47, 8);
533 WMSetButtonAction(panel
->rgbBtn
, modeButtonCallback
, panel
);
534 WMSetButtonImagePosition(panel
->rgbBtn
, WIPImageOnly
);
535 WMSetButtonImage(panel
->rgbBtn
, scrPtr
->rgbIcon
);
537 panel
->cmykBtn
= WMCreateCustomButton(panel
->slidersFrm
,
538 WBBStateLightMask
|WBBStateChangeMask
);
539 WMResizeWidget(panel
->cmykBtn
, 46, 24);
540 WMMoveWidget(panel
->cmykBtn
, 93, 8);
541 WMSetButtonAction(panel
->cmykBtn
, modeButtonCallback
, panel
);
542 WMSetButtonImagePosition(panel
->cmykBtn
, WIPImageOnly
);
543 WMSetButtonImage(panel
->cmykBtn
, scrPtr
->cmykIcon
);
545 panel
->hsbBtn
= WMCreateCustomButton(panel
->slidersFrm
,
546 WBBStateLightMask
|WBBStateChangeMask
);
547 WMResizeWidget(panel
->hsbBtn
, 46, 24);
548 WMMoveWidget(panel
->hsbBtn
, 139, 8);
549 WMSetButtonAction(panel
->hsbBtn
, modeButtonCallback
, panel
);
550 WMSetButtonImagePosition(panel
->hsbBtn
, WIPImageOnly
);
551 WMSetButtonImage(panel
->hsbBtn
, scrPtr
->hsbIcon
);
553 /* Let's Group the Slider Panel Buttons Together */
554 WMGroupButtons(panel
->grayBtn
, panel
->rgbBtn
);
555 WMGroupButtons(panel
->grayBtn
, panel
->cmykBtn
);
556 WMGroupButtons(panel
->grayBtn
, panel
->hsbBtn
);
558 textcolor
= WMDarkGrayColor(scrPtr
);
560 /* Widgets for GrayScale Panel */
561 panel
->grayFrm
= WMCreateFrame(panel
->slidersFrm
);
562 WMSetFrameRelief(panel
->grayFrm
, WRFlat
);
563 WMResizeWidget(panel
->grayFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26 - 32);
564 WMMoveWidget(panel
->grayFrm
, 0, 34);
566 panel
->grayMinL
= WMCreateLabel(panel
->grayFrm
);
567 WMResizeWidget(panel
->grayMinL
, 20, 10);
568 WMMoveWidget(panel
->grayMinL
, 2, 2);
569 WMSetLabelText(panel
->grayMinL
, "0");
570 WMSetLabelTextAlignment(panel
->grayMinL
, WALeft
);
571 WMSetLabelTextColor(panel
->grayMinL
, textcolor
);
572 WMSetLabelFont(panel
->grayMinL
, panel
->font8
);
574 panel
->grayMaxL
= WMCreateLabel(panel
->grayFrm
);
575 WMResizeWidget(panel
->grayMaxL
, 40, 10);
576 WMMoveWidget(panel
->grayMaxL
, 104, 2);
577 WMSetLabelText(panel
->grayMaxL
, "100");
578 WMSetLabelTextAlignment(panel
->grayMaxL
, WARight
);
579 WMSetLabelTextColor(panel
->grayMaxL
, textcolor
);
580 WMSetLabelFont(panel
->grayMaxL
, panel
->font8
);
582 panel
->grayBrightnessS
= WMCreateSlider(panel
->grayFrm
);
583 WMResizeWidget(panel
->grayBrightnessS
, 141, 16);
584 WMMoveWidget(panel
->grayBrightnessS
, 2, 14);
585 WMSetSliderMinValue(panel
->grayBrightnessS
, 0);
586 WMSetSliderMaxValue(panel
->grayBrightnessS
, 100);
587 WMSetSliderKnobThickness(panel
->grayBrightnessS
, knobThickness
);
588 WMSetSliderAction(panel
->grayBrightnessS
, grayBrightnessSliderCallback
,
599 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
600 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
601 RDestroyImage(image
);
604 W_PaintText(W_VIEW(panel
->grayBrightnessS
), pixmap
->pixmap
,
605 panel
->font12
, 2, 0, 100, WALeft
, WMColorGC(scrPtr
->white
),
606 False
, "Brightness", strlen("Brightness"));
608 wwarning(NO_MEMORY_ERR
);
610 WMSetSliderImage(panel
->grayBrightnessS
, pixmap
);
611 WMReleasePixmap(pixmap
);
613 panel
->grayBrightnessT
= WMCreateTextField(panel
->grayFrm
);
614 WMResizeWidget(panel
->grayBrightnessT
, 40, 18);
615 WMMoveWidget(panel
->grayBrightnessT
, 146, 13);
616 WMSetTextFieldAlignment(panel
->grayBrightnessT
, WALeft
);
617 WMAddNotificationObserver(grayBrightnessTextFieldCallback
, panel
,
618 WMTextDidEndEditingNotification
, panel
->grayBrightnessT
);
620 for (i
=0; i
< 7; i
++) {
621 pixmap
= WMCreatePixmap(scrPtr
, 13, 13, scrPtr
->depth
, False
);
623 graybuttoncolor
= WMCreateRGBColor(scrPtr
, (255/6)*i
<< 8,
624 (255/6)*i
<< 8, (255/6)*i
<< 8, True
);
625 WMPaintColorSwatch(graybuttoncolor
, pixmap
->pixmap
, 0, 0, 15, 15);
626 WMReleaseColor(graybuttoncolor
);
628 panel
->grayPresetBtn
[i
] = WMCreateCommandButton(panel
->grayFrm
);
629 WMResizeWidget(panel
->grayPresetBtn
[i
], 20, 24);
630 WMMoveWidget(panel
->grayPresetBtn
[i
], 2+(i
*20), 34);
631 WMSetButtonAction(panel
->grayPresetBtn
[i
],
632 grayPresetButtonCallback
, panel
);
633 WMSetButtonImage(panel
->grayPresetBtn
[i
], pixmap
);
634 WMSetButtonImagePosition(panel
->grayPresetBtn
[i
], WIPImageOnly
);
635 WMReleasePixmap(pixmap
);
639 /* End of GrayScale Panel */
641 /* Widgets for RGB Panel */
642 panel
->rgbFrm
= WMCreateFrame(panel
->slidersFrm
);
643 WMSetFrameRelief(panel
->rgbFrm
, WRFlat
);
644 WMResizeWidget(panel
->rgbFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26 - 32);
645 WMMoveWidget(panel
->rgbFrm
, 0, 34);
647 panel
->rgbMinL
= WMCreateLabel(panel
->rgbFrm
);
648 WMResizeWidget(panel
->rgbMinL
, 20, 10);
649 WMMoveWidget(panel
->rgbMinL
, 2, 2);
650 WMSetLabelText(panel
->rgbMinL
, "0");
651 WMSetLabelTextAlignment(panel
->rgbMinL
, WALeft
);
652 WMSetLabelTextColor(panel
->rgbMinL
, textcolor
);
653 WMSetLabelFont(panel
->rgbMinL
, panel
->font8
);
655 panel
->rgbMaxL
= WMCreateLabel(panel
->rgbFrm
);
656 WMResizeWidget(panel
->rgbMaxL
, 40, 10);
657 WMMoveWidget(panel
->rgbMaxL
, 104, 2);
658 WMSetLabelText(panel
->rgbMaxL
, "255");
659 WMSetLabelTextAlignment(panel
->rgbMaxL
, WARight
);
660 WMSetLabelTextColor(panel
->rgbMaxL
, textcolor
);
661 WMSetLabelFont(panel
->rgbMaxL
, panel
->font8
);
663 panel
->rgbRedS
= WMCreateSlider(panel
->rgbFrm
);
664 WMResizeWidget(panel
->rgbRedS
, 141, 16);
665 WMMoveWidget(panel
->rgbRedS
, 2, 14);
666 WMSetSliderMinValue(panel
->rgbRedS
, 0);
667 WMSetSliderMaxValue(panel
->rgbRedS
, 255);
668 WMSetSliderKnobThickness(panel
->rgbRedS
, knobThickness
);
669 WMSetSliderAction(panel
->rgbRedS
, rgbSliderCallback
, panel
);
675 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
676 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
677 RDestroyImage(image
);
680 W_PaintText(W_VIEW(panel
->rgbRedS
), pixmap
->pixmap
, panel
->font12
,
681 2, 0, 100, WALeft
, WMColorGC(scrPtr
->white
), False
, "Red",
684 wwarning(NO_MEMORY_ERR
);
686 WMSetSliderImage(panel
->rgbRedS
, pixmap
);
687 WMReleasePixmap(pixmap
);
689 panel
->rgbRedT
= WMCreateTextField(panel
->rgbFrm
);
690 WMResizeWidget(panel
->rgbRedT
, 40, 18);
691 WMMoveWidget(panel
->rgbRedT
, 146, 13);
692 WMSetTextFieldAlignment(panel
->rgbRedT
, WALeft
);
693 WMAddNotificationObserver(rgbTextFieldCallback
, panel
,
694 WMTextDidEndEditingNotification
, panel
->rgbRedT
);
696 panel
->rgbGreenS
= WMCreateSlider(panel
->rgbFrm
);
697 WMResizeWidget(panel
->rgbGreenS
, 141, 16);
698 WMMoveWidget(panel
->rgbGreenS
, 2, 36);
699 WMSetSliderMinValue(panel
->rgbGreenS
, 0);
700 WMSetSliderMaxValue(panel
->rgbGreenS
, 255);
701 WMSetSliderKnobThickness(panel
->rgbGreenS
, knobThickness
);
702 WMSetSliderAction(panel
->rgbGreenS
, rgbSliderCallback
, panel
);
708 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
709 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
710 RDestroyImage(image
);
713 W_PaintText(W_VIEW(panel
->rgbGreenS
), pixmap
->pixmap
, panel
->font12
,
714 2, 0, 100, WALeft
, WMColorGC(scrPtr
->white
), False
, "Green",
717 wwarning(NO_MEMORY_ERR
);
719 WMSetSliderImage(panel
->rgbGreenS
, pixmap
);
720 WMReleasePixmap(pixmap
);
722 panel
->rgbGreenT
= WMCreateTextField(panel
->rgbFrm
);
723 WMResizeWidget(panel
->rgbGreenT
, 40, 18);
724 WMMoveWidget(panel
->rgbGreenT
, 146, 35);
725 WMSetTextFieldAlignment(panel
->rgbGreenT
, WALeft
);
726 WMAddNotificationObserver(rgbTextFieldCallback
, panel
,
727 WMTextDidEndEditingNotification
, panel
->rgbGreenT
);
730 panel
->rgbBlueS
= WMCreateSlider(panel
->rgbFrm
);
731 WMResizeWidget(panel
->rgbBlueS
, 141, 16);
732 WMMoveWidget(panel
->rgbBlueS
, 2, 58);
733 WMSetSliderMinValue(panel
->rgbBlueS
, 0);
734 WMSetSliderMaxValue(panel
->rgbBlueS
, 255);
735 WMSetSliderKnobThickness(panel
->rgbBlueS
, knobThickness
);
736 WMSetSliderAction(panel
->rgbBlueS
, rgbSliderCallback
, panel
);
742 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
743 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
744 RDestroyImage(image
);
747 W_PaintText(W_VIEW(panel
->rgbBlueS
), pixmap
->pixmap
, panel
->font12
,
748 2, 0, 100, WALeft
, WMColorGC(scrPtr
->white
), False
, "Blue",
751 wwarning(NO_MEMORY_ERR
);
753 WMSetSliderImage(panel
->rgbBlueS
, pixmap
);
754 WMReleasePixmap(pixmap
);
756 panel
->rgbBlueT
= WMCreateTextField(panel
->rgbFrm
);
757 WMResizeWidget(panel
->rgbBlueT
, 40, 18);
758 WMMoveWidget(panel
->rgbBlueT
, 146, 57);
759 WMSetTextFieldAlignment(panel
->rgbBlueT
, WALeft
);
760 WMAddNotificationObserver(rgbTextFieldCallback
, panel
,
761 WMTextDidEndEditingNotification
, panel
->rgbBlueT
);
762 /* End of RGB Panel */
764 /* Widgets for CMYK Panel */
765 panel
->cmykFrm
= WMCreateFrame(panel
->slidersFrm
);
766 WMSetFrameRelief(panel
->cmykFrm
, WRFlat
);
767 WMResizeWidget(panel
->cmykFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26 - 32);
768 WMMoveWidget(panel
->cmykFrm
, 0, 34);
770 panel
->cmykMinL
= WMCreateLabel(panel
->cmykFrm
);
771 WMResizeWidget(panel
->cmykMinL
, 20, 10);
772 WMMoveWidget(panel
->cmykMinL
, 2, 2);
773 WMSetLabelText(panel
->cmykMinL
, "0");
774 WMSetLabelTextAlignment(panel
->cmykMinL
, WALeft
);
775 WMSetLabelTextColor(panel
->cmykMinL
, textcolor
);
776 WMSetLabelFont(panel
->cmykMinL
, panel
->font8
);
778 panel
->cmykMaxL
= WMCreateLabel(panel
->cmykFrm
);
779 WMResizeWidget(panel
->cmykMaxL
, 40, 10);
780 WMMoveWidget(panel
->cmykMaxL
, 104, 2);
781 WMSetLabelText(panel
->cmykMaxL
, "100");
782 WMSetLabelTextAlignment(panel
->cmykMaxL
, WARight
);
783 WMSetLabelTextColor(panel
->cmykMaxL
, textcolor
);
784 WMSetLabelFont(panel
->cmykMaxL
, panel
->font8
);
786 panel
->cmykCyanS
= WMCreateSlider(panel
->cmykFrm
);
787 WMResizeWidget(panel
->cmykCyanS
, 141, 16);
788 WMMoveWidget(panel
->cmykCyanS
, 2, 14);
789 WMSetSliderMinValue(panel
->cmykCyanS
, 0);
790 WMSetSliderMaxValue(panel
->cmykCyanS
, 100);
791 WMSetSliderKnobThickness(panel
->cmykCyanS
, knobThickness
);
792 WMSetSliderAction(panel
->cmykCyanS
, cmykSliderCallback
, panel
);
802 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
803 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
804 RDestroyImage(image
);
807 W_PaintText(W_VIEW(panel
->cmykCyanS
), pixmap
->pixmap
, panel
->font12
,
808 2, 0, 100, WALeft
, WMColorGC(scrPtr
->black
), False
, "Cyan",
811 wwarning(NO_MEMORY_ERR
);
813 WMSetSliderImage(panel
->cmykCyanS
, pixmap
);
814 WMReleasePixmap(pixmap
);
816 panel
->cmykCyanT
= WMCreateTextField(panel
->cmykFrm
);
817 WMResizeWidget(panel
->cmykCyanT
, 40, 18);
818 WMMoveWidget(panel
->cmykCyanT
, 146, 13);
819 WMSetTextFieldAlignment(panel
->cmykCyanT
, WALeft
);
820 WMAddNotificationObserver(cmykTextFieldCallback
, panel
,
821 WMTextDidEndEditingNotification
, panel
->cmykCyanT
);
824 panel
->cmykMagentaS
= WMCreateSlider(panel
->cmykFrm
);
825 WMResizeWidget(panel
->cmykMagentaS
, 141, 16);
826 WMMoveWidget(panel
->cmykMagentaS
, 2, 36);
827 WMSetSliderMinValue(panel
->cmykMagentaS
, 0);
828 WMSetSliderMaxValue(panel
->cmykMagentaS
, 100);
829 WMSetSliderKnobThickness(panel
->cmykMagentaS
, knobThickness
);
830 WMSetSliderAction(panel
->cmykMagentaS
, cmykSliderCallback
, panel
);
836 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
837 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
838 RDestroyImage(image
);
841 W_PaintText(W_VIEW(panel
->cmykMagentaS
), pixmap
->pixmap
, panel
->font12
,
842 2, 0, 100, WALeft
, WMColorGC(scrPtr
->black
), False
, "Magenta",
845 wwarning(NO_MEMORY_ERR
);
847 WMSetSliderImage(panel
->cmykMagentaS
, pixmap
);
848 WMReleasePixmap(pixmap
);
850 panel
->cmykMagentaT
= WMCreateTextField(panel
->cmykFrm
);
851 WMResizeWidget(panel
->cmykMagentaT
, 40, 18);
852 WMMoveWidget(panel
->cmykMagentaT
, 146, 35);
853 WMSetTextFieldAlignment(panel
->cmykMagentaT
, WALeft
);
854 WMAddNotificationObserver(cmykTextFieldCallback
, panel
,
855 WMTextDidEndEditingNotification
, panel
->cmykMagentaT
);
858 panel
->cmykYellowS
= WMCreateSlider(panel
->cmykFrm
);
859 WMResizeWidget(panel
->cmykYellowS
, 141, 16);
860 WMMoveWidget(panel
->cmykYellowS
, 2, 58);
861 WMSetSliderMinValue(panel
->cmykYellowS
, 0);
862 WMSetSliderMaxValue(panel
->cmykYellowS
, 100);
863 WMSetSliderKnobThickness(panel
->cmykYellowS
, knobThickness
);
864 WMSetSliderAction(panel
->cmykYellowS
, cmykSliderCallback
, panel
);
870 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
871 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
872 RDestroyImage(image
);
875 W_PaintText(W_VIEW(panel
->cmykYellowS
), pixmap
->pixmap
, panel
->font12
,
876 2, 0, 100, WALeft
, WMColorGC(scrPtr
->black
), False
, "Yellow",
879 wwarning(NO_MEMORY_ERR
);
881 WMSetSliderImage(panel
->cmykYellowS
, pixmap
);
882 WMReleasePixmap(pixmap
);
884 panel
->cmykYellowT
= WMCreateTextField(panel
->cmykFrm
);
885 WMResizeWidget(panel
->cmykYellowT
, 40, 18);
886 WMMoveWidget(panel
->cmykYellowT
, 146, 57);
887 WMSetTextFieldAlignment(panel
->cmykYellowT
, WALeft
);
888 WMAddNotificationObserver(cmykTextFieldCallback
, panel
,
889 WMTextDidEndEditingNotification
, panel
->cmykYellowT
);
892 panel
->cmykBlackS
= WMCreateSlider(panel
->cmykFrm
);
893 WMResizeWidget(panel
->cmykBlackS
, 141, 16);
894 WMMoveWidget(panel
->cmykBlackS
, 2, 80);
895 WMSetSliderMinValue(panel
->cmykBlackS
, 0);
896 WMSetSliderMaxValue(panel
->cmykBlackS
, 100);
897 WMSetSliderValue(panel
->cmykBlackS
, 0);
898 WMSetSliderKnobThickness(panel
->cmykBlackS
, knobThickness
);
899 WMSetSliderAction(panel
->cmykBlackS
, cmykSliderCallback
, panel
);
905 image
= RRenderGradient(141, 16, &from
, &to
, RGRD_HORIZONTAL
);
906 pixmap
= WMCreatePixmapFromRImage(scrPtr
, image
, 0);
907 RDestroyImage(image
);
910 W_PaintText(W_VIEW(panel
->cmykBlackS
), pixmap
->pixmap
, panel
->font12
,
911 2, 0, 100, WALeft
, WMColorGC(scrPtr
->black
), False
, "Black",
914 wwarning(NO_MEMORY_ERR
);
916 WMSetSliderImage(panel
->cmykBlackS
, pixmap
);
917 WMReleasePixmap(pixmap
);
919 panel
->cmykBlackT
= WMCreateTextField(panel
->cmykFrm
);
920 WMResizeWidget(panel
->cmykBlackT
, 40, 18);
921 WMMoveWidget(panel
->cmykBlackT
, 146, 79);
922 WMSetTextFieldAlignment(panel
->cmykBlackT
, WALeft
);
923 WMAddNotificationObserver(cmykTextFieldCallback
, panel
,
924 WMTextDidEndEditingNotification
, panel
->cmykBlackT
);
925 /* End of CMYK Panel */
927 /* Widgets for HSB Panel */
928 panel
->hsbFrm
= WMCreateFrame(panel
->slidersFrm
);
929 WMSetFrameRelief(panel
->hsbFrm
, WRFlat
);
930 WMResizeWidget(panel
->hsbFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26 - 32);
931 WMMoveWidget(panel
->hsbFrm
, 0, 34);
933 panel
->hsbHueS
= WMCreateSlider(panel
->hsbFrm
);
934 WMResizeWidget(panel
->hsbHueS
, 141, 16);
935 WMMoveWidget(panel
->hsbHueS
, 2, 14);
936 WMSetSliderMinValue(panel
->hsbHueS
, 0);
937 WMSetSliderMaxValue(panel
->hsbHueS
, 359);
938 WMSetSliderKnobThickness(panel
->hsbHueS
, knobThickness
);
939 WMSetSliderAction(panel
->hsbHueS
, hsbSliderCallback
, panel
);
941 panel
->hsbHueT
= WMCreateTextField(panel
->hsbFrm
);
942 WMResizeWidget(panel
->hsbHueT
, 40, 18);
943 WMMoveWidget(panel
->hsbHueT
, 146, 13);
944 WMSetTextFieldAlignment(panel
->hsbHueT
, WALeft
);
945 WMAddNotificationObserver(hsbTextFieldCallback
, panel
,
946 WMTextDidEndEditingNotification
, panel
->hsbHueT
);
949 panel
->hsbSaturationS
= WMCreateSlider(panel
->hsbFrm
);
950 WMResizeWidget(panel
->hsbSaturationS
, 141, 16);
951 WMMoveWidget(panel
->hsbSaturationS
, 2, 36);
952 WMSetSliderMinValue(panel
->hsbSaturationS
, 0);
953 WMSetSliderMaxValue(panel
->hsbSaturationS
, 100);
954 WMSetSliderKnobThickness(panel
->hsbSaturationS
, knobThickness
);
955 WMSetSliderAction(panel
->hsbSaturationS
, hsbSliderCallback
, panel
);
957 panel
->hsbSaturationT
= WMCreateTextField(panel
->hsbFrm
);
958 WMResizeWidget(panel
->hsbSaturationT
, 40, 18);
959 WMMoveWidget(panel
->hsbSaturationT
, 146, 35);
960 WMSetTextFieldAlignment(panel
->hsbSaturationT
, WALeft
);
961 WMAddNotificationObserver(hsbTextFieldCallback
, panel
,
962 WMTextDidEndEditingNotification
, panel
->hsbSaturationT
);
965 panel
->hsbBrightnessS
= WMCreateSlider(panel
->hsbFrm
);
966 WMResizeWidget(panel
->hsbBrightnessS
, 141, 16);
967 WMMoveWidget(panel
->hsbBrightnessS
, 2, 58);
968 WMSetSliderMinValue(panel
->hsbBrightnessS
, 0);
969 WMSetSliderMaxValue(panel
->hsbBrightnessS
, 100);
970 WMSetSliderKnobThickness(panel
->hsbBrightnessS
, knobThickness
);
971 WMSetSliderAction(panel
->hsbBrightnessS
, hsbSliderCallback
, panel
);
973 panel
->hsbBrightnessT
= WMCreateTextField(panel
->hsbFrm
);
974 WMResizeWidget(panel
->hsbBrightnessT
, 40, 18);
975 WMMoveWidget(panel
->hsbBrightnessT
, 146, 57);
976 WMSetTextFieldAlignment(panel
->hsbBrightnessT
, WALeft
);
977 WMAddNotificationObserver(hsbTextFieldCallback
, panel
,
978 WMTextDidEndEditingNotification
, panel
->hsbBrightnessT
);
979 /* End of HSB Panel */
982 WMReleaseColor(textcolor
);
984 /* Widgets for the CustomPalette Panel */
985 panel
->customPaletteFrm
= WMCreateFrame(panel
->win
);
986 WMSetFrameRelief(panel
->customPaletteFrm
, WRFlat
);
987 WMResizeWidget(panel
->customPaletteFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26);
988 WMMoveWidget(panel
->customPaletteFrm
, 5, 80);
990 panel
->customPaletteHistoryBtn
= WMCreatePopUpButton(
991 panel
->customPaletteFrm
);
992 WMAddPopUpButtonItem(panel
->customPaletteHistoryBtn
, "Spectrum");
993 WMSetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
,
994 WMGetPopUpButtonNumberOfItems(panel
->customPaletteHistoryBtn
)-1);
995 WMSetPopUpButtonAction(panel
->customPaletteHistoryBtn
,
996 customPaletteHistoryCallback
, panel
);
997 WMResizeWidget(panel
->customPaletteHistoryBtn
, PWIDTH
- 8, 20);
998 WMMoveWidget(panel
->customPaletteHistoryBtn
, 0, 0);
1000 panel
->customPaletteContentFrm
= WMCreateFrame(panel
->customPaletteFrm
);
1001 WMSetFrameRelief(panel
->customPaletteContentFrm
, WRSunken
);
1002 WMResizeWidget(panel
->customPaletteContentFrm
, PWIDTH
- 8, PHEIGHT
- 156);
1003 WMMoveWidget(panel
->customPaletteContentFrm
, 0, 23);
1005 panel
->customPaletteContentView
= W_CreateView(
1006 W_VIEW(panel
->customPaletteContentFrm
));
1007 /* XXX Test if we can create a view */
1008 W_ResizeView(panel
->customPaletteContentView
, customPaletteWidth
,
1009 customPaletteHeight
);
1010 W_MoveView(panel
->customPaletteContentView
, 2, 2);
1012 /* Create event handler to handle expose/click events in CustomPalette */
1013 WMCreateEventHandler(panel
->customPaletteContentView
,
1014 ButtonPressMask
|ButtonReleaseMask
|EnterWindowMask
| LeaveWindowMask
|
1015 ButtonMotionMask
, customPaletteHandleActionEvents
, panel
);
1017 WMCreateEventHandler(panel
->customPaletteContentView
, ExposureMask
,
1018 customPaletteHandleEvents
, panel
);
1020 panel
->customPaletteMenuBtn
= WMCreatePopUpButton(panel
->customPaletteFrm
);
1021 WMSetPopUpButtonPullsDown(panel
->customPaletteMenuBtn
, 1);
1022 WMSetPopUpButtonText(panel
->customPaletteMenuBtn
, "Palette");
1023 WMSetPopUpButtonAction(panel
->customPaletteMenuBtn
,
1024 customPaletteMenuCallback
, panel
);
1025 WMResizeWidget(panel
->customPaletteMenuBtn
, PWIDTH
- 8, 20);
1026 WMMoveWidget(panel
->customPaletteMenuBtn
, 0, PHEIGHT
- 130);
1028 WMAddPopUpButtonItem(panel
->customPaletteMenuBtn
, "New from File...");
1029 WMAddPopUpButtonItem(panel
->customPaletteMenuBtn
, "Rename...");
1030 WMAddPopUpButtonItem(panel
->customPaletteMenuBtn
, "Remove");
1031 WMAddPopUpButtonItem(panel
->customPaletteMenuBtn
, "Copy");
1032 WMAddPopUpButtonItem(panel
->customPaletteMenuBtn
, "New from Clipboard");
1034 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRename
, 0);
1035 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRemove
, 0);
1036 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuCopy
, 0);
1037 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
,
1038 CPmenuNewFromClipboard
, 0);
1040 customRenderSpectrum(panel
);
1041 panel
->currentPalette
= 0;
1042 panel
->palx
= customPaletteWidth
/2;
1043 panel
->paly
= customPaletteHeight
/2;
1046 /* Widgets for the ColorList Panel */
1047 panel
->colorListFrm
= WMCreateFrame(panel
->win
);
1048 WMSetFrameRelief(panel
->colorListFrm
, WRFlat
);
1049 WMResizeWidget(panel
->colorListFrm
, PWIDTH
- 8, PHEIGHT
- 80 - 26);
1050 WMMoveWidget(panel
->colorListFrm
, 5, 80);
1052 panel
->colorListHistoryBtn
= WMCreatePopUpButton(panel
->colorListFrm
);
1053 WMAddPopUpButtonItem(panel
->colorListHistoryBtn
, "X11-Colors");
1054 WMSetPopUpButtonSelectedItem(panel
->colorListHistoryBtn
,
1055 WMGetPopUpButtonNumberOfItems(panel
->colorListHistoryBtn
)-1);
1056 /* WMSetPopUpButtonAction(panel->colorListHistoryBtn,
1057 * colorListHistoryCallback, panel); */
1058 WMResizeWidget(panel
->colorListHistoryBtn
, PWIDTH
- 8, 20);
1059 WMMoveWidget(panel
->colorListHistoryBtn
, 0, 0);
1061 panel
->colorListContentLst
= WMCreateList(panel
->colorListFrm
);
1062 WMSetListAction(panel
->colorListContentLst
, colorListSelect
, panel
);
1063 WMSetListUserDrawProc(panel
->colorListContentLst
, colorListPaintItem
);
1064 WMResizeWidget(panel
->colorListContentLst
, PWIDTH
- 8, PHEIGHT
- 156);
1065 WMMoveWidget(panel
->colorListContentLst
, 0, 23);
1066 WMHangData(panel
->colorListContentLst
, panel
);
1068 panel
->colorListColorMenuBtn
= WMCreatePopUpButton(panel
->colorListFrm
);
1069 WMSetPopUpButtonPullsDown(panel
->colorListColorMenuBtn
, 1);
1070 WMSetPopUpButtonText(panel
->colorListColorMenuBtn
, "Color");
1071 WMSetPopUpButtonAction(panel
->colorListColorMenuBtn
,
1072 colorListColorMenuCallback
, panel
);
1073 WMResizeWidget(panel
->colorListColorMenuBtn
, (PWIDTH
- 16)/2, 20);
1074 WMMoveWidget(panel
->colorListColorMenuBtn
, 0, PHEIGHT
- 130);
1076 WMAddPopUpButtonItem(panel
->colorListColorMenuBtn
, "Add...");
1077 WMAddPopUpButtonItem(panel
->colorListColorMenuBtn
, "Rename...");
1078 WMAddPopUpButtonItem(panel
->colorListColorMenuBtn
, "Remove");
1080 WMSetPopUpButtonItemEnabled(panel
->colorListColorMenuBtn
, CLmenuAdd
, 0);
1081 WMSetPopUpButtonItemEnabled(panel
->colorListColorMenuBtn
, CLmenuRename
, 0);
1082 WMSetPopUpButtonItemEnabled(panel
->colorListColorMenuBtn
, CLmenuRemove
, 0);
1084 panel
->colorListListMenuBtn
= WMCreatePopUpButton(panel
->colorListFrm
);
1085 WMSetPopUpButtonPullsDown(panel
->colorListListMenuBtn
, 1);
1086 WMSetPopUpButtonText(panel
->colorListListMenuBtn
, "List");
1087 WMSetPopUpButtonAction(panel
->colorListListMenuBtn
,
1088 colorListListMenuCallback
, panel
);
1089 WMResizeWidget(panel
->colorListListMenuBtn
, (PWIDTH
- 16)/2, 20);
1090 WMMoveWidget(panel
->colorListListMenuBtn
, (PWIDTH
- 16)/2 + 8,
1093 WMAddPopUpButtonItem(panel
->colorListListMenuBtn
, "New...");
1094 WMAddPopUpButtonItem(panel
->colorListListMenuBtn
, "Rename...");
1095 WMAddPopUpButtonItem(panel
->colorListListMenuBtn
, "Remove");
1097 WMSetPopUpButtonItemEnabled(panel
->colorListListMenuBtn
, CLmenuAdd
, 0);
1098 WMSetPopUpButtonItemEnabled(panel
->colorListListMenuBtn
, CLmenuRename
, 0);
1099 WMSetPopUpButtonItemEnabled(panel
->colorListListMenuBtn
, CLmenuRemove
, 0);
1101 WMRealizeWidget(panel
->win
);
1102 WMMapSubwidgets(panel
->win
);
1104 WMMapSubwidgets(panel
->wheelFrm
);
1105 WMMapSubwidgets(panel
->slidersFrm
);
1106 WMMapSubwidgets(panel
->grayFrm
);
1107 WMMapSubwidgets(panel
->rgbFrm
);
1108 WMMapSubwidgets(panel
->cmykFrm
);
1109 WMMapSubwidgets(panel
->hsbFrm
);
1110 WMMapSubwidgets(panel
->customPaletteFrm
);
1111 WMMapSubwidgets(panel
->customPaletteContentFrm
);
1112 WMMapSubwidgets(panel
->colorListFrm
);
1114 /* Pixmap to indicate selection positions
1115 * wheelframe MUST be mapped.
1117 panel
->selectionImg
= XCreatePixmap(scrPtr
->display
,
1118 WMWidgetXID(panel
->win
), 4, 4, scrPtr
->depth
);
1119 XFillRectangle(scrPtr
->display
, panel
->selectionImg
, bgc
, 0, 0, 4, 4);
1120 XFillRectangle(scrPtr
->display
, panel
->selectionImg
, wgc
, 1, 1, 2, 2);
1122 readConfiguration(panel
);
1130 WMGetColorPanel(WMScreen
*scrPtr
)
1132 WMColorPanel
*panel
;
1134 if (scrPtr
->sharedColorPanel
)
1135 return scrPtr
->sharedColorPanel
;
1137 panel
= makeColorPanel(scrPtr
, "colorPanel");
1139 scrPtr
->sharedColorPanel
= panel
;
1146 WMFreeColorPanel(WMColorPanel
*panel
)
1148 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1150 if (panel
== scr
->sharedColorPanel
) {
1151 scr
->sharedColorPanel
= NULL
;
1157 WMRemoveNotificationObserver(panel
);
1158 WMUnmapWidget(panel
->win
);
1161 WMReleaseFont(panel
->font8
);
1162 WMReleaseFont(panel
->font12
);
1165 wheelDestroyMatrix(panel
->wheelMtrx
);
1166 if (panel
->wheelImg
)
1167 XFreePixmap(scr
->display
, panel
->wheelImg
);
1168 if (panel
->selectionImg
)
1169 XFreePixmap(scr
->display
, panel
->selectionImg
);
1170 if (panel
->selectionBackImg
)
1171 XFreePixmap(scr
->display
, panel
->selectionBackImg
);
1172 RDestroyImage(panel
->customPaletteImg
);
1175 if (panel
->lastBrowseDir
)
1176 wfree(panel
->lastBrowseDir
);
1177 if (panel
->configurationPath
)
1178 wfree(panel
->configurationPath
);
1180 WMDestroyWidget(panel
->win
);
1187 WMCloseColorPanel(WMColorPanel
*panel
)
1189 WMFreeColorPanel(panel
);
1194 WMShowColorPanel(WMColorPanel
*panel
)
1196 WMScreen
*scr
= WMWidgetScreen(panel
->win
);
1197 WMColor
*white
= WMWhiteColor(scr
);
1199 if (panel
->color
.set
== cpNone
)
1200 WMSetColorPanelColor(panel
, white
);
1201 WMReleaseColor(white
);
1203 if (panel
->mode
!= WMWheelModeColorPanel
)
1204 WMPerformButtonClick(panel
->wheelBtn
);
1206 WMMapWidget(panel
->win
);
1211 closeWindowCallback(WMWidget
*w
, void *data
)
1213 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
1215 WMCloseColorPanel(panel
);
1220 readConfiguration(W_ColorPanel
*panel
)
1222 /* XXX Doesn't take care of "invalid" files */
1226 struct stat stat_buf
;
1229 if (stat(panel
->configurationPath
, &stat_buf
)!=0) {
1230 if (mkdir(panel
->configurationPath
,
1231 S_IRWXU
|S_IRGRP
|S_IROTH
|S_IXGRP
|S_IXOTH
)!=0) {
1232 wsyserror("Color Panel: Could not create directory %s needed"
1233 " to store configurations", panel
->configurationPath
);
1234 WMSetPopUpButtonEnabled(panel
->customPaletteMenuBtn
, False
);
1235 WMSetPopUpButtonEnabled(panel
->colorListColorMenuBtn
, False
);
1236 WMSetPopUpButtonEnabled(panel
->colorListListMenuBtn
, False
);
1237 WMRunAlertPanel(WMWidgetScreen(panel
->win
), panel
->win
,
1239 "Could not create ColorPanel configuration directory",
1245 if (!(dPtr
= opendir(panel
->configurationPath
))) {
1246 wwarning(NO_FILE_ERR
, "%s", panel
->configurationPath
);
1250 while ((dp
= readdir(dPtr
)) != NULL
) {
1251 unsigned int perm_mask
;
1252 char *path
= wstrappend(panel
->configurationPath
,
1255 if (dp
->d_name
[0] != '.') {
1256 item
= WMGetPopUpButtonNumberOfItems(
1257 panel
->customPaletteHistoryBtn
);
1258 WMAddPopUpButtonItem(panel
->customPaletteHistoryBtn
, dp
->d_name
);
1260 perm_mask
= (access(path
, R_OK
) == 0);
1261 WMSetPopUpButtonItemEnabled(panel
->customPaletteHistoryBtn
,
1266 (void)closedir(dPtr
);
1271 readXColors(W_ColorPanel
*panel
)
1273 struct stat stat_buf
;
1275 char line
[MAX_LENGTH
];
1276 int red
, green
, blue
;
1281 if (stat(RGBTXT
, &stat_buf
) != 0) {
1282 wsyserror(NO_FILE_ERR
, " %s", RGBTXT
);
1286 if ((rgbtxt
= fopen(RGBTXT
, "r"))) {
1287 while (fgets(line
, MAX_LENGTH
, rgbtxt
)) {
1288 if (sscanf(line
, "%d%d%d %[^\n]", &red
, &green
, &blue
, name
)) {
1289 color
= wmalloc(sizeof(RColor
));
1290 color
->red
= (unsigned char)red
;
1291 color
->green
= (unsigned char)green
;
1292 color
->blue
= (unsigned char)blue
;
1293 item
= WMAddListItem(panel
->colorListContentLst
, name
);
1294 item
->clientData
= (void *)color
;
1300 wsyserror(NO_FILE_ERR
, "%s", RGBTXT
);
1307 WMSetColorPanelPickerMode(WMColorPanel
*panel
, WMColorPanelMode mode
)
1309 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1311 if (mode
!= WMWheelModeColorPanel
) {
1312 WMUnmapWidget(panel
->wheelFrm
);
1313 if (panel
->selectionBackImg
) {
1314 XFreePixmap(WMWidgetScreen(panel
->win
)->display
,
1315 panel
->selectionBackImg
);
1316 panel
->selectionBackImg
= None
;
1319 if (mode
!= WMGrayModeColorPanel
)
1320 WMUnmapWidget(panel
->grayFrm
);
1321 if (mode
!= WMRGBModeColorPanel
)
1322 WMUnmapWidget(panel
->rgbFrm
);
1323 if (mode
!= WMCMYKModeColorPanel
)
1324 WMUnmapWidget(panel
->cmykFrm
);
1325 if (mode
!= WMHSBModeColorPanel
)
1326 WMUnmapWidget(panel
->hsbFrm
);
1327 if (mode
!= WMCustomPaletteModeColorPanel
) {
1328 WMUnmapWidget(panel
->customPaletteFrm
);
1329 if (panel
->selectionBackImg
) {
1330 XFreePixmap(WMWidgetScreen(panel
->win
)->display
,
1331 panel
->selectionBackImg
);
1332 panel
->selectionBackImg
= None
;
1335 if (mode
!= WMColorListModeColorPanel
)
1336 WMUnmapWidget(panel
->colorListFrm
);
1337 if ((mode
!= WMGrayModeColorPanel
) && (mode
!= WMRGBModeColorPanel
) &&
1338 (mode
!= WMCMYKModeColorPanel
) && (mode
!= WMHSBModeColorPanel
))
1339 WMUnmapWidget(panel
->slidersFrm
);
1341 panel
->slidersmode
= mode
;
1343 if (mode
== WMWheelModeColorPanel
) {
1344 WMMapWidget(panel
->wheelFrm
);
1345 WMSetButtonSelected(panel
->wheelBtn
, True
);
1346 if (panel
->lastChanged
!= WMWheelModeColorPanel
)
1350 } else if (mode
== WMGrayModeColorPanel
) {
1351 WMMapWidget(panel
->slidersFrm
);
1352 WMSetButtonSelected(panel
->slidersBtn
, True
);
1353 WMMapWidget(panel
->grayFrm
);
1354 WMSetButtonSelected(panel
->grayBtn
, True
);
1355 WMSetButtonImage(panel
->slidersBtn
, scr
->grayIcon
);
1356 if (panel
->lastChanged
!= WMGrayModeColorPanel
)
1358 } else if (mode
== WMRGBModeColorPanel
) {
1359 WMMapWidget(panel
->slidersFrm
);
1360 WMSetButtonSelected(panel
->slidersBtn
, True
);
1361 WMMapWidget(panel
->rgbFrm
);
1362 WMSetButtonSelected(panel
->rgbBtn
, True
);
1363 WMSetButtonImage(panel
->slidersBtn
, scr
->rgbIcon
);
1364 if (panel
->lastChanged
!= WMRGBModeColorPanel
)
1366 } else if (mode
== WMCMYKModeColorPanel
) {
1367 WMMapWidget(panel
->slidersFrm
);
1368 WMSetButtonSelected(panel
->slidersBtn
, True
);
1369 WMMapWidget(panel
->cmykFrm
);
1370 WMSetButtonSelected(panel
->cmykBtn
, True
);
1371 WMSetButtonImage(panel
->slidersBtn
, scr
->cmykIcon
);
1372 if (panel
->lastChanged
!= WMCMYKModeColorPanel
)
1374 } else if (mode
== WMHSBModeColorPanel
) {
1375 WMMapWidget(panel
->slidersFrm
);
1376 WMSetButtonSelected(panel
->slidersBtn
, True
);
1377 WMMapWidget(panel
->hsbFrm
);
1378 WMSetButtonSelected(panel
->hsbBtn
, True
);
1379 WMSetButtonImage(panel
->slidersBtn
, scr
->hsbIcon
);
1380 if (panel
->lastChanged
!= WMHSBModeColorPanel
)
1382 } else if (mode
== WMCustomPaletteModeColorPanel
) {
1383 WMMapWidget(panel
->customPaletteFrm
);
1384 WMSetButtonSelected(panel
->customPaletteBtn
, True
);
1385 customSetPalette(panel
);
1386 } else if (mode
== WMColorListModeColorPanel
) {
1387 WMMapWidget(panel
->colorListFrm
);
1388 WMSetButtonSelected(panel
->colorListBtn
, True
);
1396 WMGetColorPanelColor(WMColorPanel
*panel
)
1398 return WMGetColorWellColor(panel
->colorWell
);
1403 WMSetColorPanelColor(WMColorPanel
*panel
, WMColor
*color
)
1405 WMSetColorWellColor(panel
->colorWell
, color
);
1407 panel
->color
.rgb
.red
= color
->color
.red
>> 8;
1408 panel
->color
.rgb
.green
= color
->color
.green
>> 8;
1409 panel
->color
.rgb
.blue
= color
->color
.blue
>> 8;
1410 panel
->color
.set
= cpRGB
;
1412 if (panel
->mode
== panel
->lastChanged
)
1413 panel
->lastChanged
= 0;
1415 WMSetColorPanelPickerMode(panel
, panel
->mode
);
1420 updateSwatch(WMColorPanel
*panel
, CPColor color
)
1422 WMScreen
*scr
= WMWidgetScreen(panel
->win
);
1425 if (color
.set
!= cpRGB
)
1426 convertCPColor(&color
);
1428 panel
->color
= color
;
1430 wellcolor
= WMCreateRGBColor(scr
, color
.rgb
.red
<< 8,
1431 color
.rgb
.green
<< 8,
1432 color
.rgb
.blue
<< 8, True
);
1434 WMSetColorWellColor(panel
->colorWell
, wellcolor
);
1435 WMReleaseColor(wellcolor
);
1437 if (!panel
->flags
.dragging
|| panel
->flags
.continuous
) {
1439 (*panel
->action
)(panel
, panel
->clientData
);
1441 WMPostNotificationName(WMColorPanelColorChangedNotification
, panel
,
1447 modeButtonCallback(WMWidget
*w
, void *data
)
1449 W_ColorPanel
*panel
= (W_ColorPanel
*)(data
);
1451 if (w
== panel
->wheelBtn
)
1452 WMSetColorPanelPickerMode(panel
, WMWheelModeColorPanel
);
1453 else if (w
== panel
->slidersBtn
)
1454 WMSetColorPanelPickerMode(panel
, panel
->slidersmode
);
1455 else if (w
== panel
->customPaletteBtn
)
1456 WMSetColorPanelPickerMode(panel
, WMCustomPaletteModeColorPanel
);
1457 else if (w
== panel
->colorListBtn
)
1458 WMSetColorPanelPickerMode(panel
, WMColorListModeColorPanel
);
1459 else if (w
== panel
->grayBtn
)
1460 WMSetColorPanelPickerMode(panel
, WMGrayModeColorPanel
);
1461 else if (w
== panel
->rgbBtn
)
1462 WMSetColorPanelPickerMode(panel
, WMRGBModeColorPanel
);
1463 else if (w
== panel
->cmykBtn
)
1464 WMSetColorPanelPickerMode(panel
, WMCMYKModeColorPanel
);
1465 else if (w
== panel
->hsbBtn
)
1466 WMSetColorPanelPickerMode(panel
, WMHSBModeColorPanel
);
1470 /****************** Magnifying Cursor Functions *******************/
1473 magnifyGetImage(WMScreen
*scr
, XImage
*image
, int x
, int y
, int w
, int h
)
1475 int x0
= 0, y0
= 0, w0
= w
, h0
= h
;
1476 const int displayWidth
= DisplayWidth(scr
->display
, scr
->screen
),
1477 displayHeight
= DisplayHeight(scr
->display
, scr
->screen
);
1479 if (!(image
&& image
->data
)) {
1480 /* The image in panel->magnifyGlass->image does not exist yet.
1481 * Grab one from the screen (not beyond) and use it from now on.
1483 if (!(image
= XGetImage(scr
->display
, scr
->rootWin
,
1486 w
, h
, AllPlanes
, ZPixmap
)))
1492 /* Coordinate correction for back pixmap
1493 * if magnifying glass is at screen-borders
1496 /* Figure 1: Shifting of rectangle-to-grab at top/left screen borders
1497 * Hatched area is beyond screen border.
1499 * |<-Cursor_x_hot->|
1500 * ________________|_____
1501 * |/ / / / / / /| | |
1502 * | / / / / / / |(x,y) |
1503 * |/_/_/_/_/_/_/|________|
1504 * |<----x0----->|<--w0-->|
1508 /* Figure 2: Shifting of rectangle-to-grab at bottom/right
1510 * Hatched area is beyond screen border
1512 * |<-Cursor_x_hot->|
1513 * ________________|_______________
1514 * | | | / / / / / /|
1515 * | (x,y)|/ / / / / / |
1516 * |___________________|_/_/_/_/_/_/|
1517 * |<-------w0-------->| |
1518 * |<---------------w--|----------->|
1523 if (x
< Cursor_x_hot
) { /* see fig. 1 */
1524 x0
= Cursor_x_hot
- x
;
1528 if (displayWidth
-1 < x
- Cursor_x_hot
+ w
) { /* see fig. 2 */
1529 w0
= (displayWidth
) - (x
- Cursor_x_hot
);
1532 if (y
< Cursor_y_hot
) { /* see fig. 1 */
1533 y0
= Cursor_y_hot
- y
;
1537 if (displayHeight
-1 < y
- Cursor_y_hot
+ h
) { /* see fig. 2 */
1538 h0
= (displayHeight
) - (y
- Cursor_y_hot
);
1540 /* end of coordinate correction */
1543 /* Grab an image from the screen, clipped if necessary,
1544 * and put it in the existing panel->magnifyGlass->image
1545 * with the corresponding clipping offset.
1547 if (!XGetSubImage(scr
->display
, scr
->rootWin
,
1548 x
- Cursor_x_hot
+ x0
,
1549 y
- Cursor_y_hot
+ y0
,
1550 w0
, h0
, AllPlanes
, ZPixmap
,
1559 magnifyGetImageStored(WMColorPanel
*panel
, int x1
, int y1
, int x2
, int y2
)
1561 /* (x1, y1) = topleft corner of existing rectangle
1562 * (x2, y2) = topleft corner of new position
1565 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1566 int xa
= 0, ya
= 0, xb
= 0, yb
= 0;
1568 const int dx
= abs(x2
- x1
),
1571 const int x_min
= Cursor_x_hot
,
1572 y_min
= Cursor_y_hot
,
1573 x_max
= DisplayWidth(scr
->display
, scr
->screen
) -1 -
1574 (Cursor_mask_width
- Cursor_x_hot
),
1575 y_max
= DisplayHeight(scr
->display
, scr
->screen
) -1 -
1576 (Cursor_mask_height
- Cursor_y_hot
);
1578 if ((dx
== 0) && (dy
== 0) && panel
->magnifyGlass
->image
)
1579 return; /* No movement */
1591 width
= Cursor_mask_width
- dx
;
1592 height
= Cursor_mask_height
- dy
;
1594 /* If the traversed distance is larger than the size of the magnifying
1595 * glass contents, there is no need to do dirty rectangles. A whole new
1596 * rectangle can be grabbed (unless that rectangle falls partially
1598 * Destroying the image and setting it to NULL will achieve that later on.
1600 * Of course, grabbing an XImage beyond the borders of the screen will
1601 * cause trouble, this is considdered a special case. Part of the screen
1602 * is grabbed, but there is no need for dirty rectangles.
1604 if ((width
<= 0) || (height
<= 0)) {
1605 if ((x2
>= x_min
) && (y2
>= y_min
) && (x2
<= x_max
) && (y2
<= y_max
)) {
1606 if (panel
->magnifyGlass
->image
)
1607 XDestroyImage(panel
->magnifyGlass
->image
);
1608 panel
->magnifyGlass
->image
= NULL
;
1611 if (panel
->magnifyGlass
->image
) {
1612 /* Get dirty rectangle from panel->magnifyGlass->image */
1613 panel
->magnifyGlass
->dirtyRect
=
1614 XSubImage(panel
->magnifyGlass
->image
, xa
, ya
, width
, height
);
1615 if (!panel
->magnifyGlass
->dirtyRect
) {
1617 return; /* X returned a NULL from XSubImage */
1622 /* Get image from screen */
1623 image
= magnifyGetImage(scr
, panel
->magnifyGlass
->image
, x2
, y2
,
1624 Cursor_mask_width
, Cursor_mask_height
);
1625 if (image
) { /* Only reassign if a *new* image was grabbed */
1626 panel
->magnifyGlass
->image
= image
;
1630 /* Copy previously stored rectangle on covered part of image */
1631 if (panel
->magnifyGlass
->image
&& panel
->magnifyGlass
->dirtyRect
) {
1634 /* "width" and "height" are used as coordinates here,
1635 * and run from [0...width-1] and [0...height-1] respectively.
1639 old_height
= height
;
1641 for (; width
>= 0; width
--)
1642 for (height
= old_height
; height
>= 0; height
--)
1643 XPutPixel(panel
->magnifyGlass
->image
, xb
+ width
, yb
+ height
,
1644 XGetPixel(panel
->magnifyGlass
->dirtyRect
, width
, height
));
1645 XDestroyImage(panel
->magnifyGlass
->dirtyRect
);
1646 panel
->magnifyGlass
->dirtyRect
= NULL
;
1654 magnifyCreatePixmap(WMColorPanel
*panel
)
1656 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1661 unsigned long color
;
1663 if (!panel
->magnifyGlass
->image
)
1666 if (!panel
->magnifyGlass
->magPix
)
1670 * Copy an area of only 5x5 pixels from the center of the image.
1672 for (u
= 0; u
< 5; u
++) {
1673 for (v
= 0; v
< 5; v
++) {
1674 color
= XGetPixel(panel
->magnifyGlass
->image
, u
+ 9, v
+ 9);
1676 XSetForeground(scr
->display
, scr
->copyGC
, color
);
1678 if ((u
== 2) && (v
== 2)) /* (2,2) is center pixel (unmagn.) */
1679 panel
->magnifyGlass
->color
= ulongToRColor(scr
, color
);
1681 /* The center square must eventually be centered around the
1682 * hotspot. The image needs shifting to achieve this. The amount of
1683 * shifting is (Cursor_mask_width/2 - 2 * square_size) = 11-10 = 1
1686 * ^------- center of center square == Cursor_x_hot
1688 XFillRectangle(scr
->display
, panel
->magnifyGlass
->magPix
,
1690 u
* 5 + (u
== 0 ? 0 : -1), v
* 5 + (v
== 0 ? 0 : -1),
1691 (u
== 0 ? 4 : 5), (v
== 0 ? 4 : 5));
1696 return panel
->magnifyGlass
->magPix
;
1698 pixmap
= XCreatePixmap(scr
->display
, W_DRAWABLE(scr
), Cursor_mask_width
,
1699 Cursor_mask_height
, scr
->depth
);
1703 XPutImage(scr
->display
, pixmap
, scr
->copyGC
, panel
->magnifyGlass
->image
,
1704 0, 0, 0, 0, Cursor_mask_width
, Cursor_mask_height
);
1706 /* Copy the magnified pixmap, with the clip mask, to background pixmap */
1707 XCopyArea(scr
->display
, panel
->magnifyGlass
->magPix
, pixmap
,
1708 scr
->clipGC
, 0, 0, Cursor_mask_width
, Cursor_mask_height
, 0, 0);
1709 /* (2,2) puts center pixel on center of glass */
1718 magnifyCreateView(W_ColorPanel
*panel
)
1720 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1723 magView
= W_CreateTopView(scr
);
1727 magView
->self
= panel
->win
;
1728 magView
->flags
.topLevel
= 1;
1729 magView
->attribFlags
|= CWOverrideRedirect
| CWSaveUnder
;
1730 magView
->attribs
.override_redirect
= True
;
1731 magView
->attribs
.save_under
= True
;
1733 W_ResizeView(magView
, Cursor_mask_width
, Cursor_mask_height
);
1735 W_RealizeView(magView
);
1742 magnifyGrabPointer(W_ColorPanel
*panel
)
1744 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1745 Pixmap magPixmap
, magPixmap2
;
1747 XColor fgColor
= {0, 0,0,0, DoRed
|DoGreen
|DoBlue
};
1748 XColor bgColor
= {0, 0xbf00, 0xa000, 0x5000, DoRed
|DoGreen
|DoBlue
};
1750 /* Cursor creation stuff */
1751 magPixmap
= XCreatePixmapFromBitmapData(scr
->display
, W_DRAWABLE(scr
),
1752 (char *)Cursor_bits
, Cursor_width
, Cursor_height
, 1, 0, 1);
1753 magPixmap2
= XCreatePixmapFromBitmapData(scr
->display
, W_DRAWABLE(scr
),
1754 (char *)Cursor_shape_bits
, Cursor_width
, Cursor_height
, 1, 0, 1);
1756 magCursor
= XCreatePixmapCursor(scr
->display
, magPixmap
, magPixmap2
,
1757 &fgColor
, &bgColor
, Cursor_x_hot
, Cursor_y_hot
);
1759 XFreePixmap(scr
->display
, magPixmap
);
1760 XFreePixmap(scr
->display
, magPixmap2
);
1762 XRecolorCursor(scr
->display
, magCursor
, &fgColor
, &bgColor
);
1764 /* Set up Pointer */
1765 XGrabPointer (scr
->display
, panel
->magnifyGlass
->view
->window
, True
,
1766 PointerMotionMask
| ButtonPressMask
,
1767 GrabModeAsync
, GrabModeAsync
,
1768 scr
->rootWin
, magCursor
, CurrentTime
);
1775 magnifyInitialize(W_ColorPanel
*panel
)
1777 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1780 Pixmap pixmap
, clip_mask
;
1782 Window root_return
, child_return
;
1784 clip_mask
= XCreatePixmapFromBitmapData(scr
->display
, W_DRAWABLE(scr
),
1785 (char *)Cursor_mask_bits
, Cursor_mask_width
, Cursor_mask_height
,
1787 panel
->magnifyGlass
->magPix
= XCreatePixmap(scr
->display
, W_DRAWABLE(scr
),
1788 5*5 -1, 5*5 -1, scr
->depth
);
1790 XQueryPointer(scr
->display
, scr
->rootWin
, &root_return
, &child_return
,
1791 &x
, &y
, &u
, &v
, &mask
);
1793 panel
->magnifyGlass
->image
= NULL
;
1795 /* Clipmask to make magnified view-contents circular */
1797 XShapeCombineMask(scr
->display
, WMViewXID(panel
->magnifyGlass
->view
),
1798 ShapeBounding
, 0, 0, clip_mask
, ShapeSet
);
1800 /* Clip circle in glass cursor */
1801 XSetClipMask(scr
->display
, scr
->clipGC
, clip_mask
);
1802 XSetClipOrigin(scr
->display
, scr
->clipGC
, 0, 0);
1805 XFreePixmap(scr
->display
, clip_mask
);
1807 /* Draw initial magnifying glass contents */
1808 magnifyGetImageStored(panel
, x
, y
, x
, y
);
1810 pixmap
= magnifyCreatePixmap(panel
);
1811 XSetWindowBackgroundPixmap(scr
->display
,
1812 WMViewXID(panel
->magnifyGlass
->view
),
1814 XClearWindow(scr
->display
, WMViewXID(panel
->magnifyGlass
->view
));
1815 XFlush(scr
->display
);
1818 XFreePixmap(scr
->display
, pixmap
);
1829 magnifyPutCursor(WMWidget
*w
, void *data
)
1831 W_ColorPanel
*panel
= (W_ColorPanel
*)(data
);
1832 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
1836 WMPoint initialPosition
;
1838 /* Destroy wheelBackImg, so it'll update properly */
1839 if (panel
->selectionBackImg
) {
1840 XFreePixmap(WMWidgetScreen(panel
->win
)->display
,
1841 panel
->selectionBackImg
);
1842 panel
->selectionBackImg
= None
;
1845 /* Create magnifying glass */
1846 panel
->magnifyGlass
= wmalloc(sizeof(MovingView
));
1847 panel
->magnifyGlass
->view
= magnifyCreateView(panel
);
1848 if (!panel
->magnifyGlass
->view
)
1851 initialPosition
= magnifyInitialize(panel
);
1852 panel
->magnifyGlass
->x
= initialPosition
.x
;
1853 panel
->magnifyGlass
->y
= initialPosition
.y
;
1855 W_MoveView(panel
->magnifyGlass
->view
,
1856 panel
->magnifyGlass
->x
- Cursor_x_hot
,
1857 panel
->magnifyGlass
->y
- Cursor_y_hot
);
1858 W_MapView(panel
->magnifyGlass
->view
);
1860 magCursor
= magnifyGrabPointer(panel
);
1862 while (panel
->magnifyGlass
->image
)
1864 WMNextEvent(scr
->display
, &event
);
1866 /* Pack motion events */
1867 while (XCheckTypedEvent(scr
->display
, MotionNotify
, &event
)) {
1873 XDestroyImage(panel
->magnifyGlass
->image
);
1874 panel
->magnifyGlass
->image
= NULL
;
1876 if (event
.xbutton
.button
== Button1
) {
1877 panel
->color
.rgb
= panel
->magnifyGlass
->color
;
1878 panel
->color
.set
= cpRGB
;
1879 updateSwatch(panel
, panel
->color
);
1881 switch (panel
->mode
) {
1882 case WMWheelModeColorPanel
:
1887 case WMGrayModeColorPanel
:
1890 case WMRGBModeColorPanel
:
1893 case WMCMYKModeColorPanel
:
1896 case WMHSBModeColorPanel
:
1902 panel
->lastChanged
= panel
->mode
;
1904 WMSetButtonSelected(panel
->magnifyBtn
, False
);
1908 while (XPending(event
.xmotion
.display
)) {
1910 XPeekEvent(event
.xmotion
.display
, &ev
);
1911 if (ev
.type
== MotionNotify
)
1912 XNextEvent(event
.xmotion
.display
, &event
);
1917 /* Get a "dirty rectangle" */
1918 magnifyGetImageStored( panel
,
1919 panel
->magnifyGlass
->x
, panel
->magnifyGlass
->y
,
1920 event
.xmotion
.x_root
, event
.xmotion
.y_root
);
1922 /* Update coordinates */
1923 panel
->magnifyGlass
->x
= event
.xmotion
.x_root
;
1924 panel
->magnifyGlass
->y
= event
.xmotion
.y_root
;
1927 W_MoveView(panel
->magnifyGlass
->view
,
1928 panel
->magnifyGlass
->x
- Cursor_x_hot
,
1929 panel
->magnifyGlass
->y
- Cursor_y_hot
);
1931 /* Put new image (with magn.) in view */
1932 pixmap
= magnifyCreatePixmap(panel
);
1933 if (pixmap
!= None
) {
1934 /* Change the window background */
1935 XSetWindowBackgroundPixmap(scr
->display
,
1936 WMViewXID(panel
->magnifyGlass
->view
), pixmap
);
1937 /* Force an Expose (handled by X) */
1938 XClearWindow(scr
->display
,
1939 WMViewXID(panel
->magnifyGlass
->view
));
1940 /* Synchronize the event queue, so the Expose is handled NOW */
1941 XFlush(scr
->display
);
1943 XFreePixmap(scr
->display
, pixmap
);
1948 /* Try XQueryPointer for this !!! It returns windows that the pointer
1949 * is over. Note: We found this solving the invisible donkey cap bug
1951 #if 0 /* As it is impossible to make this work in all cases,
1952 * we consider it confusing. Therefore we disabled it.
1954 case FocusOut
: /* fall through */
1957 * Color Panel window (panel->win) lost or received focus.
1958 * We need to update the pixmap in the magnifying glass.
1960 * BUG Doesn't work with focus switches between two windows
1961 * if none of them is the color panel.
1963 XUngrabPointer(scr
->display
, CurrentTime
);
1964 W_UnmapView(panel
->magnifyGlass
->view
);
1966 magnifyInitialize(panel
);
1968 W_MapView(panel
->magnifyGlass
->view
);
1969 XGrabPointer (scr
->display
, panel
->magnifyGlass
->view
->window
,
1970 True
, PointerMotionMask
| ButtonPressMask
,
1971 GrabModeAsync
, GrabModeAsync
,
1972 scr
->rootWin
, magCursor
, CurrentTime
);
1976 WMHandleEvent(&event
);
1981 XUngrabPointer(scr
->display
, CurrentTime
);
1982 XFreeCursor(scr
->display
, magCursor
);
1984 XFreePixmap(scr
->display
, panel
->magnifyGlass
->magPix
);
1985 panel
->magnifyGlass
->magPix
= None
;
1987 W_UnmapView(panel
->magnifyGlass
->view
);
1988 W_DestroyView(panel
->magnifyGlass
->view
);
1989 panel
->magnifyGlass
->view
= NULL
;
1991 wfree(panel
->magnifyGlass
);
1996 /****************** ColorWheel Functions ************************/
1999 wheelCreateMatrix(unsigned int width
, unsigned int height
)
2001 wheelMatrix
*matrix
= NULL
;
2004 assert((width
> 0) && (height
> 0));
2006 matrix
= wmalloc(sizeof(wheelMatrix
));
2007 memset(matrix
, 0, sizeof(wheelMatrix
));
2008 matrix
->width
= width
;
2009 matrix
->height
= height
;
2011 for (i
= 0; i
< 3; i
++) {
2012 matrix
->data
[i
] = wmalloc(width
*height
*sizeof(unsigned char));
2020 wheelDestroyMatrix(wheelMatrix
*matrix
)
2027 for (i
= 0; i
< 3; i
++) {
2028 if (matrix
->data
[i
])
2029 wfree(matrix
->data
[i
]);
2036 wheelInitMatrix(W_ColorPanel
*panel
)
2040 unsigned char *rp
, *gp
, *bp
;
2046 const int cw_halfsize
= (colorWheelSize
+ 4)/2,
2047 cw_sqsize
= (colorWheelSize
+4) * (colorWheelSize
+4),
2048 uchar_shift
= getShift(sizeof(unsigned char));
2050 if (!panel
->wheelMtrx
)
2053 cpColor
.hsv
.value
= 255;
2054 cpColor
.set
= cpHSV
;
2057 ofs
[1] = -(colorWheelSize
+ 4);
2059 /* offsets are counterclockwise (in triangles).
2062 * _______________________________________
2063 * [1] |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| o
2064 * s |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| f
2065 * f |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| s
2066 * o | | | | | | | | | | | | | | | | | | | | | [3]
2070 * |\ /| <-- triangles
2076 for (y
= 0; y
< cw_halfsize
; y
++) {
2077 for (x
= y
; x
< (colorWheelSize
+4-y
); x
++) {
2078 /* (xcor, ycor) is (x,y) relative to center of matrix */
2079 xcor
= 2 * x
- 4 - colorWheelSize
;
2080 ycor
= 2 * y
- 4 - colorWheelSize
;
2082 /* RColor.saturation is unsigned char and will wrap after 255 */
2084 sqrtf( (float)(xcor
*xcor
) + (float)(ycor
*ycor
)) /
2085 (float)colorWheelSize
);
2087 cpColor
.hsv
.saturation
= (unsigned char)sat
;
2089 ofs
[0]++; /* top quarter of matrix*/
2090 ofs
[1] += colorWheelSize
+ 4; /* left quarter */
2091 ofs
[2] = cw_sqsize
- 1 - ofs
[0]; /* bottom quarter */
2092 ofs
[3] = cw_sqsize
- 1 - ofs
[1]; /* right quarter */
2096 dhue
[0] = rint(atan((float)ycor
/ (float)xcor
) *
2097 (180.0 / M_PI
)) + (xcor
< 0 ? 180.0 : 0.0);
2101 dhue
[0] = 360 - dhue
[0]; /* Reverse direction of ColorWheel */
2102 dhue
[1] = 270 - dhue
[0] + (dhue
[0] > 270 ? 360 : 0);
2103 dhue
[2] = dhue
[0] - 180 + (dhue
[0] < 180 ? 360 : 0);
2104 dhue
[3] = 90 - dhue
[0] + (dhue
[0] > 90 ? 360 : 0);
2106 for (i
= 0; i
< 4; i
++) {
2107 rp
= panel
->wheelMtrx
->data
[0] + (ofs
[i
] << uchar_shift
);
2108 gp
= panel
->wheelMtrx
->data
[1] + (ofs
[i
] << uchar_shift
);
2109 bp
= panel
->wheelMtrx
->data
[2] + (ofs
[i
] << uchar_shift
);
2111 cpColor
.hsv
.hue
= dhue
[i
];
2112 convertCPColor(&cpColor
);
2114 *rp
= (unsigned char)(cpColor
.rgb
.red
);
2115 *gp
= (unsigned char)(cpColor
.rgb
.green
);
2116 *bp
= (unsigned char)(cpColor
.rgb
.blue
);
2120 for (i
= 0; i
< 4; i
++) {
2121 rp
= panel
->wheelMtrx
->data
[0] + (ofs
[i
] << uchar_shift
);
2122 gp
= panel
->wheelMtrx
->data
[1] + (ofs
[i
] << uchar_shift
);
2123 bp
= panel
->wheelMtrx
->data
[2] + (ofs
[i
] << uchar_shift
);
2125 *rp
= (unsigned char)0;
2126 *gp
= (unsigned char)0;
2127 *bp
= (unsigned char)0;
2133 ofs
[1] += 1 - (colorWheelSize
+ 4) * (colorWheelSize
+ 4 - 1 - 2*y
);
2139 wheelCalculateValues(W_ColorPanel
*panel
, int maxvalue
)
2144 for (i
= 0; i
< 256; i
++) {
2145 /* We divide by 128 in advance, and check whether that number divides
2146 * by 2 properly. If not, we add one to round the number correctly
2148 v
= (i
*maxvalue
) >> 7;
2149 panel
->wheelMtrx
->values
[i
] = (unsigned char)((v
>> 1) +(v
& 0x01));
2155 wheelRender(W_ColorPanel
*panel
)
2157 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2160 unsigned char *rp
, *gp
, *bp
;
2162 unsigned long ofs
= 0;
2163 unsigned char shift
= getShift(sizeof(unsigned char));
2165 image
= RCreateImage(colorWheelSize
+4, colorWheelSize
+4, False
);
2167 wwarning(NO_MEMORY_ERR
);
2171 /* TODO Make this transparent istead of gray */
2172 gray
.red
= gray
.green
= gray
.blue
= 0xaa;
2174 for (y
= 0; y
< colorWheelSize
+4; y
++) {
2175 for (x
= 0; x
< colorWheelSize
+4; x
++) {
2176 rp
= image
->data
[0] + (ofs
<< shift
);
2177 gp
= image
->data
[1] + (ofs
<< shift
);
2178 bp
= image
->data
[2] + (ofs
<< shift
);
2180 if (wheelInsideColorWheel(panel
, ofs
)) {
2181 *rp
= (unsigned char)(panel
->wheelMtrx
->values
[
2182 panel
->wheelMtrx
->data
[0][ofs
] ]);
2183 *gp
= (unsigned char)(panel
->wheelMtrx
->values
[
2184 panel
->wheelMtrx
->data
[1][ofs
] ]);
2185 *bp
= (unsigned char)(panel
->wheelMtrx
->values
[
2186 panel
->wheelMtrx
->data
[2][ofs
] ]);
2189 *rp
= (unsigned char)(gray
.red
);
2190 *gp
= (unsigned char)(gray
.green
);
2191 *bp
= (unsigned char)(gray
.blue
);
2197 if (panel
->wheelImg
)
2198 XFreePixmap(scr
->display
, panel
->wheelImg
);
2200 RConvertImage(scr
->rcontext
, image
, &panel
->wheelImg
);
2201 RDestroyImage(image
);
2203 /* Check if backimage exists. If it doesn't, allocate and fill it */
2204 if (!panel
->selectionBackImg
) {
2205 panel
->selectionBackImg
= XCreatePixmap(scr
->display
,
2206 W_VIEW(panel
->wheelFrm
)->window
, 4, 4, scr
->depth
);
2207 XCopyArea(scr
->display
, panel
->wheelImg
, panel
->selectionBackImg
,
2208 scr
->copyGC
, panel
->colx
-2, panel
->coly
-2, 4, 4, 0, 0);
2209 /* -2 is hot spot correction */
2215 wheelInsideColorWheel(W_ColorPanel
*panel
, unsigned long ofs
)
2217 return ((panel
->wheelMtrx
->data
[0][ofs
] != 0) &&
2218 (panel
->wheelMtrx
->data
[1][ofs
] != 0) &&
2219 (panel
->wheelMtrx
->data
[2][ofs
] != 0));
2224 wheelPaint (W_ColorPanel
*panel
)
2226 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2228 XCopyArea(scr
->display
, panel
->wheelImg
, panel
->wheelView
->window
,
2229 scr
->copyGC
, 0, 0, colorWheelSize
+4, colorWheelSize
+4, 0, 0);
2231 /* Draw selection image */
2232 XCopyArea(scr
->display
, panel
->selectionImg
, panel
->wheelView
->window
,
2233 scr
->copyGC
, 0, 0, 4, 4, panel
->colx
-2, panel
->coly
-2);
2238 wheelHandleEvents(XEvent
*event
, void *data
)
2240 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2242 switch (event
->type
) {
2244 if (event
->xexpose
.count
!= 0) /* TODO Improve */
2253 wheelHandleActionEvents(XEvent
*event
, void *data
)
2255 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2257 switch (event
->type
) {
2259 if (getPickerPart(panel
, event
->xbutton
.x
, event
->xbutton
.y
) ==
2262 panel
->lastChanged
= WMWheelModeColorPanel
;
2263 panel
->flags
.dragging
= 1;
2265 wheelPositionSelection(panel
, event
->xbutton
.x
, event
->xbutton
.y
);
2270 panel
->flags
.dragging
= 0;
2271 if (!panel
->flags
.continuous
) {
2273 (*panel
->action
)(panel
, panel
->clientData
);
2278 if (panel
->flags
.dragging
) {
2279 if (getPickerPart(panel
, event
->xmotion
.x
, event
->xmotion
.y
) ==
2281 wheelPositionSelection(panel
, event
->xmotion
.x
,
2285 wheelPositionSelectionOutBounds(panel
, event
->xmotion
.x
,
2294 getPickerPart(W_ColorPanel
*panel
, int x
, int y
)
2302 if (panel
->mode
== WMWheelModeColorPanel
) {
2303 if ((lx
>= 2) && (lx
<= 2+colorWheelSize
) && (ly
>= 2) &&
2304 (ly
<= 2+colorWheelSize
)) {
2306 ofs
= ly
*panel
->wheelMtrx
->width
+lx
;
2308 if (wheelInsideColorWheel(panel
, ofs
))
2309 return COLORWHEEL_PART
;
2313 if (panel
->mode
== WMCustomPaletteModeColorPanel
) {
2314 if ((lx
>= 2) && (lx
< customPaletteWidth
-2) && (ly
>= 2) &&
2315 (ly
< customPaletteHeight
-2)) {
2316 return CUSTOMPALETTE_PART
;
2325 wheelBrightnessSliderCallback(WMWidget
*w
, void *data
)
2329 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2331 value
= 255-WMGetSliderValue(panel
->wheelBrightnessS
);
2333 wheelCalculateValues(panel
, value
);
2335 if (panel
->color
.set
== cpRGB
) {
2336 convertCPColor(&panel
->color
);
2337 panel
->color
.set
= cpHSV
;
2340 panel
->color
.hsv
.value
= value
;
2344 wheelUpdateSelection(panel
);
2349 wheelUpdateSelection(W_ColorPanel
*panel
)
2351 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2353 updateSwatch(panel
, panel
->color
);
2354 panel
->lastChanged
= WMWheelModeColorPanel
;
2356 /* Redraw color selector (and make a backup of the part it will cover) */
2357 XCopyArea(scr
->display
, panel
->wheelImg
, panel
->selectionBackImg
,
2358 scr
->copyGC
, panel
->colx
-2, panel
->coly
-2, 4, 4, 0, 0);
2359 /* "-2" is correction for hotspot location */
2360 XCopyArea(scr
->display
, panel
->selectionImg
, panel
->wheelView
->window
,
2361 scr
->copyGC
, 0, 0, 4, 4, panel
->colx
-2, panel
->coly
-2);
2367 wheelUndrawSelection(W_ColorPanel
*panel
)
2369 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2371 XCopyArea(scr
->display
, panel
->selectionBackImg
, panel
->wheelView
->window
,
2372 scr
->copyGC
, 0, 0, 4, 4, panel
->colx
-2, panel
->coly
-2);
2377 wheelPositionSelection(W_ColorPanel
*panel
, int x
, int y
)
2379 unsigned long ofs
= (y
* panel
->wheelMtrx
->width
)+ x
;
2381 panel
->color
.rgb
.red
= panel
->wheelMtrx
->values
[
2382 panel
->wheelMtrx
->data
[0][ofs
] ];
2384 panel
->color
.rgb
.green
= panel
->wheelMtrx
->values
[
2385 panel
->wheelMtrx
->data
[1][ofs
] ];
2387 panel
->color
.rgb
.blue
= panel
->wheelMtrx
->values
[
2388 panel
->wheelMtrx
->data
[2][ofs
] ];
2389 panel
->color
.set
= cpRGB
;
2391 wheelUndrawSelection(panel
);
2396 wheelUpdateSelection(panel
);
2397 wheelUpdateBrightnessGradientFromLocation(panel
);
2401 wheelPositionSelectionOutBounds(W_ColorPanel
*panel
, int x
, int y
)
2407 xcor
= x
* 2 - colorWheelSize
- 4;
2408 ycor
= y
* 2 - colorWheelSize
- 4;
2410 panel
->color
.hsv
.saturation
= 255;
2411 panel
->color
.hsv
.value
= 255 - WMGetSliderValue(panel
->wheelBrightnessS
);
2414 hue
= rint(atan(- (float)ycor
/ (float)xcor
) * (180.0/M_PI
));
2425 if ((xcor
> 0) && (ycor
> 0))
2428 panel
->color
.hsv
.hue
= hue
;
2429 panel
->color
.set
= cpHSV
;
2430 convertCPColor(&panel
->color
);
2432 wheelUndrawSelection(panel
);
2434 panel
->colx
= 2 + rint((colorWheelSize
* (1.0 +
2435 cos( panel
->color
.hsv
.hue
* (M_PI
/180.0) ))) / 2.0);
2436 /* "+2" because of "colorWheelSize + 4" */
2437 panel
->coly
= 2 + rint((colorWheelSize
* (1.0 +
2438 sin(- panel
->color
.hsv
.hue
* (M_PI
/180.0) ))) / 2.0);
2440 wheelUpdateSelection(panel
);
2441 cpColor
= panel
->color
;
2442 wheelUpdateBrightnessGradient(panel
, cpColor
);
2446 wheelUpdateBrightnessGradientFromLocation(W_ColorPanel
*panel
)
2451 ofs
= panel
->coly
* panel
->wheelMtrx
->width
+ panel
->colx
;
2453 from
.rgb
.red
= panel
->wheelMtrx
->data
[0][ofs
];
2454 from
.rgb
.green
= panel
->wheelMtrx
->data
[1][ofs
];
2455 from
.rgb
.blue
= panel
->wheelMtrx
->data
[2][ofs
];
2458 wheelUpdateBrightnessGradient(panel
, from
);
2462 wheelUpdateBrightnessGradient(W_ColorPanel
*panel
, CPColor topColor
)
2466 WMPixmap
*sliderPxmp
;
2468 to
.red
= to
.green
= to
.blue
= 0;
2470 if (topColor
.set
== cpHSV
)
2471 convertCPColor(&topColor
);
2473 sliderImg
= RRenderGradient(16, 153, &(topColor
.rgb
), &to
, RGRD_VERTICAL
);
2474 sliderPxmp
= WMCreatePixmapFromRImage(WMWidgetScreen(panel
->win
),
2476 RDestroyImage(sliderImg
);
2477 WMSetSliderImage(panel
->wheelBrightnessS
, sliderPxmp
);
2478 WMReleasePixmap(sliderPxmp
);
2481 /****************** Grayscale Panel Functions ***************/
2484 grayBrightnessSliderCallback(WMWidget
*w
, void *data
)
2489 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2491 value
= WMGetSliderValue(panel
->grayBrightnessS
);
2493 sprintf(tmp
, "%d", value
);
2495 WMSetTextFieldText(panel
->grayBrightnessT
, tmp
);
2496 cpColor
.rgb
.red
= cpColor
.rgb
.green
= cpColor
.rgb
.blue
= rint(2.55*value
);
2497 cpColor
.set
= cpRGB
;
2499 updateSwatch(panel
, cpColor
);
2500 panel
->lastChanged
= WMGrayModeColorPanel
;
2504 grayPresetButtonCallback(WMWidget
*w
, void *data
)
2510 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2513 if (w
== panel
->grayPresetBtn
[i
])
2518 value
= rint((100.0*i
)/6.0);
2519 sprintf(tmp
, "%d", value
);
2521 WMSetTextFieldText(panel
->grayBrightnessT
, tmp
);
2522 cpColor
.rgb
.red
= cpColor
.rgb
.green
= cpColor
.rgb
.blue
=
2523 rint((255.0*i
)/6.0);
2524 cpColor
.set
= cpRGB
;
2526 WMSetSliderValue(panel
->grayBrightnessS
, rint((100.0*i
)/6.0));
2528 updateSwatch(panel
, cpColor
);
2529 panel
->lastChanged
= WMGrayModeColorPanel
;
2533 grayBrightnessTextFieldCallback(void *observerData
,
2534 WMNotification
*notification
)
2539 W_ColorPanel
*panel
= (W_ColorPanel
*)observerData
;
2541 value
= atoi(WMGetTextFieldText(panel
->grayBrightnessT
));
2547 sprintf(tmp
, "%d", value
);
2548 WMSetTextFieldText(panel
->grayBrightnessT
, tmp
);
2549 WMSetSliderValue(panel
->grayBrightnessS
, value
);
2551 cpColor
.rgb
.red
= cpColor
.rgb
.green
= cpColor
.rgb
.blue
=
2552 rint((255.0*value
)/100.0);
2553 cpColor
.set
= cpRGB
;
2555 updateSwatch(panel
, cpColor
);
2556 panel
->lastChanged
= WMGrayModeColorPanel
;
2559 /******************* RGB Panel Functions *****************/
2562 rgbSliderCallback(WMWidget
*w
, void *data
)
2567 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2569 value
[0] = WMGetSliderValue(panel
->rgbRedS
);
2570 value
[1] = WMGetSliderValue(panel
->rgbGreenS
);
2571 value
[2] = WMGetSliderValue(panel
->rgbBlueS
);
2573 sprintf(tmp
, "%d", value
[0]);
2574 WMSetTextFieldText(panel
->rgbRedT
, tmp
);
2575 sprintf(tmp
, "%d", value
[1]);
2576 WMSetTextFieldText(panel
->rgbGreenT
, tmp
);
2577 sprintf(tmp
, "%d", value
[2]);
2578 WMSetTextFieldText(panel
->rgbBlueT
, tmp
);
2580 cpColor
.rgb
.red
= value
[0];
2581 cpColor
.rgb
.green
= value
[1];
2582 cpColor
.rgb
.blue
= value
[2];
2583 cpColor
.set
= cpRGB
;
2585 updateSwatch(panel
, cpColor
);
2586 panel
->lastChanged
= WMRGBModeColorPanel
;
2590 rgbTextFieldCallback(void *observerData
, WMNotification
*notification
)
2596 W_ColorPanel
*panel
= (W_ColorPanel
*)observerData
;
2598 value
[0] = atoi(WMGetTextFieldText(panel
->rgbRedT
));
2599 value
[1] = atoi(WMGetTextFieldText(panel
->rgbGreenT
));
2600 value
[2] = atoi(WMGetTextFieldText(panel
->rgbBlueT
));
2602 for (n
=0; n
< 3; n
++) {
2609 sprintf(tmp
, "%d", value
[0]);
2610 WMSetTextFieldText(panel
->rgbRedT
, tmp
);
2611 sprintf(tmp
, "%d", value
[1]);
2612 WMSetTextFieldText(panel
->rgbGreenT
, tmp
);
2613 sprintf(tmp
, "%d", value
[2]);
2614 WMSetTextFieldText(panel
->rgbBlueT
, tmp
);
2616 WMSetSliderValue(panel
->rgbRedS
, value
[0]);
2617 WMSetSliderValue(panel
->rgbGreenS
, value
[1]);
2618 WMSetSliderValue(panel
->rgbBlueS
, value
[2]);
2620 cpColor
.rgb
.red
= value
[0];
2621 cpColor
.rgb
.green
= value
[1];
2622 cpColor
.rgb
.blue
= value
[2];
2623 cpColor
.set
= cpRGB
;
2625 updateSwatch(panel
, cpColor
);
2626 panel
->lastChanged
= WMRGBModeColorPanel
;
2630 /******************* CMYK Panel Functions *****************/
2633 cmykSliderCallback(WMWidget
*w
, void *data
)
2638 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2641 value
[0] = WMGetSliderValue(panel
->cmykCyanS
);
2642 value
[1] = WMGetSliderValue(panel
->cmykMagentaS
);
2643 value
[2] = WMGetSliderValue(panel
->cmykYellowS
);
2644 value
[3] = WMGetSliderValue(panel
->cmykBlackS
);
2646 sprintf(tmp
, "%d", value
[0]);
2647 WMSetTextFieldText(panel
->cmykCyanT
, tmp
);
2648 sprintf(tmp
, "%d", value
[1]);
2649 WMSetTextFieldText(panel
->cmykMagentaT
, tmp
);
2650 sprintf(tmp
, "%d", value
[2]);
2651 WMSetTextFieldText(panel
->cmykYellowT
, tmp
);
2652 sprintf(tmp
, "%d", value
[3]);
2653 WMSetTextFieldText(panel
->cmykBlackT
, tmp
);
2655 scale
= 2.55 * (1.0 - (value
[3] / 100.0));
2656 cpColor
.rgb
.red
= rint((100.0 - value
[0]) * scale
);
2657 cpColor
.rgb
.green
= rint((100.0 - value
[1]) * scale
);
2658 cpColor
.rgb
.blue
= rint((100.0 - value
[2]) * scale
);
2659 cpColor
.set
= cpRGB
;
2661 updateSwatch(panel
, cpColor
);
2662 panel
->lastChanged
= WMCMYKModeColorPanel
;
2666 cmykTextFieldCallback(void *observerData
, WMNotification
*notification
)
2673 W_ColorPanel
*panel
= (W_ColorPanel
*)observerData
;
2675 value
[0] = atoi(WMGetTextFieldText(panel
->cmykCyanT
));
2676 value
[1] = atoi(WMGetTextFieldText(panel
->cmykMagentaT
));
2677 value
[2] = atoi(WMGetTextFieldText(panel
->cmykYellowT
));
2678 value
[3] = atoi(WMGetTextFieldText(panel
->cmykBlackT
));
2680 for (n
=0; n
< 4; n
++) {
2687 sprintf(tmp
, "%d", value
[0]);
2688 WMSetTextFieldText(panel
->cmykCyanT
, tmp
);
2690 sprintf(tmp
, "%d", value
[1]);
2691 WMSetTextFieldText(panel
->cmykMagentaT
, tmp
);
2693 sprintf(tmp
, "%d", value
[2]);
2694 WMSetTextFieldText(panel
->cmykYellowT
, tmp
);
2696 sprintf(tmp
, "%d", value
[3]);
2697 WMSetTextFieldText(panel
->cmykBlackT
, tmp
);
2699 WMSetSliderValue(panel
->cmykCyanS
, value
[0]);
2700 WMSetSliderValue(panel
->cmykMagentaS
, value
[1]);
2701 WMSetSliderValue(panel
->cmykYellowS
, value
[2]);
2702 WMSetSliderValue(panel
->cmykBlackS
, value
[3]);
2704 scale
= 2.55 * (1.0 - (value
[3] / 100.0));
2705 cpColor
.rgb
.red
= rint((100.0 - value
[0]) * scale
);
2706 cpColor
.rgb
.green
= rint((100.0 - value
[1]) * scale
);
2707 cpColor
.rgb
.blue
= rint((100.0 - value
[2]) * scale
);
2708 cpColor
.set
= cpRGB
;
2710 updateSwatch(panel
, cpColor
);
2711 panel
->lastChanged
= WMCMYKModeColorPanel
;
2714 /********************** HSB Panel Functions ***********************/
2717 hsbSliderCallback(WMWidget
*w
, void *data
)
2722 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
2724 value
[0] = WMGetSliderValue(panel
->hsbHueS
);
2725 value
[1] = WMGetSliderValue(panel
->hsbSaturationS
);
2726 value
[2] = WMGetSliderValue(panel
->hsbBrightnessS
);
2728 sprintf(tmp
, "%d", value
[0]);
2729 WMSetTextFieldText(panel
->hsbHueT
, tmp
);
2730 sprintf(tmp
, "%d", value
[1]);
2731 WMSetTextFieldText(panel
->hsbSaturationT
, tmp
);
2732 sprintf(tmp
, "%d", value
[2]);
2733 WMSetTextFieldText(panel
->hsbBrightnessT
, tmp
);
2735 cpColor
.hsv
.hue
= value
[0];
2736 cpColor
.hsv
.saturation
= value
[1]*2.55;
2737 cpColor
.hsv
.value
= value
[2]*2.55;
2738 cpColor
.set
= cpHSV
;
2740 convertCPColor(&cpColor
);
2742 panel
->lastChanged
= WMHSBModeColorPanel
;
2743 updateSwatch(panel
, cpColor
);
2745 if (w
!= panel
->hsbBrightnessS
)
2746 hsbUpdateBrightnessGradient(panel
);
2747 if (w
!= panel
->hsbSaturationS
)
2748 hsbUpdateSaturationGradient(panel
);
2749 if (w
!= panel
->hsbHueS
)
2750 hsbUpdateHueGradient(panel
);
2754 hsbTextFieldCallback(void *observerData
, WMNotification
*notification
)
2760 W_ColorPanel
*panel
= (W_ColorPanel
*)observerData
;
2762 value
[0] = atoi(WMGetTextFieldText(panel
->hsbHueT
));
2763 value
[1] = atoi(WMGetTextFieldText(panel
->hsbSaturationT
));
2764 value
[2] = atoi(WMGetTextFieldText(panel
->hsbBrightnessT
));
2771 for (n
=1; n
< 3; n
++) {
2778 sprintf(tmp
, "%d", value
[0]);
2779 WMSetTextFieldText(panel
->hsbHueT
, tmp
);
2780 sprintf(tmp
, "%d", value
[1]);
2781 WMSetTextFieldText(panel
->hsbSaturationT
, tmp
);
2782 sprintf(tmp
, "%d", value
[2]);
2783 WMSetTextFieldText(panel
->hsbBrightnessT
, tmp
);
2785 WMSetSliderValue(panel
->hsbHueS
, value
[0]);
2786 WMSetSliderValue(panel
->hsbSaturationS
, value
[1]);
2787 WMSetSliderValue(panel
->hsbBrightnessS
, value
[2]);
2789 cpColor
.hsv
.hue
= value
[0];
2790 cpColor
.hsv
.saturation
= value
[1]*2.55;
2791 cpColor
.hsv
.value
= value
[2]*2.55;
2792 cpColor
.set
= cpHSV
;
2794 convertCPColor(&cpColor
);
2796 panel
->lastChanged
= WMHSBModeColorPanel
;
2797 updateSwatch(panel
, cpColor
);
2799 hsbUpdateBrightnessGradient(panel
);
2800 hsbUpdateSaturationGradient(panel
);
2801 hsbUpdateHueGradient(panel
);
2805 hsbUpdateBrightnessGradient(W_ColorPanel
*panel
)
2807 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2811 WMPixmap
*sliderPxmp
;
2813 from
.red
= from
.green
= from
.blue
= 0;
2814 to
.hsv
= panel
->color
.hsv
;
2818 convertCPColor(&to
);
2820 sliderImg
= RRenderGradient(141, 16, &from
, &(to
.rgb
), RGRD_HORIZONTAL
);
2821 sliderPxmp
= WMCreatePixmapFromRImage(scr
, sliderImg
, 0);
2822 RDestroyImage(sliderImg
);
2825 W_PaintText(W_VIEW(panel
->hsbBrightnessS
), sliderPxmp
->pixmap
,
2826 panel
->font12
, 2, 0, 100, WALeft
, WMColorGC(scr
->white
),
2827 False
, "Brightness", strlen("Brightness"));
2829 wwarning(NO_MEMORY_ERR
);
2831 WMSetSliderImage(panel
->hsbBrightnessS
, sliderPxmp
);
2832 WMReleasePixmap(sliderPxmp
);
2836 hsbUpdateSaturationGradient(W_ColorPanel
*panel
)
2838 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2842 WMPixmap
*sliderPxmp
;
2844 from
.hsv
= panel
->color
.hsv
;
2845 from
.hsv
.saturation
= 0;
2847 convertCPColor(&from
);
2849 to
.hsv
= panel
->color
.hsv
;
2850 to
.hsv
.saturation
= 255;
2852 convertCPColor(&to
);
2854 sliderImg
= RRenderGradient(141, 16, &(from
.rgb
), &(to
.rgb
),
2856 sliderPxmp
= WMCreatePixmapFromRImage(scr
, sliderImg
, 0);
2857 RDestroyImage(sliderImg
);
2860 W_PaintText(W_VIEW(panel
->hsbSaturationS
), sliderPxmp
->pixmap
,
2861 panel
->font12
, 2, 0, 100, WALeft
,
2862 WMColorGC(from
.hsv
.value
< 128 ? scr
->white
: scr
->black
), False
,
2863 "Saturation", strlen("Saturation"));
2865 wwarning(NO_MEMORY_ERR
);
2867 WMSetSliderImage(panel
->hsbSaturationS
, sliderPxmp
);
2868 WMReleasePixmap(sliderPxmp
);
2872 hsbUpdateHueGradient(W_ColorPanel
*panel
)
2874 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2875 RColor
**colors
= NULL
;
2878 WMPixmap
*sliderPxmp
;
2881 hsvcolor
= panel
->color
.hsv
;
2883 colors
= wmalloc(sizeof(RColor
*)*(8));
2884 for (i
=0; i
<7; i
++) {
2885 hsvcolor
.hue
= (360*i
)/6;
2886 colors
[i
] = wmalloc(sizeof(RColor
));
2887 RHSVtoRGB(&hsvcolor
, colors
[i
]);
2891 sliderImg
= RRenderMultiGradient(141, 16, colors
, RGRD_HORIZONTAL
);
2892 sliderPxmp
= WMCreatePixmapFromRImage(scr
, sliderImg
, 0);
2893 RDestroyImage(sliderImg
);
2896 W_PaintText(W_VIEW(panel
->hsbHueS
), sliderPxmp
->pixmap
,
2897 panel
->font12
, 2, 0, 100, WALeft
,
2898 WMColorGC(hsvcolor
.value
< 128 ? scr
->white
: scr
->black
), False
,
2899 "Hue", strlen("Hue"));
2901 wwarning(NO_MEMORY_ERR
);
2903 WMSetSliderImage(panel
->hsbHueS
, sliderPxmp
);
2904 WMReleasePixmap(sliderPxmp
);
2912 /*************** Custom Palette Functions ****************/
2915 customRenderSpectrum(W_ColorPanel
*panel
)
2920 unsigned char *rp
, *gp
, *bp
;
2923 spectrum
= RCreateImage(SPECTRUM_WIDTH
, SPECTRUM_HEIGHT
, 0);
2925 for (y
=0; y
<360; y
++) {
2926 cpColor
.hsv
.hue
= y
;
2927 cpColor
.hsv
.saturation
= 0;
2928 cpColor
.hsv
.value
= 255;
2929 cpColor
.set
= cpHSV
;
2931 for (x
=0; x
<511; x
++) {
2932 ofs
= (y
* 511) + x
;
2934 convertCPColor(&cpColor
);
2936 rp
= spectrum
->data
[0] + ofs
;
2937 gp
= spectrum
->data
[1] + ofs
;
2938 bp
= spectrum
->data
[2] + ofs
;
2940 *rp
= (unsigned char)cpColor
.rgb
.red
;
2941 *gp
= (unsigned char)cpColor
.rgb
.green
;
2942 *bp
= (unsigned char)cpColor
.rgb
.blue
;
2945 cpColor
.hsv
.saturation
++;
2948 cpColor
.hsv
.value
--;
2951 if (panel
->customPaletteImg
) {
2952 RDestroyImage(panel
->customPaletteImg
);
2953 panel
->customPaletteImg
= NULL
;
2955 panel
->customPaletteImg
= spectrum
;
2961 customSetPalette(W_ColorPanel
*panel
)
2963 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
2968 image
= XCreatePixmap(scr
->display
, W_DRAWABLE(scr
), customPaletteWidth
,
2969 customPaletteHeight
, scr
->depth
);
2971 scaledImg
= RScaleImage(panel
->customPaletteImg
, customPaletteWidth
,
2972 customPaletteHeight
);
2973 RConvertImage(scr
->rcontext
, scaledImg
, &image
);
2974 RDestroyImage(scaledImg
);
2976 XCopyArea(scr
->display
, image
, panel
->customPaletteContentView
->window
,
2977 scr
->copyGC
, 0, 0, customPaletteWidth
, customPaletteHeight
, 0, 0);
2979 /* Check backimage exists. If it doesn't, allocate and fill it */
2980 if (!panel
->selectionBackImg
) {
2981 panel
->selectionBackImg
= XCreatePixmap(scr
->display
,
2982 panel
->customPaletteContentView
->window
, 4, 4, scr
->depth
);
2985 XCopyArea(scr
->display
, image
, panel
->selectionBackImg
, scr
->copyGC
,
2986 panel
->palx
-2, panel
->paly
-2, 4, 4, 0, 0);
2987 XCopyArea(scr
->display
, panel
->selectionImg
,
2988 panel
->customPaletteContentView
->window
, scr
->copyGC
, 0 , 0, 4, 4,
2989 panel
->palx
-2, panel
->paly
-2);
2990 XFreePixmap(scr
->display
, image
);
2992 panel
->palXRatio
= (float)(panel
->customPaletteImg
->width
) /
2993 (float)(customPaletteWidth
);
2994 panel
->palYRatio
= (float)(panel
->customPaletteImg
->height
) /
2995 (float)(customPaletteHeight
);
2997 item
= WMGetPopUpButtonSelectedItem (panel
->customPaletteHistoryBtn
);
3002 customPalettePositionSelection(W_ColorPanel
*panel
, int x
, int y
)
3004 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
3008 /* undraw selection */
3009 XCopyArea(scr
->display
, panel
->selectionBackImg
,
3010 panel
->customPaletteContentView
->window
, scr
->copyGC
, 0, 0, 4, 4,
3011 panel
->palx
-2, panel
->paly
-2);
3016 ofs
= rint(x
* panel
->palXRatio
) + rint(y
* panel
->palYRatio
) *
3017 panel
->customPaletteImg
->width
;
3019 panel
->color
.rgb
.red
= panel
->customPaletteImg
->data
[0][ofs
];
3020 panel
->color
.rgb
.green
= panel
->customPaletteImg
->data
[1][ofs
];
3021 panel
->color
.rgb
.blue
= panel
->customPaletteImg
->data
[2][ofs
];
3022 panel
->color
.set
= cpRGB
;
3024 updateSwatch(panel
, panel
->color
);
3025 panel
->lastChanged
= WMCustomPaletteModeColorPanel
;
3027 /* Redraw color selector (and make a backup of the part it will cover) */
3028 XCopyArea(scr
->display
, panel
->customPaletteContentView
->window
,
3029 panel
->selectionBackImg
, scr
->copyGC
, panel
->palx
-2, panel
->paly
-2,
3030 4, 4, 0, 0); /* "-2" is correction for hotspot location */
3031 XCopyArea(scr
->display
, panel
->selectionImg
,
3032 panel
->customPaletteContentView
->window
, scr
->copyGC
, 0, 0, 4, 4,
3033 panel
->palx
-2, panel
->paly
-2); /* see above */
3038 customPalettePositionSelectionOutBounds(W_ColorPanel
*panel
, int x
, int y
)
3044 if (x
>= customPaletteWidth
)
3045 x
= customPaletteWidth
-2;
3046 if (y
>= customPaletteHeight
)
3047 y
= customPaletteHeight
-2;
3049 customPalettePositionSelection(panel
, x
, y
);
3054 customPaletteHandleEvents(XEvent
*event
, void *data
)
3056 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3058 switch (event
->type
) {
3060 if (event
->xexpose
.count
!= 0) /* TODO Improve. */
3062 customSetPalette(panel
);
3068 customPaletteHandleActionEvents(XEvent
*event
, void *data
)
3070 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3073 switch (event
->type
) {
3075 x
= event
->xbutton
.x
;
3076 y
= event
->xbutton
.y
;
3078 if (getPickerPart(panel
, x
, y
) == CUSTOMPALETTE_PART
) {
3079 panel
->flags
.dragging
= 1;
3080 customPalettePositionSelection(panel
, x
, y
);
3085 panel
->flags
.dragging
= 0;
3086 if (!panel
->flags
.continuous
) {
3088 (*panel
->action
)(panel
, panel
->clientData
);
3093 x
= event
->xmotion
.x
;
3094 y
= event
->xmotion
.y
;
3096 if (panel
->flags
.dragging
) {
3097 if (getPickerPart(panel
, x
, y
) == CUSTOMPALETTE_PART
) {
3098 customPalettePositionSelection(panel
, x
, y
);
3101 customPalettePositionSelectionOutBounds(panel
, x
, y
);
3109 customPaletteMenuCallback(WMWidget
*w
, void *data
)
3111 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3112 int item
= WMGetPopUpButtonSelectedItem(panel
->customPaletteMenuBtn
);
3115 case CPmenuNewFromFile
:
3116 customPaletteMenuNewFromFile(panel
);
3119 customPaletteMenuRename(panel
);
3122 customPaletteMenuRemove(panel
);
3126 case CPmenuNewFromClipboard
:
3133 customPaletteMenuNewFromFile(W_ColorPanel
*panel
)
3135 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
3136 WMOpenPanel
*browseP
;
3138 char *filename
= NULL
;
3142 RImage
*tmpImg
= NULL
;
3144 if ((!panel
->lastBrowseDir
) || (strcmp(panel
->lastBrowseDir
,"\0") == 0))
3145 spath
= wexpandpath(wgethomedir());
3147 spath
= wexpandpath(panel
->lastBrowseDir
);
3149 browseP
= WMGetOpenPanel(scr
);
3150 WMSetFilePanelCanChooseDirectories(browseP
, 0);
3151 WMSetFilePanelCanChooseFiles(browseP
, 1);
3153 /* Get a filename */
3154 if (WMRunModalFilePanelForDirectory(browseP
, panel
->win
, spath
,
3155 "Open Palette", RSupportedFileFormats()) ) {
3156 filepath
= WMGetFilePanelFileName(browseP
);
3158 /* Get seperation position between path and filename */
3159 i
= strrchr(filepath
, '/') - filepath
+ 1;
3160 if (i
> strlen(filepath
))
3161 i
= strlen(filepath
);
3163 /* Store last browsed path */
3164 if (panel
->lastBrowseDir
)
3165 wfree(panel
->lastBrowseDir
);
3166 panel
->lastBrowseDir
= wmalloc((i
+1)*sizeof(char));
3167 strncpy(panel
->lastBrowseDir
, filepath
, i
);
3168 panel
->lastBrowseDir
[i
] = '\0';
3170 /* Get filename from path */
3171 filename
= wstrdup(filepath
+ i
);
3173 /* Check for duplicate files, and rename it if there are any */
3174 tmp
= wstrappend(panel
->configurationPath
, filename
);
3175 while (access (tmp
, F_OK
) == 0) {
3180 newName
= generateNewFilename(filename
);
3184 tmp
= wstrappend(panel
->configurationPath
, filename
);
3188 /* Copy image to $(gnustepdir)/Library/Colors/ &
3189 * Add filename to history menu */
3190 if (fetchFile (panel
->configurationPath
, filepath
, filename
) == 0) {
3192 /* filepath is a "local" path now the file has been copied */
3194 filepath
= wstrappend(panel
->configurationPath
, filename
);
3196 /* load the image & add menu entries */
3197 tmpImg
= RLoadImage(scr
->rcontext
, filepath
, 0);
3199 if (panel
->customPaletteImg
)
3200 RDestroyImage(panel
->customPaletteImg
);
3201 panel
->customPaletteImg
= tmpImg
;
3203 customSetPalette(panel
);
3204 WMAddPopUpButtonItem(panel
->customPaletteHistoryBtn
, filename
);
3206 panel
->currentPalette
= WMGetPopUpButtonNumberOfItems(
3207 panel
->customPaletteHistoryBtn
)-1;
3209 WMSetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
,
3210 panel
->currentPalette
);
3213 tmp
= wstrappend(panel
->configurationPath
, filename
);
3215 i
= remove(tmp
); /* Delete the file, it doesn't belong here */
3216 WMRunAlertPanel(scr
, panel
->win
, "File Error",
3217 "Invalid file format !", "OK", NULL
, NULL
);
3219 wsyserror("can't remove file %s", tmp
);
3220 WMRunAlertPanel(scr
, panel
->win
, "File Error",
3221 "Couldn't remove file from Configuration Directory !",
3229 WMFreeFilePanel(browseP
);
3236 customPaletteMenuRename(W_ColorPanel
*panel
)
3238 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
3239 char *toName
= NULL
;
3241 char *toPath
, *fromPath
;
3245 item
= WMGetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
);
3246 fromName
= WMGetPopUpButtonItem(panel
->customPaletteHistoryBtn
, item
);
3248 toName
= WMRunInputPanel(scr
, panel
->win
, "Rename", "Rename palette to:",
3249 fromName
, "OK", "Cancel");
3253 /* As some people do certain stupid things... */
3254 if (strcmp(toName
, fromName
) == 0) {
3259 /* For normal people */
3260 fromPath
= wstrappend(panel
->configurationPath
, fromName
);
3261 toPath
= wstrappend(panel
->configurationPath
, toName
);
3263 if (access (toPath
, F_OK
) == 0) {
3264 /* Careful, this palette exists already */
3265 if (WMRunAlertPanel(scr
, panel
->win
, "Warning",
3266 "Palette already exists !\n\nOverwrite ?", "No", "Yes",
3268 /* "No" = 0, "Yes" = 1 */
3269 int items
= WMGetPopUpButtonNumberOfItems(
3270 panel
->customPaletteHistoryBtn
);
3274 /* Remove from History list too */
3276 while ((index
< items
) && (strcmp(WMGetPopUpButtonItem(
3277 panel
->customPaletteHistoryBtn
, index
),
3281 if (index
< items
) {
3282 WMRemovePopUpButtonItem(panel
->customPaletteHistoryBtn
,
3297 if ( rename(fromPath
, toPath
) != 0)
3298 wsyserror("Couldn't rename palette %s to %s\n", fromName
, toName
);
3300 WMRemovePopUpButtonItem(panel
->customPaletteHistoryBtn
, item
);
3301 WMInsertPopUpButtonItem(panel
->customPaletteHistoryBtn
, item
,
3304 WMSetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
, item
);
3314 customPaletteMenuRemove(W_ColorPanel
*panel
)
3316 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
3322 item
= WMGetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
);
3324 tmp
= wstrappend( "This will permanently remove the palette ",
3325 WMGetPopUpButtonItem(panel
->customPaletteHistoryBtn
, item
));
3326 text
= wstrappend( tmp
,
3327 ".\n\nAre you sure you want to remove this palette ?");
3330 choice
= WMRunAlertPanel(scr
, panel
->win
, "Remove", text
, "Yes", "No",
3332 /* returns 0 (= "Yes") or 1 (="No") */
3337 tmp
= wstrappend(panel
->configurationPath
,
3338 WMGetPopUpButtonItem(panel
->customPaletteHistoryBtn
, item
));
3340 if ( remove(tmp
) == 0) {
3341 /* item-1 always exists */
3342 WMSetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
,
3345 customPaletteHistoryCallback(panel
->customPaletteHistoryBtn
,
3347 customSetPalette(panel
);
3349 WMRemovePopUpButtonItem(panel
->customPaletteHistoryBtn
, item
);
3352 wsyserror("Couldn't remove palette %s\n", tmp
);
3360 customPaletteHistoryCallback(WMWidget
*w
, void *data
)
3362 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3363 W_Screen
*scr
= WMWidgetScreen(panel
->win
);
3367 unsigned char perm_mask
;
3369 item
= WMGetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
);
3370 if (item
== panel
->currentPalette
)
3374 customRenderSpectrum(panel
);
3376 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRename
,
3378 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRemove
,
3381 /* Load file from configpath */
3382 filename
= wstrappend( panel
->configurationPath
,
3383 WMGetPopUpButtonItem(panel
->customPaletteHistoryBtn
, item
) );
3385 /* If the file corresponding to the item does not exist,
3386 * remove it from the history list and select the next one.
3388 perm_mask
= (access(filename
, F_OK
) == 0);
3390 /* File does not exist */
3392 WMSetPopUpButtonSelectedItem(panel
->customPaletteHistoryBtn
,
3394 WMRemovePopUpButtonItem(panel
->customPaletteHistoryBtn
, item
);
3395 customPaletteHistoryCallback(w
, data
);
3400 tmp
= RLoadImage(scr
->rcontext
, filename
, 0);
3402 if (panel
->customPaletteImg
) {
3403 RDestroyImage(panel
->customPaletteImg
);
3404 panel
->customPaletteImg
= NULL
;
3406 panel
->customPaletteImg
= tmp
;
3409 /* If the image is not writable, don't allow removing/renaming */
3410 perm_mask
= (access(filename
, W_OK
) == 0);
3411 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRename
,
3413 WMSetPopUpButtonItemEnabled(panel
->customPaletteMenuBtn
, CPmenuRemove
,
3418 customSetPalette(panel
);
3420 panel
->currentPalette
= item
;
3423 /************************* ColorList Panel Functions **********************/
3426 colorListPaintItem(WMList
*lPtr
, int index
, Drawable d
, char *text
,
3427 int state
, WMRect
*rect
)
3429 int width
, height
, x
, y
;
3430 RColor color
= *((RColor
*)WMGetListItem(lPtr
, index
)->clientData
);
3431 WMScreen
*scr
= WMWidgetScreen(lPtr
);
3432 Display
*dpy
= WMScreenDisplay(scr
);
3433 W_ColorPanel
*panel
= WMGetHangedData(lPtr
);
3434 WMColor
*white
= WMWhiteColor(scr
);
3435 WMColor
*black
= WMBlackColor(scr
);
3438 width
= rect
->size
.width
;
3439 height
= rect
->size
.height
;
3443 if (state
& WLDSSelected
)
3444 WMPaintColorSwatch(white
, d
, x
+15, y
, width
-15, height
);
3446 XClearArea(dpy
, d
, x
+15, y
, width
-15, height
, False
);
3448 fillColor
= WMCreateRGBColor(scr
, color
.red
*256, color
.green
*256,
3449 color
.blue
*256, False
);
3451 WMSetColorInGC(fillColor
, WMColorGC(fillColor
));
3452 WMPaintColorSwatch(fillColor
, d
, x
, y
, 15, 15);
3453 WMReleaseColor(fillColor
);
3455 WMDrawString(scr
, d
, WMColorGC(black
), panel
->font12
, x
+18, y
, text
,
3458 WMReleaseColor(white
);
3459 WMReleaseColor(black
);
3464 colorListSelect(WMWidget
*w
, void *data
)
3466 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3469 cpColor
.rgb
= *((RColor
*)WMGetListSelectedItem(w
)->clientData
);
3470 cpColor
.set
= cpRGB
;
3472 panel
->lastChanged
= WMColorListModeColorPanel
;
3473 updateSwatch(panel
, cpColor
);
3478 colorListColorMenuCallback(WMWidget
*w
, void *data
)
3480 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3481 int item
= WMGetPopUpButtonSelectedItem(panel
->colorListColorMenuBtn
);
3495 colorListListMenuCallback(WMWidget
*w
, void *data
)
3497 W_ColorPanel
*panel
= (W_ColorPanel
*)data
;
3498 int item
= WMGetPopUpButtonSelectedItem(panel
->colorListListMenuBtn
);
3502 /* New Color List */
3503 colorListListMenuNew(panel
);
3514 colorListListMenuNew(W_ColorPanel
*panel
)
3520 /*************** Panel Initialisation Functions *****************/
3523 wheelInit(W_ColorPanel
*panel
)
3527 if (panel
->color
.set
!= cpHSV
)
3528 convertCPColor(&panel
->color
);
3530 WMSetSliderValue(panel
->wheelBrightnessS
, 255 - panel
->color
.hsv
.value
);
3532 panel
->colx
= 2 + rint((colorWheelSize
/ 2.0) *
3533 (1 + ( panel
->color
.hsv
.saturation
/255.0) *
3534 cos( panel
->color
.hsv
.hue
* M_PI
/180.0)));
3535 panel
->coly
= 2 + rint((colorWheelSize
/ 2.0) *
3536 (1 + ( panel
->color
.hsv
.saturation
/255.0) *
3537 sin(- panel
->color
.hsv
.hue
*M_PI
/180.0)));
3539 wheelCalculateValues(panel
, panel
->color
.hsv
.value
);
3541 cpColor
= panel
->color
;
3542 cpColor
.hsv
.value
= 255;
3543 cpColor
.set
= cpHSV
;
3544 wheelUpdateBrightnessGradient(panel
, cpColor
);
3549 grayInit(W_ColorPanel
*panel
)
3554 if (panel
->color
.set
!= cpHSV
)
3555 convertCPColor(&panel
->color
);
3557 value
= rint(panel
->color
.hsv
.value
/2.55);
3558 WMSetSliderValue(panel
->grayBrightnessS
, value
);
3560 sprintf(tmp
, "%d", value
);
3561 WMSetTextFieldText(panel
->grayBrightnessT
, tmp
);
3566 rgbInit(W_ColorPanel
*panel
)
3570 if (panel
->color
.set
!= cpRGB
)
3571 convertCPColor(&panel
->color
);
3573 WMSetSliderValue(panel
->rgbRedS
, panel
->color
.rgb
.red
);
3574 WMSetSliderValue(panel
->rgbGreenS
, panel
->color
.rgb
.green
);
3575 WMSetSliderValue(panel
->rgbBlueS
, panel
->color
.rgb
.blue
);
3577 sprintf(tmp
, "%d", panel
->color
.rgb
.red
);
3578 WMSetTextFieldText(panel
->rgbRedT
, tmp
);
3579 sprintf(tmp
, "%d", panel
->color
.rgb
.green
);
3580 WMSetTextFieldText(panel
->rgbGreenT
, tmp
);
3581 sprintf(tmp
, "%d", panel
->color
.rgb
.blue
);
3582 WMSetTextFieldText(panel
->rgbBlueT
, tmp
);
3587 cmykInit(W_ColorPanel
*panel
)
3592 if (panel
->color
.set
!= cpRGB
)
3593 convertCPColor(&panel
->color
);
3595 value
[0] = rint((255-panel
->color
.rgb
.red
)/2.55);
3596 value
[1] = rint((255-panel
->color
.rgb
.green
)/2.55);
3597 value
[2] = rint((255-panel
->color
.rgb
.blue
)/2.55);
3599 WMSetSliderValue(panel
->cmykCyanS
, value
[0]);
3600 WMSetSliderValue(panel
->cmykMagentaS
, value
[1]);
3601 WMSetSliderValue(panel
->cmykYellowS
, value
[2]);
3602 WMSetSliderValue(panel
->cmykBlackS
, 0);
3604 sprintf(tmp
, "%d", value
[0]);
3605 WMSetTextFieldText(panel
->cmykCyanT
, tmp
);
3606 sprintf(tmp
, "%d", value
[1]);
3607 WMSetTextFieldText(panel
->cmykMagentaT
, tmp
);
3608 sprintf(tmp
, "%d", value
[2]);
3609 WMSetTextFieldText(panel
->cmykYellowT
, tmp
);
3610 WMSetTextFieldText(panel
->cmykBlackT
, "0");
3615 hsbInit(W_ColorPanel
*panel
)
3620 if (panel
->color
.set
!= cpHSV
)
3621 convertCPColor(&panel
->color
);
3623 value
[0] = panel
->color
.hsv
.hue
;
3624 value
[1] = rint(panel
->color
.hsv
.saturation
/2.55);
3625 value
[2] = rint(panel
->color
.hsv
.value
/2.55);
3627 WMSetSliderValue(panel
->hsbHueS
,value
[0]);
3628 WMSetSliderValue(panel
->hsbSaturationS
,value
[1]);
3629 WMSetSliderValue(panel
->hsbBrightnessS
,value
[2]);
3631 sprintf(tmp
, "%d", value
[0]);
3632 WMSetTextFieldText(panel
->hsbHueT
, tmp
);
3633 sprintf(tmp
, "%d", value
[1]);
3634 WMSetTextFieldText(panel
->hsbSaturationT
, tmp
);
3635 sprintf(tmp
, "%d", value
[2]);
3636 WMSetTextFieldText(panel
->hsbBrightnessT
, tmp
);
3638 hsbUpdateBrightnessGradient(panel
);
3639 hsbUpdateSaturationGradient(panel
);
3640 hsbUpdateHueGradient(panel
);
3645 /************************** Common utility functions ************************/
3648 fetchFile(char *toPath
, char *srcFile
, char *destFile
)
3655 if ((src
= open(srcFile
, O_RDONLY
)) == 0) {
3656 wsyserror("Could not open %s", srcFile
);
3660 tmp
= wstrappend(toPath
, destFile
);
3661 if ((dest
= open( tmp
, O_RDWR
|O_CREAT
, S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
))
3663 wsyserror("Could not create %s", tmp
);
3671 while ((n
= read(src
, buf
, BUFSIZE
)) > 0)
3673 if (write (dest
, buf
, n
) != n
) {
3674 wsyserror("Write error on file %s", destFile
);
3684 generateNewFilename(char *curName
)
3698 ((ptr
= strrchr(ptr
, '{')) == 0) ||
3699 sscanf(ptr
, "{%i}%c", &n
, &c
) != 1
3701 return wstrappend(curName
, " {1}");
3703 baseLen
= ptr
- curName
-1;
3705 newName
= wmalloc(baseLen
+ 16);
3706 strncpy(newName
, curName
, baseLen
);
3707 newName
[baseLen
] = 0;
3709 sprintf(&newName
[baseLen
], " {%i}", n
+1);
3716 convertCPColor(CPColor
*color
)
3718 unsigned short old_hue
= 0;
3720 switch (color
->set
) {
3722 wwarning("Color Panel: Color unspecified");
3725 old_hue
= color
->hsv
.hue
;
3726 RRGBtoHSV(&(color
->rgb
), &(color
->hsv
));
3728 /* In black the hue is undefined, and may change by conversion
3729 * Same for white. */
3731 ((color
->rgb
.red
== 0) &&
3732 (color
->rgb
.green
== 0) &&
3733 (color
->rgb
.blue
== 0)) ||
3734 ((color
->rgb
.red
== 0) &&
3735 (color
->rgb
.green
== 0) &&
3736 (color
->rgb
.blue
== 255))
3738 color
->hsv
.hue
= old_hue
;
3741 RHSVtoRGB(&(color
->hsv
), &(color
->rgb
));
3747 #define ABS_SHIFT(val, shift) \
3748 (((shift) > 0) ? (val) >> (shift) : (val) << -(shift))
3751 ulongToRColor(WMScreen
*scr
, unsigned long value
)
3754 XColor
*xcolor
= NULL
;
3756 if (!(xcolor
= wmalloc(sizeof(XColor
)) )) {
3757 wwarning(NO_MEMORY_ERR
);
3764 xcolor
->pixel
= value
;
3765 XQueryColor(scr
->display
, scr
->rcontext
->cmap
, xcolor
);
3767 color
.red
= xcolor
->red
>> 8;
3768 color
.green
= xcolor
->green
>> 8;
3769 color
.blue
= xcolor
->blue
>> 8;
3778 getShift(unsigned char value
)
3780 unsigned char i
= -1;
3795 #ifdef SHAPE_WAS_DEFINED
3796 #undef SHAPE_WAS_DEFINED