src/balloon.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1998-2003 Alfredo K. Kojima
   5  *  Copyright (c) 2014 Window Maker Team
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #ifdef BALLOON_TEXT
  25
  26 #include <stdio.h>
  27 #include <X11/Xlib.h>
  28 #include <X11/Xutil.h>
  29 #ifdef SHAPED_BALLOON
  30 #include <X11/extensions/shape.h>
  31 #endif
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #include <wraster.h>
  37
  38 #include "WindowMaker.h"
  39 #include "screen.h"
  40 #include "texture.h"
  41 #include "framewin.h"
  42 #include "icon.h"
  43 #include "appicon.h"
  44 #include "workspace.h"
  45 #include "balloon.h"
  46 #include "misc.h"
  47
  48
  49 typedef struct _WBalloon {
  50         Window window;
  51
  52 #ifdef SHAPED_BALLOON
  53         GC monoGC;
  54 #endif
  55         int prevType;
  56
  57         Window objectWindow;
  58         char *text;
  59         int h;
  60
  61         WMHandlerID timer;
  62
  63         Pixmap contents;
  64         Pixmap apercu;
  65
  66         char mapped;
  67         char ignoreTimer;
  68 } WBalloon;
  69
  70 #define TOP     0
  71 #define BOTTOM  1
  72 #define LEFT    0
  73 #define RIGHT   2
  74
  75 #define TLEFT (TOP|LEFT)
  76 #define TRIGHT (TOP|RIGHT)
  77 #define BLEFT (BOTTOM|LEFT)
  78 #define BRIGHT (BOTTOM|RIGHT)
  79
  80 static int countLines(const char *text)
  81 {
  82         const char *p = text;
  83         int h = 1;
  84
  85         while (*p) {
  86                 if (*p == '\n' && p[1] != 0)
  87                         h++;
  88                 p++;
  89         }
  90         return h;
  91 }
  92
  93 static int getMaxStringWidth(WMFont *font, const char *text)
  94 {
  95         const char *p = text;
  96         const char *pb = p;
  97         int pos = 0;
  98         int w = 0, wt;
  99
 100         while (*p) {
 101                 if (*p == '\n') {
 102                         wt = WMWidthOfString(font, pb, pos);
 103                         if (wt > w)
 104                                 w = wt;
 105                         pos = 0;
 106                         pb = p + 1;
 107                 } else {
 108                         pos++;
 109                 }
 110                 p++;
 111         }
 112         if (pos > 0) {
 113                 wt = WMWidthOfString(font, pb, pos);
 114                 if (wt > w)
 115                         w = wt;
 116         }
 117         return w;
 118 }
 119
 120 static void drawMultiLineString(WMScreen *scr, Pixmap pixmap, WMColor *color,
 121                     WMFont *font, int x, int y, const char *text, int len)
 122 {
 123         const char *p = text;
 124         const char *pb = p;
 125         int l = 0, pos = 0;
 126         int height = WMFontHeight(font);
 127
 128         while (*p && p - text < len) {
 129                 if (*p == '\n') {
 130                         WMDrawString(scr, pixmap, color, font, x, y + l * height, pb, pos);
 131                         l++;
 132                         pos = 0;
 133                         pb = p + 1;
 134                 } else {
 135                         pos++;
 136                 }
 137                 p++;
 138         }
 139         if (pos > 0)
 140                 WMDrawString(scr, pixmap, color, font, x, y + l * height, pb, pos);
 141 }
 142
 143 #ifdef SHAPED_BALLOON
 144
 145 #define SPACE 12
 146
 147 static void drawBalloon(WScreen *scr, Pixmap bitmap, Pixmap pix, int x, int y, int w, int h, int side)
 148 {
 149         GC bgc = scr->balloon->monoGC;
 150         GC gc = scr->draw_gc;
 151         int rad = h * 3 / 10;
 152         XPoint pt[3], ipt[3];
 153         int w1;
 154
 155         /* outline */
 156         XSetForeground(dpy, bgc, 1);
 157
 158         XFillArc(dpy, bitmap, bgc, x, y, rad, rad, 90 * 64, 90 * 64);
 159         XFillArc(dpy, bitmap, bgc, x, y + h - 1 - rad, rad, rad, 180 * 64, 90 * 64);
 160
 161         XFillArc(dpy, bitmap, bgc, x + w - 1 - rad, y, rad, rad, 0 * 64, 90 * 64);
 162         XFillArc(dpy, bitmap, bgc, x + w - 1 - rad, y + h - 1 - rad, rad, rad, 270 * 64, 90 * 64);
 163
 164         XFillRectangle(dpy, bitmap, bgc, x, y + rad / 2, w, h - rad);
 165         XFillRectangle(dpy, bitmap, bgc, x + rad / 2, y, w - rad, h);
 166
 167         /* interior */
 168         XSetForeground(dpy, gc, scr->white_pixel);
 169
 170         XFillArc(dpy, pix, gc, x + 1, y + 1, rad, rad, 90 * 64, 90 * 64);
 171         XFillArc(dpy, pix, gc, x + 1, y + h - 2 - rad, rad, rad, 180 * 64, 90 * 64);
 172
 173         XFillArc(dpy, pix, gc, x + w - 2 - rad, y + 1, rad, rad, 0 * 64, 90 * 64);
 174         XFillArc(dpy, pix, gc, x + w - 2 - rad, y + h - 2 - rad, rad, rad, 270 * 64, 90 * 64);
 175
 176         XFillRectangle(dpy, pix, gc, x + 1, y + 1 + rad / 2, w - 2, h - 2 - rad);
 177         XFillRectangle(dpy, pix, gc, x + 1 + rad / 2, y + 1, w - 2 - rad, h - 2);
 178
 179         if (side & BOTTOM) {
 180                 pt[0].y = y + h - 1;
 181                 pt[1].y = y + h - 1 + SPACE;
 182                 pt[2].y = y + h - 1;
 183                 ipt[0].y = pt[0].y - 1;
 184                 ipt[1].y = pt[1].y - 1;
 185                 ipt[2].y = pt[2].y - 1;
 186         } else {
 187                 pt[0].y = y;
 188                 pt[1].y = y - SPACE;
 189                 pt[2].y = y;
 190                 ipt[0].y = pt[0].y + 1;
 191                 ipt[1].y = pt[1].y + 1;
 192                 ipt[2].y = pt[2].y + 1;
 193         }
 194
 195         /*w1 = WMAX(h, 24); */
 196         w1 = WMAX(h, 21);
 197
 198         if (side & RIGHT) {
 199                 pt[0].x = x + w - w1 + 2 * w1 / 16;
 200                 pt[1].x = x + w - w1 + 11 * w1 / 16;
 201                 pt[2].x = x + w - w1 + 7 * w1 / 16;
 202                 ipt[0].x = x + 1 + w - w1 + 2 * (w1 - 1) / 16;
 203                 ipt[1].x = x + 1 + w - w1 + 11 * (w1 - 1) / 16;
 204                 ipt[2].x = x + 1 + w - w1 + 7 * (w1 - 1) / 16;
 205                 /*ipt[0].x = pt[0].x+1;
 206                    ipt[1].x = pt[1].x;
 207                    ipt[2].x = pt[2].x; */
 208         } else {
 209                 pt[0].x = x + w1 - 2 * w1 / 16;
 210                 pt[1].x = x + w1 - 11 * w1 / 16;
 211                 pt[2].x = x + w1 - 7 * w1 / 16;
 212                 ipt[0].x = x - 1 + w1 - 2 * (w1 - 1) / 16;
 213                 ipt[1].x = x - 1 + w1 - 11 * (w1 - 1) / 16;
 214                 ipt[2].x = x - 1 + w1 - 7 * (w1 - 1) / 16;
 215                 /*ipt[0].x = pt[0].x-1;
 216                    ipt[1].x = pt[1].x;
 217                    ipt[2].x = pt[2].x; */
 218         }
 219
 220         XFillPolygon(dpy, bitmap, bgc, pt, 3, Convex, CoordModeOrigin);
 221         XFillPolygon(dpy, pix, gc, ipt, 3, Convex, CoordModeOrigin);
 222
 223         /* fix outline */
 224         XSetForeground(dpy, gc, scr->black_pixel);
 225
 226         XDrawLines(dpy, pix, gc, pt, 3, CoordModeOrigin);
 227         if (side & RIGHT) {
 228                 pt[0].x++;
 229                 pt[2].x--;
 230         } else {
 231                 pt[0].x--;
 232                 pt[2].x++;
 233         }
 234         XDrawLines(dpy, pix, gc, pt, 3, CoordModeOrigin);
 235 }
 236
 237 static Pixmap makePixmap(WScreen *scr, int width, int height, int side, Pixmap *mask)
 238 {
 239         WBalloon *bal = scr->balloon;
 240         Pixmap bitmap;
 241         Pixmap pixmap;
 242         int x, y;
 243
 244         bitmap = XCreatePixmap(dpy, scr->root_win, width + SPACE, height + SPACE, 1);
 245
 246         if (!bal->monoGC)
 247                 bal->monoGC = XCreateGC(dpy, bitmap, 0, NULL);
 248
 249         XSetForeground(dpy, bal->monoGC, 0);
 250         XFillRectangle(dpy, bitmap, bal->monoGC, 0, 0, width + SPACE, height + SPACE);
 251
 252         pixmap = XCreatePixmap(dpy, scr->root_win, width + SPACE, height + SPACE, scr->w_depth);
 253         XSetForeground(dpy, scr->draw_gc, scr->black_pixel);
 254         XFillRectangle(dpy, pixmap, scr->draw_gc, 0, 0, width + SPACE, height + SPACE);
 255
 256         if (side & BOTTOM)
 257                 y = 0;
 258         else
 259                 y = SPACE;
 260         x = 0;
 261
 262         drawBalloon(scr, bitmap, pixmap, x, y, width, height, side);
 263
 264         *mask = bitmap;
 265
 266         return pixmap;
 267 }
 268
 269 static void showText(WScreen *scr, int x, int y, int h, int w, const char *text)
 270 {
 271         int width;
 272         int height;
 273         Pixmap pixmap;
 274         Pixmap mask;
 275         WMFont *font = scr->info_text_font;
 276         int side = 0;
 277         int ty;
 278         int bx, by;
 279
 280         if (scr->balloon->contents)
 281                 XFreePixmap(dpy, scr->balloon->contents);
 282
 283         width = getMaxStringWidth(font, text) + 16;
 284         height = countLines(text) * WMFontHeight(font) + 4;
 285
 286         if (height < 16)
 287                 height = 16;
 288         if (width < height)
 289                 width = height;
 290
 291         if (x + width > scr->scr_width) {
 292                 side = RIGHT;
 293                 bx = x - width + w / 2;
 294                 if (bx < 0)
 295                         bx = 0;
 296         } else {
 297                 side = LEFT;
 298                 bx = x + w / 2;
 299         }
 300         if (bx + width > scr->scr_width)
 301                 bx = scr->scr_width - width;
 302
 303         if (y - (height + SPACE) < 0) {
 304                 side |= TOP;
 305                 by = y + h - 1;
 306                 ty = SPACE;
 307         } else {
 308                 side |= BOTTOM;
 309                 by = y - (height + SPACE);
 310                 ty = 0;
 311         }
 312         pixmap = makePixmap(scr, width, height, side, &mask);
 313
 314         drawMultiLineString(scr->wmscreen, pixmap, scr->black, font, 8, ty + 2, text, strlen(text));
 315
 316         XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap);
 317         scr->balloon->contents = pixmap;
 318
 319         XResizeWindow(dpy, scr->balloon->window, width, height + SPACE);
 320         XShapeCombineMask(dpy, scr->balloon->window, ShapeBounding, 0, 0, mask, ShapeSet);
 321         XFreePixmap(dpy, mask);
 322         XMoveWindow(dpy, scr->balloon->window, bx, by);
 323         XMapRaised(dpy, scr->balloon->window);
 324
 325         scr->balloon->mapped = 1;
 326 }
 327 #else                           /* !SHAPED_BALLOON */
 328
 329 static void showText(WScreen *scr, int x, int y, int h, int w, const char *text)
 330 {
 331         int width;
 332         int height;
 333         Pixmap pixmap;
 334         WMFont *font = scr->info_text_font;
 335
 336         if (scr->balloon->contents)
 337                 XFreePixmap(dpy, scr->balloon->contents);
 338
 339         width = getMaxStringWidth(font, text) + 8;
 340         /*width = WMWidthOfString(font, text, strlen(text))+8; */
 341         height = countLines(text) * WMFontHeight(font) + 4;
 342
 343         if (x < 0)
 344                 x = 0;
 345         else if (x + width > scr->scr_width - 1)
 346                 x = scr->scr_width - width;
 347
 348         if (y - height - 2 < 0) {
 349                 y += h;
 350                 if (y < 0)
 351                         y = 0;
 352         } else {
 353                 y -= height + 2;
 354         }
 355
 356         if (scr->window_title_texture[0])
 357                 XSetForeground(dpy, scr->draw_gc, scr->window_title_texture[0]->any.color.pixel);
 358         else
 359                 XSetForeground(dpy, scr->draw_gc, scr->light_pixel);
 360
 361         pixmap = XCreatePixmap(dpy, scr->root_win, width, height, scr->w_depth);
 362         XFillRectangle(dpy, pixmap, scr->draw_gc, 0, 0, width, height);
 363
 364         drawMultiLineString(scr->wmscreen, pixmap, scr->window_title_color[0], font, 4, 2, text, strlen(text));
 365
 366         XResizeWindow(dpy, scr->balloon->window, width, height);
 367         XMoveWindow(dpy, scr->balloon->window, x, y);
 368
 369         XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap);
 370         XClearWindow(dpy, scr->balloon->window);
 371         XMapRaised(dpy, scr->balloon->window);
 372
 373         scr->balloon->contents = pixmap;
 374
 375         scr->balloon->mapped = 1;
 376 }
 377 #endif                          /* !SHAPED_BALLOON */
 378
 379 static void showApercu(WScreen *scr, int x, int y, int height, int width, char *title, Pixmap apercu)
 380 {
 381         Pixmap pixmap;
 382         WMFont *font = scr->info_text_font;
 383         int titleHeight = 0;
 384         char *shortenTitle = title;
 385
 386         if (scr->balloon->contents)
 387                 XFreePixmap(dpy, scr->balloon->contents);
 388
 389         if (wPreferences.miniwin_title_balloon) {
 390                 shortenTitle = ShrinkString(font, title, width - APERCU_BORDER);
 391                 titleHeight = countLines(shortenTitle) * WMFontHeight(font) + 4;
 392                 height += titleHeight;
 393         }
 394
 395         if (x < 0)
 396                 x = 0;
 397         else if (x + width > scr->scr_width - 1)
 398                 x = scr->scr_width - width - APERCU_BORDER;
 399
 400         if (y - height - 2 < 0) {
 401                 y += wPreferences.icon_size;
 402                 if (y < 0)
 403                         y = 0;
 404         } else {
 405                 y -= height + 2;
 406         }
 407
 408         if (scr->window_title_texture[0])
 409                 XSetForeground(dpy, scr->draw_gc, scr->window_title_texture[0]->any.color.pixel);
 410         else
 411                 XSetForeground(dpy, scr->draw_gc, scr->light_pixel);
 412
 413         pixmap = XCreatePixmap(dpy, scr->root_win, width, height, scr->w_depth);
 414         XFillRectangle(dpy, pixmap, scr->draw_gc, 0, 0, width, height);
 415
 416         if (shortenTitle && wPreferences.miniwin_title_balloon) {
 417                 drawMultiLineString(scr->wmscreen, pixmap, scr->window_title_color[0], font,
 418                                                 APERCU_BORDER, APERCU_BORDER, shortenTitle, strlen(shortenTitle));
 419                 wfree(shortenTitle);
 420         }
 421
 422         XCopyArea(dpy, apercu, pixmap, scr->draw_gc,
 423                                 0, 0, (wPreferences.icon_size - 1 - APERCU_BORDER) * wPreferences.apercu_size,
 424                                 (wPreferences.icon_size - 1 - APERCU_BORDER) * wPreferences.apercu_size,
 425                                 APERCU_BORDER, APERCU_BORDER + titleHeight);
 426
 427 #ifdef SHAPED_BALLOON
 428         XShapeCombineMask(dpy, scr->balloon->window, ShapeBounding, 0, 0, None, ShapeSet);
 429 #endif
 430         XResizeWindow(dpy, scr->balloon->window, width, height);
 431         XMoveWindow(dpy, scr->balloon->window, x, y);
 432
 433         XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap);
 434
 435         XClearWindow(dpy, scr->balloon->window);
 436         XMapRaised(dpy, scr->balloon->window);
 437
 438
 439         scr->balloon->contents = pixmap;
 440
 441         scr->balloon->mapped = 1;
 442 }
 443
 444 static void showBalloon(WScreen *scr)
 445 {
 446         int x, y;
 447         Window foow;
 448         unsigned foo, w;
 449
 450         scr->balloon->timer = NULL;
 451         scr->balloon->ignoreTimer = 1;
 452
 453         if (!XGetGeometry(dpy, scr->balloon->objectWindow, &foow, &x, &y, &w, &foo, &foo, &foo)) {
 454                 scr->balloon->prevType = 0;
 455                 return;
 456         }
 457
 458         if (wPreferences.miniwin_apercu_balloon && scr->balloon->apercu != None)
 459                 /* used to display either the apercu alone or the apercu and the title */
 460                 showApercu(scr, x, y, (wPreferences.icon_size - 1) * wPreferences.apercu_size,
 461                                         (wPreferences.icon_size - 1) * wPreferences.apercu_size,
 462                                         scr->balloon->text, scr->balloon->apercu);
 463         else
 464                 showText(scr, x, y, scr->balloon->h, w, scr->balloon->text);
 465 }
 466
 467 static void frameBalloon(WObjDescriptor *object)
 468 {
 469         WFrameWindow *fwin = (WFrameWindow *) object->parent;
 470         WScreen *scr = fwin->core->screen_ptr;
 471
 472         if (fwin->titlebar != object->self || !fwin->flags.is_client_window_frame) {
 473                 wBalloonHide(scr);
 474                 return;
 475         }
 476         if (fwin->title && fwin->flags.incomplete_title) {
 477                 scr->balloon->h = (fwin->titlebar ? fwin->titlebar->height : 0);
 478                 scr->balloon->text = wstrdup(fwin->title);
 479                 scr->balloon->objectWindow = fwin->core->window;
 480                 scr->balloon->timer = WMAddTimerHandler(BALLOON_DELAY, (WMCallback *) showBalloon, scr);
 481         }
 482 }
 483
 484 static void miniwindowBalloon(WObjDescriptor *object)
 485 {
 486         WIcon *icon = (WIcon *) object->parent;
 487         WScreen *scr = icon->core->screen_ptr;
 488
 489         if (!icon->icon_name) {
 490                 wBalloonHide(scr);
 491                 return;
 492         }
 493         scr->balloon->h = icon->core->height;
 494         scr->balloon->text = wstrdup(icon->icon_name);
 495         scr->balloon->apercu = icon->apercu;
 496         scr->balloon->objectWindow = icon->core->window;
 497
 498         if ((scr->balloon->prevType == object->parent_type || scr->balloon->prevType == WCLASS_APPICON)
 499             && scr->balloon->ignoreTimer) {
 500                 XUnmapWindow(dpy, scr->balloon->window);
 501                 showBalloon(scr);
 502         } else {
 503                 scr->balloon->timer = WMAddTimerHandler(BALLOON_DELAY, (WMCallback *) showBalloon, scr);
 504         }
 505 }
 506
 507 static void appiconBalloon(WObjDescriptor *object)
 508 {
 509         WAppIcon *aicon = (WAppIcon *) object->parent;
 510         WScreen *scr = aicon->icon->core->screen_ptr;
 511         char *tmp;
 512
 513         /* Show balloon if it is the Clip and the workspace name is > 5 chars */
 514         if (object->parent == w_global.clip.icon) {
 515                 if (strlen(w_global.workspace.array[w_global.workspace.current]->name) > 5) {
 516                         scr->balloon->text = wstrdup(w_global.workspace.array[w_global.workspace.current]->name);
 517                 } else {
 518                         wBalloonHide(scr);
 519                         return;
 520                 }
 521         } else if (aicon->command && aicon->wm_class) {
 522                 int len;
 523                 WApplication *app;
 524                 unsigned int app_win_cnt = 0;
 525
 526                 if (object->parent_type == WCLASS_DOCK_ICON) {
 527                         if (aicon->main_window) {
 528                                 app = wApplicationOf(aicon->main_window);
 529                                 if (app && app->main_window_desc && app->main_window_desc->fake_group)
 530                                         app_win_cnt = app->main_window_desc->fake_group->retainCount - 1;
 531                         }
 532                 }
 533
 534                 /* Check to see if it is a GNUstep app */
 535                 if (strcmp(aicon->wm_class, "GNUstep") == 0)
 536                         len = strlen(aicon->command) + strlen(aicon->wm_instance) + 8;
 537                 else
 538                         len = strlen(aicon->command) + strlen(aicon->wm_class) + 8;
 539
 540                 if (app_win_cnt > 0)
 541                         len += 1 + snprintf(NULL, 0, "%u", app_win_cnt);
 542
 543                 tmp = wmalloc(len);
 544                 /* Check to see if it is a GNUstep App */
 545                 if (strcmp(aicon->wm_class, "GNUstep") == 0)
 546                         if (app_win_cnt > 0)
 547                                 snprintf(tmp, len, "%u %s\n(%s)", app_win_cnt, aicon->wm_instance, aicon->command);
 548                         else
 549                                 snprintf(tmp, len, "%s\n(%s)", aicon->wm_instance, aicon->command);
 550                 else
 551                         if (app_win_cnt > 0)
 552                                 snprintf(tmp, len, "%u %s\n(%s)", app_win_cnt, aicon->wm_class, aicon->command);
 553                         else
 554                                 snprintf(tmp, len, "%s\n(%s)", aicon->wm_class, aicon->command);
 555                 scr->balloon->text = tmp;
 556         } else if (aicon->command) {
 557                 scr->balloon->text = wstrdup(aicon->command);
 558         } else if (aicon->wm_class) {
 559                 /* Check to see if it is a GNUstep App */
 560                 if (strcmp(aicon->wm_class, "GNUstep") == 0)
 561                         scr->balloon->text = wstrdup(aicon->wm_instance);
 562                 else
 563                         scr->balloon->text = wstrdup(aicon->wm_class);
 564         } else {
 565                 wBalloonHide(scr);
 566                 return;
 567         }
 568         scr->balloon->h = aicon->icon->core->height - 2;
 569
 570         scr->balloon->objectWindow = aicon->icon->core->window;
 571         if ((scr->balloon->prevType == object->parent_type || scr->balloon->prevType == WCLASS_MINIWINDOW)
 572             && scr->balloon->ignoreTimer) {
 573                 XUnmapWindow(dpy, scr->balloon->window);
 574                 showBalloon(scr);
 575         } else {
 576                 scr->balloon->timer = WMAddTimerHandler(BALLOON_DELAY, (WMCallback *) showBalloon, scr);
 577         }
 578 }
 579
 580 void wBalloonInitialize(WScreen *scr)
 581 {
 582         WBalloon *bal;
 583         XSetWindowAttributes attribs;
 584         unsigned long vmask;
 585
 586         bal = wmalloc(sizeof(WBalloon));
 587
 588         scr->balloon = bal;
 589
 590         vmask = CWSaveUnder | CWOverrideRedirect | CWColormap | CWBackPixel | CWBorderPixel;
 591         attribs.save_under = True;
 592         attribs.override_redirect = True;
 593         attribs.colormap = scr->w_colormap;
 594         attribs.background_pixel = scr->icon_back_texture->normal.pixel;
 595         attribs.border_pixel = 0;       /* do not care */
 596
 597         bal->window = XCreateWindow(dpy, scr->root_win, 1, 1, 10, 10, 1,
 598                                     scr->w_depth, CopyFromParent, scr->w_visual, vmask, &attribs);
 599 #if 0
 600         /* select EnterNotify to so that the balloon will be unmapped
 601          * when the pointer is moved over it */
 602         XSelectInput(dpy, bal->window, EnterWindowMask);
 603 #endif
 604 }
 605
 606 void wBalloonEnteredObject(WScreen *scr, WObjDescriptor *object)
 607 {
 608         WBalloon *balloon = scr->balloon;
 609
 610         if (balloon->timer) {
 611                 WMDeleteTimerHandler(balloon->timer);
 612                 balloon->timer = NULL;
 613                 balloon->ignoreTimer = 0;
 614         }
 615
 616         if (scr->balloon->text)
 617                 wfree(scr->balloon->text);
 618         scr->balloon->text = NULL;
 619
 620         scr->balloon->apercu = None;
 621
 622         if (!object) {
 623                 wBalloonHide(scr);
 624                 balloon->ignoreTimer = 0;
 625                 return;
 626         }
 627
 628         switch (object->parent_type) {
 629         case WCLASS_FRAME:
 630                 if (wPreferences.window_balloon)
 631                         frameBalloon(object);
 632                 break;
 633         case WCLASS_DOCK_ICON:
 634                 if (wPreferences.appicon_balloon)
 635                         appiconBalloon(object);
 636                 break;
 637         case WCLASS_MINIWINDOW:
 638                 if (wPreferences.miniwin_title_balloon || wPreferences.miniwin_apercu_balloon)
 639                         miniwindowBalloon(object);
 640                 break;
 641         case WCLASS_APPICON:
 642                 if (wPreferences.appicon_balloon)
 643                         appiconBalloon(object);
 644                 break;
 645         default:
 646                 wBalloonHide(scr);
 647                 break;
 648         }
 649         scr->balloon->prevType = object->parent_type;
 650 }
 651
 652 void wBalloonHide(WScreen *scr)
 653 {
 654         if (scr) {
 655                 if (scr->balloon->mapped) {
 656                         XUnmapWindow(dpy, scr->balloon->window);
 657                         scr->balloon->mapped = 0;
 658                 } else if (scr->balloon->timer) {
 659                         WMDeleteTimerHandler(scr->balloon->timer);
 660                         scr->balloon->timer = NULL;
 661                 }
 662                 scr->balloon->prevType = 0;
 663         }
 664 }
 665
 666 #endif