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