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