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