WINGs/wcolorwell.c

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