Move files to util

src/util/common.c

@@ -31,7 +31,7 @@
 #include <glib.h>
 #include <glib/gstdio.h>
 #include "common.h"
-#include "../server.h"
+#include "server.h"
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <pwd.h>

src/util/server.c

@@ -0,0 +1,674 @@
+/**************************************************************************
+*
+* Tint2 panel
+*
+* Copyright (C) 2007 Pål Staurland (staura@gmail.com)
+* Modified (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr)
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License version 2
+* as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+**************************************************************************/
+
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xrender.h>
+#include <X11/extensions/Xrandr.h>
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "common.h"
+#include "config.h"
+#include "server.h"
+#include "signals.h"
+#include "window.h"
+
+Server server;
+
+void server_catch_error(Display *d, XErrorEvent *ev)
+{
+}
+
+void server_init_atoms()
+{
+    server.atom._XROOTPMAP_ID = XInternAtom(server.display, "_XROOTPMAP_ID", False);
+    server.atom._XROOTMAP_ID = XInternAtom(server.display, "_XROOTMAP_ID", False);
+    server.atom._NET_CURRENT_DESKTOP = XInternAtom(server.display, "_NET_CURRENT_DESKTOP", False);
+    server.atom._NET_NUMBER_OF_DESKTOPS = XInternAtom(server.display, "_NET_NUMBER_OF_DESKTOPS", False);
+    server.atom._NET_DESKTOP_NAMES = XInternAtom(server.display, "_NET_DESKTOP_NAMES", False);
+    server.atom._NET_DESKTOP_GEOMETRY = XInternAtom(server.display, "_NET_DESKTOP_GEOMETRY", False);
+    server.atom._NET_DESKTOP_VIEWPORT = XInternAtom(server.display, "_NET_DESKTOP_VIEWPORT", False);
+    server.atom._NET_WORKAREA = XInternAtom(server.display, "_NET_WORKAREA", False);
+    server.atom._NET_ACTIVE_WINDOW = XInternAtom(server.display, "_NET_ACTIVE_WINDOW", False);
+    server.atom._NET_WM_WINDOW_TYPE = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE", False);
+    server.atom._NET_WM_STATE_SKIP_PAGER = XInternAtom(server.display, "_NET_WM_STATE_SKIP_PAGER", False);
+    server.atom._NET_WM_STATE_SKIP_TASKBAR = XInternAtom(server.display, "_NET_WM_STATE_SKIP_TASKBAR", False);
+    server.atom._NET_WM_STATE_STICKY = XInternAtom(server.display, "_NET_WM_STATE_STICKY", False);
+    server.atom._NET_WM_STATE_DEMANDS_ATTENTION = XInternAtom(server.display, "_NET_WM_STATE_DEMANDS_ATTENTION", False);
+    server.atom._NET_WM_WINDOW_TYPE_DOCK = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_DOCK", False);
+    server.atom._NET_WM_WINDOW_TYPE_DESKTOP = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_DESKTOP", False);
+    server.atom._NET_WM_WINDOW_TYPE_TOOLBAR = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_TOOLBAR", False);
+    server.atom._NET_WM_WINDOW_TYPE_MENU = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_MENU", False);
+    server.atom._NET_WM_WINDOW_TYPE_SPLASH = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_SPLASH", False);
+    server.atom._NET_WM_WINDOW_TYPE_DIALOG = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_DIALOG", False);
+    server.atom._NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_NORMAL", False);
+    server.atom._NET_WM_DESKTOP = XInternAtom(server.display, "_NET_WM_DESKTOP", False);
+    server.atom.WM_STATE = XInternAtom(server.display, "WM_STATE", False);
+    server.atom._NET_WM_STATE = XInternAtom(server.display, "_NET_WM_STATE", False);
+    server.atom._NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(server.display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
+    server.atom._NET_WM_STATE_MAXIMIZED_HORZ = XInternAtom(server.display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+    server.atom._NET_WM_STATE_SHADED = XInternAtom(server.display, "_NET_WM_STATE_SHADED", False);
+    server.atom._NET_WM_STATE_HIDDEN = XInternAtom(server.display, "_NET_WM_STATE_HIDDEN", False);
+    server.atom._NET_WM_STATE_BELOW = XInternAtom(server.display, "_NET_WM_STATE_BELOW", False);
+    server.atom._NET_WM_STATE_ABOVE = XInternAtom(server.display, "_NET_WM_STATE_ABOVE", False);
+    server.atom._NET_WM_STATE_MODAL = XInternAtom(server.display, "_NET_WM_STATE_MODAL", False);
+    server.atom._NET_CLIENT_LIST = XInternAtom(server.display, "_NET_CLIENT_LIST", False);
+    server.atom._NET_WM_VISIBLE_NAME = XInternAtom(server.display, "_NET_WM_VISIBLE_NAME", False);
+    server.atom._NET_WM_NAME = XInternAtom(server.display, "_NET_WM_NAME", False);
+    server.atom._NET_WM_STRUT = XInternAtom(server.display, "_NET_WM_STRUT", False);
+    server.atom._NET_WM_ICON = XInternAtom(server.display, "_NET_WM_ICON", False);
+    server.atom._NET_WM_ICON_GEOMETRY = XInternAtom(server.display, "_NET_WM_ICON_GEOMETRY", False);
+    server.atom._NET_WM_ICON_NAME = XInternAtom(server.display, "_NET_WM_ICON_NAME", False);
+    server.atom._NET_CLOSE_WINDOW = XInternAtom(server.display, "_NET_CLOSE_WINDOW", False);
+    server.atom.UTF8_STRING = XInternAtom(server.display, "UTF8_STRING", False);
+    server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.display, "_NET_SUPPORTING_WM_CHECK", False);
+    server.atom._NET_WM_CM_S0 = XInternAtom(server.display, "_NET_WM_CM_S0", False);
+    server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.display, "_NET_WM_NAME", False);
+    server.atom._NET_WM_STRUT_PARTIAL = XInternAtom(server.display, "_NET_WM_STRUT_PARTIAL", False);
+    server.atom.WM_NAME = XInternAtom(server.display, "WM_NAME", False);
+    server.atom.__SWM_VROOT = XInternAtom(server.display, "__SWM_VROOT", False);
+    server.atom._MOTIF_WM_HINTS = XInternAtom(server.display, "_MOTIF_WM_HINTS", False);
+    server.atom.WM_HINTS = XInternAtom(server.display, "WM_HINTS", False);
+    gchar *name = g_strdup_printf("_XSETTINGS_S%d", DefaultScreen(server.display));
+    server.atom._XSETTINGS_SCREEN = XInternAtom(server.display, name, False);
+    g_free(name);
+    server.atom._XSETTINGS_SETTINGS = XInternAtom(server.display, "_XSETTINGS_SETTINGS", False);
+
+    // systray protocol
+    name = g_strdup_printf("_NET_SYSTEM_TRAY_S%d", DefaultScreen(server.display));
+    server.atom._NET_SYSTEM_TRAY_SCREEN = XInternAtom(server.display, name, False);
+    g_free(name);
+    server.atom._NET_SYSTEM_TRAY_OPCODE = XInternAtom(server.display, "_NET_SYSTEM_TRAY_OPCODE", False);
+    server.atom.MANAGER = XInternAtom(server.display, "MANAGER", False);
+    server.atom._NET_SYSTEM_TRAY_MESSAGE_DATA = XInternAtom(server.display, "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
+    server.atom._NET_SYSTEM_TRAY_ORIENTATION = XInternAtom(server.display, "_NET_SYSTEM_TRAY_ORIENTATION", False);
+    server.atom._NET_SYSTEM_TRAY_ICON_SIZE = XInternAtom(server.display, "_NET_SYSTEM_TRAY_ICON_SIZE", False);
+    server.atom._NET_SYSTEM_TRAY_PADDING = XInternAtom(server.display, "_NET_SYSTEM_TRAY_PADDING", False);
+    server.atom._XEMBED = XInternAtom(server.display, "_XEMBED", False);
+    server.atom._XEMBED_INFO = XInternAtom(server.display, "_XEMBED_INFO", False);
+    server.atom._NET_WM_PID = XInternAtom(server.display, "_NET_WM_PID", True);
+
+    // drag 'n' drop
+    server.atom.XdndAware = XInternAtom(server.display, "XdndAware", False);
+    server.atom.XdndEnter = XInternAtom(server.display, "XdndEnter", False);
+    server.atom.XdndPosition = XInternAtom(server.display, "XdndPosition", False);
+    server.atom.XdndStatus = XInternAtom(server.display, "XdndStatus", False);
+    server.atom.XdndDrop = XInternAtom(server.display, "XdndDrop", False);
+    server.atom.XdndLeave = XInternAtom(server.display, "XdndLeave", False);
+    server.atom.XdndSelection = XInternAtom(server.display, "XdndSelection", False);
+    server.atom.XdndTypeList = XInternAtom(server.display, "XdndTypeList", False);
+    server.atom.XdndActionCopy = XInternAtom(server.display, "XdndActionCopy", False);
+    server.atom.XdndFinished = XInternAtom(server.display, "XdndFinished", False);
+    server.atom.TARGETS = XInternAtom(server.display, "TARGETS", False);
+}
+
+const char *GetAtomName(Display *disp, Atom a)
+{
+    if (a == None)
+        return "None";
+    else
+        return XGetAtomName(disp, a);
+}
+
+void cleanup_server()
+{
+    if (server.colormap)
+        XFreeColormap(server.display, server.colormap);
+    server.colormap = 0;
+    if (server.colormap32)
+        XFreeColormap(server.display, server.colormap32);
+    server.colormap32 = 0;
+    if (server.monitors) {
+        for (int i = 0; i < server.num_monitors; ++i) {
+            g_strfreev(server.monitors[i].names);
+            server.monitors[i].names = NULL;
+        }
+        free(server.monitors);
+        server.monitors = NULL;
+    }
+    if (server.gc)
+        XFreeGC(server.display, server.gc);
+    server.gc = NULL;
+    server.disable_transparency = FALSE;
+#ifdef HAVE_SN
+    if (server.pids)
+        g_tree_destroy(server.pids);
+    server.pids = NULL;
+#endif
+}
+
+void send_event32(Window win, Atom at, long data1, long data2, long data3)
+{
+    XEvent event;
+
+    event.xclient.type = ClientMessage;
+    event.xclient.serial = 0;
+    event.xclient.send_event = True;
+    event.xclient.display = server.display;
+    event.xclient.window = win;
+    event.xclient.message_type = at;
+
+    event.xclient.format = 32;
+    event.xclient.data.l[0] = data1;
+    event.xclient.data.l[1] = data2;
+    event.xclient.data.l[2] = data3;
+    event.xclient.data.l[3] = 0;
+    event.xclient.data.l[4] = 0;
+
+    XSendEvent(server.display, server.root_win, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
+}
+
+int get_property32(Window win, Atom at, Atom type)
+{
+    Atom type_ret;
+    int format_ret = 0, data = 0;
+    unsigned long nitems_ret = 0;
+    unsigned long bafter_ret = 0;
+    unsigned char *prop_value = 0;
+    int result;
+
+    if (!win)
+        return 0;
+
+    result = XGetWindowProperty(server.display,
+                                win,
+                                at,
+                                0,
+                                0x7fffffff,
+                                False,
+                                type,
+                                &type_ret,
+                                &format_ret,
+                                &nitems_ret,
+                                &bafter_ret,
+                                &prop_value);
+
+    if (result == Success && prop_value) {
+        data = ((gulong *)prop_value)[0];
+        XFree(prop_value);
+    }
+    return data;
+}
+
+void *server_get_property(Window win, Atom at, Atom type, int *num_results)
+{
+    Atom type_ret;
+    int format_ret = 0;
+    unsigned long nitems_ret = 0;
+    unsigned long bafter_ret = 0;
+    unsigned char *prop_value;
+
+    if (!win)
+        return NULL;
+
+    int result = XGetWindowProperty(server.display,
+                                    win,
+                                    at,
+                                    0,
+                                    0x7fffffff,
+                                    False,
+                                    type,
+                                    &type_ret,
+                                    &format_ret,
+                                    &nitems_ret,
+                                    &bafter_ret,
+                                    &prop_value);
+
+    // Send fill_color resultcount
+    if (num_results)
+        *num_results = (int)nitems_ret;
+
+    if (result == Success && prop_value)
+        return prop_value;
+    else
+        return NULL;
+}
+
+void get_root_pixmap()
+{
+    Pixmap ret = None;
+
+    Atom pixmap_atoms[] = {server.atom._XROOTPMAP_ID, server.atom._XROOTMAP_ID};
+    for (int i = 0; i < sizeof(pixmap_atoms) / sizeof(Atom); ++i) {
+        unsigned long *res = (unsigned long *)server_get_property(server.root_win, pixmap_atoms[i], XA_PIXMAP, NULL);
+        if (res) {
+            ret = *((Pixmap *)res);
+            XFree(res);
+            break;
+        }
+    }
+    server.root_pmap = ret;
+
+    if (server.root_pmap == None) {
+        fprintf(stderr, "tint2: pixmap background detection failed\n");
+    } else {
+        XGCValues gcv;
+        gcv.ts_x_origin = 0;
+        gcv.ts_y_origin = 0;
+        gcv.fill_style = FillTiled;
+        unsigned mask = GCTileStipXOrigin | GCTileStipYOrigin | GCFillStyle | GCTile;
+
+        gcv.tile = server.root_pmap;
+        XChangeGC(server.display, server.gc, mask, &gcv);
+    }
+}
+
+int compare_monitor_pos(const void *monitor1, const void *monitor2)
+{
+    const Monitor *m1 = (const Monitor *)monitor1;
+    const Monitor *m2 = (const Monitor *)monitor2;
+
+    if (m1->x < m2->x) {
+        return -1;
+    } else if (m1->x > m2->x) {
+        return 1;
+    } else if (m1->y < m2->y) {
+        return -1;
+    } else if (m1->y > m2->y) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int monitor_includes_monitor(const void *monitor1, const void *monitor2)
+{
+    const Monitor *m1 = (const Monitor *)monitor1;
+    const Monitor *m2 = (const Monitor *)monitor2;
+
+    if (m1->x >= m2->x && m1->y >= m2->y && (m1->x + m1->width) <= (m2->x + m2->width) &&
+        (m1->y + m1->height) <= (m2->y + m2->height)) {
+        // m1 included inside m2
+        return 1;
+    } else {
+        return -1;
+    }
+}
+
+void sort_monitors()
+{
+    qsort(server.monitors, server.num_monitors, sizeof(Monitor), compare_monitor_pos);
+}
+
+void get_monitors()
+{
+    if (XineramaIsActive(server.display)) {
+        int num_monitors;
+        XineramaScreenInfo *info = XineramaQueryScreens(server.display, &num_monitors);
+        XRRScreenResources *res = XRRGetScreenResourcesCurrent(server.display, server.root_win);
+        RROutput primary_output = XRRGetOutputPrimary(server.display, server.root_win);
+
+        if (res && res->ncrtc >= num_monitors) {
+            // use xrandr to identify monitors (does not work with proprietery nvidia drivers)
+            fprintf(stderr, "tint2: xRandr: Found crtc's: %d\n", res->ncrtc);
+            server.monitors = calloc(res->ncrtc, sizeof(Monitor));
+            num_monitors = 0;
+            for (int i = 0; i < res->ncrtc; ++i) {
+                XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(server.display, res, res->crtcs[i]);
+                // Ignore empty crtc
+                if (!crtc_info->width || !crtc_info->height) {
+                    fprintf(stderr, "tint2: xRandr: crtc %d seems disabled\n", i);
+                    XRRFreeCrtcInfo(crtc_info);
+                    continue;
+                }
+                int i_monitor = num_monitors;
+                num_monitors++;
+                server.monitors[i_monitor].x = crtc_info->x;
+                server.monitors[i_monitor].y = crtc_info->y;
+                server.monitors[i_monitor].width = crtc_info->width;
+                server.monitors[i_monitor].height = crtc_info->height;
+                server.monitors[i_monitor].names = calloc((crtc_info->noutput + 1), sizeof(gchar *));
+                for (int j = 0; j < crtc_info->noutput; ++j) {
+                    XRROutputInfo *output_info = XRRGetOutputInfo(server.display, res, crtc_info->outputs[j]);
+                    fprintf(stderr, "tint2: xRandr: Linking output %s with crtc %d\n", output_info->name, i);
+                    server.monitors[i_monitor].names[j] = g_strdup(output_info->name);
+                    XRRFreeOutputInfo(output_info);
+                    server.monitors[i_monitor].primary = crtc_info->outputs[j] == primary_output;
+                }
+                server.monitors[i_monitor].names[crtc_info->noutput] = NULL;
+                XRRFreeCrtcInfo(crtc_info);
+            }
+        } else if (info && num_monitors > 0) {
+            server.monitors = calloc(num_monitors, sizeof(Monitor));
+            for (int i = 0; i < num_monitors; i++) {
+                server.monitors[i].x = info[i].x_org;
+                server.monitors[i].y = info[i].y_org;
+                server.monitors[i].width = info[i].width;
+                server.monitors[i].height = info[i].height;
+                server.monitors[i].names = NULL;
+            }
+        }
+
+        // Sort monitors by inclusion
+        qsort(server.monitors, num_monitors, sizeof(Monitor), monitor_includes_monitor);
+
+        // Remove monitors included in other ones
+        int i = 0;
+        while (i < num_monitors) {
+            for (int j = 0; j < i; j++) {
+                if (monitor_includes_monitor(&server.monitors[i], &server.monitors[j]) > 0) {
+                    goto next;
+                }
+            }
+            i++;
+        }
+    next:
+        for (int j = i; j < num_monitors; ++j)
+            if (server.monitors[j].names)
+                g_strfreev(server.monitors[j].names);
+        server.num_monitors = i;
+        server.monitors = realloc(server.monitors, server.num_monitors * sizeof(Monitor));
+        qsort(server.monitors, server.num_monitors, sizeof(Monitor), compare_monitor_pos);
+
+        if (res)
+            XRRFreeScreenResources(res);
+        XFree(info);
+    }
+
+    if (!server.num_monitors) {
+        server.num_monitors = 1;
+        server.monitors = calloc(1, sizeof(Monitor));
+        server.monitors[0].x = server.monitors[0].y = 0;
+        server.monitors[0].width = DisplayWidth(server.display, server.screen);
+        server.monitors[0].height = DisplayHeight(server.display, server.screen);
+        server.monitors[0].names = 0;
+    }
+}
+
+void print_monitors()
+{
+    fprintf(stderr, "tint2: Number of monitors: %d\n", server.num_monitors);
+    for (int i = 0; i < server.num_monitors; i++) {
+        fprintf(stderr,
+                "Monitor %d: x = %d, y = %d, w = %d, h = %d\n",
+                i + 1,
+                server.monitors[i].x,
+                server.monitors[i].y,
+                server.monitors[i].width,
+                server.monitors[i].height);
+    }
+}
+
+void server_get_number_of_desktops()
+{
+    if (server.viewports) {
+        free(server.viewports);
+        server.viewports = NULL;
+    }
+
+    server.num_desktops = get_property32(server.root_win, server.atom._NET_NUMBER_OF_DESKTOPS, XA_CARDINAL);
+    if (server.num_desktops > 1)
+        return;
+
+    int num_results;
+    long *work_area_size = server_get_property(server.root_win, server.atom._NET_WORKAREA, XA_CARDINAL, &num_results);
+    if (!work_area_size)
+        return;
+    int work_area_width = work_area_size[0] + work_area_size[2];
+    int work_area_height = work_area_size[1] + work_area_size[3];
+    XFree(work_area_size);
+
+    long *x_screen_size =
+        server_get_property(server.root_win, server.atom._NET_DESKTOP_GEOMETRY, XA_CARDINAL, &num_results);
+    if (!x_screen_size)
+        return;
+    int x_screen_width = x_screen_size[0];
+    int x_screen_height = x_screen_size[1];
+    XFree(x_screen_size);
+
+    int num_viewports = MAX(x_screen_width / work_area_width, 1) * MAX(x_screen_height / work_area_height, 1);
+    if (num_viewports <= 1) {
+        server.num_desktops = 1;
+        return;
+    }
+
+    server.viewports = calloc(num_viewports, sizeof(Viewport));
+    int k = 0;
+    for (int i = 0; i < MAX(x_screen_height / work_area_height, 1); i++) {
+        for (int j = 0; j < MAX(x_screen_width / work_area_width, 1); j++) {
+            server.viewports[k].x = j * work_area_width;
+            server.viewports[k].y = i * work_area_height;
+            server.viewports[k].width = work_area_width;
+            server.viewports[k].height = work_area_height;
+            k++;
+        }
+    }
+
+    server.num_desktops = num_viewports;
+}
+
+GSList *get_desktop_names()
+{
+    if (server.viewports) {
+        GSList *list = NULL;
+        for (int j = 0; j < server.num_desktops; j++) {
+            list = g_slist_append(list, g_strdup_printf("%d", j + 1));
+        }
+        return list;
+    }
+
+    int count;
+    GSList *list = NULL;
+    gchar *data_ptr =
+        server_get_property(server.root_win, server.atom._NET_DESKTOP_NAMES, server.atom.UTF8_STRING, &count);
+    if (data_ptr) {
+        list = g_slist_append(list, g_strdup(data_ptr));
+        for (int j = 0; j < count - 1; j++) {
+            if (*(data_ptr + j) == '\0') {
+                gchar *ptr = (gchar *)data_ptr + j + 1;
+                list = g_slist_append(list, g_strdup(ptr));
+            }
+        }
+        XFree(data_ptr);
+    }
+    return list;
+}
+
+int get_current_desktop()
+{
+    if (!server.viewports) {
+        return MAX(0,
+                   MIN(server.num_desktops - 1,
+                       get_property32(server.root_win, server.atom._NET_CURRENT_DESKTOP, XA_CARDINAL)));
+    }
+
+    int num_results;
+    long *work_area_size = server_get_property(server.root_win, server.atom._NET_WORKAREA, XA_CARDINAL, &num_results);
+    if (!work_area_size)
+        return 0;
+    int work_area_width = work_area_size[0] + work_area_size[2];
+    int work_area_height = work_area_size[1] + work_area_size[3];
+    XFree(work_area_size);
+
+    if (work_area_width <= 0 || work_area_height <= 0)
+        return 0;
+
+    long *viewport = server_get_property(server.root_win, server.atom._NET_DESKTOP_VIEWPORT, XA_CARDINAL, &num_results);
+    if (!viewport)
+        return 0;
+    int viewport_x = viewport[0];
+    int viewport_y = viewport[1];
+    XFree(viewport);
+
+    long *x_screen_size =
+        server_get_property(server.root_win, server.atom._NET_DESKTOP_GEOMETRY, XA_CARDINAL, &num_results);
+    if (!x_screen_size)
+        return 0;
+    int x_screen_width = x_screen_size[0];
+    XFree(x_screen_size);
+
+    int ncols = x_screen_width / work_area_width;
+
+    //	fprintf(stderr, "tint2: \n");
+    //	fprintf(stderr, "tint2: Work area size: %d x %d\n", work_area_width, work_area_height);
+    //	fprintf(stderr, "tint2: Viewport pos: %d x %d\n", viewport_x, viewport_y);
+    //	fprintf(stderr, "tint2: Viewport i: %d\n", (viewport_y / work_area_height) * ncols + viewport_x / work_area_width);
+
+    int result = (viewport_y / work_area_height) * ncols + viewport_x / work_area_width;
+    return MAX(0, MIN(server.num_desktops - 1, result));
+}
+
+void change_desktop(int desktop)
+{
+    if (!server.viewports) {
+        send_event32(server.root_win, server.atom._NET_CURRENT_DESKTOP, desktop, 0, 0);
+    } else {
+        send_event32(server.root_win,
+                     server.atom._NET_DESKTOP_VIEWPORT,
+                     server.viewports[desktop].x,
+                     server.viewports[desktop].y,
+                     0);
+    }
+}
+
+void get_desktops()
+{
+    // detect number of desktops
+    // wait 15s to leave some time for window manager startup
+    for (int i = 0; i < 15; i++) {
+        server_get_number_of_desktops();
+        if (server.num_desktops > 0)
+            break;
+        sleep(1);
+    }
+    if (server.num_desktops == 0) {
+        server.num_desktops = 1;
+        fprintf(stderr, "tint2: warning : WM doesn't respect NETWM specs. tint2 default to 1 desktop.\n");
+    }
+}
+
+void server_init_visual()
+{
+    // inspired by freedesktops fdclock ;)
+    XVisualInfo templ = {.screen = server.screen, .depth = 32, .class = TrueColor};
+    int nvi;
+    XVisualInfo *xvi =
+        XGetVisualInfo(server.display, VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi);
+
+    Visual *visual = NULL;
+    if (xvi) {
+        XRenderPictFormat *format;
+        for (int i = 0; i < nvi; i++) {
+            format = XRenderFindVisualFormat(server.display, xvi[i].visual);
+            if (format->type == PictTypeDirect && format->direct.alphaMask) {
+                visual = xvi[i].visual;
+                break;
+            }
+        }
+    }
+    XFree(xvi);
+
+    // check composite manager
+    server.composite_manager = XGetSelectionOwner(server.display, server.atom._NET_WM_CM_S0);
+    if (server.colormap)
+        XFreeColormap(server.display, server.colormap);
+    if (server.colormap32)
+        XFreeColormap(server.display, server.colormap32);
+
+    if (visual) {
+        server.visual32 = visual;
+        server.colormap32 = XCreateColormap(server.display, server.root_win, visual, AllocNone);
+    }
+
+    if (!server.disable_transparency && visual && server.composite_manager != None && !snapshot_path) {
+        XSetWindowAttributes attrs;
+        attrs.event_mask = StructureNotifyMask;
+        XChangeWindowAttributes(server.display, server.composite_manager, CWEventMask, &attrs);
+
+        server.real_transparency = TRUE;
+        server.depth = 32;
+        fprintf(stderr, "tint2: real transparency on... depth: %d\n", server.depth);
+        server.colormap = XCreateColormap(server.display, server.root_win, visual, AllocNone);
+        server.visual = visual;
+    } else {
+        // no composite manager or snapshot mode => fake transparency
+        server.real_transparency = FALSE;
+        server.depth = DefaultDepth(server.display, server.screen);
+        fprintf(stderr, "tint2: real transparency off.... depth: %d\n", server.depth);
+        server.colormap = DefaultColormap(server.display, server.screen);
+        server.visual = DefaultVisual(server.display, server.screen);
+    }
+}
+
+void server_init_xdamage()
+{
+    XDamageQueryExtension(server.display, &server.xdamage_event_type, &server.xdamage_event_error_type);
+    server.xdamage_event_type += XDamageNotify;
+    server.xdamage_event_error_type += XDamageNotify;
+}
+
+// Forward mouse click to the desktop window
+void forward_click(XEvent *e)
+{
+    // forward the click to the desktop window (thanks conky)
+    XUngrabPointer(server.display, e->xbutton.time);
+    e->xbutton.window = server.root_win;
+    // icewm doesn't open under the mouse.
+    // and xfce doesn't open at all.
+    e->xbutton.x = e->xbutton.x_root;
+    e->xbutton.y = e->xbutton.y_root;
+    // fprintf(stderr, "tint2: **** %d, %d\n", e->xbutton.x, e->xbutton.y);
+    // XSetInputFocus(server.display, e->xbutton.window, RevertToParent, e->xbutton.time);
+    XSendEvent(server.display, e->xbutton.window, False, ButtonPressMask, e);
+}
+
+void handle_crash(const char *reason)
+{
+#ifndef DISABLE_BACKTRACE
+    char path[4096];
+    sprintf(path, "%s/.tint2-crash.log", get_home_dir());
+    int log_fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
+    log_string(log_fd, RED "tint2: crashed, reason: ");
+    log_string(log_fd, reason);
+    log_string(log_fd, RESET "\n");
+    dump_backtrace(log_fd);
+    log_string(log_fd, RED "Please create a bug report with this log output." RESET "\n");
+    close(log_fd);
+#endif
+}
+
+void x11_io_error(Display *display)
+{
+    handle_crash("X11 I/O error");
+}
+
+#ifdef HAVE_SN
+static int error_trap_depth = 0;
+
+void error_trap_push(SnDisplay *display, Display *xdisplay)
+{
+    ++error_trap_depth;
+}
+
+void error_trap_pop(SnDisplay *display, Display *xdisplay)
+{
+    if (error_trap_depth == 0) {
+        fprintf(stderr, "tint2: Error trap underflow!\n");
+        return;
+    }
+
+    XSync(xdisplay, False); /* get all errors out of the queue */
+    --error_trap_depth;
+}
+#endif // HAVE_SN

src/util/server.h

@@ -0,0 +1,195 @@
+/**************************************************************************
+* server :
+* -
+*
+* Check COPYING file for Copyright
+*
+**************************************************************************/
+
+#ifndef SERVER_H
+#define SERVER_H
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/Xinerama.h>
+
+#ifdef HAVE_SN
+#include <libsn/sn.h>
+#endif
+#include <glib.h>
+
+extern gboolean primary_monitor_first;
+
+typedef struct Global_atom {
+    Atom _XROOTPMAP_ID;
+    Atom _XROOTMAP_ID;
+    Atom _NET_CURRENT_DESKTOP;
+    Atom _NET_NUMBER_OF_DESKTOPS;
+    Atom _NET_DESKTOP_NAMES;
+    Atom _NET_DESKTOP_GEOMETRY;
+    Atom _NET_DESKTOP_VIEWPORT;
+    Atom _NET_WORKAREA;
+    Atom _NET_ACTIVE_WINDOW;
+    Atom _NET_WM_WINDOW_TYPE;
+    Atom _NET_WM_STATE_SKIP_PAGER;
+    Atom _NET_WM_STATE_SKIP_TASKBAR;
+    Atom _NET_WM_STATE_STICKY;
+    Atom _NET_WM_STATE_DEMANDS_ATTENTION;
+    Atom _NET_WM_WINDOW_TYPE_DOCK;
+    Atom _NET_WM_WINDOW_TYPE_DESKTOP;
+    Atom _NET_WM_WINDOW_TYPE_TOOLBAR;
+    Atom _NET_WM_WINDOW_TYPE_MENU;
+    Atom _NET_WM_WINDOW_TYPE_SPLASH;
+    Atom _NET_WM_WINDOW_TYPE_DIALOG;
+    Atom _NET_WM_WINDOW_TYPE_NORMAL;
+    Atom _NET_WM_DESKTOP;
+    Atom WM_STATE;
+    Atom _NET_WM_STATE;
+    Atom _NET_WM_STATE_MAXIMIZED_VERT;
+    Atom _NET_WM_STATE_MAXIMIZED_HORZ;
+    Atom _NET_WM_STATE_SHADED;
+    Atom _NET_WM_STATE_HIDDEN;
+    Atom _NET_WM_STATE_BELOW;
+    Atom _NET_WM_STATE_ABOVE;
+    Atom _NET_WM_STATE_MODAL;
+    Atom _NET_CLIENT_LIST;
+    Atom _NET_WM_NAME;
+    Atom _NET_WM_VISIBLE_NAME;
+    Atom _NET_WM_STRUT;
+    Atom _NET_WM_ICON;
+    Atom _NET_WM_ICON_GEOMETRY;
+    Atom _NET_WM_ICON_NAME;
+    Atom _NET_CLOSE_WINDOW;
+    Atom UTF8_STRING;
+    Atom _NET_SUPPORTING_WM_CHECK;
+    Atom _NET_WM_CM_S0;
+    Atom _NET_WM_STRUT_PARTIAL;
+    Atom WM_NAME;
+    Atom __SWM_VROOT;
+    Atom _MOTIF_WM_HINTS;
+    Atom WM_HINTS;
+    Atom _NET_SYSTEM_TRAY_SCREEN;
+    Atom _NET_SYSTEM_TRAY_OPCODE;
+    Atom MANAGER;
+    Atom _NET_SYSTEM_TRAY_MESSAGE_DATA;
+    Atom _NET_SYSTEM_TRAY_ORIENTATION;
+    Atom _NET_SYSTEM_TRAY_ICON_SIZE;
+    Atom _NET_SYSTEM_TRAY_PADDING;
+    Atom _XEMBED;
+    Atom _XEMBED_INFO;
+    Atom _NET_WM_PID;
+    Atom _XSETTINGS_SCREEN;
+    Atom _XSETTINGS_SETTINGS;
+    Atom XdndAware;
+    Atom XdndEnter;
+    Atom XdndPosition;
+    Atom XdndStatus;
+    Atom XdndDrop;
+    Atom XdndLeave;
+    Atom XdndSelection;
+    Atom XdndTypeList;
+    Atom XdndActionCopy;
+    Atom XdndFinished;
+    Atom TARGETS;
+} Global_atom;
+
+typedef struct Property {
+    unsigned char *data;
+    int format, nitems;
+    Atom type;
+} Property;
+
+// Returns the name of an Atom as string. Do not free the string.
+const char *GetAtomName(Display *disp, Atom a);
+
+typedef struct Monitor {
+    int x;
+    int y;
+    int width;
+    int height;
+    gboolean primary;
+    gchar **names;
+} Monitor;
+
+typedef struct Viewport {
+    int x;
+    int y;
+    int width;
+    int height;
+} Viewport;
+
+typedef struct Server {
+    Display *display;
+    int x11_fd;
+    Window root_win;
+    Window composite_manager;
+    gboolean real_transparency;
+    gboolean disable_transparency;
+    // current desktop
+    int desktop;
+    int screen;
+    int depth;
+    int num_desktops;
+    // number of monitor (without monitor included into another one)
+    int num_monitors;
+    // Non-null only if WM uses viewports (compiz) and number of viewports > 1.
+    // In that case there are num_desktops viewports.
+    Viewport *viewports;
+    Monitor *monitors;
+    gboolean got_root_win;
+    Visual *visual;
+    Visual *visual32;
+    // root background
+    Pixmap root_pmap;
+    GC gc;
+    Colormap colormap;
+    Colormap colormap32;
+    Global_atom atom;
+    int xdamage_event_type;
+    int xdamage_event_error_type;
+    gboolean has_shm;
+#ifdef HAVE_SN
+    SnDisplay *sn_display;
+    GTree *pids;
+#endif // HAVE_SN
+} Server;
+
+extern Server server;
+
+// freed memory
+void cleanup_server();
+
+void send_event32(Window win, Atom at, long data1, long data2, long data3);
+int get_property32(Window win, Atom at, Atom type);
+void *server_get_property(Window win, Atom at, Atom type, int *num_results);
+Atom server_get_atom(char *atom_name);
+void server_catch_error(Display *d, XErrorEvent *ev);
+void server_init_atoms();
+void server_init_visual();
+void server_init_xdamage();
+
+void x11_io_error(Display *display);
+void handle_crash(const char *reason);
+
+// detect root background
+void get_root_pixmap();
+
+// detect monitors and desktops
+void get_monitors();
+void sort_monitors();
+void print_monitors();
+void get_desktops();
+void server_get_number_of_desktops();
+GSList *get_desktop_names();
+int get_current_desktop();
+void change_desktop(int desktop);
+
+// Forward mouse click to the desktop window
+void forward_click(XEvent *e);
+
+#ifdef HAVE_SN
+void error_trap_push(SnDisplay *display, Display *xdisplay);
+void error_trap_pop(SnDisplay *display, Display *xdisplay);
+#endif
+
+#endif

src/util/signals.c

@@ -0,0 +1,166 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <glib.h>
+#ifdef HAVE_SN
+#include <libsn/sn.h>
+#endif
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "common.h"
+#include "panel.h"
+#include "launcher.h"
+#include "server.h"
+#include "signals.h"
+
+static sig_atomic_t signal_pending;
+
+void signal_handler(int sig)
+{
+    // signal handler is light as it should be
+    signal_pending = sig;
+}
+
+void reset_signals()
+{
+    for (int sig = 1; sig < 32; sig++) {
+        signal(sig, SIG_DFL);
+    }
+    sigset_t signal_set;
+    sigemptyset(&signal_set);
+    sigprocmask(SIG_SETMASK, &signal_set, NULL);
+}
+
+void init_signals()
+{
+    // Set signal handlers
+    signal_pending = 0;
+
+    reset_signals();
+
+    struct sigaction sa_chld = {.sa_handler = SIG_IGN};
+    sigaction(SIGCHLD, &sa_chld, 0);
+
+    struct sigaction sa = {.sa_handler = signal_handler, .sa_flags = SA_RESTART};
+    sigaction(SIGUSR1, &sa, 0);
+    sigaction(SIGUSR2, &sa, 0);
+    sigaction(SIGINT, &sa, 0);
+    sigaction(SIGTERM, &sa, 0);
+    sigaction(SIGHUP, &sa, 0);
+
+#ifdef BACKTRACE_ON_SIGNAL
+    struct sigaction sa_crash = {.sa_handler = crash_handler};
+    sigaction(SIGSEGV, &sa_crash, 0);
+    sigaction(SIGFPE, &sa_crash, 0);
+    sigaction(SIGPIPE, &sa_crash, 0);
+    sigaction(SIGBUS, &sa_crash, 0);
+    sigaction(SIGABRT, &sa_crash, 0);
+    sigaction(SIGSYS, &sa_crash, 0);
+#endif
+}
+
+#ifdef BACKTRACE_ON_SIGNAL
+void crash_handler(int sig)
+{
+    handle_crash(signal_name(sig));
+    struct sigaction sa = {.sa_handler = SIG_DFL};
+    sigaction(sig, &sa, 0);
+    raise(sig);
+}
+#endif
+
+int sigchild_pipe_valid = FALSE;
+int sigchild_pipe[2];
+
+static void sigchld_handler(int sig)
+{
+    if (!sigchild_pipe_valid)
+        return;
+    int savedErrno = errno;
+    ssize_t unused = write(sigchild_pipe[1], "x", 1);
+    (void)unused;
+    fsync(sigchild_pipe[1]);
+    errno = savedErrno;
+}
+
+void sigchld_handler_async()
+{
+    // Wait for all dead processes
+    pid_t pid;
+    int status;
+    while ((pid = waitpid(-1, &status, WNOHANG)) != -1 && pid != 0) {
+#ifdef HAVE_SN
+        if (startup_notifications) {
+            SnLauncherContext *ctx = (SnLauncherContext *)g_tree_lookup(server.pids, GINT_TO_POINTER(pid));
+            if (ctx) {
+                g_tree_remove(server.pids, GINT_TO_POINTER(pid));
+                sn_launcher_context_complete(ctx);
+                sn_launcher_context_unref(ctx);
+            }
+        }
+#endif
+        for (GList *l = panel_config.execp_list; l; l = l->next) {
+            Execp *execp = (Execp *)l->data;
+            if (g_tree_lookup(execp->backend->cmd_pids, GINT_TO_POINTER(pid)))
+                execp_cmd_completed(execp, pid);
+        }
+    }
+}
+
+void handle_sigchld_events()
+{
+    if (sigchild_pipe_valid) {
+        char buffer[1];
+        while (read(sigchild_pipe[0], buffer, sizeof(buffer)) > 0) {
+            sigchld_handler_async();
+        }
+    }
+}
+
+void init_signals_postconfig()
+{
+    gboolean need_sigchld = FALSE;
+#ifdef HAVE_SN
+    // Initialize startup-notification
+    if (startup_notifications) {
+        server.sn_display = sn_display_new(server.display, error_trap_push, error_trap_pop);
+        server.pids = g_tree_new(cmp_ptr);
+        need_sigchld = TRUE;
+    }
+#endif // HAVE_SN
+    if (panel_config.execp_list)
+        need_sigchld = TRUE;
+
+    if (need_sigchld) {
+        // Setup a handler for child termination
+        if (pipe(sigchild_pipe) != 0) {
+            fprintf(stderr, "tint2: Creating pipe failed.\n");
+        } else {
+            fcntl(sigchild_pipe[0], F_SETFL, O_NONBLOCK | fcntl(sigchild_pipe[0], F_GETFL));
+            fcntl(sigchild_pipe[1], F_SETFL, O_NONBLOCK | fcntl(sigchild_pipe[1], F_GETFL));
+            sigchild_pipe_valid = 1;
+            struct sigaction act = {.sa_handler = sigchld_handler, .sa_flags = SA_RESTART};
+            if (sigaction(SIGCHLD, &act, 0)) {
+                perror("sigaction");
+            }
+        }
+    }
+}
+
+void emit_self_restart(const char *reason)
+{
+    fprintf(stderr,
+            YELLOW "%s %d: triggering tint2 restart, reason: %s" RESET "\n",
+            __FILE__,
+            __LINE__,
+            reason);
+    signal_pending = SIGUSR1;
+}
+
+int get_signal_pending()
+{
+    return signal_pending;
+}

src/util/signals.h

@@ -0,0 +1,15 @@
+#ifndef SIGNALS_H
+#define SIGNALS_H
+
+void init_signals();
+void init_signals_postconfig();
+void emit_self_restart(const char *reason);
+int get_signal_pending();
+void reset_signals();
+
+void handle_sigchld_events();
+
+extern int sigchild_pipe_valid;
+extern int sigchild_pipe[2];
+
+#endif

src/util/tracing.c

@@ -0,0 +1,164 @@
+#include "timer.h"
+
+#ifdef HAVE_TRACING
+
+#ifdef ENABLE_EXECINFO
+#include <execinfo.h>
+#endif
+#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define GREEN "\033[1;32m"
+#define YELLOW "\033[1;33m"
+#define RED "\033[1;31m"
+#define BLUE "\033[1;34m"
+#define RESET "\033[0m"
+
+static GList *tracing_events = NULL;
+static sig_atomic_t tracing = FALSE;
+
+typedef struct TracingEvent {
+    void *address;
+    void *caller;
+    double time;
+    gboolean enter;
+} TracingEvent;
+
+void __attribute__ ((constructor)) init_tracing()
+{
+    tracing_events = NULL;
+    tracing = FALSE;
+}
+
+void cleanup_tracing()
+{
+    g_list_free_full(tracing_events, free);
+    tracing_events = NULL;
+    tracing = FALSE;
+}
+
+char *addr2name(void *func)
+{
+#ifdef ENABLE_EXECINFO
+    void *array[1];
+    array[0] = func;
+    char **strings = backtrace_symbols(array, 1);
+    char *result = strdup(strings[0] ? strings[0] : "??");
+    free(strings);
+    return result;
+#else
+    char *result = (char*) calloc(32, 1);
+    sprintf(result, "%p", func);
+    return result;
+#endif
+}
+
+void add_tracing_event(void *func, void *caller, gboolean enter)
+{
+    TracingEvent *entry = (TracingEvent *)calloc(sizeof(TracingEvent), 1);
+    entry->address = func;
+    entry->caller = caller;
+    entry->time = get_time();
+    entry->enter = enter;
+    tracing_events = g_list_append(tracing_events, entry);
+}
+
+void start_tracing(void *root)
+{
+    if (tracing_events)
+        cleanup_tracing();
+    add_tracing_event(root, NULL, TRUE);
+    tracing = TRUE;
+}
+
+void stop_tracing()
+{
+    tracing = FALSE;
+}
+
+void __cyg_profile_func_enter(void *func, void *caller)
+{
+    if (tracing)
+        add_tracing_event(func, caller, TRUE);
+}
+
+void __cyg_profile_func_exit(void *func, void *caller)
+{
+    if (tracing)
+        add_tracing_event(func, caller, FALSE);
+}
+
+void print_tracing_events()
+{
+    GList *stack = NULL;
+    int depth = 0;
+    double now = get_time();
+    for (GList *i = tracing_events; i; i = i->next) {
+        TracingEvent *e = (TracingEvent *)i->data;
+        if (e->enter) {
+            // Push a new function on the stack
+            for (int d = 0; d < depth; d++)
+                fprintf(stderr, "tint2:  ");
+            char *name = addr2name(e->address);
+            char *caller = addr2name(e->caller);
+            fprintf(stderr,
+                    "%s called from %s\n",
+                    name,
+                    caller);
+            stack = g_list_append(stack, e);
+            depth++;
+        } else {
+            // Pop a function from the stack, if matching, and print
+            if (stack) {
+                TracingEvent *old = (TracingEvent *)g_list_last(stack)->data;
+                if (old->address == e->address) {
+                    depth--;
+                    for (int d = 0; d < depth; d++)
+                        fprintf(stderr, "tint2:  ");
+                    char *name = addr2name(e->address);
+                    double duration = (e->time - old->time) * 1.0e3;
+                    fprintf(stderr,
+                            "-- %s exited after %.1f ms",
+                            name,
+                            duration);
+                    if (duration >= 1.0) {
+                        fprintf(stderr, YELLOW "tint2:  ");
+                        for (int d = 0; d < duration; d++) {
+                            fprintf(stderr, "tint2: #");
+                        }
+                        fprintf(stderr, RESET);
+                    }
+                    fprintf(stderr, "tint2: \n");
+                    free(name);
+                    stack = g_list_delete_link(stack, g_list_last(stack));
+                }
+            }
+        }
+    }
+    while (stack) {
+        TracingEvent *old = (TracingEvent *)g_list_last(stack)->data;
+        depth--;
+        for (int d = 0; d < depth; d++)
+            fprintf(stderr, "tint2:  ");
+        char *name = addr2name(old->address);
+        double duration = (now - old->time) * 1.0e3;
+        fprintf(stderr,
+                "-- %s exited after %.1f ms",
+                name,
+                duration);
+        if (duration >= 1.0) {
+            fprintf(stderr, YELLOW "tint2:  ");
+            for (int d = 0; d < duration; d++) {
+                fprintf(stderr, "tint2: #");
+            }
+            fprintf(stderr, RESET);
+        }
+        fprintf(stderr, "tint2: \n");
+        free(name);
+        stack = g_list_delete_link(stack, g_list_last(stack));
+    }
+}
+
+#endif

src/util/tracing.h

@@ -0,0 +1,15 @@
+#ifndef TRACING_H
+#define TRACING_H
+
+#ifdef HAVE_TRACING
+
+void init_tracing();
+void cleanup_tracing();
+
+void start_tracing(void *root);
+void stop_tracing();
+void print_tracing_events();
+
+#endif
+
+#endif