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 static unsigned draggingSourceOperation(WMView *self, Bool local);
  57 static void beganDragImage(WMView *self, WMPixmap *image, WMPoint point);
  58 static void endedDragImage(WMView *self, WMPixmap *image, WMPoint point,
  59                            Bool deposited);
  60
  61
  62 static WMDragSourceProcs _DragSourceProcs = {
  63     draggingSourceOperation,
  64     beganDragImage,
  65     endedDragImage,
  66     NULL
  67 };
  68
  69
  70 static unsigned draggingEntered(WMView *self, WMDraggingInfo *info);
  71 static unsigned draggingUpdated(WMView *self, WMDraggingInfo *info);
  72 static void draggingExited(WMView *self, WMDraggingInfo *info);
  73 static Bool prepareForDragOperation(WMView *self, WMDraggingInfo *info);
  74 static Bool performDragOperation(WMView *self, WMDraggingInfo *info);
  75 static void concludeDragOperation(WMView *self, WMDraggingInfo *info);
  76
  77 static WMDragDestinationProcs _DragDestinationProcs = {
  78     draggingEntered,
  79     draggingUpdated,
  80     draggingExited,
  81     prepareForDragOperation,
  82     performDragOperation,
  83     concludeDragOperation
  84 };
  85
  86
  87 #define DEFAULT_WIDTH           60
  88 #define DEFAULT_HEIGHT          30
  89 #define DEFAULT_BORDER_WIDTH    6
  90
  91 #define MIN_WIDTH       16
  92 #define MIN_HEIGHT      8
  93
  94
  95
  96 static void
  97 colorChangedObserver(void *data, WMNotification *notification)
  98 {
  99     WMColorPanel *panel = (WMColorPanel*)WMGetNotificationObject(notification);
 100     WMColorWell *cPtr = (WMColorWell*)data;
 101     WMColor *color;
 102
 103     if (!cPtr->flags.active)
 104         return;
 105
 106     color = WMGetColorPanelColor(panel);
 107
 108     WMSetColorWellColor(cPtr, color);
 109     WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
 110 }
 111
 112
 113 static void
 114 updateColorCallback(void *self, void *data)
 115 {
 116     WMColorPanel *panel = (WMColorPanel*)self;
 117     WMColorWell *cPtr = (ColorWell*)data;
 118     WMColor *color;
 119
 120     color = WMGetColorPanelColor(panel);
 121     WMSetColorWellColor(cPtr, color);
 122     WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
 123 }
 124
 125
 126
 127 static void
 128 activatedObserver(void *data, WMNotification *notification)
 129 {
 130 /*
 131     WMColorWell *cPtr = (WMColorWell*)data;
 132
 133     if (!cPtr->flags.active || WMGetNotificationObject(notification) == cPtr)
 134         return;
 135
 136     W_SetViewBackgroundColor(cPtr->view, WMWidgetScreen(cPtr)->gray);
 137     paintColorWell(cPtr);
 138
 139     cPtr->flags.active = 0;
 140  */
 141 }
 142
 143
 144
 145 WMColorWell*
 146 WMCreateColorWell(WMWidget *parent)
 147 {
 148     ColorWell *cPtr;
 149
 150     cPtr = wmalloc(sizeof(ColorWell));
 151     memset(cPtr, 0, sizeof(ColorWell));
 152
 153     cPtr->widgetClass = WC_ColorWell;
 154
 155     cPtr->view = W_CreateView(W_VIEW(parent));
 156     if (!cPtr->view) {
 157         wfree(cPtr);
 158         return NULL;
 159     }
 160     cPtr->view->self = cPtr;
 161
 162     cPtr->view->delegate = &_ColorWellViewDelegate;
 163
 164     cPtr->colorView = W_CreateView(cPtr->view);
 165     if (!cPtr->colorView) {
 166         W_DestroyView(cPtr->view);
 167         wfree(cPtr);
 168         return NULL;
 169     }
 170     cPtr->colorView->self = cPtr;
 171
 172     WMCreateEventHandler(cPtr->view, ExposureMask|StructureNotifyMask
 173                          |ClientMessageMask, handleEvents, cPtr);
 174
 175     WMCreateEventHandler(cPtr->colorView, ExposureMask, handleEvents, cPtr);
 176
 177     WMCreateEventHandler(cPtr->colorView, ButtonPressMask|ButtonMotionMask
 178                          |EnterWindowMask, handleDragEvents, cPtr);
 179
 180     WMCreateEventHandler(cPtr->view, ButtonPressMask, handleActionEvents,
 181                          cPtr);
 182
 183     cPtr->colorView->flags.mapWhenRealized = 1;
 184
 185     cPtr->flags.bordered = 1;
 186
 187     W_ResizeView(cPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 188
 189     WMAddNotificationObserver(activatedObserver, cPtr,
 190                               _ColorWellActivatedNotification, NULL);
 191
 192     cPtr->color = WMBlackColor(WMWidgetScreen(cPtr));
 193
 194     WMAddNotificationObserver(colorChangedObserver, cPtr,
 195                               WMColorPanelColorChangedNotification, NULL);
 196
 197    // WMSetViewDragSourceProcs(cPtr->view, &_DragSourceProcs);
 198   //  WMSetViewDragDestinationProcs(cPtr->view, &_DragDestinationProcs);
 199
 200     {
 201         char *types[2] = {"application/X-color", NULL};
 202
 203         //WMRegisterViewForDraggedTypes(cPtr->view, types);
 204     }
 205
 206     return cPtr;
 207 }
 208
 209
 210 void
 211 WMSetColorWellColor(WMColorWell *cPtr, WMColor *color)
 212 {
 213     if (cPtr->color)
 214         WMReleaseColor(cPtr->color);
 215
 216     cPtr->color = WMRetainColor(color);
 217
 218     if (cPtr->colorView->flags.realized && cPtr->colorView->flags.mapped)
 219         paintColorWell(cPtr);
 220 }
 221
 222
 223 WMColor*
 224 WMGetColorWellColor(WMColorWell *cPtr)
 225 {
 226     return cPtr->color;
 227 }
 228
 229
 230 void
 231 WSetColorWellBordered(WMColorWell *cPtr, Bool flag)
 232 {
 233     if (cPtr->flags.bordered != flag) {
 234         cPtr->flags.bordered = flag;
 235         W_ResizeView(cPtr->view, cPtr->view->size.width, cPtr->view->size.height);
 236     }
 237 }
 238
 239
 240 #define MIN(a,b)        ((a) > (b) ? (b) : (a))
 241
 242 static void
 243 willResizeColorWell(W_ViewDelegate *self, WMView *view,
 244                     unsigned int *width, unsigned int *height)
 245 {
 246     WMColorWell *cPtr = (WMColorWell*)view->self;
 247     int bw;
 248
 249     if (cPtr->flags.bordered) {
 250
 251         if (*width < MIN_WIDTH)
 252             *width = MIN_WIDTH;
 253         if (*height < MIN_HEIGHT)
 254             *height = MIN_HEIGHT;
 255
 256         bw = (int)((float)MIN(*width, *height)*0.24);
 257
 258         W_ResizeView(cPtr->colorView, *width-2*bw, *height-2*bw);
 259
 260         if (cPtr->colorView->pos.x!=bw || cPtr->colorView->pos.y!=bw)
 261             W_MoveView(cPtr->colorView, bw, bw);
 262     } else {
 263         W_ResizeView(cPtr->colorView, *width, *height);
 264
 265         W_MoveView(cPtr->colorView, 0, 0);
 266     }
 267 }
 268
 269
 270 static void
 271 paintColorWell(ColorWell *cPtr)
 272 {
 273     W_Screen *scr = cPtr->view->screen;
 274
 275     W_DrawRelief(scr, cPtr->view->window, 0, 0, cPtr->view->size.width,
 276                  cPtr->view->size.height, WRRaised);
 277
 278     W_DrawRelief(scr, cPtr->colorView->window, 0, 0,
 279                  cPtr->colorView->size.width, cPtr->colorView->size.height,
 280                  WRSunken);
 281
 282     if (cPtr->color)
 283         WMPaintColorSwatch(cPtr->color, cPtr->colorView->window,
 284                            2, 2, cPtr->colorView->size.width-4,
 285                            cPtr->colorView->size.height-4);
 286 }
 287
 288
 289
 290 static void
 291 handleEvents(XEvent *event, void *data)
 292 {
 293     ColorWell *cPtr = (ColorWell*)data;
 294
 295     CHECK_CLASS(data, WC_ColorWell);
 296
 297
 298     switch (event->type) {
 299      case Expose:
 300         if (event->xexpose.count!=0)
 301             break;
 302         paintColorWell(cPtr);
 303         break;
 304
 305      case DestroyNotify:
 306         destroyColorWell(cPtr);
 307         break;
 308
 309     }
 310 }
 311
 312
 313 static unsigned
 314 draggingSourceOperation(WMView *self, Bool local)
 315 {
 316     puts("DRAG SOURCE");
 317     return 0;
 318 }
 319
 320
 321 static void
 322 beganDragImage(WMView *self, WMPixmap *image, WMPoint point)
 323 {
 324     puts("BEGAN DRAG");
 325 }
 326
 327
 328 static void
 329 endedDragImage(WMView *self, WMPixmap *image, WMPoint point, Bool deposited)
 330 {
 331     if (deposited)
 332         puts("ENDED DRAG SUCCESS");
 333     else
 334         puts("ENDED DRAG CANCEL");
 335 }
 336
 337
 338
 339 static WMPixmap*
 340 makeDragPixmap(WMColorWell *cPtr)
 341 {
 342     WMScreen *scr = cPtr->view->screen;
 343     Pixmap pix;
 344
 345     pix = XCreatePixmap(scr->display, W_DRAWABLE(scr), 16, 16, scr->depth);
 346
 347     XFillRectangle(scr->display, pix, WMColorGC(cPtr->color), 0, 0, 15, 15);
 348
 349     XDrawRectangle(scr->display, pix, WMColorGC(scr->black), 0, 0, 15, 15);
 350
 351     return WMCreatePixmapFromXPixmaps(scr, pix, None, 16, 16, scr->depth);
 352 }
 353
 354
 355 static void
 356 handleDragEvents(XEvent *event, void *data)
 357 {
 358     WMColorWell *cPtr = (ColorWell*)data;
 359
 360     switch (event->type) {
 361      case ButtonPress:
 362         if (event->xbutton.button == Button1) {
 363             cPtr->ipoint.x = event->xbutton.x;
 364             cPtr->ipoint.y = event->xbutton.y;
 365         }
 366         break;
 367
 368      case MotionNotify:
 369         if (event->xmotion.state & Button1Mask) {
 370             if (abs(cPtr->ipoint.x - event->xmotion.x) > 4
 371                 || abs(cPtr->ipoint.y - event->xmotion.y) > 4) {
 372                 WMSize offs;
 373                 WMPixmap *pixmap;
 374                 char *types[2] = {"application/X-color", NULL};
 375
 376                 offs.width = 2;
 377                 offs.height = 2;
 378                 pixmap = makeDragPixmap(cPtr);
 379 /*
 380                 WMDragImageFromView(cPtr->view, pixmap, types,
 381                                     wmkpoint(event->xmotion.x_root,
 382                                              event->xmotion.y_root),
 383                                     offs, event, True);
 384                                    */
 385
 386                 WMReleasePixmap(pixmap);
 387             }
 388         }
 389         break;
 390     }
 391 }
 392
 393
 394 static void
 395 handleActionEvents(XEvent *event, void *data)
 396 {
 397     WMColorWell *cPtr = (ColorWell*)data;
 398     WMScreen *scr = WMWidgetScreen(cPtr);
 399     WMColorPanel *cpanel;
 400
 401     if (cPtr->flags.active)
 402         W_SetViewBackgroundColor(cPtr->view, scr->gray);
 403     else
 404         W_SetViewBackgroundColor(cPtr->view, scr->white);
 405     paintColorWell(cPtr);
 406
 407     cPtr->flags.active ^= 1;
 408
 409     if (cPtr->flags.active) {
 410         WMPostNotificationName(_ColorWellActivatedNotification, cPtr, NULL);
 411     }
 412     cpanel = WMGetColorPanel(scr);
 413
 414     WMSetColorPanelAction(cpanel, updateColorCallback, cPtr);
 415
 416     if (cPtr->color)
 417         WMSetColorPanelColor(cpanel, cPtr->color);
 418     WMShowColorPanel(cpanel);
 419 }
 420
 421
 422 static void
 423 destroyColorWell(ColorWell *cPtr)
 424 {
 425     WMRemoveNotificationObserver(cPtr);
 426
 427     if (cPtr->color)
 428         WMReleaseColor(cPtr->color);
 429
 430     wfree(cPtr);
 431 }
 432
 433
 434
 435 static unsigned
 436 draggingEntered(WMView *self, WMDraggingInfo *info)
 437 {
 438     WMPoint point = WMGetViewScreenPosition(self);
 439
 440     printf("%i %i || %i %i %i %i\n", info->location.x, info->location.y,
 441            point.x, point.y, W_VIEW_WIDTH(self), W_VIEW_HEIGHT(self));
 442
 443     if (info->location.x >= point.x
 444         && info->location.y >= point.y
 445         && info->location.x < point.x + W_VIEW_WIDTH(self)
 446         && info->location.y < point.y + W_VIEW_HEIGHT(self)) {
 447         /* self */
 448         puts("ENTERED 0");
 449         return 0;
 450     } else {
 451         puts("ENTERED 1");
 452         return 1;
 453     }
 454 }
 455
 456
 457 static unsigned
 458 draggingUpdated(WMView *self, WMDraggingInfo *info)
 459 {
 460
 461     WMPoint point = WMGetViewScreenPosition(self);
 462
 463     puts("UPDATED");
 464     if (info->location.x >= point.x
 465         && info->location.y >= point.y
 466         && info->location.x < point.x + W_VIEW_WIDTH(self)
 467         && info->location.y < point.y + W_VIEW_WIDTH(self)) {
 468         return 0;
 469     } else {
 470         return 1;
 471     }
 472 }
 473
 474
 475 static void
 476 draggingExited(WMView *self, WMDraggingInfo *info)
 477 {
 478     puts("EXITED");
 479 }
 480
 481
 482 static Bool
 483 prepareForDragOperation(WMView *self, WMDraggingInfo *info)
 484 {
 485     puts("PREPARING");
 486     return True;
 487 }
 488
 489
 490 static Bool
 491 performDragOperation(WMView *self, WMDraggingInfo *info)
 492 {
 493     WMData *data;
 494
 495  //   data = WMGetDroppedData(self);
 496     puts("DROPPED");
 497     return True;
 498 }
 499
 500
 501 static void
 502 concludeDragOperation(WMView *self, WMDraggingInfo *info)
 503 {
 504     puts("FINISHED");
 505 }