WINGs/wcolorwell.c

   1
   2 #include "WINGsP.h"
   3
   4 #define XDND_COLOR_DATA_TYPE "application/X-color"
   5
   6 char *WMColorWellDidChangeNotification = "WMColorWellDidChangeNotification";
   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
  26         WMArray *xdndTypes;
  27 } ColorWell;
  28
  29 static char *_ColorWellActivatedNotification = "_ColorWellActivatedNotification";
  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 willResizeColorWell(W_ViewDelegate * self, WMView * view, unsigned int *width, unsigned int *height);
  41
  42 W_ViewDelegate _ColorWellViewDelegate = {
  43         NULL,
  44         NULL,
  45         NULL,
  46         NULL,
  47         willResizeColorWell
  48 };
  49
  50 static WMArray *dropDataTypes(WMView * self);
  51 static WMDragOperationType wantedDropOperation(WMView * self);
  52 static Bool acceptDropOperation(WMView * self, WMDragOperationType operation);
  53 static WMData *fetchDragData(WMView * self, char *type);
  54
  55 static WMDragSourceProcs _DragSourceProcs = {
  56         dropDataTypes,
  57         wantedDropOperation,
  58         NULL,
  59         acceptDropOperation,
  60         NULL,
  61         NULL,
  62         fetchDragData
  63 };
  64
  65 static WMArray *requiredDataTypes(WMView * self,
  66                                   WMDragOperationType requestedOperation, WMArray * sourceDataTypes);
  67 static WMDragOperationType allowedOperation(WMView * self,
  68                                             WMDragOperationType requestedOperation, WMArray * sourceDataTypes);
  69 static void performDragOperation(WMView * self, WMArray * dropDatas,
  70                                  WMArray * operationsList, WMPoint * dropLocation);
  71
  72 static WMDragDestinationProcs _DragDestinationProcs = {
  73         NULL,
  74         requiredDataTypes,
  75         allowedOperation,
  76         NULL,
  77         performDragOperation,
  78         NULL
  79 };
  80
  81 #define DEFAULT_WIDTH           60
  82 #define DEFAULT_HEIGHT          30
  83 #define DEFAULT_BORDER_WIDTH    6
  84
  85 #define MIN_WIDTH       16
  86 #define MIN_HEIGHT      8
  87
  88 static void colorChangedObserver(void *data, WMNotification * notification)
  89 {
  90         WMColorPanel *panel = (WMColorPanel *) WMGetNotificationObject(notification);
  91         WMColorWell *cPtr = (WMColorWell *) data;
  92         WMColor *color;
  93
  94         if (!cPtr->flags.active)
  95                 return;
  96
  97         color = WMGetColorPanelColor(panel);
  98
  99         WMSetColorWellColor(cPtr, color);
 100         WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
 101 }
 102
 103 static void updateColorCallback(void *self, void *data)
 104 {
 105         WMColorPanel *panel = (WMColorPanel *) self;
 106         WMColorWell *cPtr = (ColorWell *) data;
 107         WMColor *color;
 108
 109         color = WMGetColorPanelColor(panel);
 110         WMSetColorWellColor(cPtr, color);
 111         WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
 112 }
 113
 114 static void activatedObserver(void *data, WMNotification * notification)
 115 {
 116         /*
 117            WMColorWell *cPtr = (WMColorWell*)data;
 118
 119            if (!cPtr->flags.active || WMGetNotificationObject(notification) == cPtr)
 120            return;
 121
 122            W_SetViewBackgroundColor(cPtr->view, WMWidgetScreen(cPtr)->gray);
 123            paintColorWell(cPtr);
 124
 125            cPtr->flags.active = 0;
 126          */
 127 }
 128
 129 static WMArray *getXdndTypeArray(void)
 130 {
 131         WMArray *types = WMCreateArray(1);
 132         WMAddToArray(types, XDND_COLOR_DATA_TYPE);
 133         return types;
 134 }
 135
 136 WMColorWell *WMCreateColorWell(WMWidget * parent)
 137 {
 138         ColorWell *cPtr;
 139
 140         cPtr = wmalloc(sizeof(ColorWell));
 141
 142         cPtr->widgetClass = WC_ColorWell;
 143
 144         cPtr->view = W_CreateView(W_VIEW(parent));
 145         if (!cPtr->view) {
 146                 wfree(cPtr);
 147                 return NULL;
 148         }
 149         cPtr->view->self = cPtr;
 150
 151         cPtr->view->delegate = &_ColorWellViewDelegate;
 152
 153         cPtr->colorView = W_CreateView(cPtr->view);
 154         if (!cPtr->colorView) {
 155                 W_DestroyView(cPtr->view);
 156                 wfree(cPtr);
 157                 return NULL;
 158         }
 159         cPtr->colorView->self = cPtr;
 160
 161         WMCreateEventHandler(cPtr->view, ExposureMask | StructureNotifyMask
 162                              | ClientMessageMask, handleEvents, cPtr);
 163
 164         WMCreateEventHandler(cPtr->colorView, ExposureMask, handleEvents, cPtr);
 165
 166         WMCreateDragHandler(cPtr->colorView, handleDragEvents, cPtr);
 167
 168         WMCreateEventHandler(cPtr->view, ButtonPressMask, handleActionEvents, cPtr);
 169
 170         cPtr->colorView->flags.mapWhenRealized = 1;
 171
 172         cPtr->flags.bordered = 1;
 173
 174         W_ResizeView(cPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 175
 176         WMAddNotificationObserver(activatedObserver, cPtr, _ColorWellActivatedNotification, NULL);
 177
 178         cPtr->color = WMBlackColor(WMWidgetScreen(cPtr));
 179
 180         WMAddNotificationObserver(colorChangedObserver, cPtr, WMColorPanelColorChangedNotification, NULL);
 181
 182         WMSetViewDragSourceProcs(cPtr->colorView, &_DragSourceProcs);
 183         WMSetViewDragDestinationProcs(cPtr->colorView, &_DragDestinationProcs);
 184
 185         cPtr->xdndTypes = getXdndTypeArray();
 186         WMRegisterViewForDraggedTypes(cPtr->colorView, cPtr->xdndTypes);
 187
 188         return cPtr;
 189 }
 190
 191 void WMSetColorWellColor(WMColorWell * cPtr, WMColor * color)
 192 {
 193         if (cPtr->color)
 194                 WMReleaseColor(cPtr->color);
 195
 196         cPtr->color = WMRetainColor(color);
 197
 198         if (cPtr->colorView->flags.realized && cPtr->colorView->flags.mapped)
 199                 paintColorWell(cPtr);
 200 }
 201
 202 WMColor *WMGetColorWellColor(WMColorWell * cPtr)
 203 {
 204         return cPtr->color;
 205 }
 206
 207 void WSetColorWellBordered(WMColorWell * cPtr, Bool flag)
 208 {
 209         flag = ((flag == 0) ? 0 : 1);
 210         if (cPtr->flags.bordered != flag) {
 211                 cPtr->flags.bordered = flag;
 212                 W_ResizeView(cPtr->view, cPtr->view->size.width, cPtr->view->size.height);
 213         }
 214 }
 215
 216 static void willResizeColorWell(W_ViewDelegate * self, WMView * view, unsigned int *width, unsigned int *height)
 217 {
 218         WMColorWell *cPtr = (WMColorWell *) view->self;
 219         int bw;
 220
 221         /* Parameter not used, but tell the compiler that it is ok */
 222         (void) self;
 223
 224         if (cPtr->flags.bordered) {
 225
 226                 if (*width < MIN_WIDTH)
 227                         *width = MIN_WIDTH;
 228                 if (*height < MIN_HEIGHT)
 229                         *height = MIN_HEIGHT;
 230
 231                 bw = (int)((float)WMIN(*width, *height) * 0.24);
 232
 233                 W_ResizeView(cPtr->colorView, *width - 2 * bw, *height - 2 * bw);
 234
 235                 if (cPtr->colorView->pos.x != bw || cPtr->colorView->pos.y != bw)
 236                         W_MoveView(cPtr->colorView, bw, bw);
 237         } else {
 238                 W_ResizeView(cPtr->colorView, *width, *height);
 239
 240                 W_MoveView(cPtr->colorView, 0, 0);
 241         }
 242 }
 243
 244 static void paintColorWell(ColorWell * cPtr)
 245 {
 246         W_Screen *scr = cPtr->view->screen;
 247
 248         W_DrawRelief(scr, cPtr->view->window, 0, 0, cPtr->view->size.width, cPtr->view->size.height, WRRaised);
 249
 250         W_DrawRelief(scr, cPtr->colorView->window, 0, 0,
 251                      cPtr->colorView->size.width, cPtr->colorView->size.height, WRSunken);
 252
 253         if (cPtr->color)
 254                 WMPaintColorSwatch(cPtr->color, cPtr->colorView->window,
 255                                    2, 2, cPtr->colorView->size.width - 4, cPtr->colorView->size.height - 4);
 256 }
 257
 258 static void handleEvents(XEvent * event, void *data)
 259 {
 260         ColorWell *cPtr = (ColorWell *) data;
 261
 262         CHECK_CLASS(data, WC_ColorWell);
 263
 264         switch (event->type) {
 265         case Expose:
 266                 if (event->xexpose.count != 0)
 267                         break;
 268                 paintColorWell(cPtr);
 269                 break;
 270
 271         case DestroyNotify:
 272                 destroyColorWell(cPtr);
 273                 break;
 274
 275         }
 276 }
 277
 278 static WMArray *dropDataTypes(WMView * self)
 279 {
 280         return ((ColorWell *) self->self)->xdndTypes;
 281 }
 282
 283 static WMDragOperationType wantedDropOperation(WMView * self)
 284 {
 285         /* Parameter not used, but tell the compiler that it is ok */
 286         (void) self;
 287
 288         return WDOperationCopy;
 289 }
 290
 291 static Bool acceptDropOperation(WMView * self, WMDragOperationType operation)
 292 {
 293         /* Parameter not used, but tell the compiler that it is ok */
 294         (void) self;
 295
 296         return (operation == WDOperationCopy);
 297 }
 298
 299 static WMData *fetchDragData(WMView * self, char *type)
 300 {
 301         char *color = WMGetColorRGBDescription(((WMColorWell *) self->self)->color);
 302         WMData *data;
 303
 304         /* Parameter not used, but tell the compiler that it is ok */
 305         (void) type;
 306
 307         data = WMCreateDataWithBytes(color, strlen(color) + 1);
 308         wfree(color);
 309
 310         return data;
 311 }
 312
 313 static WMPixmap *makeDragPixmap(WMColorWell * cPtr)
 314 {
 315         WMScreen *scr = cPtr->view->screen;
 316         Pixmap pix;
 317
 318         pix = XCreatePixmap(scr->display, W_DRAWABLE(scr), 16, 16, scr->depth);
 319
 320         XFillRectangle(scr->display, pix, WMColorGC(cPtr->color), 0, 0, 15, 15);
 321
 322         XDrawRectangle(scr->display, pix, WMColorGC(scr->black), 0, 0, 15, 15);
 323
 324         return WMCreatePixmapFromXPixmaps(scr, pix, None, 16, 16, scr->depth);
 325 }
 326
 327 static void handleDragEvents(XEvent * event, void *data)
 328 {
 329         WMColorWell *cPtr = (ColorWell *) data;
 330
 331         if (event->type == ButtonPress && event->xbutton.button == Button1) {
 332                 /* initialise drag icon */
 333                 WMSetViewDragImage(cPtr->colorView, makeDragPixmap(cPtr));
 334         }
 335
 336         WMDragImageFromView(cPtr->colorView, event);
 337 }
 338
 339 static void handleActionEvents(XEvent * event, void *data)
 340 {
 341         WMColorWell *cPtr = (ColorWell *) data;
 342         WMScreen *scr = WMWidgetScreen(cPtr);
 343         WMColorPanel *cpanel;
 344
 345         /* Parameter not used, but tell the compiler that it is ok */
 346         (void) event;
 347
 348         if (cPtr->flags.active)
 349                 W_SetViewBackgroundColor(cPtr->view, scr->gray);
 350         else
 351                 W_SetViewBackgroundColor(cPtr->view, scr->white);
 352         paintColorWell(cPtr);
 353
 354         cPtr->flags.active ^= 1;
 355
 356         if (cPtr->flags.active) {
 357                 WMPostNotificationName(_ColorWellActivatedNotification, cPtr, NULL);
 358         }
 359         cpanel = WMGetColorPanel(scr);
 360
 361         WMSetColorPanelAction(cpanel, updateColorCallback, cPtr);
 362
 363         if (cPtr->color)
 364                 WMSetColorPanelColor(cpanel, cPtr->color);
 365         WMShowColorPanel(cpanel);
 366 }
 367
 368 static void destroyColorWell(ColorWell * cPtr)
 369 {
 370         WMRemoveNotificationObserver(cPtr);
 371
 372         if (cPtr->color)
 373                 WMReleaseColor(cPtr->color);
 374
 375         WMFreeArray(cPtr->xdndTypes);
 376
 377         wfree(cPtr);
 378 }
 379
 380 static Bool dropIsOk(WMDragOperationType request, WMArray * sourceDataTypes)
 381 {
 382         WMArrayIterator iter;
 383         char *type;
 384
 385         if (request == WDOperationCopy) {
 386                 WM_ITERATE_ARRAY(sourceDataTypes, type, iter) {
 387                         if (type != NULL && strcmp(type, XDND_COLOR_DATA_TYPE) == 0) {
 388                                 return True;
 389                         }
 390                 }
 391         }
 392
 393         return False;
 394 }
 395
 396 static WMArray *requiredDataTypes(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
 397 {
 398         if (dropIsOk(request, sourceDataTypes))
 399                 return ((ColorWell *) self->self)->xdndTypes;
 400         else
 401                 return NULL;
 402 }
 403
 404 static WMDragOperationType allowedOperation(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
 405 {
 406         /* Parameter not used, but tell the compiler that it is ok */
 407         (void) self;
 408
 409         if (dropIsOk(request, sourceDataTypes))
 410                 return WDOperationCopy;
 411         else
 412                 return WDOperationNone;
 413 }
 414
 415 static void performDragOperation(WMView * self, WMArray * dropData, WMArray * operations, WMPoint * dropLocation)
 416 {
 417         char *colorName;
 418         WMColor *color;
 419         WMData *data;
 420
 421         /* Parameter not used, but tell the compiler that it is ok */
 422         (void) operations;
 423         (void) dropLocation;
 424
 425         /* only one operation requested (WDOperationCopy) implies only one data */
 426         data = (WMData *) WMGetFromArray(dropData, 0);
 427
 428         if (data != NULL) {
 429                 colorName = (char *)WMDataBytes(data);
 430                 color = WMCreateNamedColor(W_VIEW_SCREEN(self), colorName, True);
 431                 WMSetColorWellColor(self->self, color);
 432                 WMReleaseColor(color);
 433         }
 434 }