WINGs/wcolorwell.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7
   8 char *WMColorWellDidChangeNotification = "WMColorWellDidChangeNotification";
   9
  10
  11 typedef struct W_ColorWell {
  12     W_Class widgetClass;
  13     WMView *view;
  14
  15     WMView *colorView;
  16
  17     WMColor *color;
  18
  19     WMAction *action;
  20     void *clientData;
  21
  22     WMPoint ipoint;
  23
  24     struct {
  25         unsigned int active:1;
  26         unsigned int bordered:1;
  27     } flags;
  28 } ColorWell;
  29
  30 static char *_ColorWellActivatedNotification = "_ColorWellActivatedNotification";
  31
  32
  33
  34 static void destroyColorWell(ColorWell *cPtr);
  35 static void paintColorWell(ColorWell *cPtr);
  36
  37 static void handleEvents(XEvent *event, void *data);
  38
  39 static void handleDragEvents(XEvent *event, void *data);
  40
  41 static void handleActionEvents(XEvent *event, void *data);
  42
  43 static void willResizeColorWell();
  44
  45
  46
  47 W_ViewDelegate _ColorWellViewDelegate = {
  48     NULL,
  49         NULL,
  50         NULL,
  51         NULL,
  52         willResizeColorWell
  53 };
  54
  55
  56 #if 0
  57 static WMDragSourceProcs dragProcs = {
  58
  59 };
  60 #endif
  61
  62 #define DEFAULT_WIDTH           60
  63 #define DEFAULT_HEIGHT          30
  64 #define DEFAULT_BORDER_WIDTH    6
  65
  66 #define MIN_WIDTH       16
  67 #define MIN_HEIGHT      8
  68
  69
  70
  71 static void
  72 colorChangedObserver(void *data, WMNotification *notification)
  73 {
  74     WMColorPanel *panel = (WMColorPanel*)WMGetNotificationObject(notification);
  75     WMColorWell *cPtr = (WMColorWell*)data;
  76     WMColor *color;
  77
  78     if (!cPtr->flags.active)
  79         return;
  80
  81     color = WMGetColorPanelColor(panel);
  82
  83     WMSetColorWellColor(cPtr, color);
  84     WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
  85 }
  86
  87
  88 static void
  89 updateColorCallback(void *self, void *data)
  90 {
  91     WMColorPanel *panel = (WMColorPanel*)self;
  92     WMColorWell *cPtr = (ColorWell*)data;
  93     WMColor *color;
  94
  95     color = WMGetColorPanelColor(panel);
  96     WMSetColorWellColor(cPtr, color);
  97     WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
  98 }
  99
 100
 101
 102 static void
 103 activatedObserver(void *data, WMNotification *notification)
 104 {
 105 /*
 106     WMColorWell *cPtr = (WMColorWell*)data;
 107
 108     if (!cPtr->flags.active || WMGetNotificationObject(notification) == cPtr)
 109         return;
 110
 111     W_SetViewBackgroundColor(cPtr->view, WMWidgetScreen(cPtr)->gray);
 112     paintColorWell(cPtr);
 113
 114     cPtr->flags.active = 0;
 115  */
 116 }
 117
 118
 119
 120 WMColorWell*
 121 WMCreateColorWell(WMWidget *parent)
 122 {
 123     ColorWell *cPtr;
 124
 125     cPtr = wmalloc(sizeof(ColorWell));
 126     memset(cPtr, 0, sizeof(ColorWell));
 127
 128     cPtr->widgetClass = WC_ColorWell;
 129
 130     cPtr->view = W_CreateView(W_VIEW(parent));
 131     if (!cPtr->view) {
 132         wfree(cPtr);
 133         return NULL;
 134     }
 135     cPtr->view->self = cPtr;
 136
 137     cPtr->view->delegate = &_ColorWellViewDelegate;
 138
 139     cPtr->colorView = W_CreateView(cPtr->view);
 140     if (!cPtr->colorView) {
 141         W_DestroyView(cPtr->view);
 142         wfree(cPtr);
 143         return NULL;
 144     }
 145     cPtr->colorView->self = cPtr;
 146
 147     WMCreateEventHandler(cPtr->view, ExposureMask|StructureNotifyMask
 148                          |ClientMessageMask, handleEvents, cPtr);
 149
 150     WMCreateEventHandler(cPtr->colorView, ExposureMask, handleEvents, cPtr);
 151
 152     WMCreateEventHandler(cPtr->colorView, ButtonPressMask|ButtonMotionMask
 153                          |EnterWindowMask, handleDragEvents, cPtr);
 154
 155     WMCreateEventHandler(cPtr->view, ButtonPressMask, handleActionEvents,
 156                          cPtr);
 157
 158     cPtr->colorView->flags.mapWhenRealized = 1;
 159
 160     cPtr->flags.bordered = 1;
 161
 162     W_ResizeView(cPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 163
 164     WMAddNotificationObserver(activatedObserver, cPtr,
 165                               _ColorWellActivatedNotification, NULL);
 166
 167     cPtr->color = WMBlackColor(WMWidgetScreen(cPtr));
 168
 169     WMAddNotificationObserver(colorChangedObserver, cPtr,
 170                               WMColorPanelColorChangedNotification, NULL);
 171
 172     return cPtr;
 173 }
 174
 175
 176 void
 177 WMSetColorWellColor(WMColorWell *cPtr, WMColor *color)
 178 {
 179     if (cPtr->color)
 180         WMReleaseColor(cPtr->color);
 181
 182     cPtr->color = WMRetainColor(color);
 183
 184     if (cPtr->colorView->flags.realized && cPtr->colorView->flags.mapped)
 185         paintColorWell(cPtr);
 186 }
 187
 188
 189 WMColor*
 190 WMGetColorWellColor(WMColorWell *cPtr)
 191 {
 192     return cPtr->color;
 193 }
 194
 195
 196 void
 197 WSetColorWellBordered(WMColorWell *cPtr, Bool flag)
 198 {
 199     if (cPtr->flags.bordered != flag) {
 200         cPtr->flags.bordered = flag;
 201         W_ResizeView(cPtr->view, cPtr->view->size.width, cPtr->view->size.height);
 202     }
 203 }
 204
 205
 206 #define MIN(a,b)        ((a) > (b) ? (b) : (a))
 207
 208 static void
 209 willResizeColorWell(W_ViewDelegate *self, WMView *view,
 210                     unsigned int *width, unsigned int *height)
 211 {
 212     WMColorWell *cPtr = (WMColorWell*)view->self;
 213     int bw;
 214
 215     if (cPtr->flags.bordered) {
 216
 217         if (*width < MIN_WIDTH)
 218             *width = MIN_WIDTH;
 219         if (*height < MIN_HEIGHT)
 220             *height = MIN_HEIGHT;
 221
 222         bw = (int)((float)MIN(*width, *height)*0.24);
 223
 224         W_ResizeView(cPtr->colorView, *width-2*bw, *height-2*bw);
 225
 226         if (cPtr->colorView->pos.x!=bw || cPtr->colorView->pos.y!=bw)
 227             W_MoveView(cPtr->colorView, bw, bw);
 228     } else {
 229         W_ResizeView(cPtr->colorView, *width, *height);
 230
 231         W_MoveView(cPtr->colorView, 0, 0);
 232     }
 233 }
 234
 235
 236 static void
 237 paintColorWell(ColorWell *cPtr)
 238 {
 239     W_Screen *scr = cPtr->view->screen;
 240
 241     W_DrawRelief(scr, cPtr->view->window, 0, 0, cPtr->view->size.width,
 242                  cPtr->view->size.height, WRRaised);
 243
 244     W_DrawRelief(scr, cPtr->colorView->window, 0, 0,
 245                  cPtr->colorView->size.width, cPtr->colorView->size.height,
 246                  WRSunken);
 247
 248     if (cPtr->color)
 249         WMPaintColorSwatch(cPtr->color, cPtr->colorView->window,
 250                            2, 2, cPtr->colorView->size.width-4,
 251                            cPtr->colorView->size.height-4);
 252 }
 253
 254
 255
 256 static void
 257 handleEvents(XEvent *event, void *data)
 258 {
 259     ColorWell *cPtr = (ColorWell*)data;
 260
 261     CHECK_CLASS(data, WC_ColorWell);
 262
 263
 264     switch (event->type) {
 265      case Expose:
 266         if (event->xexpose.count!=0)
 267             break;
 268         paintColorWell(cPtr);
 269         break;
 270
 271      case DestroyNotify:
 272         destroyColorWell(cPtr);
 273         break;
 274
 275     }
 276 }
 277
 278
 279 static WMPixmap*
 280 makeDragPixmap(WMColorWell *cPtr)
 281 {
 282     WMScreen *scr = cPtr->view->screen;
 283     Pixmap pix;
 284
 285     pix = XCreatePixmap(scr->display, W_DRAWABLE(scr), 16, 16, scr->depth);
 286
 287     XFillRectangle(scr->display, pix, WMColorGC(cPtr->color), 0, 0, 15, 15);
 288
 289     XDrawRectangle(scr->display, pix, WMColorGC(scr->black), 0, 0, 15, 15);
 290
 291     return WMCreatePixmapFromXPixmaps(scr, pix, None, 16, 16, scr->depth);
 292 }
 293
 294
 295 static void
 296 slideView(WMView *view, int srcX, int srcY, int dstX, int dstY)
 297 {
 298     double x, y, dx, dy;
 299     int i;
 300
 301     srcX -= 8;
 302     srcY -= 8;
 303     dstX -= 8;
 304     dstY -= 8;
 305
 306     x = srcX;
 307     y = srcY;
 308
 309     dx = (double)(dstX-srcX)/20.0;
 310     dy = (double)(dstY-srcY)/20.0;
 311
 312     for (i = 0; i < 20; i++) {
 313         W_MoveView(view, x, y);
 314         XFlush(view->screen->display);
 315
 316         x += dx;
 317         y += dy;
 318     }
 319 }
 320
 321
 322 static void
 323 dragColor(ColorWell *cPtr, XEvent *event, WMPixmap *image)
 324 {
 325     WMView *dragView;
 326     WMScreen *scr = cPtr->view->screen;
 327     Display *dpy = scr->display;
 328     XColor black = {0, 0,0,0, DoRed|DoGreen|DoBlue};
 329     XColor green = {0x0045b045, 0x4500,0xb000,0x4500, DoRed|DoGreen|DoBlue};
 330     XColor back = {0, 0xffff,0xffff,0xffff, DoRed|DoGreen|DoBlue};
 331     Bool done = False;
 332     WMColorWell *activeWell = NULL;
 333
 334     dragView = W_CreateTopView(scr);
 335
 336     W_ResizeView(dragView, 16, 16);
 337     dragView->attribFlags |= CWOverrideRedirect | CWSaveUnder;
 338     dragView->attribs.event_mask = StructureNotifyMask;
 339     dragView->attribs.override_redirect = True;
 340     dragView->attribs.save_under = True;
 341
 342     W_MoveView(dragView, event->xmotion.x_root-8, event->xmotion.y_root-8);
 343
 344     W_RealizeView(dragView);
 345
 346     W_MapView(dragView);
 347
 348     XSetWindowBackgroundPixmap(dpy, dragView->window, WMGetPixmapXID(image));
 349     XClearWindow(dpy, dragView->window);
 350
 351
 352     XGrabPointer(dpy, dragView->window, True,
 353                  ButtonMotionMask|ButtonReleaseMask|EnterWindowMask,
 354                  GrabModeSync, GrabModeAsync,
 355                  scr->rootWin, scr->defaultCursor, CurrentTime);
 356
 357     while (!done) {
 358         XEvent ev;
 359         WMView *view;
 360
 361         XAllowEvents(dpy, SyncPointer, CurrentTime);
 362         WMNextEvent(dpy, &ev);
 363
 364         switch (ev.type) {
 365          case ButtonRelease:
 366             if (activeWell != NULL) {
 367                 WMSetColorWellColor(activeWell, cPtr->color);
 368                 WMPostNotificationName(WMColorWellDidChangeNotification,
 369                                        activeWell, NULL);
 370             } else {
 371                 slideView(dragView, ev.xbutton.x_root, ev.xbutton.y_root,
 372                           event->xmotion.x_root, event->xmotion.y_root);
 373             }
 374
 375             done = True;
 376             break;
 377
 378          case EnterNotify:
 379             view = W_GetViewForXWindow(dpy, ev.xcrossing.window);
 380
 381             if (view && view->self && W_CLASS(view->self) == WC_ColorWell
 382                 && view->self != activeWell && view->self != cPtr) {
 383
 384                 activeWell = view->self;
 385                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
 386             } else if (view->self!=NULL && view->self != activeWell) {
 387                 XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
 388                 activeWell = NULL;
 389             }
 390             break;
 391
 392          case MotionNotify:
 393             W_MoveView(dragView, ev.xmotion.x_root-8, ev.xmotion.y_root-8);
 394             break;
 395
 396          default:
 397             WMHandleEvent(&ev);
 398             break;
 399         }
 400     }
 401     XUngrabPointer(dpy, CurrentTime);
 402     XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
 403
 404     W_DestroyView(dragView);
 405 }
 406
 407
 408 static void
 409 handleDragEvents(XEvent *event, void *data)
 410 {
 411     WMColorWell *cPtr = (ColorWell*)data;
 412
 413     switch (event->type) {
 414      case ButtonPress:
 415         if (event->xbutton.button == Button1) {
 416             cPtr->ipoint.x = event->xbutton.x;
 417             cPtr->ipoint.y = event->xbutton.y;
 418         }
 419         break;
 420
 421      case MotionNotify:
 422         if (event->xmotion.state & Button1Mask) {
 423             if (abs(cPtr->ipoint.x - event->xmotion.x) > 4
 424                 || abs(cPtr->ipoint.y - event->xmotion.y) > 4) {
 425                 WMSize offs;
 426                 WMPixmap *pixmap;
 427
 428                 offs.width = 2;
 429                 offs.height = 2;
 430                 pixmap = makeDragPixmap(cPtr);
 431
 432                 /*
 433                 WMDragImageFromView(cPtr->view, pixmap, cPtr->view->pos,
 434                                    offs, event, True);
 435                  * */
 436
 437                 dragColor(cPtr, event, pixmap);
 438
 439                 WMReleasePixmap(pixmap);
 440             }
 441         }
 442         break;
 443     }
 444 }
 445
 446
 447 static void
 448 handleActionEvents(XEvent *event, void *data)
 449 {
 450     WMColorWell *cPtr = (ColorWell*)data;
 451     WMScreen *scr = WMWidgetScreen(cPtr);
 452     WMColorPanel *cpanel;
 453
 454     if (cPtr->flags.active)
 455         W_SetViewBackgroundColor(cPtr->view, scr->gray);
 456     else
 457         W_SetViewBackgroundColor(cPtr->view, scr->white);
 458     paintColorWell(cPtr);
 459
 460     cPtr->flags.active ^= 1;
 461
 462     if (cPtr->flags.active) {
 463         WMPostNotificationName(_ColorWellActivatedNotification, cPtr, NULL);
 464     }
 465     cpanel = WMGetColorPanel(scr);
 466
 467     WMSetColorPanelAction(cpanel, updateColorCallback, cPtr);
 468
 469     if (cPtr->color)
 470         WMSetColorPanelColor(cpanel, cPtr->color);
 471     WMShowColorPanel(cpanel);
 472 }
 473
 474
 475 static void
 476 destroyColorWell(ColorWell *cPtr)
 477 {
 478     WMRemoveNotificationObserver(cPtr);
 479
 480     if (cPtr->color)
 481         WMReleaseColor(cPtr->color);
 482
 483     wfree(cPtr);
 484 }
 485