WINGs/wballoon.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 #include <X11/extensions/shape.h>
   8
   9
  10 typedef struct W_Balloon {
  11     W_View *view;
  12
  13     WMHashTable *table;                /* Table from view ptr to text */
  14
  15     WMColor *backColor;
  16     WMColor *textColor;
  17     WMFont *font;
  18
  19     WMHandlerID timer;                 /* timer for showing balloon */
  20
  21     WMHandlerID noDelayTimer;
  22
  23     int delay;
  24
  25     Window forWindow;                  /* window for which the balloon
  26                                         * is being show in the moment */
  27
  28     struct {
  29         WMAlignment alignment:2;
  30         unsigned enabled:1;
  31         unsigned noDelay:1;
  32     } flags;
  33 } Balloon;
  34
  35
  36
  37 #define DEFAULT_WIDTH           60
  38 #define DEFAULT_HEIGHT          14
  39 #define DEFAULT_ALIGNMENT       WALeft
  40 #define DEFAULT_DELAY           500
  41
  42 #define NO_DELAY_DELAY          150
  43
  44
  45 static void destroyBalloon(Balloon *bPtr);
  46
  47
  48 static void handleEvents(XEvent *event, void *data);
  49
  50 static void showText(Balloon *bPtr, int x, int y, int w, int h, char *text);
  51
  52
  53 struct W_Balloon*
  54 W_CreateBalloon(WMScreen *scr)
  55 {
  56     Balloon *bPtr;
  57
  58     bPtr = wmalloc(sizeof(Balloon));
  59     memset(bPtr, 0, sizeof(Balloon));
  60
  61     bPtr->view = W_CreateTopView(scr);
  62     if (!bPtr->view) {
  63         free(bPtr);
  64         return NULL;
  65     }
  66     bPtr->view->self = bPtr;
  67
  68     bPtr->view->attribFlags |= CWOverrideRedirect;
  69     bPtr->view->attribs.override_redirect = True;
  70
  71     bPtr->textColor = WMRetainColor(bPtr->view->screen->black);
  72
  73     WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
  74
  75     W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
  76     bPtr->flags.alignment = DEFAULT_ALIGNMENT;
  77
  78     bPtr->table = WMCreateHashTable(WMIntHashCallbacks);
  79
  80     bPtr->delay = DEFAULT_DELAY;
  81
  82     bPtr->flags.enabled = 1;
  83
  84     return bPtr;
  85 }
  86
  87
  88
  89 void
  90 WMSetBalloonTextAlignment(WMScreen *scr, WMAlignment alignment)
  91 {
  92     scr->balloon->flags.alignment = alignment;
  93
  94 }
  95
  96
  97 void
  98 WMSetBalloonTextForView(char *text, WMView *view)
  99 {
 100     char *oldText = NULL;
 101     WMScreen *scr = view->screen;
 102
 103     if (text) {
 104         oldText = WMHashInsert(scr->balloon->table, view, wstrdup(text));
 105     } else {
 106         oldText = WMHashGet(scr->balloon->table, view);
 107
 108         WMHashRemove(scr->balloon->table, view);
 109     }
 110
 111     if (oldText) {
 112         free(oldText);
 113     }
 114 }
 115
 116
 117 void
 118 WMSetBalloonFont(WMScreen *scr, WMFont *font)
 119 {
 120     Balloon *bPtr = scr->balloon;
 121
 122     if (bPtr->font!=NULL)
 123         WMReleaseFont(bPtr->font);
 124
 125     if (font)
 126         bPtr->font = WMRetainFont(font);
 127     else
 128         bPtr->font = NULL;
 129 }
 130
 131
 132 void
 133 WMSetBalloonTextColor(WMScreen *scr, WMColor *color)
 134 {
 135     Balloon *bPtr = scr->balloon;
 136
 137     if (bPtr->textColor)
 138         WMReleaseColor(bPtr->textColor);
 139
 140     bPtr->textColor = WMRetainColor(color);
 141 }
 142
 143
 144 void
 145 WMSetBalloonDelay(WMScreen *scr, int delay)
 146 {
 147     scr->balloon->delay = delay;
 148 }
 149
 150
 151 void
 152 WMSetBalloonEnabled(WMScreen *scr, Bool flag)
 153 {
 154     scr->balloon->flags.enabled = flag;
 155
 156     W_UnmapView(scr->balloon->view);
 157 }
 158
 159
 160 static void
 161 clearNoDelay(void *data)
 162 {
 163     Balloon *bPtr = (Balloon*)data;
 164
 165     bPtr->flags.noDelay = 0;
 166     bPtr->noDelayTimer = NULL;
 167 }
 168
 169
 170 void
 171 W_BalloonHandleLeaveView(WMView *view)
 172 {
 173     Balloon *bPtr = view->screen->balloon;
 174
 175     if (bPtr->view->flags.mapped && bPtr->forWindow == view->window) {
 176         W_UnmapView(bPtr->view);
 177
 178         if (bPtr->timer)
 179             WMDeleteTimerHandler(bPtr->timer);
 180
 181         bPtr->timer = NULL;
 182
 183         bPtr->noDelayTimer = WMAddTimerHandler(NO_DELAY_DELAY, clearNoDelay,
 184                                                bPtr);
 185     }
 186     bPtr->forWindow = None;
 187 }
 188
 189
 190 static void
 191 showBalloon(void *data)
 192 {
 193     char *text;
 194     WMView *view = (WMView*)data;
 195     Balloon *bPtr = view->screen->balloon;
 196     int x, y;
 197     Window foo;
 198
 199     bPtr->timer = NULL;
 200
 201     text = WMHashGet(bPtr->table, view);
 202     if (!text)
 203         return;
 204
 205     XTranslateCoordinates(view->screen->display, view->window,
 206                           view->screen->rootWin, 0, 0, &x, &y, &foo);
 207
 208     if (!bPtr->view->flags.realized)
 209         W_RealizeView(bPtr->view);
 210
 211     showText(bPtr, x, y, view->size.width, view->size.height, text);
 212
 213     bPtr->forWindow = view->window;
 214
 215     bPtr->flags.noDelay = 1;
 216 }
 217
 218
 219
 220 void
 221 W_BalloonHandleEnterView(WMView *view)
 222 {
 223     Balloon *bPtr = view->screen->balloon;
 224     char *text;
 225
 226     if (!bPtr->flags.enabled)
 227         return;
 228
 229     text = WMHashGet(bPtr->table, view);
 230     if (!text) {
 231         bPtr->forWindow = None;
 232
 233         if (bPtr->view->flags.realized)
 234             W_UnmapView(bPtr->view);
 235
 236         return;
 237     }
 238
 239     if (bPtr->timer)
 240         WMDeleteTimerHandler(bPtr->timer);
 241
 242     if (bPtr->noDelayTimer)
 243         WMDeleteTimerHandler(bPtr->noDelayTimer);
 244     bPtr->noDelayTimer = NULL;
 245
 246     if (bPtr->flags.noDelay) {
 247         bPtr->timer = NULL;
 248
 249         showBalloon(view);
 250     } else {
 251         bPtr->timer = WMAddTimerHandler(bPtr->delay, showBalloon, view);
 252     }
 253 }
 254
 255
 256 #define TOP     0
 257 #define BOTTOM  1
 258 #define LEFT    0
 259 #define RIGHT   2
 260
 261 #define TLEFT   (TOP|LEFT)
 262 #define TRIGHT  (TOP|RIGHT)
 263 #define BLEFT   (BOTTOM|LEFT)
 264 #define BRIGHT  (BOTTOM|RIGHT)
 265
 266
 267
 268 #define         SPACE   12
 269
 270
 271 static void
 272 drawBalloon(Display *dpy, Pixmap pix, GC gc, int x, int y, int w, int h,
 273             int side)
 274 {
 275     int rad = h*3/10;
 276     XPoint pt[3];
 277
 278     XFillArc(dpy, pix, gc, x, y, rad, rad, 90*64, 90*64);
 279     XFillArc(dpy, pix, gc, x, y+h-1-rad, rad, rad, 180*64, 90*64);
 280
 281     XFillArc(dpy, pix, gc, x+w-1-rad, y, rad, rad, 0*64, 90*64);
 282     XFillArc(dpy, pix, gc, x+w-1-rad, y+h-1-rad, rad, rad, 270*64, 90*64);
 283
 284     XFillRectangle(dpy, pix, gc, x, y+rad/2, w, h-rad);
 285     XFillRectangle(dpy, pix, gc, x+rad/2, y, w-rad, h);
 286
 287     if (side & BOTTOM) {
 288         pt[0].y = y+h-1;
 289         pt[1].y = y+h-1+SPACE;
 290         pt[2].y = y+h-1;
 291     } else {
 292         pt[0].y = y;
 293         pt[1].y = y-SPACE;
 294         pt[2].y = y;
 295     }
 296     if (side & RIGHT) {
 297         pt[0].x = x+w-h+2*h/16;
 298         pt[1].x = x+w-h+11*h/16;
 299         pt[2].x = x+w-h+7*h/16;
 300     } else {
 301         pt[0].x = x+h-2*h/16;
 302         pt[1].x = x+h-11*h/16;
 303         pt[2].x = x+h-7*h/16;
 304     }
 305     XFillPolygon(dpy, pix, gc, pt, 3, Convex, CoordModeOrigin);
 306 }
 307
 308
 309 static Pixmap
 310 makePixmap(WMScreen *scr, int width, int height, int side, Pixmap *mask)
 311 {
 312     Display *dpy = WMScreenDisplay(scr);
 313     Pixmap bitmap;
 314     Pixmap pixmap;
 315     int x, y;
 316     WMColor *black = WMBlackColor(scr);
 317     WMColor *white = WMWhiteColor(scr);
 318
 319     bitmap = XCreatePixmap(dpy, scr->rootWin, width+SPACE, height+SPACE, 1);
 320
 321     XSetForeground(dpy, scr->monoGC, 0);
 322     XFillRectangle(dpy, bitmap, scr->monoGC, 0, 0, width+SPACE, height+SPACE);
 323
 324     pixmap = XCreatePixmap(dpy, scr->rootWin, width+SPACE, height+SPACE,
 325                            scr->depth);
 326
 327     XFillRectangle(dpy, pixmap, WMColorGC(black), 0, 0,
 328                    width+SPACE, height+SPACE);
 329
 330     if (side & BOTTOM) {
 331         y = 0;
 332     } else {
 333         y = SPACE;
 334     }
 335     x = 0;
 336
 337     XSetForeground(dpy, scr->monoGC, 1);
 338     drawBalloon(dpy, bitmap, scr->monoGC, x, y, width, height, side);
 339     drawBalloon(dpy, pixmap, WMColorGC(white), x+1, y+1, width-2, height-2,
 340                 side);
 341
 342     *mask = bitmap;
 343
 344     WMReleaseColor(black);
 345     WMReleaseColor(white);
 346
 347     return pixmap;
 348 }
 349
 350
 351 static void
 352 showText(Balloon *bPtr, int x, int y, int h, int w, char *text)
 353 {
 354     WMScreen *scr = bPtr->view->screen;
 355     Display *dpy = WMScreenDisplay(scr);
 356     int width;
 357     int height;
 358     Pixmap pixmap;
 359     Pixmap mask;
 360     WMFont *font = bPtr->font ? bPtr->font : scr->normalFont;
 361     int textHeight;
 362     int side = 0;
 363     int ty;
 364     int bx, by;
 365
 366     {
 367         int w;
 368         char *ptr, *ptr2;
 369
 370         ptr2 = ptr = text;
 371         width = 0;
 372         while (ptr && ptr2) {
 373             ptr2 = strchr(ptr, '\n');
 374             if (ptr2) {
 375                 w = WMWidthOfString(font, ptr, ptr2 - ptr);
 376             } else {
 377                 w = WMWidthOfString(font, ptr, strlen(ptr));
 378             }
 379             if (w > width)
 380                 width = w;
 381             ptr = ptr2 + 1;
 382         }
 383     }
 384
 385     width += 16;
 386
 387     textHeight = W_GetTextHeight(font, text, width, False);
 388
 389     height = textHeight + 4;
 390
 391     if (height < 16)
 392         height = 16;
 393     if (width < height)
 394         width = height;
 395
 396     if (x + width > scr->rootView->size.width) {
 397         side = RIGHT;
 398         bx = x - width + w/2;
 399         if (bx < 0)
 400             bx = 0;
 401     } else {
 402         side = LEFT;
 403         bx = x + w/2;
 404     }
 405     if (bx + width > scr->rootView->size.width)
 406         bx = scr->rootView->size.width - width;
 407
 408     if (y - (height + SPACE) < 0) {
 409         side |= TOP;
 410         by = y+h-1;
 411         ty = SPACE;
 412     } else {
 413         side |= BOTTOM;
 414         by = y - (height + SPACE);
 415         ty = 0;
 416     }
 417     pixmap = makePixmap(scr, width, height, side, &mask);
 418
 419     W_PaintText(bPtr->view, pixmap, font, 8, ty + (height - textHeight)/2,
 420                 width, bPtr->flags.alignment,
 421                 WMColorGC(bPtr->textColor ? bPtr->textColor : scr->black),
 422                 False, text, strlen(text));
 423
 424     XSetWindowBackgroundPixmap(dpy, bPtr->view->window, pixmap);
 425
 426     W_ResizeView(bPtr->view, width, height+SPACE);
 427
 428     XFreePixmap(dpy, pixmap);
 429
 430     XShapeCombineMask(dpy, bPtr->view->window, ShapeBounding, 0, 0, mask,
 431                       ShapeSet);
 432     XFreePixmap(dpy, mask);
 433
 434     W_MoveView(bPtr->view, bx, by);
 435
 436     W_MapView(bPtr->view);
 437 }
 438
 439
 440 static void
 441 handleEvents(XEvent *event, void *data)
 442 {
 443     Balloon *bPtr = (Balloon*)data;
 444
 445     switch (event->type) {
 446      case DestroyNotify:
 447         destroyBalloon(bPtr);
 448         break;
 449     }
 450 }
 451
 452
 453 static void
 454 destroyBalloon(Balloon *bPtr)
 455 {
 456     WMHashEnumerator e;
 457     char *str;
 458
 459     e = WMEnumerateHashTable(bPtr->table);
 460
 461     while ((str = WMNextHashEnumeratorItem(&e))) {
 462         free(str);
 463     }
 464     WMFreeHashTable(bPtr->table);
 465
 466     if (bPtr->textColor)
 467         WMReleaseColor(bPtr->textColor);
 468
 469     if (bPtr->font)
 470         WMReleaseFont(bPtr->font);
 471
 472     free(bPtr);
 473 }