?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some more fixes from Alban to the color panel.
[wmaker-crm.git] / WINGs / wcolorpanel.c
blob664129ad4f9d061acf695d974d5a418ab1c46046
1 /*
2 * ColorPanel for WINGs
3 *
4 * by ]d : Original idea and basic initial code
5 * Pascal Hofstee : Code for wheeldrawing and calculating
6 * colors from it.
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 ;-)
14 *
15 */
16
17
18 /* TODO:
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.
23 * - Stored colors
24 * - Resizing
25 */
26
27 #include "../src/config.h"
28 #include "WINGsP.h"
29 #include <math.h>
30 #include <unistd.h>
31 #include <ctype.h>
32 #include <fcntl.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <dirent.h>
36 #include <errno.h>
37
38 /* BUG There's something fishy with shaped windows */
39 #if 1
40 #ifdef SHAPE
41 #define SHAPE_WAS_DEFINED
42 #undef SHAPE
43 #endif
44 #endif
45
46
47 #ifdef SHAPE
48 #include <X11/extensions/shape.h>
49 #endif
50
51
52 #ifndef PATH_MAX
53 # define PATH_MAX 1024
54 #endif
55
56
57 char *WMColorPanelColorChangedNotification = "WMColorPanelColorChangedNotification";
58
59 /*
60 * Error Messages
61 */
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"
65
66
67 /*
68 * Bitmaps for magnifying glass cursor
69 */
70
71 /* 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};
86
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};
100
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};
111
112
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 */
120 } MovingView;
121
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 ? */
126 cpNone,
127 cpRGB,
128 cpHSV
129 } set;
130 } CPColor;
131
132
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 */
137 } wheelMatrix;
138
139 typedef struct W_ColorPanel {
140 WMWindow *win;
141 WMFont *font8;
142 WMFont *font12;
143 void *clientData;
144 WMAction2 *action;
145
146 /* Common Stuff */
147 WMColorWell *colorWell;
148 WMButton *magnifyBtn;
149 WMButton *wheelBtn;
150 WMButton *slidersBtn;
151 WMButton *customPaletteBtn;
152 WMButton *colorListBtn;
153
154 /* Magnifying Glass */
155 MovingView *magnifyGlass;
156
157 /* ColorWheel Panel */
158 WMFrame *wheelFrm;
159 WMSlider *wheelBrightnessS;
160 WMView *wheelView;
161
162 /* Slider Panels */
163 WMFrame *slidersFrm;
164 WMFrame *seperatorFrm;
165 WMButton *grayBtn;
166 WMButton *rgbBtn;
167 WMButton *cmykBtn;
168 WMButton *hsbBtn;
169 /* Gray Scale Panel */
170 WMFrame *grayFrm;
171 WMLabel *grayMinL;
172 WMLabel *grayMaxL;
173 WMSlider *grayBrightnessS;
174 WMTextField *grayBrightnessT;
175 WMButton *grayPresetBtn[7];
176
177 /* RGB Panel */
178 WMFrame *rgbFrm;
179 WMLabel *rgbMinL;
180 WMLabel *rgbMaxL;
181 WMSlider *rgbRedS;
182 WMSlider *rgbGreenS;
183 WMSlider *rgbBlueS;
184 WMTextField *rgbRedT;
185 WMTextField *rgbGreenT;
186 WMTextField *rgbBlueT;
187
188 /* CMYK Panel */
189 WMFrame *cmykFrm;
190 WMLabel *cmykMinL;
191 WMLabel *cmykMaxL;
192 WMSlider *cmykCyanS;
193 WMSlider *cmykMagentaS;
194 WMSlider *cmykYellowS;
195 WMSlider *cmykBlackS;
196 WMTextField *cmykCyanT;
197 WMTextField *cmykMagentaT;
198 WMTextField *cmykYellowT;
199 WMTextField *cmykBlackT;
200
201 /* HSB Panel */
202 WMFrame *hsbFrm;
203 WMSlider *hsbHueS;
204 WMSlider *hsbSaturationS;
205 WMSlider *hsbBrightnessS;
206 WMTextField *hsbHueT;
207 WMTextField *hsbSaturationT;
208 WMTextField *hsbBrightnessT;
209
210 /* Custom Palette Panel*/
211 WMFrame *customPaletteFrm;
212 WMPopUpButton *customPaletteHistoryBtn;
213 WMFrame *customPaletteContentFrm;
214 WMPopUpButton *customPaletteMenuBtn;
215 WMView *customPaletteContentView;
216
217 /* Color List Panel */
218 WMFrame *colorListFrm;
219 WMPopUpButton *colorListHistoryBtn;
220 WMList *colorListContentLst;
221 WMPopUpButton *colorListColorMenuBtn;
222 WMPopUpButton *colorListListMenuBtn;
223
224 /* Look-Up Tables and Images */
225 wheelMatrix *wheelMtrx;
226 Pixmap wheelImg;
227 Pixmap selectionImg;
228 Pixmap selectionBackImg;
229 RImage *customPaletteImg;
230 char *lastBrowseDir;
231
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
239 CustomPaletteMode */
240 float palXRatio, palYRatio; /* Ratios in x & y between
241 original and scaled
242 palettesize */
243 int currentPalette;
244 char *configurationPath;
245
246 struct {
247 unsigned int continuous:1;
248 unsigned int dragging:1;
249 } flags;
250 } W_ColorPanel;
251
252 enum {
253 CPmenuNewFromFile,
254 CPmenuRename,
255 CPmenuRemove,
256 CPmenuCopy,
257 CPmenuNewFromClipboard
258 } customPaletteMenuItem;
259
260 enum {
261 CLmenuAdd,
262 CLmenuRename,
263 CLmenuRemove
264 } colorListMenuItem;
265
266
267 #define PWIDTH 194
268 #define PHEIGHT 266
269 #define colorWheelSize 150
270 #define customPaletteWidth 182
271 #define customPaletteHeight 106
272 #define knobThickness 8
273
274 #define SPECTRUM_WIDTH 511
275 #define SPECTRUM_HEIGHT 360
276
277 #define COLORWHEEL_PART 1
278 #define CUSTOMPALETTE_PART 2
279 #define BUFSIZE 1024
280
281 #ifndef RGBTXT
282 #define RGBTXT "/usr/X11R6/lib/X11/rgb.txt"
283 #endif
284
285 #define MAX_LENGTH 1024
286
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);
293
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);
298
299 static void closeWindowCallback(WMWidget *w, void *data);
300
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,
306 int x2, int y2);
307 static XImage* magnifyGetImage(WMScreen *scr, XImage *image, int x, int y,
308 int w, int h);
309
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);
317
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);
323
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);
328
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);
333
334 static void rgbSliderCallback(WMWidget *w, void *data);
335 static void rgbTextFieldCallback(void *observerData,
336 WMNotification *notification);
337
338 static void cmykSliderCallback(WMWidget *w, void *data);
339 static void cmykTextFieldCallback(void *observerData,
340 WMNotification *notification);
341
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);
348
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,
355 int x, int y);
356 static void customPaletteMenuCallback(WMWidget *w, void *data);
357 static void customPaletteHistoryCallback(WMWidget *w, void *data);
358
359 static void customPaletteMenuNewFromFile(W_ColorPanel *panel);
360 static void customPaletteMenuRename(W_ColorPanel *panel);
361 static void customPaletteMenuRemove(W_ColorPanel *panel);
362
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);
369
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);
375
376
377
378 void
379 WMSetColorPanelAction(WMColorPanel *panel, WMAction2 *action, void *data)
380 {
381 panel->action = action;
382 panel->clientData = data;
383 }
384
385 static WMColorPanel*
386 makeColorPanel(WMScreen *scrPtr, char *name)
387 {
388 WMColorPanel *panel;
389 RImage *image;
390 WMPixmap *pixmap;
391 RColor from;
392 RColor to;
393 WMColor *textcolor, *graybuttoncolor;
394 int i;
395 GC bgc = WMColorGC(scrPtr->black);
396 GC wgc = WMColorGC(scrPtr->white);
397
398
399 panel = wmalloc(sizeof(WMColorPanel));
400 memset(panel, 0, sizeof(WMColorPanel));
401
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 */
409
410 panel->font8 = WMSystemFontOfSize(scrPtr, 8);
411 panel->font12 = WMSystemFontOfSize(scrPtr, 12);
412
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);
418
419
420 /* Set Default ColorPanel Mode(s) */
421 panel->mode = WMWheelModeColorPanel;
422 panel->lastChanged = 0;
423 panel->slidersmode = WMRGBModeColorPanel;
424 panel->configurationPath = wstrappend(wusergnusteppath(),
425 "/Library/Colors/");
426
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);
432
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);
440
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);
448
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);
456
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);
464
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);
472
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);
477
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);
483
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);
488
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);
493
494 WMCreateEventHandler(panel->wheelView, ExposureMask, wheelHandleEvents,
495 panel);
496
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,
503 panel);
504 WMSetSliderKnobThickness(panel->wheelBrightnessS, knobThickness);
505
506 panel->wheelMtrx = wheelCreateMatrix(colorWheelSize+4, colorWheelSize+4);
507 wheelInitMatrix(panel);
508
509
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);
515
516 panel->seperatorFrm = WMCreateFrame(panel->slidersFrm);
517 WMSetFrameRelief(panel->seperatorFrm, WRPushed);
518 WMResizeWidget(panel->seperatorFrm, PWIDTH - 8, 2);
519 WMMoveWidget(panel->seperatorFrm, 0, 1);
520
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);
528
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);
536
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);
544
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);
552
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);
557
558 textcolor = WMDarkGrayColor(scrPtr);
559
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);
565
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);
573
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);
581
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,
589 panel);
590
591 from.red = 0;
592 from.green = 0;
593 from.blue = 0;
594
595 to.red = 255;
596 to.green = 255;
597 to.blue = 255;
598
599 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
600 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
601 RDestroyImage(image);
602
603 if (pixmap)
604 W_PaintText(W_VIEW(panel->grayBrightnessS), pixmap->pixmap,
605 panel->font12, 2, 0, 100, WALeft, WMColorGC(scrPtr->white),
606 False, "Brightness", strlen("Brightness"));
607 else
608 wwarning(NO_MEMORY_ERR);
609
610 WMSetSliderImage(panel->grayBrightnessS, pixmap);
611 WMReleasePixmap(pixmap);
612
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);
619
620 for (i=0; i < 7; i++) {
621 pixmap = WMCreatePixmap(scrPtr, 13, 13, scrPtr->depth, False);
622
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);
627
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);
636
637 }
638
639 /* End of GrayScale Panel */
640
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);
646
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);
654
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);
662
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);
670
671 to.red = 255;
672 to.green = 0;
673 to.blue = 0;
674
675 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
676 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
677 RDestroyImage(image);
678
679 if (pixmap)
680 W_PaintText(W_VIEW(panel->rgbRedS), pixmap->pixmap, panel->font12,
681 2, 0, 100, WALeft, WMColorGC(scrPtr->white), False, "Red",
682 strlen("Red"));
683 else
684 wwarning(NO_MEMORY_ERR);
685
686 WMSetSliderImage(panel->rgbRedS, pixmap);
687 WMReleasePixmap(pixmap);
688
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);
695
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);
703
704 to.red = 0;
705 to.green = 255;
706 to.blue = 0;
707
708 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
709 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
710 RDestroyImage(image);
711
712 if (pixmap)
713 W_PaintText(W_VIEW(panel->rgbGreenS), pixmap->pixmap, panel->font12,
714 2, 0, 100, WALeft, WMColorGC(scrPtr->white), False, "Green",
715 strlen("Green"));
716 else
717 wwarning(NO_MEMORY_ERR);
718
719 WMSetSliderImage(panel->rgbGreenS, pixmap);
720 WMReleasePixmap(pixmap);
721
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);
728
729
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);
737
738 to.red = 0;
739 to.green = 0;
740 to.blue = 255;
741
742 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
743 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
744 RDestroyImage(image);
745
746 if (pixmap)
747 W_PaintText(W_VIEW(panel->rgbBlueS), pixmap->pixmap, panel->font12,
748 2, 0, 100, WALeft, WMColorGC(scrPtr->white), False, "Blue",
749 strlen("Blue"));
750 else
751 wwarning(NO_MEMORY_ERR);
752
753 WMSetSliderImage(panel->rgbBlueS, pixmap);
754 WMReleasePixmap(pixmap);
755
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 */
763
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);
769
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);
777
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);
785
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);
793
794 from.red = 255;
795 from.green = 255;
796 from.blue = 255;
797
798 to.red = 0;
799 to.green = 255;
800 to.blue = 255;
801
802 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
803 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
804 RDestroyImage(image);
805
806 if (pixmap)
807 W_PaintText(W_VIEW(panel->cmykCyanS), pixmap->pixmap, panel->font12,
808 2, 0, 100, WALeft, WMColorGC(scrPtr->black), False, "Cyan",
809 strlen("Cyan"));
810 else
811 wwarning(NO_MEMORY_ERR);
812
813 WMSetSliderImage(panel->cmykCyanS, pixmap);
814 WMReleasePixmap(pixmap);
815
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);
822
823
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);
831
832 to.red = 255;
833 to.green = 0;
834 to.blue = 255;
835
836 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
837 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
838 RDestroyImage(image);
839
840 if (pixmap)
841 W_PaintText(W_VIEW(panel->cmykMagentaS), pixmap->pixmap, panel->font12,
842 2, 0, 100, WALeft, WMColorGC(scrPtr->black), False, "Magenta",
843 strlen("Magenta"));
844 else
845 wwarning(NO_MEMORY_ERR);
846
847 WMSetSliderImage(panel->cmykMagentaS, pixmap);
848 WMReleasePixmap(pixmap);
849
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);
856
857
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);
865
866 to.red = 255;
867 to.green = 255;
868 to.blue = 0;
869
870 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
871 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
872 RDestroyImage(image);
873
874 if (pixmap)
875 W_PaintText(W_VIEW(panel->cmykYellowS), pixmap->pixmap, panel->font12,
876 2, 0, 100, WALeft, WMColorGC(scrPtr->black), False, "Yellow",
877 strlen("Yellow"));
878 else
879 wwarning(NO_MEMORY_ERR);
880
881 WMSetSliderImage(panel->cmykYellowS, pixmap);
882 WMReleasePixmap(pixmap);
883
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);
890
891
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);
900
901 to.red = 0;
902 to.green = 0;
903 to.blue = 0;
904
905 image = RRenderGradient(141, 16, &from, &to, RGRD_HORIZONTAL);
906 pixmap = WMCreatePixmapFromRImage(scrPtr, image, 0);
907 RDestroyImage(image);
908
909 if (pixmap)
910 W_PaintText(W_VIEW(panel->cmykBlackS), pixmap->pixmap, panel->font12,
911 2, 0, 100, WALeft, WMColorGC(scrPtr->black), False, "Black",
912 strlen("Black"));
913 else
914 wwarning(NO_MEMORY_ERR);
915
916 WMSetSliderImage(panel->cmykBlackS, pixmap);
917 WMReleasePixmap(pixmap);
918
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 */
926
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);
932
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);
940
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);
947
948
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);
956
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);
963
964
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);
972
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 */
980
981
982 WMReleaseColor(textcolor);
983
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);
989
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);
999
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);
1004
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);
1011
1012 /* Create event handler to handle expose/click events in CustomPalette */
1013 WMCreateEventHandler(panel->customPaletteContentView,
1014 ButtonPressMask|ButtonReleaseMask|EnterWindowMask| LeaveWindowMask |
1015 ButtonMotionMask, customPaletteHandleActionEvents, panel);
1016
1017 WMCreateEventHandler(panel->customPaletteContentView, ExposureMask,
1018 customPaletteHandleEvents, panel);
1019
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);
1027
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");
1033
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);
1039
1040 customRenderSpectrum(panel);
1041 panel->currentPalette = 0;
1042 panel->palx = customPaletteWidth/2;
1043 panel->paly = customPaletteHeight/2;
1044
1045
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);
1051
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);
1060
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);
1067
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);
1075
1076 WMAddPopUpButtonItem(panel->colorListColorMenuBtn, "Add...");
1077 WMAddPopUpButtonItem(panel->colorListColorMenuBtn, "Rename...");
1078 WMAddPopUpButtonItem(panel->colorListColorMenuBtn, "Remove");
1079
1080 WMSetPopUpButtonItemEnabled(panel->colorListColorMenuBtn, CLmenuAdd, 0);
1081 WMSetPopUpButtonItemEnabled(panel->colorListColorMenuBtn, CLmenuRename, 0);
1082 WMSetPopUpButtonItemEnabled(panel->colorListColorMenuBtn, CLmenuRemove, 0);
1083
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,
1091 PHEIGHT - 130);
1092
1093 WMAddPopUpButtonItem(panel->colorListListMenuBtn, "New...");
1094 WMAddPopUpButtonItem(panel->colorListListMenuBtn, "Rename...");
1095 WMAddPopUpButtonItem(panel->colorListListMenuBtn, "Remove");
1096
1097 WMSetPopUpButtonItemEnabled(panel->colorListListMenuBtn, CLmenuAdd, 0);
1098 WMSetPopUpButtonItemEnabled(panel->colorListListMenuBtn, CLmenuRename, 0);
1099 WMSetPopUpButtonItemEnabled(panel->colorListListMenuBtn, CLmenuRemove, 0);
1100
1101 WMRealizeWidget(panel->win);
1102 WMMapSubwidgets(panel->win);
1103
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);
1113
1114 /* Pixmap to indicate selection positions
1115 * wheelframe MUST be mapped.
1116 */
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);
1121
1122 readConfiguration(panel);
1123 readXColors(panel);
1124
1125 return panel;
1126 }
1127
1128
1129 WMColorPanel*
1130 WMGetColorPanel(WMScreen *scrPtr)
1131 {
1132 WMColorPanel *panel;
1133
1134 if (scrPtr->sharedColorPanel)
1135 return scrPtr->sharedColorPanel;
1136
1137 panel = makeColorPanel(scrPtr, "colorPanel");
1138
1139 scrPtr->sharedColorPanel = panel;
1140
1141 return panel;
1142 }
1143
1144
1145 void
1146 WMFreeColorPanel(WMColorPanel *panel)
1147 {
1148 W_Screen *scr = WMWidgetScreen(panel->win);
1149
1150 if (panel == scr->sharedColorPanel) {
1151 scr->sharedColorPanel = NULL;
1152 }
1153
1154 if (!panel)
1155 return;
1156
1157 WMRemoveNotificationObserver(panel);
1158 WMUnmapWidget(panel->win);
1159
1160 /* fonts */
1161 WMReleaseFont(panel->font8);
1162 WMReleaseFont(panel->font12);
1163
1164 /* pixmaps */
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);
1173
1174 /* structs */
1175 if (panel->lastBrowseDir)
1176 wfree(panel->lastBrowseDir);
1177 if (panel->configurationPath)
1178 wfree(panel->configurationPath);
1179
1180 WMDestroyWidget(panel->win);
1181
1182 wfree(panel);
1183 }
1184
1185
1186 void
1187 WMCloseColorPanel(WMColorPanel *panel)
1188 {
1189 WMFreeColorPanel(panel);
1190 }
1191
1192
1193 void
1194 WMShowColorPanel(WMColorPanel *panel)
1195 {
1196 WMScreen *scr = WMWidgetScreen(panel->win);
1197 WMColor *white = WMWhiteColor(scr);
1198
1199 if (panel->color.set == cpNone)
1200 WMSetColorPanelColor(panel, white);
1201 WMReleaseColor(white);
1202
1203 if (panel->mode != WMWheelModeColorPanel)
1204 WMPerformButtonClick(panel->wheelBtn);
1205
1206 WMMapWidget(panel->win);
1207 }
1208
1209
1210 static void
1211 closeWindowCallback(WMWidget *w, void *data)
1212 {
1213 W_ColorPanel *panel = (W_ColorPanel*)data;
1214
1215 WMCloseColorPanel(panel);
1216 }
1217
1218
1219 static void
1220 readConfiguration(W_ColorPanel *panel)
1221 {
1222 /* XXX Doesn't take care of "invalid" files */
1223
1224 DIR *dPtr;
1225 struct dirent *dp;
1226 struct stat stat_buf;
1227 int item;
1228
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,
1238 "File Error",
1239 "Could not create ColorPanel configuration directory",
1240 "OK", NULL, NULL);
1241 }
1242 return;
1243 }
1244
1245 if (!(dPtr = opendir(panel->configurationPath))) {
1246 wwarning(NO_FILE_ERR, "%s", panel->configurationPath);
1247 return;
1248 }
1249
1250 while ((dp = readdir(dPtr)) != NULL) {
1251 unsigned int perm_mask;
1252 char *path = wstrappend(panel->configurationPath,
1253 dp->d_name);
1254
1255 if (dp->d_name[0] != '.') {
1256 item = WMGetPopUpButtonNumberOfItems(
1257 panel->customPaletteHistoryBtn);
1258 WMAddPopUpButtonItem(panel->customPaletteHistoryBtn, dp->d_name);
1259
1260 perm_mask = (access(path, R_OK) == 0);
1261 WMSetPopUpButtonItemEnabled(panel->customPaletteHistoryBtn,
1262 item, perm_mask);
1263 }
1264 free(path);
1265 }
1266 (void)closedir(dPtr);
1267 }
1268
1269
1270 static void
1271 readXColors(W_ColorPanel *panel)
1272 {
1273 struct stat stat_buf;
1274 FILE *rgbtxt;
1275 char line[MAX_LENGTH];
1276 int red, green, blue;
1277 char name[48];
1278 RColor *color;
1279 WMListItem *item;
1280
1281 if (stat(RGBTXT, &stat_buf) != 0) {
1282 wsyserror(NO_FILE_ERR, " %s", RGBTXT);
1283 return;
1284 }
1285 else {
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;
1295 }
1296 }
1297 fclose(rgbtxt);
1298 }
1299 else {
1300 wsyserror(NO_FILE_ERR, "%s", RGBTXT);
1301 }
1302 }
1303 }
1304
1305
1306 void
1307 WMSetColorPanelPickerMode(WMColorPanel *panel, WMColorPanelMode mode)
1308 {
1309 W_Screen *scr = WMWidgetScreen(panel->win);
1310
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;
1317 }
1318 }
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;
1333 }
1334 }
1335 if (mode != WMColorListModeColorPanel)
1336 WMUnmapWidget(panel->colorListFrm);
1337 if ((mode != WMGrayModeColorPanel) && (mode != WMRGBModeColorPanel) &&
1338 (mode != WMCMYKModeColorPanel) && (mode != WMHSBModeColorPanel))
1339 WMUnmapWidget(panel->slidersFrm);
1340 else
1341 panel->slidersmode = mode;
1342
1343 if (mode == WMWheelModeColorPanel) {
1344 WMMapWidget(panel->wheelFrm);
1345 WMSetButtonSelected(panel->wheelBtn, True);
1346 if (panel->lastChanged != WMWheelModeColorPanel)
1347 wheelInit(panel);
1348 wheelRender(panel);
1349 wheelPaint(panel);
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)
1357 grayInit(panel);
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)
1365 rgbInit(panel);
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)
1373 cmykInit(panel);
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)
1381 hsbInit(panel);
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);
1389 }
1390
1391 panel->mode = mode;
1392 }
1393
1394
1395 WMColor*
1396 WMGetColorPanelColor(WMColorPanel *panel)
1397 {
1398 return WMGetColorWellColor(panel->colorWell);
1399 }
1400
1401
1402 void
1403 WMSetColorPanelColor(WMColorPanel *panel, WMColor *color)
1404 {
1405 WMSetColorWellColor(panel->colorWell, color);
1406
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;
1411
1412 if (panel->mode == panel->lastChanged)
1413 panel->lastChanged = 0;
1414
1415 WMSetColorPanelPickerMode(panel, panel->mode);
1416 }
1417
1418
1419 static void
1420 updateSwatch(WMColorPanel *panel, CPColor color)
1421 {
1422 WMScreen *scr = WMWidgetScreen(panel->win);
1423 WMColor *wellcolor;
1424
1425 if (color.set != cpRGB)
1426 convertCPColor(&color);
1427
1428 panel->color = color;
1429
1430 wellcolor = WMCreateRGBColor(scr, color.rgb.red << 8,
1431 color.rgb.green << 8,
1432 color.rgb.blue << 8, True);
1433
1434 WMSetColorWellColor(panel->colorWell, wellcolor);
1435 WMReleaseColor(wellcolor);
1436
1437 if (!panel->flags.dragging || panel->flags.continuous) {
1438 if (panel->action)
1439 (*panel->action)(panel, panel->clientData);
1440
1441 WMPostNotificationName(WMColorPanelColorChangedNotification, panel,
1442 NULL);
1443 }
1444 }
1445
1446 static void
1447 modeButtonCallback(WMWidget *w, void *data)
1448 {
1449 W_ColorPanel *panel = (W_ColorPanel*)(data);
1450
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);
1467 }
1468
1469
1470 /****************** Magnifying Cursor Functions *******************/
1471
1472 static XImage*
1473 magnifyGetImage(WMScreen *scr, XImage *image, int x, int y, int w, int h)
1474 {
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);
1478
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.
1482 */
1483 if (!(image = XGetImage(scr->display, scr->rootWin,
1484 x - Cursor_x_hot,
1485 y - Cursor_y_hot,
1486 w, h, AllPlanes, ZPixmap)))
1487 wwarning(X_ERR);
1488
1489 return image;
1490 }
1491
1492 /* Coordinate correction for back pixmap
1493 * if magnifying glass is at screen-borders
1494 */
1495
1496 /* Figure 1: Shifting of rectangle-to-grab at top/left screen borders
1497 * Hatched area is beyond screen border.
1498 *
1499 * |<-Cursor_x_hot->|
1500 * ________________|_____
1501 * |/ / / / / / /| | |
1502 * | / / / / / / |(x,y) |
1503 * |/_/_/_/_/_/_/|________|
1504 * |<----x0----->|<--w0-->|
1505 * 0
1506 */
1507
1508 /* Figure 2: Shifting of rectangle-to-grab at bottom/right
1509 * screen borders
1510 * Hatched area is beyond screen border
1511 *
1512 * |<-Cursor_x_hot->|
1513 * ________________|_______________
1514 * | | | / / / / / /|
1515 * | (x,y)|/ / / / / / |
1516 * |___________________|_/_/_/_/_/_/|
1517 * |<-------w0-------->| |
1518 * |<---------------w--|----------->|
1519 * | |
1520 * x0 Displaywidth-1
1521 */
1522
1523 if (x < Cursor_x_hot) { /* see fig. 1 */
1524 x0 = Cursor_x_hot - x;
1525 w0 = w - x0;
1526 }
1527
1528 if (displayWidth -1 < x - Cursor_x_hot + w) { /* see fig. 2 */
1529 w0 = (displayWidth) - (x - Cursor_x_hot);
1530 }
1531
1532 if (y < Cursor_y_hot) { /* see fig. 1 */
1533 y0 = Cursor_y_hot - y;
1534 h0 = h - y0;
1535 }
1536
1537 if (displayHeight -1 < y - Cursor_y_hot + h) { /* see fig. 2 */
1538 h0 = (displayHeight) - (y - Cursor_y_hot);
1539 }
1540 /* end of coordinate correction */
1541
1542
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.
1546 */
1547 if (!XGetSubImage(scr->display, scr->rootWin,
1548 x - Cursor_x_hot + x0,
1549 y - Cursor_y_hot + y0,
1550 w0, h0, AllPlanes, ZPixmap,
1551 image, x0, y0))
1552 wwarning(X_ERR);
1553
1554 return NULL;
1555 }
1556
1557
1558 static void
1559 magnifyGetImageStored(WMColorPanel *panel, int x1, int y1, int x2, int y2)
1560 {
1561 /* (x1, y1) = topleft corner of existing rectangle
1562 * (x2, y2) = topleft corner of new position
1563 */
1564
1565 W_Screen *scr = WMWidgetScreen(panel->win);
1566 int xa = 0, ya = 0, xb = 0, yb = 0;
1567 int width, height;
1568 const int dx = abs(x2 - x1),
1569 dy = abs(y2 - y1);
1570 XImage *image;
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);
1577
1578 if ((dx == 0) && (dy == 0) && panel->magnifyGlass->image)
1579 return; /* No movement */
1580
1581 if (x1 < x2)
1582 xa = dx;
1583 else
1584 xb = dx;
1585
1586 if (y1 < y2)
1587 ya = dy;
1588 else
1589 yb = dy;
1590
1591 width = Cursor_mask_width - dx;
1592 height = Cursor_mask_height - dy;
1593
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
1597 * off screen).
1598 * Destroying the image and setting it to NULL will achieve that later on.
1599 *
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.
1603 */
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;
1609 }
1610 } else {
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) {
1616 wwarning(X_ERR);
1617 return; /* X returned a NULL from XSubImage */
1618 }
1619 }
1620 }
1621
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;
1627 return;
1628 }
1629
1630 /* Copy previously stored rectangle on covered part of image */
1631 if (panel->magnifyGlass->image && panel->magnifyGlass->dirtyRect) {
1632 int old_height;
1633
1634 /* "width" and "height" are used as coordinates here,
1635 * and run from [0...width-1] and [0...height-1] respectively.
1636 */
1637 width--;
1638 height--;
1639 old_height = height;
1640
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;
1647 }
1648
1649 return;
1650 }
1651
1652
1653 static Pixmap
1654 magnifyCreatePixmap(WMColorPanel *panel)
1655 {
1656 W_Screen *scr = WMWidgetScreen(panel->win);
1657 int u, v;
1658 #ifndef SHAPE
1659 Pixmap pixmap;
1660 #endif
1661 unsigned long color;
1662
1663 if (!panel->magnifyGlass->image)
1664 return None;
1665
1666 if (!panel->magnifyGlass->magPix)
1667 return None;
1668
1669 /*
1670 * Copy an area of only 5x5 pixels from the center of the image.
1671 */
1672 for (u = 0; u < 5; u++) {
1673 for (v = 0; v < 5; v++) {
1674 color = XGetPixel(panel->magnifyGlass->image, u + 9, v + 9);
1675
1676 XSetForeground(scr->display, scr->copyGC, color);
1677
1678 if ((u == 2) && (v == 2)) /* (2,2) is center pixel (unmagn.) */
1679 panel->magnifyGlass->color = ulongToRColor(scr, color);
1680
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
1684 * _ _ _ _ _
1685 * |_|_|_|_|_|
1686 * ^------- center of center square == Cursor_x_hot
1687 */
1688 XFillRectangle(scr->display, panel->magnifyGlass->magPix,
1689 scr->copyGC,
1690 u * 5 + (u == 0 ? 0 : -1), v * 5 + (v == 0 ? 0 : -1),
1691 (u == 0 ? 4 : 5), (v == 0 ? 4 : 5));
1692 }
1693 }
1694
1695 #ifdef SHAPE
1696 return panel->magnifyGlass->magPix;
1697 #else
1698 pixmap = XCreatePixmap(scr->display, W_DRAWABLE(scr), Cursor_mask_width,
1699 Cursor_mask_height, scr->depth);
1700 if (!pixmap)
1701 return None;
1702
1703 XPutImage(scr->display, pixmap, scr->copyGC, panel->magnifyGlass->image,
1704 0, 0, 0, 0, Cursor_mask_width, Cursor_mask_height);
1705
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 */
1710
1711 return pixmap;
1712 #endif
1713
1714 }
1715
1716
1717 static WMView*
1718 magnifyCreateView(W_ColorPanel *panel)
1719 {
1720 W_Screen *scr = WMWidgetScreen(panel->win);
1721 WMView *magView;
1722
1723 magView = W_CreateTopView(scr);
1724 if (!magView)
1725 return NULL;
1726
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;
1732
1733 W_ResizeView(magView, Cursor_mask_width, Cursor_mask_height);
1734
1735 W_RealizeView(magView);
1736
1737 return magView;
1738 }
1739
1740
1741 static Cursor
1742 magnifyGrabPointer(W_ColorPanel *panel)
1743 {
1744 W_Screen *scr = WMWidgetScreen(panel->win);
1745 Pixmap magPixmap, magPixmap2;
1746 Cursor magCursor;
1747 XColor fgColor = {0, 0,0,0, DoRed|DoGreen|DoBlue};
1748 XColor bgColor = {0, 0xbf00, 0xa000, 0x5000, DoRed|DoGreen|DoBlue};
1749
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);
1755
1756 magCursor = XCreatePixmapCursor(scr->display, magPixmap, magPixmap2,
1757 &fgColor, &bgColor, Cursor_x_hot, Cursor_y_hot);
1758
1759 XFreePixmap(scr->display, magPixmap);
1760 XFreePixmap(scr->display, magPixmap2);
1761
1762 XRecolorCursor(scr->display, magCursor, &fgColor, &bgColor);
1763
1764 /* Set up Pointer */
1765 XGrabPointer (scr->display, panel->magnifyGlass->view->window, True,
1766 PointerMotionMask | ButtonPressMask,
1767 GrabModeAsync, GrabModeAsync,
1768 scr->rootWin, magCursor, CurrentTime);
1769
1770 return magCursor;
1771 }
1772
1773
1774 static WMPoint
1775 magnifyInitialize(W_ColorPanel *panel)
1776 {
1777 W_Screen *scr = WMWidgetScreen(panel->win);
1778 int x, y, u, v;
1779 unsigned int mask;
1780 Pixmap pixmap, clip_mask;
1781 WMPoint point;
1782 Window root_return, child_return;
1783
1784 clip_mask = XCreatePixmapFromBitmapData(scr->display, W_DRAWABLE(scr),
1785 (char *)Cursor_mask_bits, Cursor_mask_width, Cursor_mask_height,
1786 1, 0, 1);
1787 panel->magnifyGlass->magPix = XCreatePixmap(scr->display, W_DRAWABLE(scr),
1788 5*5 -1, 5*5 -1, scr->depth);
1789
1790 XQueryPointer(scr->display, scr->rootWin, &root_return, &child_return,
1791 &x, &y, &u, &v, &mask);
1792
1793 panel->magnifyGlass->image = NULL;
1794
1795 /* Clipmask to make magnified view-contents circular */
1796 #ifdef SHAPE
1797 XShapeCombineMask(scr->display, WMViewXID(panel->magnifyGlass->view),
1798 ShapeBounding, 0, 0, clip_mask, ShapeSet);
1799 #else
1800 /* Clip circle in glass cursor */
1801 XSetClipMask(scr->display, scr->clipGC, clip_mask);
1802 XSetClipOrigin(scr->display, scr->clipGC, 0, 0);
1803 #endif
1804
1805 XFreePixmap(scr->display, clip_mask);
1806
1807 /* Draw initial magnifying glass contents */
1808 magnifyGetImageStored(panel, x, y, x, y);
1809
1810 pixmap = magnifyCreatePixmap(panel);
1811 XSetWindowBackgroundPixmap(scr->display,
1812 WMViewXID(panel->magnifyGlass->view),
1813 pixmap);
1814 XClearWindow(scr->display, WMViewXID(panel->magnifyGlass->view));
1815 XFlush(scr->display);
1816
1817 #ifndef SHAPE
1818 XFreePixmap(scr->display, pixmap);
1819 #endif
1820
1821 point.x = x;
1822 point.y = y;
1823
1824 return point;
1825 }
1826
1827
1828 static void
1829 magnifyPutCursor(WMWidget *w, void *data)
1830 {
1831 W_ColorPanel *panel = (W_ColorPanel*)(data);
1832 W_Screen *scr = WMWidgetScreen(panel->win);
1833 Cursor magCursor;
1834 Pixmap pixmap;
1835 XEvent event;
1836 WMPoint initialPosition;
1837
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;
1843 }
1844
1845 /* Create magnifying glass */
1846 panel->magnifyGlass = wmalloc(sizeof(MovingView));
1847 panel->magnifyGlass->view = magnifyCreateView(panel);
1848 if (!panel->magnifyGlass->view)
1849 return;
1850
1851 initialPosition = magnifyInitialize(panel);
1852 panel->magnifyGlass->x = initialPosition.x;
1853 panel->magnifyGlass->y = initialPosition.y;
1854
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);
1859
1860 magCursor = magnifyGrabPointer(panel);
1861
1862 while (panel->magnifyGlass->image)
1863 {
1864 WMNextEvent(scr->display, &event);
1865
1866 /* Pack motion events */
1867 while (XCheckTypedEvent(scr->display, MotionNotify, &event)) {
1868 }
1869
1870 switch (event.type)
1871 {
1872 case ButtonPress:
1873 XDestroyImage(panel->magnifyGlass->image);
1874 panel->magnifyGlass->image = NULL;
1875
1876 if (event.xbutton.button == Button1) {
1877 panel->color.rgb = panel->magnifyGlass->color;
1878 panel->color.set = cpRGB;
1879 updateSwatch(panel, panel->color);
1880 }
1881 switch (panel->mode) {
1882 case WMWheelModeColorPanel:
1883 wheelInit(panel);
1884 wheelRender(panel);
1885 wheelPaint(panel);
1886 break;
1887 case WMGrayModeColorPanel:
1888 grayInit(panel);
1889 break;
1890 case WMRGBModeColorPanel:
1891 rgbInit(panel);
1892 break;
1893 case WMCMYKModeColorPanel:
1894 cmykInit(panel);
1895 break;
1896 case WMHSBModeColorPanel:
1897 hsbInit(panel);
1898 break;
1899 default:
1900 break;
1901 }
1902 panel->lastChanged = panel->mode;
1903
1904 WMSetButtonSelected(panel->magnifyBtn, False);
1905 break;
1906
1907 case MotionNotify:
1908 while (XPending(event.xmotion.display)) {
1909 XEvent ev;
1910 XPeekEvent(event.xmotion.display, &ev);
1911 if (ev.type == MotionNotify)
1912 XNextEvent(event.xmotion.display, &event);
1913 else
1914 break;
1915 }
1916
1917 /* Get a "dirty rectangle" */
1918 magnifyGetImageStored( panel,
1919 panel->magnifyGlass->x, panel->magnifyGlass->y,
1920 event.xmotion.x_root, event.xmotion.y_root);
1921
1922 /* Update coordinates */
1923 panel->magnifyGlass->x = event.xmotion.x_root;
1924 panel->magnifyGlass->y = event.xmotion.y_root;
1925
1926 /* Move view */
1927 W_MoveView(panel->magnifyGlass->view,
1928 panel->magnifyGlass->x - Cursor_x_hot,
1929 panel->magnifyGlass->y - Cursor_y_hot);
1930
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);
1942 #ifndef SHAPE
1943 XFreePixmap(scr->display, pixmap);
1944 #endif
1945 }
1946 break;
1947
1948 /* Try XQueryPointer for this !!! It returns windows that the pointer
1949 * is over. Note: We found this solving the invisible donkey cap bug
1950 */
1951 #if 0 /* As it is impossible to make this work in all cases,
1952 * we consider it confusing. Therefore we disabled it.
1953 */
1954 case FocusOut: /* fall through */
1955 case FocusIn:
1956 /*
1957 * Color Panel window (panel->win) lost or received focus.
1958 * We need to update the pixmap in the magnifying glass.
1959 *
1960 * BUG Doesn't work with focus switches between two windows
1961 * if none of them is the color panel.
1962 */
1963 XUngrabPointer(scr->display, CurrentTime);
1964 W_UnmapView(panel->magnifyGlass->view);
1965
1966 magnifyInitialize(panel);
1967
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);
1973 break;
1974 #endif
1975 default:
1976 WMHandleEvent(&event);
1977 break;
1978 } /* of switch */
1979 }
1980
1981 XUngrabPointer(scr->display, CurrentTime);
1982 XFreeCursor(scr->display, magCursor);
1983
1984 XFreePixmap(scr->display, panel->magnifyGlass->magPix);
1985 panel->magnifyGlass->magPix = None;
1986
1987 W_UnmapView(panel->magnifyGlass->view);
1988 W_DestroyView(panel->magnifyGlass->view);
1989 panel->magnifyGlass->view = NULL;
1990
1991 wfree(panel->magnifyGlass);
1992 }
1993
1994
1995
1996 /****************** ColorWheel Functions ************************/
1997
1998 static wheelMatrix*
1999 wheelCreateMatrix(unsigned int width, unsigned int height)
2000 {
2001 wheelMatrix *matrix = NULL;
2002 int i;
2003
2004 assert((width > 0) && (height > 0));
2005
2006 matrix = wmalloc(sizeof(wheelMatrix));
2007 memset(matrix, 0, sizeof(wheelMatrix));
2008 matrix->width = width;
2009 matrix->height = height;
2010
2011 for (i = 0; i < 3; i++) {
2012 matrix->data[i] = wmalloc(width*height*sizeof(unsigned char));
2013 }
2014
2015 return matrix;
2016 }
2017
2018
2019 static void
2020 wheelDestroyMatrix(wheelMatrix *matrix)
2021 {
2022 int i;
2023
2024 if (!matrix)
2025 return;
2026
2027 for (i = 0; i < 3; i++) {
2028 if (matrix->data[i])
2029 wfree(matrix->data[i]);
2030 }
2031 wfree(matrix);
2032 }
2033
2034
2035 static void
2036 wheelInitMatrix(W_ColorPanel *panel)
2037 {
2038 int i;
2039 int x,y;
2040 unsigned char *rp, *gp, *bp;
2041 CPColor cpColor;
2042 long ofs[4];
2043 int xcor, ycor;
2044 unsigned short sat;
2045 int dhue[4];
2046 const int cw_halfsize = (colorWheelSize + 4)/2,
2047 cw_sqsize = (colorWheelSize +4) * (colorWheelSize +4),
2048 uchar_shift = getShift(sizeof(unsigned char));
2049
2050 if (!panel->wheelMtrx)
2051 return;
2052
2053 cpColor.hsv.value = 255;
2054 cpColor.set = cpHSV;
2055
2056 ofs[0] = -1;
2057 ofs[1] = -(colorWheelSize + 4);
2058
2059 /* offsets are counterclockwise (in triangles).
2060 *
2061 * ofs[0] ---->
2062 * _______________________________________
2063 * [1] |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| o
2064 * s |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| f
2065 * f |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| s
2066 * o | | | | | | | | | | | | | | | | | | | | | [3]
2067 *
2068 * <---- ofs[2]
2069 * ____
2070 * |\ /| <-- triangles
2071 * | \/ |
2072 * | /\ |
2073 * |/__\|
2074 */
2075
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;
2081
2082 /* RColor.saturation is unsigned char and will wrap after 255 */
2083 sat = rint(255.0 *
2084 sqrtf( (float)(xcor*xcor) + (float)(ycor*ycor)) /
2085 (float)colorWheelSize);
2086
2087 cpColor.hsv.saturation = (unsigned char)sat;
2088
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 */
2093
2094 if (sat < 256) {
2095 if (xcor != 0)
2096 dhue[0] = rint(atan((float)ycor / (float)xcor) *
2097 (180.0 / M_PI)) + (xcor < 0 ? 180.0 : 0.0);
2098 else
2099 dhue[0] = 270;
2100
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);
2105
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);
2110
2111 cpColor.hsv.hue = dhue[i];
2112 convertCPColor(&cpColor);
2113
2114 *rp = (unsigned char)(cpColor.rgb.red);
2115 *gp = (unsigned char)(cpColor.rgb.green);
2116 *bp = (unsigned char)(cpColor.rgb.blue);
2117 }
2118 }
2119 else {
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);
2124
2125 *rp = (unsigned char)0;
2126 *gp = (unsigned char)0;
2127 *bp = (unsigned char)0;
2128 }
2129 }
2130 }
2131
2132 ofs[0] += 2*y+1;
2133 ofs[1] += 1 - (colorWheelSize + 4) * (colorWheelSize + 4 - 1 - 2*y);
2134 }
2135 }
2136
2137
2138 static void
2139 wheelCalculateValues(W_ColorPanel *panel, int maxvalue)
2140 {
2141 unsigned int i;
2142 unsigned int v;
2143
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
2147 */
2148 v = (i*maxvalue) >> 7;
2149 panel->wheelMtrx->values[i] = (unsigned char)((v >> 1) +(v & 0x01));
2150 }
2151 }
2152
2153
2154 static void
2155 wheelRender(W_ColorPanel *panel)
2156 {
2157 W_Screen *scr = WMWidgetScreen(panel->win);
2158 int x,y;
2159 RImage *image;
2160 unsigned char *rp, *gp, *bp;
2161 RColor gray;
2162 unsigned long ofs = 0;
2163 unsigned char shift = getShift(sizeof(unsigned char));
2164
2165 image = RCreateImage(colorWheelSize+4, colorWheelSize+4, False);
2166 if (!image) {
2167 wwarning(NO_MEMORY_ERR);
2168 return;
2169 }
2170
2171 /* TODO Make this transparent istead of gray */
2172 gray.red = gray.green = gray.blue = 0xaa;
2173
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);
2179
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] ]);
2187 }
2188 else {
2189 *rp = (unsigned char)(gray.red);
2190 *gp = (unsigned char)(gray.green);
2191 *bp = (unsigned char)(gray.blue);
2192 }
2193 ofs++;
2194 }
2195 }
2196
2197 if (panel->wheelImg)
2198 XFreePixmap(scr->display, panel->wheelImg);
2199
2200 RConvertImage(scr->rcontext, image, &panel->wheelImg);
2201 RDestroyImage(image);
2202
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 */
2210 }
2211 }
2212
2213
2214 static Bool
2215 wheelInsideColorWheel(W_ColorPanel *panel, unsigned long ofs)
2216 {
2217 return ((panel->wheelMtrx->data[0][ofs] != 0) &&
2218 (panel->wheelMtrx->data[1][ofs] != 0) &&
2219 (panel->wheelMtrx->data[2][ofs] != 0));
2220 }
2221
2222
2223 static void
2224 wheelPaint (W_ColorPanel *panel)
2225 {
2226 W_Screen *scr = WMWidgetScreen(panel->win);
2227
2228 XCopyArea(scr->display, panel->wheelImg, panel->wheelView->window,
2229 scr->copyGC, 0, 0, colorWheelSize+4, colorWheelSize+4, 0, 0);
2230
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);
2234 }
2235
2236
2237 static void
2238 wheelHandleEvents(XEvent *event, void *data)
2239 {
2240 W_ColorPanel *panel = (W_ColorPanel*)data;
2241
2242 switch (event->type) {
2243 case Expose:
2244 if (event->xexpose.count != 0) /* TODO Improve */
2245 break;
2246 wheelPaint(panel);
2247 break;
2248 }
2249 }
2250
2251
2252 static void
2253 wheelHandleActionEvents(XEvent *event, void *data)
2254 {
2255 W_ColorPanel *panel = (W_ColorPanel*)data;
2256
2257 switch (event->type) {
2258 case ButtonPress:
2259 if (getPickerPart(panel, event->xbutton.x, event->xbutton.y) ==
2260 COLORWHEEL_PART) {
2261
2262 panel->lastChanged = WMWheelModeColorPanel;
2263 panel->flags.dragging = 1;
2264
2265 wheelPositionSelection(panel, event->xbutton.x, event->xbutton.y);
2266 }
2267 break;
2268
2269 case ButtonRelease:
2270 panel->flags.dragging = 0;
2271 if (!panel->flags.continuous) {
2272 if (panel->action)
2273 (*panel->action)(panel, panel->clientData);
2274 }
2275 break;
2276
2277 case MotionNotify:
2278 if (panel->flags.dragging) {
2279 if (getPickerPart(panel, event->xmotion.x, event->xmotion.y) ==
2280 COLORWHEEL_PART) {
2281 wheelPositionSelection(panel, event->xmotion.x,
2282 event->xmotion.y);
2283 }
2284 else
2285 wheelPositionSelectionOutBounds(panel, event->xmotion.x,
2286 event->xmotion.y);
2287 }
2288 break;
2289 }
2290 }
2291
2292
2293 static int
2294 getPickerPart(W_ColorPanel *panel, int x, int y)
2295 {
2296 int lx, ly;
2297 unsigned long ofs;
2298
2299 lx = x;
2300 ly = y;
2301
2302 if (panel->mode == WMWheelModeColorPanel) {
2303 if ((lx >= 2) && (lx <= 2+colorWheelSize) && (ly >= 2) &&
2304 (ly <= 2+colorWheelSize)) {
2305
2306 ofs = ly*panel->wheelMtrx->width+lx;
2307
2308 if (wheelInsideColorWheel(panel, ofs))
2309 return COLORWHEEL_PART;
2310 }
2311 }
2312
2313 if (panel->mode == WMCustomPaletteModeColorPanel) {
2314 if ((lx >= 2) && (lx < customPaletteWidth-2) && (ly >= 2) &&
2315 (ly < customPaletteHeight-2)) {
2316 return CUSTOMPALETTE_PART;
2317 }
2318 }
2319
2320 return 0;
2321 }
2322
2323
2324 static void
2325 wheelBrightnessSliderCallback(WMWidget *w, void *data)
2326 {
2327 int value;
2328
2329 W_ColorPanel *panel = (W_ColorPanel*)data;
2330
2331 value = 255-WMGetSliderValue(panel->wheelBrightnessS);
2332
2333 wheelCalculateValues(panel, value);
2334
2335 if (panel->color.set == cpRGB) {
2336 convertCPColor(&panel->color);
2337 panel->color.set = cpHSV;
2338 }
2339
2340 panel->color.hsv.value = value;
2341
2342 wheelRender(panel);
2343 wheelPaint(panel);
2344 wheelUpdateSelection(panel);
2345 }
2346
2347
2348 static void
2349 wheelUpdateSelection(W_ColorPanel *panel)
2350 {
2351 W_Screen *scr = WMWidgetScreen(panel->win);
2352
2353 updateSwatch(panel, panel->color);
2354 panel->lastChanged = WMWheelModeColorPanel;
2355
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);
2362 /* see above */
2363 }
2364
2365
2366 static void
2367 wheelUndrawSelection(W_ColorPanel *panel)
2368 {
2369 W_Screen *scr = WMWidgetScreen(panel->win);
2370
2371 XCopyArea(scr->display, panel->selectionBackImg, panel->wheelView->window,
2372 scr->copyGC, 0, 0, 4, 4, panel->colx -2, panel->coly -2);
2373 /* see above */
2374 }
2375
2376 static void
2377 wheelPositionSelection(W_ColorPanel *panel, int x, int y)
2378 {
2379 unsigned long ofs = (y * panel->wheelMtrx->width)+ x;
2380
2381 panel->color.rgb.red = panel->wheelMtrx->values[
2382 panel->wheelMtrx->data[0][ofs] ];
2383
2384 panel->color.rgb.green = panel->wheelMtrx->values[
2385 panel->wheelMtrx->data[1][ofs] ];
2386
2387 panel->color.rgb.blue = panel->wheelMtrx->values[
2388 panel->wheelMtrx->data[2][ofs] ];
2389 panel->color.set = cpRGB;
2390
2391 wheelUndrawSelection(panel);
2392
2393 panel->colx = x;
2394 panel->coly = y;
2395
2396 wheelUpdateSelection(panel);
2397 wheelUpdateBrightnessGradientFromLocation(panel);
2398 }
2399
2400 static void
2401 wheelPositionSelectionOutBounds(W_ColorPanel *panel, int x, int y)
2402 {
2403 int hue;
2404 int xcor, ycor;
2405 CPColor cpColor;
2406
2407 xcor = x * 2 - colorWheelSize - 4;
2408 ycor = y * 2 - colorWheelSize - 4;
2409
2410 panel->color.hsv.saturation = 255;
2411 panel->color.hsv.value = 255 - WMGetSliderValue(panel->wheelBrightnessS);
2412
2413 if (xcor != 0)
2414 hue = rint(atan(- (float)ycor / (float)xcor) * (180.0/M_PI));
2415 else {
2416 if (ycor < 0)
2417 hue = 90;
2418 else
2419 hue = 270;
2420 }
2421
2422 if (xcor < 0)
2423 hue += 180;
2424
2425 if ((xcor > 0) && (ycor > 0))
2426 hue += 360;
2427
2428 panel->color.hsv.hue = hue;
2429 panel->color.set = cpHSV;
2430 convertCPColor(&panel->color);
2431
2432 wheelUndrawSelection(panel);
2433
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);
2439
2440 wheelUpdateSelection(panel);
2441 cpColor = panel->color;
2442 wheelUpdateBrightnessGradient(panel, cpColor);
2443 }
2444
2445 static void
2446 wheelUpdateBrightnessGradientFromLocation(W_ColorPanel *panel)
2447 {
2448 CPColor from;
2449 unsigned long ofs;
2450
2451 ofs = panel->coly * panel->wheelMtrx->width + panel->colx;
2452
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];
2456 from.set = cpRGB;
2457
2458 wheelUpdateBrightnessGradient(panel, from);
2459 }
2460
2461 static void
2462 wheelUpdateBrightnessGradient(W_ColorPanel *panel, CPColor topColor)
2463 {
2464 RColor to;
2465 RImage *sliderImg;
2466 WMPixmap *sliderPxmp;
2467
2468 to.red = to.green = to.blue = 0;
2469
2470 if (topColor.set == cpHSV)
2471 convertCPColor(&topColor);
2472
2473 sliderImg = RRenderGradient(16, 153, &(topColor.rgb), &to, RGRD_VERTICAL);
2474 sliderPxmp = WMCreatePixmapFromRImage(WMWidgetScreen(panel->win),
2475 sliderImg, 0);
2476 RDestroyImage(sliderImg);
2477 WMSetSliderImage(panel->wheelBrightnessS, sliderPxmp);
2478 WMReleasePixmap(sliderPxmp);
2479 }
2480
2481 /****************** Grayscale Panel Functions ***************/
2482
2483 static void
2484 grayBrightnessSliderCallback(WMWidget *w, void *data)
2485 {
2486 CPColor cpColor;
2487 int value;
2488 char tmp[4];
2489 W_ColorPanel *panel = (W_ColorPanel*)data;
2490
2491 value = WMGetSliderValue(panel->grayBrightnessS);
2492
2493 sprintf(tmp, "%d", value);
2494
2495 WMSetTextFieldText(panel->grayBrightnessT, tmp);
2496 cpColor.rgb.red = cpColor.rgb.green = cpColor.rgb.blue = rint(2.55*value);
2497 cpColor.set = cpRGB;
2498
2499 updateSwatch(panel, cpColor);
2500 panel->lastChanged = WMGrayModeColorPanel;
2501 }
2502
2503 static void
2504 grayPresetButtonCallback(WMWidget *w, void *data)
2505 {
2506 CPColor cpColor;
2507 char tmp[4];
2508 int value;
2509 int i=0;
2510 W_ColorPanel *panel = (W_ColorPanel*)data;
2511
2512 while (i < 7) {
2513 if (w == panel->grayPresetBtn[i])
2514 break;
2515 i++;
2516 }
2517
2518 value = rint((100.0*i)/6.0);
2519 sprintf(tmp, "%d", value);
2520
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;
2525
2526 WMSetSliderValue(panel->grayBrightnessS, rint((100.0*i)/6.0));
2527
2528 updateSwatch(panel, cpColor);
2529 panel->lastChanged = WMGrayModeColorPanel;
2530 }
2531
2532 static void
2533 grayBrightnessTextFieldCallback(void *observerData,
2534 WMNotification *notification)
2535 {
2536 CPColor cpColor;
2537 char tmp[4];
2538 int value;
2539 W_ColorPanel *panel = (W_ColorPanel*)observerData;
2540
2541 value = atoi(WMGetTextFieldText(panel->grayBrightnessT));
2542 if (value > 100)
2543 value = 100;
2544 if (value < 0)
2545 value = 0;
2546
2547 sprintf(tmp, "%d", value);
2548 WMSetTextFieldText(panel->grayBrightnessT, tmp);
2549 WMSetSliderValue(panel->grayBrightnessS, value);
2550
2551 cpColor.rgb.red = cpColor.rgb.green = cpColor.rgb.blue =
2552 rint((255.0*value)/100.0);
2553 cpColor.set = cpRGB;
2554
2555 updateSwatch(panel, cpColor);
2556 panel->lastChanged = WMGrayModeColorPanel;
2557 }
2558
2559 /******************* RGB Panel Functions *****************/
2560
2561 static void
2562 rgbSliderCallback(WMWidget *w, void *data)
2563 {
2564 CPColor cpColor;
2565 int value[3];
2566 char tmp[4];
2567 W_ColorPanel *panel = (W_ColorPanel*)data;
2568
2569 value[0] = WMGetSliderValue(panel->rgbRedS);
2570 value[1] = WMGetSliderValue(panel->rgbGreenS);
2571 value[2] = WMGetSliderValue(panel->rgbBlueS);
2572
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);
2579
2580 cpColor.rgb.red = value[0];
2581 cpColor.rgb.green = value[1];
2582 cpColor.rgb.blue = value[2];
2583 cpColor.set = cpRGB;
2584
2585 updateSwatch(panel, cpColor);
2586 panel->lastChanged = WMRGBModeColorPanel;
2587 }
2588
2589 static void
2590 rgbTextFieldCallback(void *observerData, WMNotification *notification)
2591 {
2592 CPColor cpColor;
2593 int value[3];
2594 char tmp[4];
2595 int n;
2596 W_ColorPanel *panel = (W_ColorPanel*)observerData;
2597
2598 value[0] = atoi(WMGetTextFieldText(panel->rgbRedT));
2599 value[1] = atoi(WMGetTextFieldText(panel->rgbGreenT));
2600 value[2] = atoi(WMGetTextFieldText(panel->rgbBlueT));
2601
2602 for (n=0; n < 3; n++) {
2603 if (value[n] > 255)
2604 value[n] = 255;
2605 if (value[n] < 0)
2606 value[n] = 0;
2607 }
2608
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);
2615
2616 WMSetSliderValue(panel->rgbRedS, value[0]);
2617 WMSetSliderValue(panel->rgbGreenS, value[1]);
2618 WMSetSliderValue(panel->rgbBlueS, value[2]);
2619
2620 cpColor.rgb.red = value[0];
2621 cpColor.rgb.green = value[1];
2622 cpColor.rgb.blue = value[2];
2623 cpColor.set = cpRGB;
2624
2625 updateSwatch(panel, cpColor);
2626 panel->lastChanged = WMRGBModeColorPanel;
2627 }
2628
2629
2630 /******************* CMYK Panel Functions *****************/
2631
2632 static void
2633 cmykSliderCallback(WMWidget *w, void *data)
2634 {
2635 CPColor cpColor;
2636 int value[4];
2637 char tmp[4];
2638 W_ColorPanel *panel = (W_ColorPanel*)data;
2639 float scale;
2640
2641 value[0] = WMGetSliderValue(panel->cmykCyanS);
2642 value[1] = WMGetSliderValue(panel->cmykMagentaS);
2643 value[2] = WMGetSliderValue(panel->cmykYellowS);
2644 value[3] = WMGetSliderValue(panel->cmykBlackS);
2645
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);
2654
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;
2660
2661 updateSwatch(panel, cpColor);
2662 panel->lastChanged = WMCMYKModeColorPanel;
2663 }
2664
2665 static void
2666 cmykTextFieldCallback(void *observerData, WMNotification *notification)
2667 {
2668 CPColor cpColor;
2669 int value[4];
2670 char tmp[4];
2671 int n;
2672 float scale;
2673 W_ColorPanel *panel = (W_ColorPanel*)observerData;
2674
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));
2679
2680 for (n=0; n < 4; n++) {
2681 if (value[n] > 100)
2682 value[n] = 100;
2683 if (value[n] < 0)
2684 value[n] = 0;
2685 }
2686
2687 sprintf(tmp, "%d", value[0]);
2688 WMSetTextFieldText(panel->cmykCyanT, tmp);
2689
2690 sprintf(tmp, "%d", value[1]);
2691 WMSetTextFieldText(panel->cmykMagentaT, tmp);
2692
2693 sprintf(tmp, "%d", value[2]);
2694 WMSetTextFieldText(panel->cmykYellowT, tmp);
2695
2696 sprintf(tmp, "%d", value[3]);
2697 WMSetTextFieldText(panel->cmykBlackT, tmp);
2698
2699 WMSetSliderValue(panel->cmykCyanS, value[0]);
2700 WMSetSliderValue(panel->cmykMagentaS, value[1]);
2701 WMSetSliderValue(panel->cmykYellowS, value[2]);
2702 WMSetSliderValue(panel->cmykBlackS, value[3]);
2703
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;
2709
2710 updateSwatch(panel, cpColor);
2711 panel->lastChanged = WMCMYKModeColorPanel;
2712 }
2713
2714 /********************** HSB Panel Functions ***********************/
2715
2716 static void
2717 hsbSliderCallback(WMWidget *w, void *data)
2718 {
2719 CPColor cpColor;
2720 int value[3];
2721 char tmp[4];
2722 W_ColorPanel *panel = (W_ColorPanel*)data;
2723
2724 value[0] = WMGetSliderValue(panel->hsbHueS);
2725 value[1] = WMGetSliderValue(panel->hsbSaturationS);
2726 value[2] = WMGetSliderValue(panel->hsbBrightnessS);
2727
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);
2734
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;
2739
2740 convertCPColor(&cpColor);
2741
2742 panel->lastChanged = WMHSBModeColorPanel;
2743 updateSwatch(panel, cpColor);
2744
2745 if (w != panel->hsbBrightnessS)
2746 hsbUpdateBrightnessGradient(panel);
2747 if (w != panel->hsbSaturationS)
2748 hsbUpdateSaturationGradient(panel);
2749 if (w != panel->hsbHueS)
2750 hsbUpdateHueGradient(panel);
2751 }
2752
2753 static void
2754 hsbTextFieldCallback(void *observerData, WMNotification *notification)
2755 {
2756 CPColor cpColor;
2757 int value[3];
2758 char tmp[4];
2759 int n;
2760 W_ColorPanel *panel = (W_ColorPanel*)observerData;
2761
2762 value[0] = atoi(WMGetTextFieldText(panel->hsbHueT));
2763 value[1] = atoi(WMGetTextFieldText(panel->hsbSaturationT));
2764 value[2] = atoi(WMGetTextFieldText(panel->hsbBrightnessT));
2765
2766 if (value[0] > 359)
2767 value[0] = 359;
2768 if (value[0] < 0)
2769 value[0] = 0;
2770
2771 for (n=1; n < 3; n++) {
2772 if (value[n] > 100)
2773 value[n] = 100;
2774 if (value[n] < 0)
2775 value[n] = 0;
2776 }
2777
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);
2784
2785 WMSetSliderValue(panel->hsbHueS, value[0]);
2786 WMSetSliderValue(panel->hsbSaturationS, value[1]);
2787 WMSetSliderValue(panel->hsbBrightnessS, value[2]);
2788
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;
2793
2794 convertCPColor(&cpColor);
2795
2796 panel->lastChanged = WMHSBModeColorPanel;
2797 updateSwatch(panel, cpColor);
2798
2799 hsbUpdateBrightnessGradient(panel);
2800 hsbUpdateSaturationGradient(panel);
2801 hsbUpdateHueGradient(panel);
2802 }
2803
2804 static void
2805 hsbUpdateBrightnessGradient(W_ColorPanel *panel)
2806 {
2807 W_Screen *scr = WMWidgetScreen(panel->win);
2808 RColor from;
2809 CPColor to;
2810 RImage *sliderImg;
2811 WMPixmap *sliderPxmp;
2812
2813 from.red = from.green = from.blue = 0;
2814 to.hsv = panel->color.hsv;
2815 to.hsv.value = 255;
2816 to.set = cpHSV;
2817
2818 convertCPColor(&to);
2819
2820 sliderImg = RRenderGradient(141, 16, &from, &(to.rgb), RGRD_HORIZONTAL);
2821 sliderPxmp = WMCreatePixmapFromRImage(scr, sliderImg, 0);
2822 RDestroyImage(sliderImg);
2823
2824 if (sliderPxmp)
2825 W_PaintText(W_VIEW(panel->hsbBrightnessS), sliderPxmp->pixmap,
2826 panel->font12, 2, 0, 100, WALeft, WMColorGC(scr->white),
2827 False, "Brightness", strlen("Brightness"));
2828 else
2829 wwarning(NO_MEMORY_ERR);
2830
2831 WMSetSliderImage(panel->hsbBrightnessS, sliderPxmp);
2832 WMReleasePixmap(sliderPxmp);
2833 }
2834
2835 static void
2836 hsbUpdateSaturationGradient(W_ColorPanel *panel)
2837 {
2838 W_Screen *scr = WMWidgetScreen(panel->win);
2839 CPColor from;
2840 CPColor to;
2841 RImage *sliderImg;
2842 WMPixmap *sliderPxmp;
2843
2844 from.hsv = panel->color.hsv;
2845 from.hsv.saturation = 0;
2846 from.set = cpHSV;
2847 convertCPColor(&from);
2848
2849 to.hsv = panel->color.hsv;
2850 to.hsv.saturation = 255;
2851 to.set = cpHSV;
2852 convertCPColor(&to);
2853
2854 sliderImg = RRenderGradient(141, 16, &(from.rgb), &(to.rgb),
2855 RGRD_HORIZONTAL);
2856 sliderPxmp = WMCreatePixmapFromRImage(scr, sliderImg, 0);
2857 RDestroyImage(sliderImg);
2858
2859 if (sliderPxmp)
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"));
2864 else
2865 wwarning(NO_MEMORY_ERR);
2866
2867 WMSetSliderImage(panel->hsbSaturationS, sliderPxmp);
2868 WMReleasePixmap(sliderPxmp);
2869 }
2870
2871 static void
2872 hsbUpdateHueGradient(W_ColorPanel *panel)
2873 {
2874 W_Screen *scr = WMWidgetScreen(panel->win);
2875 RColor **colors = NULL;
2876 RHSVColor hsvcolor;
2877 RImage *sliderImg;
2878 WMPixmap *sliderPxmp;
2879 int i;
2880
2881 hsvcolor = panel->color.hsv;
2882
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]);
2888 }
2889 colors[7] = NULL;
2890
2891 sliderImg = RRenderMultiGradient(141, 16, colors, RGRD_HORIZONTAL);
2892 sliderPxmp = WMCreatePixmapFromRImage(scr, sliderImg, 0);
2893 RDestroyImage(sliderImg);
2894
2895 if (sliderPxmp)
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"));
2900 else
2901 wwarning(NO_MEMORY_ERR);
2902
2903 WMSetSliderImage(panel->hsbHueS, sliderPxmp);
2904 WMReleasePixmap(sliderPxmp);
2905
2906 for (i=0; i<7; i++)
2907 wfree(colors[i]);
2908
2909 wfree(colors);
2910 }
2911
2912 /*************** Custom Palette Functions ****************/
2913
2914 static void
2915 customRenderSpectrum(W_ColorPanel *panel)
2916 {
2917 RImage *spectrum;
2918 int x,y;
2919 unsigned long ofs;
2920 unsigned char *rp, *gp, *bp;
2921 CPColor cpColor;
2922
2923 spectrum = RCreateImage(SPECTRUM_WIDTH, SPECTRUM_HEIGHT, 0);
2924
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;
2930
2931 for (x=0; x<511; x++) {
2932 ofs = (y * 511) + x;
2933
2934 convertCPColor(&cpColor);
2935
2936 rp = spectrum->data[0] + ofs;
2937 gp = spectrum->data[1] + ofs;
2938 bp = spectrum->data[2] + ofs;
2939
2940 *rp = (unsigned char)cpColor.rgb.red;
2941 *gp = (unsigned char)cpColor.rgb.green;
2942 *bp = (unsigned char)cpColor.rgb.blue;
2943
2944 if (x<255)
2945 cpColor.hsv.saturation++;
2946
2947 if (x>255)
2948 cpColor.hsv.value--;
2949 }
2950 }
2951 if (panel->customPaletteImg) {
2952 RDestroyImage(panel->customPaletteImg);
2953 panel->customPaletteImg = NULL;
2954 }
2955 panel->customPaletteImg = spectrum;
2956 }
2957
2958
2959
2960 static void
2961 customSetPalette(W_ColorPanel *panel)
2962 {
2963 W_Screen *scr = WMWidgetScreen(panel->win);
2964 RImage *scaledImg;
2965 Pixmap image;
2966 int item;
2967
2968 image = XCreatePixmap(scr->display, W_DRAWABLE(scr), customPaletteWidth,
2969 customPaletteHeight, scr->depth);
2970
2971 scaledImg = RScaleImage(panel->customPaletteImg, customPaletteWidth,
2972 customPaletteHeight);
2973 RConvertImage(scr->rcontext, scaledImg, &image);
2974 RDestroyImage(scaledImg);
2975
2976 XCopyArea(scr->display, image, panel->customPaletteContentView->window,
2977 scr->copyGC, 0, 0, customPaletteWidth, customPaletteHeight, 0, 0);
2978
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);
2983 }
2984
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);
2991
2992 panel->palXRatio = (float)(panel->customPaletteImg->width) /
2993 (float)(customPaletteWidth);
2994 panel->palYRatio = (float)(panel->customPaletteImg->height) /
2995 (float)(customPaletteHeight);
2996
2997 item = WMGetPopUpButtonSelectedItem (panel->customPaletteHistoryBtn);
2998 }
2999
3000
3001 static void
3002 customPalettePositionSelection(W_ColorPanel *panel, int x, int y)
3003 {
3004 W_Screen *scr = WMWidgetScreen(panel->win);
3005 unsigned long ofs;
3006
3007
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);
3012
3013 panel->palx = x;
3014 panel->paly = y;
3015
3016 ofs = rint(x * panel->palXRatio) + rint(y * panel->palYRatio) *
3017 panel->customPaletteImg->width;
3018
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;
3023
3024 updateSwatch(panel, panel->color);
3025 panel->lastChanged = WMCustomPaletteModeColorPanel;
3026
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 */
3034 }
3035
3036
3037 static void
3038 customPalettePositionSelectionOutBounds(W_ColorPanel *panel, int x, int y)
3039 {
3040 if (x < 2)
3041 x = 2;
3042 if (y < 2)
3043 y = 2;
3044 if (x >= customPaletteWidth)
3045 x = customPaletteWidth -2;
3046 if (y >= customPaletteHeight)
3047 y = customPaletteHeight -2;
3048
3049 customPalettePositionSelection(panel, x, y);
3050 }
3051
3052
3053 static void
3054 customPaletteHandleEvents(XEvent *event, void *data)
3055 {
3056 W_ColorPanel *panel = (W_ColorPanel*)data;
3057
3058 switch (event->type) {
3059 case Expose:
3060 if (event->xexpose.count != 0) /* TODO Improve. */
3061 break;
3062 customSetPalette(panel);
3063 break;
3064 }
3065 }
3066
3067 static void
3068 customPaletteHandleActionEvents(XEvent *event, void *data)
3069 {
3070 W_ColorPanel *panel = (W_ColorPanel*)data;
3071 int x, y;
3072
3073 switch (event->type) {
3074 case ButtonPress:
3075 x = event->xbutton.x;
3076 y = event->xbutton.y;
3077
3078 if (getPickerPart(panel, x, y) == CUSTOMPALETTE_PART) {
3079 panel->flags.dragging = 1;
3080 customPalettePositionSelection(panel, x, y);
3081 }
3082 break;
3083
3084 case ButtonRelease:
3085 panel->flags.dragging = 0;
3086 if (!panel->flags.continuous) {
3087 if (panel->action)
3088 (*panel->action)(panel, panel->clientData);
3089 }
3090 break;
3091
3092 case MotionNotify:
3093 x = event->xmotion.x;
3094 y = event->xmotion.y;
3095
3096 if (panel->flags.dragging) {
3097 if (getPickerPart(panel, x, y) == CUSTOMPALETTE_PART) {
3098 customPalettePositionSelection(panel, x, y);
3099 }
3100 else
3101 customPalettePositionSelectionOutBounds(panel, x, y);
3102 }
3103 break;
3104 }
3105 }
3106
3107
3108 static void
3109 customPaletteMenuCallback(WMWidget *w, void *data)
3110 {
3111 W_ColorPanel *panel = (W_ColorPanel*)data;
3112 int item = WMGetPopUpButtonSelectedItem(panel->customPaletteMenuBtn);
3113
3114 switch (item) {
3115 case CPmenuNewFromFile:
3116 customPaletteMenuNewFromFile(panel);
3117 break;
3118 case CPmenuRename:
3119 customPaletteMenuRename(panel);
3120 break;
3121 case CPmenuRemove:
3122 customPaletteMenuRemove(panel);
3123 break;
3124 case CPmenuCopy:
3125 break;
3126 case CPmenuNewFromClipboard:
3127 break;
3128 }
3129 }
3130
3131
3132 static void
3133 customPaletteMenuNewFromFile(W_ColorPanel *panel)
3134 {
3135 W_Screen *scr = WMWidgetScreen(panel->win);
3136 WMOpenPanel *browseP;
3137 char *filepath;
3138 char *filename = NULL;
3139 char *spath;
3140 char *tmp;
3141 int i;
3142 RImage *tmpImg = NULL;
3143
3144 if ((!panel->lastBrowseDir) || (strcmp(panel->lastBrowseDir,"\0") == 0))
3145 spath = wexpandpath(wgethomedir());
3146 else
3147 spath = wexpandpath(panel->lastBrowseDir);
3148
3149 browseP = WMGetOpenPanel(scr);
3150 WMSetFilePanelCanChooseDirectories(browseP, 0);
3151 WMSetFilePanelCanChooseFiles(browseP, 1);
3152
3153 /* Get a filename */
3154 if (WMRunModalFilePanelForDirectory(browseP, panel->win, spath,
3155 "Open Palette", RSupportedFileFormats()) ) {
3156 filepath = WMGetFilePanelFileName(browseP);
3157
3158 /* Get seperation position between path and filename */
3159 i = strrchr(filepath, '/') - filepath + 1;
3160 if (i > strlen(filepath))
3161 i = strlen(filepath);
3162
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';
3169
3170 /* Get filename from path */
3171 filename = wstrdup(filepath + i);
3172
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) {
3176 char *newName;
3177
3178 wfree(tmp);
3179
3180 newName = generateNewFilename(filename);
3181 wfree(filename);
3182 filename = newName;
3183
3184 tmp = wstrappend(panel->configurationPath, filename);
3185 }
3186 wfree(tmp);
3187
3188 /* Copy image to $(gnustepdir)/Library/Colors/ &
3189 * Add filename to history menu */
3190 if (fetchFile (panel->configurationPath, filepath, filename) == 0) {
3191
3192 /* filepath is a "local" path now the file has been copied */
3193 wfree(filepath);
3194 filepath = wstrappend(panel->configurationPath, filename);
3195
3196 /* load the image & add menu entries */
3197 tmpImg = RLoadImage(scr->rcontext, filepath, 0);
3198 if (tmpImg) {
3199 if (panel->customPaletteImg)
3200 RDestroyImage(panel->customPaletteImg);
3201 panel->customPaletteImg = tmpImg;
3202
3203 customSetPalette(panel);
3204 WMAddPopUpButtonItem(panel->customPaletteHistoryBtn, filename);
3205
3206 panel->currentPalette = WMGetPopUpButtonNumberOfItems(
3207 panel->customPaletteHistoryBtn)-1;
3208
3209 WMSetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn,
3210 panel->currentPalette);
3211 }
3212 } else {
3213 tmp = wstrappend(panel->configurationPath, filename);
3214
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);
3218 if (i != 0) {
3219 wsyserror("can't remove file %s", tmp);
3220 WMRunAlertPanel(scr, panel->win, "File Error",
3221 "Couldn't remove file from Configuration Directory !",
3222 "OK", NULL, NULL);
3223 }
3224 wfree(tmp);
3225 }
3226 wfree(filepath);
3227 wfree(filename);
3228 }
3229 WMFreeFilePanel(browseP);
3230
3231 wfree(spath);
3232 }
3233
3234
3235 static void
3236 customPaletteMenuRename(W_ColorPanel *panel)
3237 {
3238 W_Screen *scr = WMWidgetScreen(panel->win);
3239 char *toName = NULL;
3240 char *fromName;
3241 char *toPath, *fromPath;
3242 int item;
3243 int index;
3244
3245 item = WMGetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn);
3246 fromName = WMGetPopUpButtonItem(panel->customPaletteHistoryBtn, item);
3247
3248 toName = WMRunInputPanel(scr, panel->win, "Rename", "Rename palette to:",
3249 fromName, "OK", "Cancel");
3250
3251 if (toName) {
3252
3253 /* As some people do certain stupid things... */
3254 if (strcmp(toName, fromName) == 0) {
3255 wfree(toName);
3256 return;
3257 }
3258
3259 /* For normal people */
3260 fromPath = wstrappend(panel->configurationPath, fromName);
3261 toPath = wstrappend(panel->configurationPath, toName);
3262
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",
3267 NULL) == 1) {
3268 /* "No" = 0, "Yes" = 1 */
3269 int items = WMGetPopUpButtonNumberOfItems(
3270 panel->customPaletteHistoryBtn);
3271
3272 remove(toPath);
3273
3274 /* Remove from History list too */
3275 index = 1;
3276 while ((index < items) && (strcmp(WMGetPopUpButtonItem(
3277 panel->customPaletteHistoryBtn, index),
3278 toName) != 0 ))
3279 index++;
3280
3281 if (index < items) {
3282 WMRemovePopUpButtonItem(panel->customPaletteHistoryBtn,
3283 index);
3284 if (index < item)
3285 item--;
3286 }
3287
3288 } else {
3289 wfree(fromPath);
3290 wfree(toName);
3291 wfree(toPath);
3292
3293 return;
3294 }
3295 }
3296
3297 if ( rename(fromPath, toPath) != 0)
3298 wsyserror("Couldn't rename palette %s to %s\n", fromName, toName);
3299 else {
3300 WMRemovePopUpButtonItem(panel->customPaletteHistoryBtn, item);
3301 WMInsertPopUpButtonItem(panel->customPaletteHistoryBtn, item,
3302 toName);
3303
3304 WMSetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn, item);
3305 }
3306 wfree(fromPath);
3307 wfree(toPath);
3308 wfree(toName);
3309 }
3310 }
3311
3312
3313 static void
3314 customPaletteMenuRemove(W_ColorPanel *panel)
3315 {
3316 W_Screen *scr = WMWidgetScreen(panel->win);
3317 char *text;
3318 char *tmp;
3319 int choice;
3320 int item;
3321
3322 item = WMGetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn);
3323
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 ?");
3328 wfree(tmp);
3329
3330 choice = WMRunAlertPanel(scr, panel->win, "Remove", text, "Yes", "No",
3331 NULL);
3332 /* returns 0 (= "Yes") or 1 (="No") */
3333 wfree(text);
3334
3335 if (choice == 0) {
3336
3337 tmp = wstrappend(panel->configurationPath,
3338 WMGetPopUpButtonItem(panel->customPaletteHistoryBtn, item ));
3339
3340 if ( remove(tmp) == 0) {
3341 /* item-1 always exists */
3342 WMSetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn,
3343 item-1);
3344
3345 customPaletteHistoryCallback(panel->customPaletteHistoryBtn,
3346 panel);
3347 customSetPalette(panel);
3348
3349 WMRemovePopUpButtonItem(panel->customPaletteHistoryBtn, item);
3350
3351 } else
3352 wsyserror("Couldn't remove palette %s\n", tmp);
3353
3354 wfree(tmp);
3355 }
3356 }
3357
3358
3359 static void
3360 customPaletteHistoryCallback(WMWidget *w, void *data)
3361 {
3362 W_ColorPanel *panel = (W_ColorPanel*)data;
3363 W_Screen *scr = WMWidgetScreen(panel->win);
3364 int item;
3365 char *filename;
3366 RImage *tmp = NULL;
3367 unsigned char perm_mask;
3368
3369 item = WMGetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn);
3370 if (item == panel->currentPalette)
3371 return;
3372
3373 if (item == 0) {
3374 customRenderSpectrum(panel);
3375
3376 WMSetPopUpButtonItemEnabled(panel->customPaletteMenuBtn, CPmenuRename,
3377 False );
3378 WMSetPopUpButtonItemEnabled(panel->customPaletteMenuBtn, CPmenuRemove,
3379 False );
3380 } else {
3381 /* Load file from configpath */
3382 filename = wstrappend( panel->configurationPath,
3383 WMGetPopUpButtonItem(panel->customPaletteHistoryBtn, item) );
3384
3385 /* If the file corresponding to the item does not exist,
3386 * remove it from the history list and select the next one.
3387 */
3388 perm_mask = (access(filename, F_OK) == 0);
3389 if (!perm_mask) {
3390 /* File does not exist */
3391 wfree(filename);
3392 WMSetPopUpButtonSelectedItem(panel->customPaletteHistoryBtn,
3393 item-1);
3394 WMRemovePopUpButtonItem(panel->customPaletteHistoryBtn, item);
3395 customPaletteHistoryCallback(w, data);
3396 return;
3397 }
3398
3399 /* Get the image */
3400 tmp = RLoadImage(scr->rcontext, filename, 0);
3401 if (tmp) {
3402 if (panel->customPaletteImg) {
3403 RDestroyImage(panel->customPaletteImg);
3404 panel->customPaletteImg = NULL;
3405 }
3406 panel->customPaletteImg = tmp;
3407 }
3408
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,
3412 perm_mask);
3413 WMSetPopUpButtonItemEnabled(panel->customPaletteMenuBtn, CPmenuRemove,
3414 perm_mask);
3415
3416 wfree(filename);
3417 }
3418 customSetPalette(panel);
3419
3420 panel->currentPalette = item;
3421 }
3422
3423 /************************* ColorList Panel Functions **********************/
3424
3425 static void
3426 colorListPaintItem(WMList *lPtr, int index, Drawable d, char *text,
3427 int state, WMRect *rect)
3428 {
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);
3436 WMColor *fillColor;
3437
3438 width = rect->size.width;
3439 height = rect->size.height;
3440 x = rect->pos.x;
3441 y = rect->pos.y;
3442
3443 if (state & WLDSSelected)
3444 WMPaintColorSwatch(white, d, x +15, y, width -15, height);
3445 else
3446 XClearArea(dpy, d, x +15, y, width -15, height, False);
3447
3448 fillColor = WMCreateRGBColor(scr, color.red*256, color.green*256,
3449 color.blue*256, False);
3450
3451 WMSetColorInGC(fillColor, WMColorGC(fillColor));
3452 WMPaintColorSwatch(fillColor, d, x, y, 15, 15);
3453 WMReleaseColor(fillColor);
3454
3455 WMDrawString(scr, d, WMColorGC(black), panel->font12, x+18, y, text,
3456 strlen(text));
3457
3458 WMReleaseColor(white);
3459 WMReleaseColor(black);
3460 }
3461
3462
3463 static void
3464 colorListSelect(WMWidget *w, void *data)
3465 {
3466 W_ColorPanel *panel = (W_ColorPanel *)data;
3467 CPColor cpColor;
3468
3469 cpColor.rgb = *((RColor *)WMGetListSelectedItem(w)->clientData);
3470 cpColor.set = cpRGB;
3471
3472 panel->lastChanged = WMColorListModeColorPanel;
3473 updateSwatch(panel, cpColor);
3474 }
3475
3476
3477 static void
3478 colorListColorMenuCallback(WMWidget *w, void *data)
3479 {
3480 W_ColorPanel *panel = (W_ColorPanel *)data;
3481 int item = WMGetPopUpButtonSelectedItem(panel->colorListColorMenuBtn);
3482
3483 switch (item) {
3484 case CLmenuAdd:
3485 break;
3486 case CLmenuRename:
3487 break;
3488 case CLmenuRemove:
3489 break;
3490 }
3491 }
3492
3493
3494 static void
3495 colorListListMenuCallback(WMWidget *w, void *data)
3496 {
3497 W_ColorPanel *panel = (W_ColorPanel *)data;
3498 int item = WMGetPopUpButtonSelectedItem(panel->colorListListMenuBtn);
3499
3500 switch (item) {
3501 case CLmenuAdd:
3502 /* New Color List */
3503 colorListListMenuNew(panel);
3504 break;
3505 case CLmenuRename:
3506 break;
3507 case CLmenuRemove:
3508 break;
3509 }
3510 }
3511
3512
3513 static void
3514 colorListListMenuNew(W_ColorPanel *panel)
3515 {
3516
3517 }
3518
3519
3520 /*************** Panel Initialisation Functions *****************/
3521
3522 static void
3523 wheelInit(W_ColorPanel *panel)
3524 {
3525 CPColor cpColor;
3526
3527 if (panel->color.set != cpHSV)
3528 convertCPColor(&panel->color);
3529
3530 WMSetSliderValue(panel->wheelBrightnessS, 255 - panel->color.hsv.value);
3531
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)));
3538
3539 wheelCalculateValues(panel, panel->color.hsv.value);
3540
3541 cpColor = panel->color;
3542 cpColor.hsv.value = 255;
3543 cpColor.set = cpHSV;
3544 wheelUpdateBrightnessGradient(panel, cpColor);
3545 }
3546
3547
3548 static void
3549 grayInit(W_ColorPanel *panel)
3550 {
3551 int value;
3552 char tmp[4];
3553
3554 if (panel->color.set != cpHSV)
3555 convertCPColor(&panel->color);
3556
3557 value = rint(panel->color.hsv.value/2.55);
3558 WMSetSliderValue(panel->grayBrightnessS, value);
3559
3560 sprintf(tmp, "%d", value);
3561 WMSetTextFieldText(panel->grayBrightnessT, tmp);
3562 }
3563
3564
3565 static void
3566 rgbInit(W_ColorPanel *panel)
3567 {
3568 char tmp[4];
3569
3570 if (panel->color.set != cpRGB)
3571 convertCPColor(&panel->color);
3572
3573 WMSetSliderValue(panel->rgbRedS, panel->color.rgb.red);
3574 WMSetSliderValue(panel->rgbGreenS, panel->color.rgb.green);
3575 WMSetSliderValue(panel->rgbBlueS, panel->color.rgb.blue);
3576
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);
3583 }
3584
3585
3586 static void
3587 cmykInit(W_ColorPanel *panel)
3588 {
3589 int value[3];
3590 char tmp[4];
3591
3592 if (panel->color.set != cpRGB)
3593 convertCPColor(&panel->color);
3594
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);
3598
3599 WMSetSliderValue(panel->cmykCyanS, value[0]);
3600 WMSetSliderValue(panel->cmykMagentaS, value[1]);
3601 WMSetSliderValue(panel->cmykYellowS, value[2]);
3602 WMSetSliderValue(panel->cmykBlackS, 0);
3603
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");
3611 }
3612
3613
3614 static void
3615 hsbInit(W_ColorPanel *panel)
3616 {
3617 int value[3];
3618 char tmp[4];
3619
3620 if (panel->color.set != cpHSV)
3621 convertCPColor(&panel->color);
3622
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);
3626
3627 WMSetSliderValue(panel->hsbHueS,value[0]);
3628 WMSetSliderValue(panel->hsbSaturationS,value[1]);
3629 WMSetSliderValue(panel->hsbBrightnessS,value[2]);
3630
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);
3637
3638 hsbUpdateBrightnessGradient(panel);
3639 hsbUpdateSaturationGradient(panel);
3640 hsbUpdateHueGradient(panel);
3641 }
3642
3643
3644
3645 /************************** Common utility functions ************************/
3646
3647 static int
3648 fetchFile(char *toPath, char *srcFile, char *destFile)
3649 {
3650 int src, dest;
3651 int n;
3652 char *tmp;
3653 char buf[BUFSIZE];
3654
3655 if ((src = open(srcFile, O_RDONLY)) == 0) {
3656 wsyserror("Could not open %s", srcFile);
3657 return -1;
3658 }
3659
3660 tmp = wstrappend(toPath, destFile);
3661 if ((dest = open( tmp, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))
3662 == 0) {
3663 wsyserror("Could not create %s", tmp);
3664 wfree(tmp);
3665 return -1;
3666 }
3667 wfree(tmp);
3668
3669
3670 /* Copy the file */
3671 while ((n = read(src, buf, BUFSIZE)) > 0)
3672 {
3673 if (write (dest, buf, n) != n) {
3674 wsyserror("Write error on file %s", destFile);
3675 return -1;
3676 }
3677 }
3678
3679 return 0;
3680 }
3681
3682
3683 char*
3684 generateNewFilename(char *curName)
3685 {
3686 int n;
3687 char c;
3688 int baseLen;
3689 char *ptr;
3690 char *newName;
3691
3692
3693 assert(curName);
3694
3695 ptr = curName;
3696
3697 if (
3698 ((ptr = strrchr(ptr, '{')) == 0) ||
3699 sscanf(ptr, "{%i}%c", &n, &c) != 1
3700 )
3701 return wstrappend(curName, " {1}");
3702
3703 baseLen = ptr - curName -1;
3704
3705 newName = wmalloc(baseLen + 16);
3706 strncpy(newName, curName, baseLen);
3707 newName[baseLen] = 0;
3708
3709 sprintf(&newName[baseLen], " {%i}", n+1);
3710
3711 return newName;
3712 }
3713
3714
3715 void
3716 convertCPColor(CPColor *color)
3717 {
3718 unsigned short old_hue = 0;
3719
3720 switch (color->set) {
3721 case cpNone:
3722 wwarning("Color Panel: Color unspecified");
3723 return;
3724 case cpRGB:
3725 old_hue = color->hsv.hue;
3726 RRGBtoHSV(&(color->rgb), &(color->hsv));
3727
3728 /* In black the hue is undefined, and may change by conversion
3729 * Same for white. */
3730 if (
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))
3737 )
3738 color->hsv.hue = old_hue;
3739 break;
3740 case cpHSV:
3741 RHSVtoRGB(&(color->hsv), &(color->rgb));
3742 break;
3743 }
3744 }
3745
3746
3747 #define ABS_SHIFT(val, shift) \
3748 (((shift) > 0) ? (val) >> (shift) : (val) << -(shift))
3749
3750 RColor
3751 ulongToRColor(WMScreen *scr, unsigned long value)
3752 {
3753 RColor color;
3754 XColor *xcolor = NULL;
3755
3756 if (!(xcolor = wmalloc(sizeof(XColor)) )) {
3757 wwarning(NO_MEMORY_ERR);
3758 color.red = 0;
3759 color.green = 0;
3760 color.blue = 0;
3761 return color;
3762 }
3763
3764 xcolor->pixel = value;
3765 XQueryColor(scr->display, scr->rcontext->cmap, xcolor);
3766
3767 color.red = xcolor->red >> 8;
3768 color.green = xcolor->green >> 8;
3769 color.blue = xcolor->blue >> 8;
3770
3771 free(xcolor);
3772
3773 return color;
3774 }
3775
3776
3777 unsigned char
3778 getShift(unsigned char value)
3779 {
3780 unsigned char i = -1;
3781
3782 if (value == 0)
3783 return 0;
3784
3785 while (value) {
3786 value >>= 1;
3787 i++;
3788 }
3789
3790 return i;
3791 }
3792
3793
3794
3795 #ifdef SHAPE_WAS_DEFINED
3796 #undef SHAPE_WAS_DEFINED
3797 #define SHAPE
3798 #endif
The Window Maker window manager