Dogcows Code - chaz/tint2/blob - src/tint.c

   1 /**************************************************************************
   2 *
   3 * Tint2 panel
   4 *
   5 * Copyright (C) 2007 Pål Staurland (staura@gmail.com)
   6 * Modified (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr)
   7 *
   8 * This program is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU General Public License version 2
  10 * as published by the Free Software Foundation.
  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 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 **************************************************************************/
  20
  21 #include <sys/stat.h>
  22 #include <sys/time.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <X11/Xutil.h>
  28 #include <X11/Xatom.h>
  29 #include <X11/Xlocale.h>
  30 #include <Imlib2.h>
  31 #include <signal.h>
  32
  33 #include "server.h"
  34 #include "window.h"
  35 #include "config.h"
  36 #include "task.h"
  37 #include "taskbar.h"
  38 #include "systraybar.h"
  39 #include "panel.h"
  40
  41
  42 void signal_handler(int sig)
  43 {
  44         // signal handler is light as it should be
  45         signal_pending = sig;
  46 }
  47
  48
  49 void init ()
  50 {
  51         // Set signal handler
  52    signal(SIGUSR1, signal_handler);
  53         signal(SIGINT, signal_handler);
  54         signal(SIGTERM, signal_handler);
  55         signal(SIGHUP, signal_handler);
  56         signal(SIGCHLD, SIG_IGN);               // don't have to wait() after fork()
  57
  58    // set global data
  59    memset(&server, 0, sizeof(Server_global));
  60    memset(&systray, 0, sizeof(Systraybar));
  61
  62    server.dsp = XOpenDisplay (NULL);
  63    if (!server.dsp) {
  64       fprintf(stderr, "tint2 exit : could not open display.\n");
  65       exit(0);
  66    }
  67    server_init_atoms ();
  68    server.screen = DefaultScreen (server.dsp);
  69         server.root_win = RootWindow(server.dsp, server.screen);
  70    server.depth = DefaultDepth (server.dsp, server.screen);
  71    server.visual = DefaultVisual (server.dsp, server.screen);
  72    server.desktop = server_get_current_desktop ();
  73         XGCValues  gcv;
  74         server.gc = XCreateGC (server.dsp, server.root_win, (unsigned long)0, &gcv) ;
  75
  76    XSetErrorHandler ((XErrorHandler) server_catch_error);
  77
  78    imlib_context_set_display (server.dsp);
  79    imlib_context_set_visual (server.visual);
  80    imlib_context_set_colormap (DefaultColormap (server.dsp, server.screen));
  81
  82    /* Catch events */
  83    XSelectInput (server.dsp, server.root_win, PropertyChangeMask|StructureNotifyMask);
  84
  85    setlocale (LC_ALL, "");
  86 }
  87
  88
  89 void cleanup()
  90 {
  91         cleanup_panel();
  92
  93    if (time1_font_desc) pango_font_description_free(time1_font_desc);
  94    if (time2_font_desc) pango_font_description_free(time2_font_desc);
  95    if (time1_format) g_free(time1_format);
  96    if (time2_format) g_free(time2_format);
  97 #ifdef ENABLE_BATTERY
  98    if (bat1_font_desc) pango_font_description_free(bat1_font_desc);
  99    if (bat2_font_desc) pango_font_description_free(bat2_font_desc);
 100         if (battery_low_cmd) g_free(battery_low_cmd);
 101         if (path_energy_now) g_free(path_energy_now);
 102         if (path_energy_full) g_free(path_energy_full);
 103         if (path_current_now) g_free(path_current_now);
 104         if (path_status) g_free(path_status);
 105 #endif
 106         if (clock_lclick_command) g_free(clock_lclick_command);
 107         if (clock_rclick_command) g_free(clock_rclick_command);
 108
 109    if (server.monitor) free(server.monitor);
 110    XFreeGC(server.dsp, server.gc);
 111    XCloseDisplay(server.dsp);
 112 }
 113
 114
 115 void window_action (Task *tsk, int action)
 116 {
 117         switch (action) {
 118                 case CLOSE:
 119                         set_close (tsk->win);
 120                         break;
 121                 case TOGGLE:
 122                         set_active(tsk->win);
 123                         break;
 124                 case ICONIFY:
 125                         XIconifyWindow (server.dsp, tsk->win, server.screen);
 126                         break;
 127                 case TOGGLE_ICONIFY:
 128                         if (tsk == task_active) XIconifyWindow (server.dsp, tsk->win, server.screen);
 129                         else set_active (tsk->win);
 130                         break;
 131                 case SHADE:
 132                         window_toggle_shade (tsk->win);
 133                         break;
 134                 case MAXIMIZE_RESTORE:
 135                         window_maximize_restore (tsk->win);
 136                         break;
 137                 case MAXIMIZE:
 138                         window_maximize_restore (tsk->win);
 139                         break;
 140                 case RESTORE:
 141                         window_maximize_restore (tsk->win);
 142                         break;
 143         }
 144 }
 145
 146
 147 void event_button_press (XEvent *e)
 148 {
 149    Panel *panel = get_panel(e->xany.window);
 150         if (!panel) return;
 151
 152         if (wm_menu) {
 153                 if ((panel_horizontal && (e->xbutton.x < panel->area.paddingxlr || e->xbutton.x > panel->area.width-panel->area.paddingxlr || e->xbutton.y < panel->area.paddingy || e->xbutton.y > panel->area.paddingy+panel->g_taskbar.height)) || (!panel_horizontal && (e->xbutton.y < panel->area.paddingxlr || e->xbutton.y > panel->area.height-panel->area.paddingxlr || e->xbutton.x < panel->area.paddingy || e->xbutton.x > panel->area.paddingy+panel->g_taskbar.width))) {
 154                         // forward the click to the desktop window (thanks conky)
 155                         XUngrabPointer(server.dsp, e->xbutton.time);
 156                         e->xbutton.window = server.root_win;
 157                         // icewm doesn't open under the mouse.
 158                         // and xfce doesn't open at all.
 159                         //e->xbutton.x = e->xbutton.x_root;
 160                         //e->xbutton.y = e->xbutton.y_root;
 161                         //printf("**** %d, %d\n", e->xbutton.x, e->xbutton.y);
 162                         XSetInputFocus(server.dsp, e->xbutton.window, RevertToParent, e->xbutton.time);
 163                         XSendEvent(server.dsp, e->xbutton.window, False, ButtonPressMask, e);
 164                         return;
 165                 }
 166         }
 167
 168         if (e->xbutton.button != 1) return;
 169
 170    if (panel_mode != MULTI_DESKTOP) {
 171       // drag and drop disabled
 172       XLowerWindow (server.dsp, panel->main_win);
 173       return;
 174    }
 175
 176    GSList *l0;
 177    Taskbar *tskbar;
 178         if (panel_horizontal) {
 179                 int x = e->xbutton.x;
 180                 for (l0 = panel->area.list; l0 ; l0 = l0->next) {
 181                         tskbar = l0->data;
 182                         if (!tskbar->area.on_screen) continue;
 183                         if (x >= tskbar->area.posx && x <= (tskbar->area.posx + tskbar->area.width))
 184                                 break;
 185                 }
 186                 if (l0) {
 187                         Task *tsk;
 188                         for (l0 = tskbar->area.list; l0 ; l0 = l0->next) {
 189                                 tsk = l0->data;
 190                                 if (x >= tsk->area.posx && x <= (tsk->area.posx + tsk->area.width)) {
 191                                         task_drag = tsk;
 192                                         break;
 193                                 }
 194                         }
 195                 }
 196         }
 197         else {
 198                 int y = e->xbutton.y;
 199                 for (l0 = panel->area.list; l0 ; l0 = l0->next) {
 200                         tskbar = l0->data;
 201                         if (!tskbar->area.on_screen) continue;
 202                         if (y >= tskbar->area.posy && y <= (tskbar->area.posy + tskbar->area.height))
 203                                 break;
 204                 }
 205                 if (l0) {
 206                         Task *tsk;
 207                         for (l0 = tskbar->area.list; l0 ; l0 = l0->next) {
 208                                 tsk = l0->data;
 209                                 if (y >= tsk->area.posy && y <= (tsk->area.posy + tsk->area.height)) {
 210                                         task_drag = tsk;
 211                                         break;
 212                                 }
 213                         }
 214                 }
 215         }
 216
 217    XLowerWindow (server.dsp, panel->main_win);
 218 }
 219
 220
 221 void event_button_release (XEvent *e)
 222 {
 223    Panel *panel = get_panel(e->xany.window);
 224         if (!panel) return;
 225
 226         if (wm_menu) {
 227                 if ((panel_horizontal && (e->xbutton.x < panel->area.paddingxlr || e->xbutton.x > panel->area.width-panel->area.paddingxlr || e->xbutton.y < panel->area.paddingy || e->xbutton.y > panel->area.paddingy+panel->g_taskbar.height)) || (!panel_horizontal && (e->xbutton.y < panel->area.paddingxlr || e->xbutton.y > panel->area.height-panel->area.paddingxlr || e->xbutton.x < panel->area.paddingy || e->xbutton.x > panel->area.paddingy+panel->g_taskbar.width))) {
 228                         // forward the click to the desktop window (thanks conky)
 229                         e->xbutton.window = server.root_win;
 230                         XSendEvent(server.dsp, e->xbutton.window, False, ButtonReleaseMask, e);
 231                         return;
 232                 }
 233         }
 234
 235    int action = TOGGLE_ICONIFY;
 236    int x = e->xbutton.x;
 237    int y = e->xbutton.y;
 238    switch (e->xbutton.button) {
 239       case 2:
 240          action = mouse_middle;
 241          break;
 242       case 3:
 243          action = mouse_right;
 244          break;
 245       case 4:
 246          action = mouse_scroll_up;
 247          break;
 248       case 5:
 249          action = mouse_scroll_down;
 250          break;
 251    }
 252
 253    // search taskbar
 254    Taskbar *tskbar;
 255    GSList *l0;
 256         Clock clk = panel->clock;
 257         if (panel_horizontal) {
 258                 if (clk.area.on_screen && x >= clk.area.posx && x <= (clk.area.posx + clk.area.width))
 259                         clock_action(e->xbutton.button);
 260                 else {
 261                         for (l0 = panel->area.list; l0 ; l0 = l0->next) {
 262                                 tskbar = l0->data;
 263                                 if (!tskbar->area.on_screen) continue;
 264                                 if (x >= tskbar->area.posx && x <= (tskbar->area.posx + tskbar->area.width))
 265                                         goto suite;
 266                         }
 267                 }
 268         }
 269         else {
 270                 if (clk.area.on_screen && y >= clk.area.posy && y <= (clk.area.posy + clk.area.height))
 271                         clock_action(e->xbutton.button);
 272                 else {
 273                         for (l0 = panel->area.list; l0 ; l0 = l0->next) {
 274                                 tskbar = l0->data;
 275                                 if (!tskbar->area.on_screen) continue;
 276                                 if (y >= tskbar->area.posy && y <= (tskbar->area.posy + tskbar->area.height))
 277                                         goto suite;
 278                         }
 279                 }
 280         }
 281
 282    // TODO: check better solution to keep window below
 283    XLowerWindow (server.dsp, panel->main_win);
 284    task_drag = 0;
 285    return;
 286
 287 suite:
 288    // drag and drop task
 289    if (task_drag) {
 290       if (tskbar != task_drag->area.parent && action == TOGGLE_ICONIFY) {
 291          if (task_drag->desktop != ALLDESKTOP && panel_mode == MULTI_DESKTOP) {
 292             windows_set_desktop(task_drag->win, tskbar->desktop);
 293             if (tskbar->desktop == server.desktop)
 294                set_active(task_drag->win);
 295             task_drag = 0;
 296          }
 297          return;
 298       }
 299       else task_drag = 0;
 300    }
 301
 302    // switch desktop
 303    if (panel_mode == MULTI_DESKTOP) {
 304       if (tskbar->desktop != server.desktop && action != CLOSE)
 305          set_desktop (tskbar->desktop);
 306         }
 307
 308    // action on task
 309    Task *tsk;
 310    GSList *l;
 311    for (l = tskbar->area.list ; l ; l = l->next) {
 312       tsk = l->data;
 313                 if (panel_horizontal) {
 314                         if (x >= tsk->area.posx && x <= (tsk->area.posx + tsk->area.width)) {
 315                                 window_action (tsk, action);
 316                                 break;
 317                         }
 318                 }
 319                 else {
 320                         if (y >= tsk->area.posy && y <= (tsk->area.posy + tsk->area.height)) {
 321                                 window_action (tsk, action);
 322                                 break;
 323                         }
 324                 }
 325    }
 326
 327    // to keep window below
 328    XLowerWindow (server.dsp, panel->main_win);
 329 }
 330
 331
 332 void event_property_notify (XEvent *e)
 333 {
 334         int i, j;
 335    Task *tsk;
 336    Window win = e->xproperty.window;
 337    Atom at = e->xproperty.atom;
 338
 339    if (win == server.root_win) {
 340       if (!server.got_root_win) {
 341          XSelectInput (server.dsp, server.root_win, PropertyChangeMask|StructureNotifyMask);
 342          server.got_root_win = 1;
 343       }
 344
 345       // Change number of desktops
 346       else if (at == server.atom._NET_NUMBER_OF_DESKTOPS) {
 347               server.nb_desktop = server_get_number_of_desktop ();
 348                         cleanup_taskbar();
 349                         init_taskbar();
 350                         visible_object();
 351                         for (i=0 ; i < nb_panel ; i++) {
 352                                 panel1[i].area.resize = 1;
 353                         }
 354                         task_refresh_tasklist();
 355                         panel_refresh = 1;
 356       }
 357       // Change desktop
 358       else if (at == server.atom._NET_CURRENT_DESKTOP) {
 359          server.desktop = server_get_current_desktop ();
 360          if (panel_mode != MULTI_DESKTOP) {
 361                                 visible_object();
 362          }
 363       }
 364       // Window list
 365       else if (at == server.atom._NET_CLIENT_LIST) {
 366          task_refresh_tasklist();
 367          panel_refresh = 1;
 368       }
 369       // Change active
 370       else if (at == server.atom._NET_ACTIVE_WINDOW) {
 371          GSList *l0;
 372         if (task_active) {
 373                                 for (i=0 ; i < nb_panel ; i++) {
 374                                         for (j=0 ; j < panel1[i].nb_desktop ; j++) {
 375                   for (l0 = panel1[i].taskbar[j].area.list; l0 ; l0 = l0->next) {
 376                      tsk = l0->data;
 377                            tsk->area.is_active = 0;
 378                   }
 379                                         }
 380                                 }
 381                 task_active = 0;
 382                         }
 383          Window w1 = window_get_active ();
 384          Task *t = task_get_task(w1);
 385          if (!t) {
 386             Window w2;
 387             if (XGetTransientForHint(server.dsp, w1, &w2) != 0)
 388                if (w2) t = task_get_task(w2);
 389          }
 390                         if (task_urgent == t) {
 391                                 init_precision();
 392                                 task_urgent = 0;
 393                         }
 394                         // put active state on all task (multi_desktop)
 395          if (t) {
 396                                 for (i=0 ; i < nb_panel ; i++) {
 397                                         for (j=0 ; j < panel1[i].nb_desktop ; j++) {
 398                   for (l0 = panel1[i].taskbar[j].area.list; l0 ; l0 = l0->next) {
 399                      tsk = l0->data;
 400                      if (tsk->win == t->win) {
 401                                 tsk->area.is_active = 1;
 402                                 //printf("active monitor %d, task %s\n", panel1[i].monitor, tsk->title);
 403                         }
 404                   }
 405                                         }
 406                                 }
 407                 task_active = t;
 408                         }
 409          panel_refresh = 1;
 410       }
 411       else if (at == server.atom._XROOTPMAP_ID) {
 412                         // change Wallpaper
 413                         for (i=0 ; i < nb_panel ; i++) {
 414                                 set_panel_background(&panel1[i]);
 415                         }
 416          panel_refresh = 1;
 417       }
 418    }
 419    else {
 420       tsk = task_get_task (win);
 421       if (!tsk) return;
 422       //printf("atom root_win = %s, %s\n", XGetAtomName(server.dsp, at), tsk->title);
 423
 424       // Window title changed
 425       if (at == server.atom._NET_WM_VISIBLE_NAME || at == server.atom._NET_WM_NAME || at == server.atom.WM_NAME) {
 426                         Task *tsk2;
 427                         GSList *l0;
 428                         get_title(tsk);
 429                         // changed other tsk->title
 430                         for (i=0 ; i < nb_panel ; i++) {
 431                                 for (j=0 ; j < panel1[i].nb_desktop ; j++) {
 432                                         for (l0 = panel1[i].taskbar[j].area.list; l0 ; l0 = l0->next) {
 433                                                 tsk2 = l0->data;
 434                                                 if (tsk->win == tsk2->win && tsk != tsk2) {
 435                                                         tsk2->title = tsk->title;
 436                                                         tsk2->area.redraw = 1;
 437                                                 }
 438                                         }
 439                                 }
 440                         }
 441          panel_refresh = 1;
 442       }
 443                 // Demand attention
 444       else if (at == server.atom._NET_WM_STATE) {
 445          if (window_is_urgent (win)) {
 446                                 task_urgent = tsk;
 447                                 tick_urgent = 0;
 448                                 time_precision = 1;
 449                         }
 450                 }
 451       else if (at == server.atom.WM_STATE) {
 452         // Iconic state
 453                         // TODO : try to delete following code
 454          if (window_is_iconified (win)) {
 455             if (task_active) {
 456                if (task_active->win == tsk->win) {
 457                                                 Task *tsk2;
 458                                                 GSList *l0;
 459                                                 for (i=0 ; i < nb_panel ; i++) {
 460                                                         for (j=0 ; j < panel1[i].nb_desktop ; j++) {
 461                                                                 for (l0 = panel1[i].taskbar[j].area.list; l0 ; l0 = l0->next) {
 462                                                                         tsk2 = l0->data;
 463                                                                         tsk2->area.is_active = 0;
 464                                                                 }
 465                                                         }
 466                                                 }
 467                   task_active = 0;
 468                }
 469             }
 470                         }
 471                 }
 472       // Window icon changed
 473       else if (at == server.atom._NET_WM_ICON) {
 474                    get_icon(tsk);
 475                         Task *tsk2;
 476                         GSList *l0;
 477                         for (i=0 ; i < nb_panel ; i++) {
 478                                 for (j=0 ; j < panel1[i].nb_desktop ; j++) {
 479                                         for (l0 = panel1[i].taskbar[j].area.list; l0 ; l0 = l0->next) {
 480                                                 tsk2 = l0->data;
 481                                                 if (tsk->win == tsk2->win && tsk != tsk2) {
 482                                                         tsk2->icon_width = tsk->icon_width;
 483                                                         tsk2->icon_height = tsk->icon_height;
 484                                                         tsk2->icon_data = tsk->icon_data;
 485                                                         tsk2->area.redraw = 1;
 486                                                 }
 487                                         }
 488                                 }
 489                         }
 490          panel_refresh = 1;
 491       }
 492       // Window desktop changed
 493       else if (at == server.atom._NET_WM_DESKTOP) {
 494                         int desktop = window_get_desktop (win);
 495                         int active = tsk->area.is_active;
 496                         //printf("  Window desktop changed %d, %d\n", tsk->desktop, desktop);
 497                         // bug in windowmaker : send unecessary 'desktop changed' when focus changed
 498                         if (desktop != tsk->desktop) {
 499                                 remove_task (tsk);
 500                                 tsk = add_task (win);
 501                                 if (tsk && active) {
 502                                         tsk->area.is_active = 1;
 503                                         task_active = tsk;
 504                                 }
 505                                 panel_refresh = 1;
 506                         }
 507       }
 508
 509       if (!server.got_root_win) server.root_win = RootWindow (server.dsp, server.screen);
 510    }
 511 }
 512
 513
 514 void event_expose (XEvent *e)
 515 {
 516    Panel *panel;
 517
 518         panel = get_panel(e->xany.window);
 519         if (!panel) return;
 520         // TODO : one panel_refresh per panel ?
 521    panel_refresh = 1;
 522 }
 523
 524
 525 void event_configure_notify (Window win)
 526 {
 527         // check 'win' move in systray
 528         TrayWindow *traywin;
 529         GSList *l;
 530         for (l = systray.list_icons; l ; l = l->next) {
 531                 traywin = (TrayWindow*)l->data;
 532                 if (traywin->id == win) {
 533                         //printf("move tray %d\n", traywin->x);
 534                         XMoveResizeWindow(server.dsp, traywin->id, traywin->x, traywin->y, traywin->width, traywin->height);
 535               panel_refresh = 1;
 536                         return;
 537                 }
 538         }
 539
 540         // check 'win' move in another monitor
 541    if (nb_panel == 1) return;
 542    if (server.nb_monitor == 1) return;
 543    Task *tsk = task_get_task (win);
 544    if (!tsk) return;
 545
 546    Panel *p = tsk->area.panel;
 547    if (p->monitor != window_get_monitor (win)) {
 548       remove_task (tsk);
 549       add_task (win);
 550       if (win == window_get_active ()) {
 551                    Task *tsk = task_get_task (win);
 552                         tsk->area.is_active = 1;
 553                         task_active = tsk;
 554                 }
 555       panel_refresh = 1;
 556    }
 557 }
 558
 559
 560 void event_timer()
 561 {
 562    struct timeval stv;
 563         int i;
 564
 565    if (gettimeofday(&stv, 0)) return;
 566
 567    if (abs(stv.tv_sec - time_clock.tv_sec) < time_precision) return;
 568         time_clock.tv_sec = stv.tv_sec;
 569         time_clock.tv_sec -= time_clock.tv_sec % time_precision;
 570
 571         // urgent task
 572         if (task_urgent) {
 573                 if (tick_urgent < max_tick_urgent) {
 574                         task_urgent->area.is_active = !task_urgent->area.is_active;
 575                         task_urgent->area.redraw = 1;
 576                         tick_urgent++;
 577                 }
 578         }
 579
 580         // update battery
 581 #ifdef ENABLE_BATTERY
 582         if (panel1[0].battery.area.on_screen) {
 583                 update_battery();
 584                 for (i=0 ; i < nb_panel ; i++)
 585                         panel1[i].battery.area.resize = 1;
 586         }
 587 #endif
 588
 589         // update clock
 590    if (time1_format) {
 591                 for (i=0 ; i < nb_panel ; i++)
 592                 panel1[i].clock.area.resize = 1;
 593         }
 594         panel_refresh = 1;
 595 }
 596
 597
 598 int main (int argc, char *argv[])
 599 {
 600    XEvent e;
 601    fd_set fd;
 602    int x11_fd, i, c;
 603    struct timeval tv;
 604    Panel *panel;
 605         GSList *it;
 606
 607    init ();
 608
 609 load_config:
 610    i = 0;
 611    c = getopt (argc, argv, "c:");
 612         init_config();
 613    if (c != -1) {
 614       i = config_read_file (optarg);
 615            c = getopt (argc, argv, "j:");
 616            if (c != -1) {
 617                         // usage: tint2 [-c] <config_file> -j <file> for internal use
 618            printf("file %s\n", optarg);
 619               cleanup();
 620            exit(0);
 621                 }
 622         }
 623    if (!i)
 624       i = config_read ();
 625    if (!i) {
 626       fprintf(stderr, "usage: tint2 [-c] <config_file>\n");
 627       cleanup();
 628       exit(1);
 629    }
 630    config_finish();
 631
 632    x11_fd = ConnectionNumber(server.dsp);
 633    XSync(server.dsp, False);
 634
 635    while (1) {
 636       // thanks to AngryLlama for the timer
 637       // Create a File Description Set containing x11_fd
 638       FD_ZERO (&fd);
 639       FD_SET (x11_fd, &fd);
 640
 641       tv.tv_usec = 500000;
 642       tv.tv_sec = 0;
 643
 644       // Wait for X Event or a Timer
 645       if (select(x11_fd+1, &fd, 0, 0, &tv)) {
 646          while (XPending (server.dsp)) {
 647             XNextEvent(server.dsp, &e);
 648
 649             switch (e.type) {
 650                case ButtonPress:
 651                   event_button_press (&e);
 652                   break;
 653
 654                case ButtonRelease:
 655                   event_button_release(&e);
 656                   break;
 657
 658                case Expose:
 659                 event_expose(&e);
 660                   break;
 661
 662                case PropertyNotify:
 663                   event_property_notify(&e);
 664                   break;
 665
 666                case ConfigureNotify:
 667                   if (e.xconfigure.window == server.root_win)
 668                      goto load_config;
 669                   else
 670                      event_configure_notify (e.xconfigure.window);
 671                   break;
 672
 673                                         case ReparentNotify:
 674                                                 if (!systray.area.on_screen)
 675                                                         break;
 676                                                 panel = (Panel*)systray.area.panel;
 677                                                 if (e.xany.window == panel->main_win) // reparented to us
 678                                                         break;
 679                                                 // FIXME: 'reparent to us' badly detected => disabled
 680                                                 break;
 681                                         case UnmapNotify:
 682                                         case DestroyNotify:
 683                                                 if (!systray.area.on_screen)
 684                                                         break;
 685                                                 for (it = systray.list_icons; it; it = g_slist_next(it)) {
 686                                                         if (((TrayWindow*)it->data)->id == e.xany.window) {
 687                                                                 remove_icon((TrayWindow*)it->data);
 688                                                                 break;
 689                                                         }
 690                                                 }
 691                                         break;
 692
 693                                         case ClientMessage:
 694                                                 if (!systray.area.on_screen) break;
 695                                                 if (e.xclient.message_type == server.atom._NET_SYSTEM_TRAY_OPCODE && e.xclient.format == 32 && e.xclient.window == net_sel_win) {
 696                                                         net_message(&e.xclient);
 697                                                 }
 698                   break;
 699             }
 700          }
 701       }
 702       event_timer();
 703
 704                 switch (signal_pending) {
 705                         case SIGUSR1:
 706                                 signal_pending = 0;
 707             goto load_config;
 708                         case SIGINT:
 709                         case SIGTERM:
 710                         case SIGHUP:
 711                            cleanup ();
 712                            return 0;
 713       }
 714
 715       if (panel_refresh) {
 716                         panel_refresh = 0;
 717
 718                         if (refresh_systray) {
 719                                 panel = (Panel*)systray.area.panel;
 720                                 XSetWindowBackgroundPixmap (server.dsp, panel->main_win, None);
 721                         }
 722                         for (i=0 ; i < nb_panel ; i++) {
 723                                 panel = &panel1[i];
 724
 725                                 if (panel->temp_pmap) XFreePixmap(server.dsp, panel->temp_pmap);
 726                                 panel->temp_pmap = XCreatePixmap(server.dsp, server.root_win, panel->area.width, panel->area.height, server.depth);
 727
 728                                 refresh(&panel->area);
 729                            XCopyArea(server.dsp, panel->temp_pmap, panel->main_win, server.gc, 0, 0, panel->area.width, panel->area.height, 0, 0);
 730                         }
 731                         XFlush (server.dsp);
 732
 733                         if (refresh_systray) {
 734                                 refresh_systray = 0;
 735                                 panel = (Panel*)systray.area.panel;
 736                                 // tint2 doen't draw systray icons. it just redraw background.
 737                                 XSetWindowBackgroundPixmap (server.dsp, panel->main_win, panel->temp_pmap);
 738                                 // force icon's refresh
 739                                 refresh_systray_icon();
 740                         }
 741                 }
 742    }
 743 }
 744
 745