WINGs/wcolorwell.c

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