libs/FTips.c

   1 /* -*-c-*- */
   2 /* Copyright (C) 2004  Olivier Chapuis */
   3 /* This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 /* ---------------------------- included header files ---------------------- */
  19
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include "libs/ftime.h"
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/Xatom.h>
  28
  29 #include "defaults.h"
  30 #include "fvwmlib.h"
  31 #include "Strings.h"
  32 #include "PictureBase.h"
  33 #include "Flocale.h"
  34 #include "Graphics.h"
  35 #include "Colorset.h"
  36 #include "libs/FScreen.h"
  37 #include "FTips.h"
  38
  39 /* ---------------------------- local definitions -------------------------- */
  40
  41 #define FVWM_TIPS_NOTHING 0
  42 #define FVWM_TIPS_WAITING 1
  43 #define FVWM_TIPS_MAPPED  2
  44
  45 /* ---------------------------- local macros ------------------------------- */
  46
  47 /* ---------------------------- imports ------------------------------------ */
  48
  49 /* ---------------------------- included code files ------------------------ */
  50
  51 /* ---------------------------- local types -------------------------------- */
  52
  53 /* ---------------------------- forward declarations ----------------------- */
  54
  55 /* ---------------------------- local variables ---------------------------- */
  56
  57 static Window win = None;
  58 static GC gc = None;
  59 static Window win_for;
  60
  61 static ftips_config *current_config, *default_config;
  62
  63 static char *label;
  64 static int state = FVWM_TIPS_NOTHING;
  65 static void *boxID = NULL;
  66
  67 static FlocaleWinString fwin_string;
  68 static rectangle box;
  69
  70 static unsigned long timeOut;
  71 static unsigned long onTime;
  72
  73 static Atom _net_um_for = None;
  74
  75 /* ---------------------------- exported variables (globals) --------------- */
  76
  77 /* ---------------------------- local functions ---------------------------- */
  78
  79 static
  80 unsigned long __get_time(void)
  81 {
  82         struct timeval t;
  83
  84         gettimeofday(&t, NULL);
  85         return (1000*t.tv_sec + t.tv_usec/1000);
  86 }
  87
  88 static
  89 void __initialize_window(Display *dpy)
  90 {
  91         XGCValues xgcv;
  92         unsigned long valuemask;
  93         XSetWindowAttributes attributes;
  94         Atom _net_um_window_type;
  95         long _net_um_window_type_tooltips;
  96
  97         valuemask = CWOverrideRedirect | CWEventMask | CWColormap;
  98         attributes.override_redirect = True;
  99         attributes.event_mask = ExposureMask;
 100         attributes.colormap = Pcmap;
 101         win = XCreateWindow(
 102                 dpy, DefaultRootWindow(dpy), 0, 0, 1, 1,
 103                 current_config->border_width, Pdepth, InputOutput, Pvisual,
 104                 valuemask, &attributes);
 105
 106         _net_um_window_type = XInternAtom(
 107                 dpy, "_NET_UM_WINDOW_TYPE", False);
 108         _net_um_window_type_tooltips = XInternAtom(
 109                 dpy, "_NET_UM_WINDOW_TYPE_TOOLTIPS", False);
 110
 111         XChangeProperty(
 112                 dpy, win, _net_um_window_type, XA_ATOM, 32, PropModeReplace,
 113                 (unsigned char *) &_net_um_window_type_tooltips, 1);
 114
 115         _net_um_for = XInternAtom(dpy, "_NET_UM_FOR", False);
 116
 117         gc = fvwmlib_XCreateGC(dpy, win, 0, &xgcv);
 118         return;
 119 }
 120
 121 static
 122 void __setup_cs(Display *dpy)
 123 {
 124         XSetWindowAttributes xswa;
 125         unsigned long valuemask = 0;
 126
 127
 128         if (current_config->colorset > -1)
 129         {
 130                 xswa.border_pixel = Colorset[current_config->colorset].fg;
 131                 xswa.background_pixel = Colorset[current_config->colorset].bg;
 132                 if (Colorset[current_config->colorset].pixmap)
 133                 {
 134                         /* set later */
 135                         xswa.background_pixmap = None;
 136                         valuemask = CWBackPixmap | CWBorderPixel;;
 137                 }
 138                 else
 139                 {
 140                         valuemask = CWBackPixel | CWBorderPixel;
 141                 }
 142         }
 143         else
 144         {
 145                 xswa.border_pixel = current_config->border_pixel;
 146                 xswa.background_pixel = current_config->bg;
 147                 valuemask = CWBackPixel | CWBorderPixel;
 148         }
 149         XChangeWindowAttributes(dpy, win, valuemask, &xswa);
 150 }
 151
 152 static
 153 void __setup_gc(Display *dpy)
 154 {
 155         XGCValues xgcv;
 156         unsigned long valuemask;
 157
 158         valuemask = GCForeground;
 159         if (current_config->colorset > -1)
 160         {
 161                 xgcv.foreground = Colorset[current_config->colorset].fg;
 162         }
 163         else
 164         {
 165                 xgcv.foreground = current_config->fg;
 166         }
 167         if (current_config->Ffont && current_config->Ffont->font != NULL)
 168         {
 169                 xgcv.font = current_config->Ffont->font->fid;
 170                 valuemask |= GCFont;
 171         }
 172         XChangeGC(dpy, gc, valuemask, &xgcv);
 173
 174         return;
 175 }
 176
 177 static
 178 void __draw(Display *dpy)
 179 {
 180         if (!current_config->Ffont)
 181         {
 182                 return;
 183         }
 184
 185         fwin_string.str = label;
 186         fwin_string.win = win;
 187         fwin_string.gc = gc;
 188         if (current_config->colorset > -1)
 189         {
 190                 fwin_string.colorset = &Colorset[current_config->colorset];
 191                 fwin_string.flags.has_colorset = True;
 192         }
 193         else
 194         {
 195                 fwin_string.flags.has_colorset = False;
 196         }
 197         fwin_string.x = 2;
 198         fwin_string.y = current_config->Ffont->ascent;
 199         FlocaleDrawString(dpy, current_config->Ffont, &fwin_string, 0);
 200
 201         return;
 202 }
 203
 204 static
 205 void __map_window(Display *dpy)
 206 {
 207         rectangle new_g;
 208         rectangle screen_g;
 209         Window dummy;
 210         fscreen_scr_arg *fsarg = NULL; /* for now no xinerama support */
 211         ftips_placement_t placement;
 212         int x,y;
 213         static int border_width = 1;
 214         static Window win_f = None;
 215
 216         if (border_width != current_config->border_width)
 217         {
 218                 XSetWindowBorderWidth(dpy, win, current_config->border_width);
 219                 border_width = current_config->border_width;
 220         }
 221
 222         FScreenGetScrRect(
 223                 fsarg,  FSCREEN_GLOBAL, &screen_g.x, &screen_g.y,
 224                 &screen_g.width, &screen_g.height);
 225
 226         new_g.height = ((current_config->Ffont)? current_config->Ffont->height:0)
 227                 + 1;
 228         new_g.width = 4;
 229
 230         if (label && current_config->Ffont)
 231         {
 232                 new_g.width += FlocaleTextWidth(
 233                         current_config->Ffont, label, strlen(label));
 234         }
 235
 236         if (current_config->placement != FTIPS_PLACEMENT_AUTO_UPDOWN &&
 237             current_config->placement != FTIPS_PLACEMENT_AUTO_LEFTRIGHT)
 238         {
 239                 placement = current_config->placement;
 240         }
 241         else
 242         {
 243                 XTranslateCoordinates(
 244                         dpy, win_for, DefaultRootWindow(dpy), box.x, box.y,
 245                         &x, &y, &dummy);
 246                 if (current_config->placement == FTIPS_PLACEMENT_AUTO_UPDOWN)
 247                 {
 248                         if (y + box.height/2 >= screen_g.height/2)
 249                         {
 250                                 placement = FTIPS_PLACEMENT_UP;
 251                         }
 252                         else
 253                         {
 254                                 placement = FTIPS_PLACEMENT_DOWN;
 255                         }
 256                 }
 257                 else
 258                 {
 259                         if (x + box.width/2 >= screen_g.width/2)
 260                         {
 261                                 placement = FTIPS_PLACEMENT_LEFT;
 262                         }
 263                         else
 264                         {
 265                                 placement = FTIPS_PLACEMENT_RIGHT;
 266                         }
 267                 }
 268         }
 269
 270         if (placement == FTIPS_PLACEMENT_RIGHT ||
 271             placement == FTIPS_PLACEMENT_LEFT)
 272         {
 273                 if (current_config->justification == FTIPS_JUSTIFICATION_CENTER)
 274                 {
 275                         y = box.y + (box.height / 2) - (new_g.height / 2) -
 276                                 current_config->border_width;
 277                 }
 278                 else if (current_config->justification ==
 279                          FTIPS_JUSTIFICATION_RIGHT_DOWN)
 280                 {
 281                         y = box.y + box.height  - new_g.height -
 282                                 (2 * current_config->border_width) -
 283                                 current_config->justification_offset;
 284                 }
 285                 else /* LEFT_UP */
 286                 {
 287                         y = box.y + current_config->justification_offset;
 288
 289                 }
 290         }
 291         else /* placement == FTIPS_PLACEMENT_DOWN ||
 292                placement == FTIPS_PLACEMENT_UP */
 293         {
 294                 if (current_config->justification == FTIPS_JUSTIFICATION_CENTER)
 295                 {
 296                         x = box.x + (box.width / 2) - (new_g.width / 2) -
 297                                 current_config->border_width;
 298                 }
 299                 else if (current_config->justification ==
 300                          FTIPS_JUSTIFICATION_RIGHT_DOWN)
 301                 {
 302                         x = box.x + box.width  - new_g.width -
 303                                 (2 * current_config->border_width) -
 304                                 current_config->justification_offset;
 305                 }
 306                 else /* LEFT_UP */
 307                 {
 308                         x = box.x + current_config->justification_offset;
 309                 }
 310         }
 311
 312         if (placement == FTIPS_PLACEMENT_RIGHT)
 313         {
 314                 x = box.x + box.width + current_config->placement_offset + 1;
 315         }
 316         else if (placement == FTIPS_PLACEMENT_LEFT)
 317         {
 318                 x = box.x - current_config->placement_offset - new_g.width
 319                         - (2 * current_config->border_width) - 1;
 320         }
 321         else if (placement == FTIPS_PLACEMENT_DOWN)
 322         {
 323                 y = box.y + box.height + current_config->placement_offset - 0;
 324         }
 325         else  /* UP */
 326         {
 327                 y = box.y - current_config->placement_offset - new_g.height
 328                         + 0 - (2 * current_config->border_width);
 329         }
 330
 331         XTranslateCoordinates(
 332                 dpy, win_for, DefaultRootWindow(dpy), x, y,
 333                 &new_g.x, &new_g.y, &dummy);
 334
 335         if (placement == FTIPS_PLACEMENT_RIGHT ||
 336             placement == FTIPS_PLACEMENT_LEFT)
 337         {
 338                 int x1,y1,l1,l2;
 339
 340                 if (new_g.x < 2)
 341                 {
 342                         x = box.x + box.width + current_config->placement_offset
 343                                 + 1;
 344                         XTranslateCoordinates(
 345                                 dpy, win_for, DefaultRootWindow(dpy), x, y,
 346                                 &x1, &y1, &dummy);
 347                         /* */
 348                         l1 = new_g.width + new_g.x - 2;
 349                         l2 = screen_g.width - (x1 + new_g.width) -
 350                                 current_config->border_width - 2;
 351                         if (l2 > l1)
 352                         {
 353                                 new_g.x = x1;
 354                         }
 355                 }
 356                 else if (new_g.x + new_g.width >
 357                          screen_g.width - (2 * current_config->border_width) - 2)
 358                 {
 359                         x = box.x - current_config->placement_offset - new_g.width
 360                                 - (2 * current_config->border_width) - 1;
 361                         XTranslateCoordinates(
 362                                 dpy, win_for, DefaultRootWindow(dpy), x, y,
 363                                 &x1, &y1, &dummy);
 364                         /* */
 365                         l1 = new_g.width + x1 - 2;
 366                         l2 = screen_g.width - (new_g.x + new_g.width) -
 367                                 (2 * current_config->border_width) - 2;
 368                         if (l1 > l2)
 369                         {
 370                                 new_g.x = x1;
 371                         }
 372                 }
 373                 if ( new_g.y < 2 )
 374                 {
 375                         new_g.y = 2;
 376                 }
 377                 else if (new_g.y + new_g.height >
 378                          screen_g.height - (2 * current_config->border_width) - 2)
 379                 {
 380                         new_g.y = screen_g.height - new_g.height -
 381                                 (2 * current_config->border_width) - 2;
 382                 }
 383         }
 384         else /* placement == FTIPS_PLACEMENT_DOWN ||
 385                 placement == FTIPS_PLACEMENT_UP */
 386         {
 387                 if (new_g.y < 2)
 388                 {
 389                         y = box.y + box.height +
 390                                 current_config->placement_offset - 0;
 391                         XTranslateCoordinates(
 392                                 dpy, win_for, DefaultRootWindow(dpy),
 393                                 x, y, &new_g.x, &new_g.y, &dummy);
 394                 }
 395                 else if (new_g.y + new_g.height >
 396                          screen_g.height - (2 * current_config->border_width) - 2)
 397                 {
 398                         y = box.y - current_config->placement_offset -
 399                                 new_g.height + 0
 400                                 - (2 * current_config->border_width);
 401                         XTranslateCoordinates(
 402                                 dpy, win_for, DefaultRootWindow(dpy),
 403                                 x, y, &new_g.x, &new_g.y, &dummy);
 404                 }
 405                 if ( new_g.x < 2 )
 406                 {
 407                         new_g.x = 2;
 408                 }
 409                 else if (new_g.x + new_g.width >
 410                          screen_g.width - (2 * current_config->border_width) - 2)
 411                 {
 412                         new_g.x = screen_g.width - new_g.width -
 413                                 (2 * current_config->border_width) - 2;
 414                 }
 415         }
 416
 417         /* make changes to window */
 418         XMoveResizeWindow(
 419                 dpy, win, new_g.x, new_g.y, new_g.width, new_g.height);
 420         __setup_gc(dpy);
 421         if (current_config->colorset > -1)
 422         {
 423                 SetWindowBackground(
 424                         dpy, win, new_g.width, new_g.height,
 425                         &Colorset[current_config->colorset], Pdepth, gc, True);
 426         }
 427         else
 428         {
 429                 XSetWindowBackground (dpy, win, current_config->bg);
 430         }
 431         if (current_config->border_width > 0)
 432         {
 433                 XSetWindowBorder(
 434                         dpy, win, Colorset[current_config->colorset].fg);
 435         }
 436
 437         if (state != FVWM_TIPS_MAPPED && win_f != win_for)
 438         {
 439                 long l_win_for;
 440
 441                 l_win_for = win_for;
 442                 XChangeProperty(
 443                         dpy, win, _net_um_for, XA_WINDOW, 32, PropModeReplace,
 444                         (unsigned char *) &l_win_for, 1);
 445                 win_f = win_for;
 446         }
 447         XMapRaised(dpy, win);
 448         state = FVWM_TIPS_MAPPED;
 449
 450         return;
 451 }
 452
 453 /* ---------------------------- interface functions ------------------------ */
 454
 455 Bool FTipsInit(Display *dpy)
 456 {
 457
 458         current_config = default_config = FTipsNewConfig();
 459         __initialize_window(dpy);
 460
 461         if (gc == None || win == None)
 462         {
 463                 return False;
 464         }
 465
 466         __setup_cs(dpy);
 467         __setup_gc(dpy);
 468
 469         memset(&fwin_string, 0, sizeof(fwin_string));
 470
 471         return True;
 472 }
 473
 474 ftips_config *FTipsNewConfig(void)
 475 {
 476         ftips_config *fc;
 477
 478         fc = (ftips_config *)safemalloc(sizeof(ftips_config));
 479
 480         memset(fc, 0, sizeof(ftips_config));
 481
 482         /* use colorset 0 as default */
 483         fc->border_width = FTIPS_DEFAULT_BORDER_WIDTH;
 484         fc->placement = FTIPS_DEFAULT_PLACEMENT;
 485         fc->justification = FTIPS_DEFAULT_JUSTIFICATION;
 486         fc->placement_offset = FTIPS_DEFAULT_PLACEMENT_OFFSET;
 487         fc->justification_offset = FTIPS_DEFAULT_JUSTIFICATION_OFFSET;
 488         fc->delay = 1000;
 489         fc->mapped_delay = 300;
 490
 491         return fc;
 492 }
 493
 494 void FTipsOn(
 495         Display *dpy, Window win_f, ftips_config *fc, void *id, char *str,
 496         int x, int y, int w, int h)
 497 {
 498         unsigned long delay;
 499
 500         box.x = x;
 501         box.y = y;
 502         box.width = w;
 503         box.height = h;
 504
 505         if (fc == NULL)
 506         {
 507                 fc = default_config;
 508         }
 509         current_config = fc;
 510
 511         if (label != NULL)
 512         {
 513                 free(label);
 514         }
 515         CopyString(&label, str);
 516         win_for = win_f;
 517
 518         if (id == boxID)
 519         {
 520                 if (id && state == FVWM_TIPS_WAITING)
 521                 {
 522                         FTipsCheck(dpy);
 523                 }
 524                 return;
 525         }
 526         onTime = __get_time();
 527         if (state == FVWM_TIPS_MAPPED)
 528         {
 529                 FTipsCancel(dpy);
 530                 delay = fc->mapped_delay;
 531         }
 532         else
 533         {
 534                 delay = fc->delay;
 535         }
 536         boxID = id;
 537         timeOut = onTime + delay;
 538         state = FVWM_TIPS_WAITING;
 539         if (delay == 0)
 540         {
 541                 FTipsCheck(dpy);
 542         }
 543
 544         return;
 545 }
 546
 547 void FTipsCancel(Display *dpy)
 548 {
 549         if (state == FVWM_TIPS_MAPPED && win != None)
 550         {
 551                 XUnmapWindow(dpy, win);
 552         }
 553         boxID = 0;
 554         state = FVWM_TIPS_NOTHING;
 555 }
 556
 557 unsigned long FTipsCheck(Display *dpy)
 558 {
 559         unsigned long ct;
 560
 561         if (state != FVWM_TIPS_WAITING || win == None)
 562         {
 563                 return 0;
 564         }
 565
 566         ct = __get_time();
 567
 568         if (ct >= timeOut)
 569         {
 570                 __map_window(dpy);
 571                 XFlush(dpy);
 572                 state = FVWM_TIPS_MAPPED;
 573                 return 0;
 574         }
 575         else
 576         {
 577                 XFlush(dpy);
 578                 return timeOut - ct;
 579         }
 580 }
 581
 582 Bool FTipsExpose(Display *dpy, XEvent *ev)
 583 {
 584         int ex,ey,ex2,ey2;
 585
 586         if (win == None || ev->xany.window != win)
 587         {
 588                 return False;
 589         }
 590         ex = ev->xexpose.x;
 591         ey = ev->xexpose.y;
 592         ex2 = ev->xexpose.x + ev->xexpose.width;
 593         ey2= ev->xexpose.y + ev->xexpose.height;
 594
 595         while (FCheckTypedWindowEvent(dpy, ev->xany.window, Expose, ev))
 596         {
 597                 ex = min(ex, ev->xexpose.x);
 598                 ey = min(ey, ev->xexpose.y);
 599                 ex2 = max(ex2, ev->xexpose.x + ev->xexpose.width);
 600                 ey2= max(ey2 , ev->xexpose.y + ev->xexpose.height);
 601         }
 602 #if 0
 603         fprintf (
 604                 stderr, "\tExpose: %i,%i,%i,%i %i\n",
 605                 ex, ey, ex2-ex, ey2-ey, ev->xexpose.count);
 606 #endif
 607         __draw(dpy);
 608
 609         return True;
 610 }
 611
 612 Bool FTipsHandleEvents(Display *dpy, XEvent *ev)
 613 {
 614         if (ev->xany.window != win)
 615         {
 616                 return False;
 617         }
 618
 619         switch(ev->type)
 620         {
 621         case Expose:
 622                 FTipsExpose(dpy, ev);
 623                 break;
 624         default:
 625                 break;
 626         }
 627         return True;
 628 }
 629
 630 void FTipsUpdateLabel(Display *dpy, char *str)
 631 {
 632         if (state != FVWM_TIPS_MAPPED && state != FVWM_TIPS_WAITING)
 633         {
 634                 return;
 635         }
 636
 637         if (label)
 638         {
 639                 free(label);
 640         }
 641         CopyString(&label, str);
 642         if (state == FVWM_TIPS_MAPPED)
 643         {
 644                 __map_window(dpy);
 645                 __draw(dpy);
 646         }
 647 }
 648
 649 void FTipsColorsetChanged(Display *dpy, int cs)
 650 {
 651         if (state != FVWM_TIPS_MAPPED || cs != current_config->colorset)
 652         {
 653                 return;
 654         }
 655         __map_window(dpy);
 656         __draw(dpy);
 657 }