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