WINGs/wballoon.c

   1
   2
   3
   4 #include "../src/config.h"
   5 #include "WINGsP.h"
   6
   7 #ifdef SHAPE
   8 #include <X11/extensions/shape.h>
   9 #endif
  10
  11
  12 typedef struct W_Balloon {
  13     W_View *view;
  14
  15     WMHashTable *table;                /* Table from view ptr to text */
  16
  17     WMColor *backColor;
  18     WMColor *textColor;
  19     WMFont *font;
  20
  21     WMHandlerID timer;                 /* timer for showing balloon */
  22
  23     WMHandlerID noDelayTimer;
  24
  25     int delay;
  26
  27     Window forWindow;                  /* window for which the balloon
  28                                         * is being show in the moment */
  29
  30     struct {
  31         WMAlignment alignment:2;
  32         unsigned enabled:1;
  33
  34         unsigned noDelay:1;
  35     } flags;
  36 } Balloon;
  37
  38
  39
  40 #define DEFAULT_WIDTH           60
  41 #define DEFAULT_HEIGHT          14
  42 #define DEFAULT_ALIGNMENT       WALeft
  43 #define DEFAULT_DELAY           500
  44
  45 #define NO_DELAY_DELAY          150
  46
  47
  48 static void destroyBalloon(Balloon *bPtr);
  49
  50
  51 static void handleEvents(XEvent *event, void *data);
  52
  53 static void showText(Balloon *bPtr, int x, int y, int w, int h, char *text);
  54
  55
  56 struct W_Balloon*
  57 W_CreateBalloon(WMScreen *scr)
  58 {
  59     Balloon *bPtr;
  60
  61     bPtr = wmalloc(sizeof(Balloon));
  62     memset(bPtr, 0, sizeof(Balloon));
  63
  64     bPtr->view = W_CreateUnmanagedTopView(scr);
  65     if (!bPtr->view) {
  66         wfree(bPtr);
  67         return NULL;
  68     }
  69     bPtr->view->self = bPtr;
  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         wfree(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->forWindow == view->window) {
 176         if (bPtr->view->flags.mapped) {
 177             W_UnmapView(bPtr->view);
 178             bPtr->noDelayTimer = WMAddTimerHandler(NO_DELAY_DELAY,
 179                                                    clearNoDelay, bPtr);
 180         }
 181         if (bPtr->timer)
 182             WMDeleteTimerHandler(bPtr->timer);
 183
 184         bPtr->timer = NULL;
 185
 186         bPtr->forWindow = None;
 187     }
 188 }
 189
 190
 191 /*
 192  * botar balao perto do cursor
 193  * so mapear balao se o mouse ficar parado pelo delay
 194  *
 195  */
 196
 197 static void
 198 showBalloon(void *data)
 199 {
 200     char *text;
 201     WMView *view = (WMView*)data;
 202     Balloon *bPtr = view->screen->balloon;
 203     int x, y;
 204     Window foo;
 205
 206     bPtr->timer = NULL;
 207
 208     text = WMHashGet(bPtr->table, view);
 209     if (!text)
 210         return;
 211
 212     XTranslateCoordinates(view->screen->display, view->window,
 213                           view->screen->rootWin, 0, 0, &x, &y, &foo);
 214
 215     if (!bPtr->view->flags.realized)
 216         W_RealizeView(bPtr->view);
 217
 218     showText(bPtr, x, y, view->size.width, view->size.height, text);
 219
 220     bPtr->flags.noDelay = 1;
 221 }
 222
 223
 224
 225 void
 226 W_BalloonHandleEnterView(WMView *view)
 227 {
 228     Balloon *bPtr = view->screen->balloon;
 229     char *text;
 230
 231     if (!bPtr->flags.enabled)
 232         return;
 233
 234     text = WMHashGet(bPtr->table, view);
 235     if (!text) {
 236         if (bPtr->view->flags.realized)
 237             W_UnmapView(bPtr->view);
 238
 239         return;
 240     }
 241
 242     if (bPtr->timer)
 243         WMDeleteTimerHandler(bPtr->timer);
 244     bPtr->timer = NULL;
 245
 246     if (bPtr->noDelayTimer)
 247         WMDeleteTimerHandler(bPtr->noDelayTimer);
 248     bPtr->noDelayTimer = NULL;
 249
 250     bPtr->forWindow = view->window;
 251
 252     if (bPtr->flags.noDelay) {
 253         bPtr->timer = NULL;
 254
 255         showBalloon(view);
 256     } else {
 257         bPtr->timer = WMAddTimerHandler(bPtr->delay, showBalloon, view);
 258     }
 259 }
 260
 261
 262 #define TOP     0
 263 #define BOTTOM  1
 264 #define LEFT    0
 265 #define RIGHT   2
 266
 267 #define TLEFT   (TOP|LEFT)
 268 #define TRIGHT  (TOP|RIGHT)
 269 #define BLEFT   (BOTTOM|LEFT)
 270 #define BRIGHT  (BOTTOM|RIGHT)
 271
 272
 273
 274 #define         SPACE   12
 275
 276
 277 static void
 278 drawBalloon(Display *dpy, Pixmap pix, GC gc, int x, int y, int w, int h,
 279             int side)
 280 {
 281     int rad = h*3/10;
 282     XPoint pt[3];
 283
 284     XFillArc(dpy, pix, gc, x, y, rad, rad, 90*64, 90*64);
 285     XFillArc(dpy, pix, gc, x, y+h-1-rad, rad, rad, 180*64, 90*64);
 286
 287     XFillArc(dpy, pix, gc, x+w-1-rad, y, rad, rad, 0*64, 90*64);
 288     XFillArc(dpy, pix, gc, x+w-1-rad, y+h-1-rad, rad, rad, 270*64, 90*64);
 289
 290     XFillRectangle(dpy, pix, gc, x, y+rad/2, w, h-rad);
 291     XFillRectangle(dpy, pix, gc, x+rad/2, y, w-rad, h);
 292
 293     if (side & BOTTOM) {
 294         pt[0].y = y+h-1;
 295         pt[1].y = y+h-1+SPACE;
 296         pt[2].y = y+h-1;
 297     } else {
 298         pt[0].y = y;
 299         pt[1].y = y-SPACE;
 300         pt[2].y = y;
 301     }
 302     if (side & RIGHT) {
 303         pt[0].x = x+w-h+2*h/16;
 304         pt[1].x = x+w-h+11*h/16;
 305         pt[2].x = x+w-h+7*h/16;
 306     } else {
 307         pt[0].x = x+h-2*h/16;
 308         pt[1].x = x+h-11*h/16;
 309         pt[2].x = x+h-7*h/16;
 310     }
 311     XFillPolygon(dpy, pix, gc, pt, 3, Convex, CoordModeOrigin);
 312 }
 313
 314
 315 static Pixmap
 316 makePixmap(WMScreen *scr, int width, int height, int side, Pixmap *mask)
 317 {
 318     Display *dpy = WMScreenDisplay(scr);
 319     Pixmap bitmap;
 320     Pixmap pixmap;
 321     int x, y;
 322     WMColor *black = WMBlackColor(scr);
 323     WMColor *white = WMWhiteColor(scr);
 324
 325     bitmap = XCreatePixmap(dpy, scr->rootWin, width+SPACE, height+SPACE, 1);
 326
 327     XSetForeground(dpy, scr->monoGC, 0);
 328     XFillRectangle(dpy, bitmap, scr->monoGC, 0, 0, width+SPACE, height+SPACE);
 329
 330     pixmap = XCreatePixmap(dpy, scr->rootWin, width+SPACE, height+SPACE,
 331                            scr->depth);
 332
 333     XFillRectangle(dpy, pixmap, WMColorGC(black), 0, 0,
 334                    width+SPACE, height+SPACE);
 335
 336     if (side & BOTTOM) {
 337         y = 0;
 338     } else {
 339         y = SPACE;
 340     }
 341     x = 0;
 342
 343     XSetForeground(dpy, scr->monoGC, 1);
 344     drawBalloon(dpy, bitmap, scr->monoGC, x, y, width, height, side);
 345     drawBalloon(dpy, pixmap, WMColorGC(white), x+1, y+1, width-2, height-2,
 346                 side);
 347
 348     *mask = bitmap;
 349
 350     WMReleaseColor(black);
 351     WMReleaseColor(white);
 352
 353     return pixmap;
 354 }
 355
 356
 357 static void
 358 showText(Balloon *bPtr, int x, int y, int h, int w, char *text)
 359 {
 360     WMScreen *scr = bPtr->view->screen;
 361     Display *dpy = WMScreenDisplay(scr);
 362     int width;
 363     int height;
 364     Pixmap pixmap;
 365     Pixmap mask;
 366     WMFont *font = bPtr->font ? bPtr->font : scr->normalFont;
 367     int textHeight;
 368     int side = 0;
 369     int ty;
 370     int bx, by;
 371
 372     {
 373         int w;
 374         char *ptr, *ptr2;
 375
 376         ptr2 = ptr = text;
 377         width = 0;
 378         while (ptr && ptr2) {
 379             ptr2 = strchr(ptr, '\n');
 380             if (ptr2) {
 381                 w = WMWidthOfString(font, ptr, ptr2 - ptr);
 382             } else {
 383                 w = WMWidthOfString(font, ptr, strlen(ptr));
 384             }
 385             if (w > width)
 386                 width = w;
 387             ptr = ptr2 + 1;
 388         }
 389     }
 390
 391     width += 16;
 392
 393     textHeight = W_GetTextHeight(font, text, width, False);
 394
 395     height = textHeight + 4;
 396
 397     if (height < 16)
 398         height = 16;
 399     if (width < height)
 400         width = height;
 401
 402     if (x + width > scr->rootView->size.width) {
 403         side = RIGHT;
 404         bx = x - width + w/2;
 405         if (bx < 0)
 406             bx = 0;
 407     } else {
 408         side = LEFT;
 409         bx = x + w/2;
 410     }
 411     if (bx + width > scr->rootView->size.width)
 412         bx = scr->rootView->size.width - width;
 413
 414     if (y - (height + SPACE) < 0) {
 415         side |= TOP;
 416         by = y+h-1;
 417         ty = SPACE;
 418     } else {
 419         side |= BOTTOM;
 420         by = y - (height + SPACE);
 421         ty = 0;
 422     }
 423     pixmap = makePixmap(scr, width, height, side, &mask);
 424
 425     W_PaintText(bPtr->view, pixmap, font, 8, ty + (height - textHeight)/2,
 426                 width, bPtr->flags.alignment,
 427                 WMColorGC(bPtr->textColor ? bPtr->textColor : scr->black),
 428                 False, text, strlen(text));
 429
 430     XSetWindowBackgroundPixmap(dpy, bPtr->view->window, pixmap);
 431
 432     W_ResizeView(bPtr->view, width, height+SPACE);
 433
 434     XFreePixmap(dpy, pixmap);
 435
 436 #ifdef SHAPE
 437     XShapeCombineMask(dpy, bPtr->view->window, ShapeBounding, 0, 0, mask,
 438                       ShapeSet);
 439 #endif
 440     XFreePixmap(dpy, mask);
 441
 442     W_MoveView(bPtr->view, bx, by);
 443
 444     W_MapView(bPtr->view);
 445 }
 446
 447
 448 static void
 449 handleEvents(XEvent *event, void *data)
 450 {
 451     Balloon *bPtr = (Balloon*)data;
 452
 453     switch (event->type) {
 454      case DestroyNotify:
 455         destroyBalloon(bPtr);
 456         break;
 457     }
 458 }
 459
 460
 461 static void
 462 destroyBalloon(Balloon *bPtr)
 463 {
 464     WMHashEnumerator e;
 465     char *str;
 466
 467     e = WMEnumerateHashTable(bPtr->table);
 468
 469     while ((str = WMNextHashEnumeratorItem(&e))) {
 470         wfree(str);
 471     }
 472     WMFreeHashTable(bPtr->table);
 473
 474     if (bPtr->textColor)
 475         WMReleaseColor(bPtr->textColor);
 476
 477     if (bPtr->font)
 478         WMReleaseFont(bPtr->font);
 479
 480     wfree(bPtr);
 481 }