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