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();
  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()
 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         if (cPtr->flags.bordered) {
 222
 223                 if (*width < MIN_WIDTH)
 224                         *width = MIN_WIDTH;
 225                 if (*height < MIN_HEIGHT)
 226                         *height = MIN_HEIGHT;
 227
 228                 bw = (int)((float)WMIN(*width, *height) * 0.24);
 229
 230                 W_ResizeView(cPtr->colorView, *width - 2 * bw, *height - 2 * bw);
 231
 232                 if (cPtr->colorView->pos.x != bw || cPtr->colorView->pos.y != bw)
 233                         W_MoveView(cPtr->colorView, bw, bw);
 234         } else {
 235                 W_ResizeView(cPtr->colorView, *width, *height);
 236
 237                 W_MoveView(cPtr->colorView, 0, 0);
 238         }
 239 }
 240
 241 static void paintColorWell(ColorWell * cPtr)
 242 {
 243         W_Screen *scr = cPtr->view->screen;
 244
 245         W_DrawRelief(scr, cPtr->view->window, 0, 0, cPtr->view->size.width, cPtr->view->size.height, WRRaised);
 246
 247         W_DrawRelief(scr, cPtr->colorView->window, 0, 0,
 248                      cPtr->colorView->size.width, cPtr->colorView->size.height, WRSunken);
 249
 250         if (cPtr->color)
 251                 WMPaintColorSwatch(cPtr->color, cPtr->colorView->window,
 252                                    2, 2, cPtr->colorView->size.width - 4, cPtr->colorView->size.height - 4);
 253 }
 254
 255 static void handleEvents(XEvent * event, void *data)
 256 {
 257         ColorWell *cPtr = (ColorWell *) data;
 258
 259         CHECK_CLASS(data, WC_ColorWell);
 260
 261         switch (event->type) {
 262         case Expose:
 263                 if (event->xexpose.count != 0)
 264                         break;
 265                 paintColorWell(cPtr);
 266                 break;
 267
 268         case DestroyNotify:
 269                 destroyColorWell(cPtr);
 270                 break;
 271
 272         }
 273 }
 274
 275 static WMArray *dropDataTypes(WMView * self)
 276 {
 277         return ((ColorWell *) self->self)->xdndTypes;
 278 }
 279
 280 static WMDragOperationType wantedDropOperation(WMView * self)
 281 {
 282         return WDOperationCopy;
 283 }
 284
 285 static Bool acceptDropOperation(WMView * self, WMDragOperationType operation)
 286 {
 287         return (operation == WDOperationCopy);
 288 }
 289
 290 static WMData *fetchDragData(WMView * self, char *type)
 291 {
 292         char *color = WMGetColorRGBDescription(((WMColorWell *) self->self)->color);
 293         WMData *data;
 294
 295         data = WMCreateDataWithBytes(color, strlen(color) + 1);
 296         wfree(color);
 297
 298         return data;
 299 }
 300
 301 static WMPixmap *makeDragPixmap(WMColorWell * cPtr)
 302 {
 303         WMScreen *scr = cPtr->view->screen;
 304         Pixmap pix;
 305
 306         pix = XCreatePixmap(scr->display, W_DRAWABLE(scr), 16, 16, scr->depth);
 307
 308         XFillRectangle(scr->display, pix, WMColorGC(cPtr->color), 0, 0, 15, 15);
 309
 310         XDrawRectangle(scr->display, pix, WMColorGC(scr->black), 0, 0, 15, 15);
 311
 312         return WMCreatePixmapFromXPixmaps(scr, pix, None, 16, 16, scr->depth);
 313 }
 314
 315 static void handleDragEvents(XEvent * event, void *data)
 316 {
 317         WMColorWell *cPtr = (ColorWell *) data;
 318
 319         if (event->type == ButtonPress && event->xbutton.button == Button1) {
 320                 /* initialise drag icon */
 321                 WMSetViewDragImage(cPtr->colorView, makeDragPixmap(cPtr));
 322         }
 323
 324         WMDragImageFromView(cPtr->colorView, event);
 325 }
 326
 327 static void handleActionEvents(XEvent * event, void *data)
 328 {
 329         WMColorWell *cPtr = (ColorWell *) data;
 330         WMScreen *scr = WMWidgetScreen(cPtr);
 331         WMColorPanel *cpanel;
 332
 333         if (cPtr->flags.active)
 334                 W_SetViewBackgroundColor(cPtr->view, scr->gray);
 335         else
 336                 W_SetViewBackgroundColor(cPtr->view, scr->white);
 337         paintColorWell(cPtr);
 338
 339         cPtr->flags.active ^= 1;
 340
 341         if (cPtr->flags.active) {
 342                 WMPostNotificationName(_ColorWellActivatedNotification, cPtr, NULL);
 343         }
 344         cpanel = WMGetColorPanel(scr);
 345
 346         WMSetColorPanelAction(cpanel, updateColorCallback, cPtr);
 347
 348         if (cPtr->color)
 349                 WMSetColorPanelColor(cpanel, cPtr->color);
 350         WMShowColorPanel(cpanel);
 351 }
 352
 353 static void destroyColorWell(ColorWell * cPtr)
 354 {
 355         WMRemoveNotificationObserver(cPtr);
 356
 357         if (cPtr->color)
 358                 WMReleaseColor(cPtr->color);
 359
 360         WMFreeArray(cPtr->xdndTypes);
 361
 362         wfree(cPtr);
 363 }
 364
 365 static Bool dropIsOk(WMDragOperationType request, WMArray * sourceDataTypes)
 366 {
 367         WMArrayIterator iter;
 368         char *type;
 369
 370         if (request == WDOperationCopy) {
 371                 WM_ITERATE_ARRAY(sourceDataTypes, type, iter) {
 372                         if (type != NULL && strcmp(type, XDND_COLOR_DATA_TYPE) == 0) {
 373                                 return True;
 374                         }
 375                 }
 376         }
 377
 378         return False;
 379 }
 380
 381 static WMArray *requiredDataTypes(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
 382 {
 383         if (dropIsOk(request, sourceDataTypes))
 384                 return ((ColorWell *) self->self)->xdndTypes;
 385         else
 386                 return NULL;
 387 }
 388
 389 static WMDragOperationType allowedOperation(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
 390 {
 391         if (dropIsOk(request, sourceDataTypes))
 392                 return WDOperationCopy;
 393         else
 394                 return WDOperationNone;
 395 }
 396
 397 static void performDragOperation(WMView * self, WMArray * dropData, WMArray * operations, WMPoint * dropLocation)
 398 {
 399         char *colorName;
 400         WMColor *color;
 401         WMData *data;
 402
 403         /* only one operation requested (WDOperationCopy) implies only one data */
 404         data = (WMData *) WMGetFromArray(dropData, 0);
 405
 406         if (data != NULL) {
 407                 colorName = (char *)WMDataBytes(data);
 408                 color = WMCreateNamedColor(W_VIEW_SCREEN(self), colorName, True);
 409                 WMSetColorWellColor(self->self, color);
 410                 WMReleaseColor(color);
 411         }
 412 }