nilix/tint2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename dsp -> display

Browse source
This commit is contained in:
o9000 2016-01-01 13:49:10 +01:00
parent 59e56e5310
commit 106471225f
14 changed files with 365 additions and 365 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/launcher/launcher.c
View file

@ -378,7 +378,7 @@ void launcher_action(LauncherIcon *icon, XEvent *evt)
SnLauncherContext *ctx = 0; SnLauncherContext *ctx = 0;
Time time; Time time;
if (startup_notifications) { if (startup_notifications) {
ctx = sn_launcher_context_new(server.sn_dsp, server.screen); ctx = sn_launcher_context_new(server.sn_display, server.screen);
sn_launcher_context_set_name(ctx, icon->icon_tooltip); sn_launcher_context_set_name(ctx, icon->icon_tooltip);
sn_launcher_context_set_description(ctx, "Application launched from tint2"); sn_launcher_context_set_description(ctx, "Application launched from tint2");
sn_launcher_context_set_binary_name(ctx, icon->cmd); sn_launcher_context_set_binary_name(ctx, icon->cmd);

6
src/launcher/xsettings-client.c
View file

@ -382,9 +382,9 @@ static void check_manager_window(XSettingsClient *client)
XGrabServer(client->display); XGrabServer(client->display);
client->manager_window = XGetSelectionOwner(server.dsp, server.atom._XSETTINGS_SCREEN); client->manager_window = XGetSelectionOwner(server.display, server.atom._XSETTINGS_SCREEN);
if (client->manager_window) if (client->manager_window)
XSelectInput(server.dsp, client->manager_window, PropertyChangeMask | StructureNotifyMask); XSelectInput(server.display, client->manager_window, PropertyChangeMask | StructureNotifyMask);
XUngrabServer(client->display); XUngrabServer(client->display);
XFlush(client->display); XFlush(client->display);
@ -458,7 +458,7 @@ Bool xsettings_client_process_event(XSettingsClient *client, XEvent *xev)
* times when the manager changes from A->B. But manager changes * times when the manager changes from A->B. But manager changes
* are going to be pretty rare. * are going to be pretty rare.
*/ */
if (xev->xany.window == RootWindow(server.dsp, server.screen)) { if (xev->xany.window == RootWindow(server.display, server.screen)) {
if (xev->xany.type == ClientMessage && xev->xclient.message_type == server.atom.MANAGER) { if (xev->xany.type == ClientMessage && xev->xclient.message_type == server.atom.MANAGER) {
check_manager_window(client); check_manager_window(client);
return True; return True;

92
src/panel.c
View file

@ -122,13 +122,13 @@ void cleanup_panel()
free_area(&p->area); free_area(&p->area);
if (p->temp_pmap) if (p->temp_pmap)
XFreePixmap(server.dsp, p->temp_pmap); XFreePixmap(server.display, p->temp_pmap);
p->temp_pmap = 0; p->temp_pmap = 0;
if (p->hidden_pixmap) if (p->hidden_pixmap)
XFreePixmap(server.dsp, p->hidden_pixmap); XFreePixmap(server.display, p->hidden_pixmap);
p->hidden_pixmap = 0; p->hidden_pixmap = 0;
if (p->main_win) if (p->main_win)
XDestroyWindow(server.dsp, p->main_win); XDestroyWindow(server.display, p->main_win);
p->main_win = 0; p->main_win = 0;
stop_timeout(p->autohide_timeout); stop_timeout(p->autohide_timeout);
} }
@ -224,7 +224,7 @@ void init_panel()
// catch some events // catch some events
XSetWindowAttributes att = {.colormap = server.colormap, .background_pixel = 0, .border_pixel = 0}; XSetWindowAttributes att = {.colormap = server.colormap, .background_pixel = 0, .border_pixel = 0};
unsigned long mask = CWEventMask | CWColormap | CWBackPixel | CWBorderPixel; unsigned long mask = CWEventMask | CWColormap | CWBackPixel | CWBorderPixel;
p->main_win = XCreateWindow(server.dsp, p->main_win = XCreateWindow(server.display,
server.root_win, server.root_win,
p->posx, p->posx,
p->posy, p->posy,
@ -243,18 +243,18 @@ void init_panel()
event_mask |= PointerMotionMask | LeaveWindowMask; event_mask |= PointerMotionMask | LeaveWindowMask;
if (panel_autohide) if (panel_autohide)
event_mask |= LeaveWindowMask | EnterWindowMask; event_mask |= LeaveWindowMask | EnterWindowMask;
XChangeWindowAttributes(server.dsp, p->main_win, CWEventMask, &(XSetWindowAttributes){.event_mask = event_mask}); XChangeWindowAttributes(server.display, p->main_win, CWEventMask, &(XSetWindowAttributes){.event_mask = event_mask});
if (!server.gc) { if (!server.gc) {
XGCValues gcv; XGCValues gcv;
server.gc = XCreateGC(server.dsp, p->main_win, 0, &gcv); server.gc = XCreateGC(server.display, p->main_win, 0, &gcv);
} }
// printf("panel %d : %d, %d, %d, %d\n", i, p->posx, p->posy, p->area.width, p->area.height); // printf("panel %d : %d, %d, %d, %d\n", i, p->posx, p->posy, p->area.width, p->area.height);
set_panel_properties(p); set_panel_properties(p);
set_panel_background(p); set_panel_background(p);
if (!snapshot_path) { if (!snapshot_path) {
// if we are not in 'snapshot' mode then map new panel // if we are not in 'snapshot' mode then map new panel
XMapWindow(server.dsp, p->main_win); XMapWindow(server.display, p->main_win);
} }
if (panel_autohide) if (panel_autohide)
@ -465,8 +465,8 @@ gboolean resize_panel(void *obj)
void update_strut(Panel *p) void update_strut(Panel *p)
{ {
if (panel_strut_policy == STRUT_NONE) { if (panel_strut_policy == STRUT_NONE) {
XDeleteProperty(server.dsp, p->main_win, server.atom._NET_WM_STRUT); XDeleteProperty(server.display, p->main_win, server.atom._NET_WM_STRUT);
XDeleteProperty(server.dsp, p->main_win, server.atom._NET_WM_STRUT_PARTIAL); XDeleteProperty(server.display, p->main_win, server.atom._NET_WM_STRUT_PARTIAL);
return; return;
} }
@ -474,7 +474,7 @@ void update_strut(Panel *p)
unsigned int d1, screen_width, screen_height; unsigned int d1, screen_width, screen_height;
Window d2; Window d2;
int d3; int d3;
XGetGeometry(server.dsp, server.root_win, &d2, &d3, &d3, &screen_width, &screen_height, &d1, &d1); XGetGeometry(server.display, server.root_win, &d2, &d3, &d3, &screen_width, &screen_height, &d1, &d1);
Monitor monitor = server.monitors[p->monitor]; Monitor monitor = server.monitors[p->monitor];
long struts[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; long struts[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
if (panel_horizontal) { if (panel_horizontal) {
@ -509,7 +509,7 @@ void update_strut(Panel *p)
} }
} }
// Old specification : fluxbox need _NET_WM_STRUT. // Old specification : fluxbox need _NET_WM_STRUT.
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_STRUT, server.atom._NET_WM_STRUT,
XA_CARDINAL, XA_CARDINAL,
@ -517,7 +517,7 @@ void update_strut(Panel *p)
PropModeReplace, PropModeReplace,
(unsigned char *)&struts, (unsigned char *)&struts,
4); 4);
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_STRUT_PARTIAL, server.atom._NET_WM_STRUT_PARTIAL,
XA_CARDINAL, XA_CARDINAL,
@ -568,13 +568,13 @@ void set_panel_items_order(Panel *p)
void set_panel_properties(Panel *p) void set_panel_properties(Panel *p)
{ {
XStoreName(server.dsp, p->main_win, panel_window_name); XStoreName(server.display, p->main_win, panel_window_name);
XSetIconName(server.dsp, p->main_win, panel_window_name); XSetIconName(server.display, p->main_win, panel_window_name);
gsize len; gsize len;
gchar *name = g_locale_to_utf8(panel_window_name, -1, NULL, &len, NULL); gchar *name = g_locale_to_utf8(panel_window_name, -1, NULL, &len, NULL);
if (name != NULL) { if (name != NULL) {
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_NAME, server.atom._NET_WM_NAME,
server.atom.UTF8_STRING, server.atom.UTF8_STRING,
@ -582,7 +582,7 @@ void set_panel_properties(Panel *p)
PropModeReplace, PropModeReplace,
(unsigned char *)name, (unsigned char *)name,
(int)len); (int)len);
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_ICON_NAME, server.atom._NET_WM_ICON_NAME,
server.atom.UTF8_STRING, server.atom.UTF8_STRING,
@ -595,7 +595,7 @@ void set_panel_properties(Panel *p)
// Dock // Dock
long val = server.atom._NET_WM_WINDOW_TYPE_DOCK; long val = server.atom._NET_WM_WINDOW_TYPE_DOCK;
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_WINDOW_TYPE, server.atom._NET_WM_WINDOW_TYPE,
XA_ATOM, XA_ATOM,
@ -605,7 +605,7 @@ void set_panel_properties(Panel *p)
1); 1);
val = ALL_DESKTOPS; val = ALL_DESKTOPS;
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_DESKTOP, server.atom._NET_WM_DESKTOP,
XA_CARDINAL, XA_CARDINAL,
@ -620,7 +620,7 @@ void set_panel_properties(Panel *p)
state[2] = server.atom._NET_WM_STATE_STICKY; state[2] = server.atom._NET_WM_STATE_STICKY;
state[3] = panel_layer == BOTTOM_LAYER ? server.atom._NET_WM_STATE_BELOW : server.atom._NET_WM_STATE_ABOVE; state[3] = panel_layer == BOTTOM_LAYER ? server.atom._NET_WM_STATE_BELOW : server.atom._NET_WM_STATE_ABOVE;
int num_atoms = panel_layer == NORMAL_LAYER ? 3 : 4; int num_atoms = panel_layer == NORMAL_LAYER ? 3 : 4;
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._NET_WM_STATE, server.atom._NET_WM_STATE,
XA_ATOM, XA_ATOM,
@ -641,11 +641,11 @@ void set_panel_properties(Panel *p)
// We do not need keyboard input focus. // We do not need keyboard input focus.
wmhints.flags |= InputHint; wmhints.flags |= InputHint;
wmhints.input = False; wmhints.input = False;
XSetWMHints(server.dsp, p->main_win, &wmhints); XSetWMHints(server.display, p->main_win, &wmhints);
// Undecorated // Undecorated
long prop[5] = {2, 0, 0, 0, 0}; long prop[5] = {2, 0, 0, 0, 0};
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom._MOTIF_WM_HINTS, server.atom._MOTIF_WM_HINTS,
server.atom._MOTIF_WM_HINTS, server.atom._MOTIF_WM_HINTS,
@ -656,7 +656,7 @@ void set_panel_properties(Panel *p)
// XdndAware - Register for Xdnd events // XdndAware - Register for Xdnd events
Atom version = 4; Atom version = 4;
XChangeProperty(server.dsp, XChangeProperty(server.display,
p->main_win, p->main_win,
server.atom.XdndAware, server.atom.XdndAware,
XA_ATOM, XA_ATOM,
@ -677,21 +677,21 @@ void set_panel_properties(Panel *p)
size_hints.max_width = p->area.width; size_hints.max_width = p->area.width;
size_hints.min_height = minheight; size_hints.min_height = minheight;
size_hints.max_height = p->area.height; size_hints.max_height = p->area.height;
XSetWMNormalHints(server.dsp, p->main_win, &size_hints); XSetWMNormalHints(server.display, p->main_win, &size_hints);
// Set WM_CLASS // Set WM_CLASS
XClassHint *classhint = XAllocClassHint(); XClassHint *classhint = XAllocClassHint();
classhint->res_name = (char *)"tint2"; classhint->res_name = (char *)"tint2";
classhint->res_class = (char *)"Tint2"; classhint->res_class = (char *)"Tint2";
XSetClassHint(server.dsp, p->main_win, classhint); XSetClassHint(server.display, p->main_win, classhint);
XFree(classhint); XFree(classhint);
} }
void set_panel_background(Panel *p) void set_panel_background(Panel *p)
{ {
if (p->area.pix) if (p->area.pix)
XFreePixmap(server.dsp, p->area.pix); XFreePixmap(server.display, p->area.pix);
p->area.pix = XCreatePixmap(server.dsp, server.root_win, p->area.width, p->area.height, server.depth); p->area.pix = XCreatePixmap(server.display, server.root_win, p->area.width, p->area.height, server.depth);
int xoff = 0, yoff = 0; int xoff = 0, yoff = 0;
if (panel_horizontal && panel_position & BOTTOM) if (panel_horizontal && panel_position & BOTTOM)
@ -706,17 +706,17 @@ void set_panel_background(Panel *p)
// copy background (server.root_pmap) in panel.area.pix // copy background (server.root_pmap) in panel.area.pix
Window dummy; Window dummy;
int x, y; int x, y;
XTranslateCoordinates(server.dsp, p->main_win, server.root_win, 0, 0, &x, &y, &dummy); XTranslateCoordinates(server.display, p->main_win, server.root_win, 0, 0, &x, &y, &dummy);
if (panel_autohide && p->is_hidden) { if (panel_autohide && p->is_hidden) {
x -= xoff; x -= xoff;
y -= yoff; y -= yoff;
} }
XSetTSOrigin(server.dsp, server.gc, -x, -y); XSetTSOrigin(server.display, server.gc, -x, -y);
XFillRectangle(server.dsp, p->area.pix, server.gc, 0, 0, p->area.width, p->area.height); XFillRectangle(server.display, p->area.pix, server.gc, 0, 0, p->area.width, p->area.height);
} }
// draw background panel // draw background panel
cairo_surface_t *cs = cairo_xlib_surface_create(server.dsp, p->area.pix, server.visual, p->area.width, p->area.height); cairo_surface_t *cs = cairo_xlib_surface_create(server.display, p->area.pix, server.visual, p->area.width, p->area.height);
cairo_t *c = cairo_create(cs); cairo_t *c = cairo_create(cs);
draw_background(&p->area, c); draw_background(&p->area, c);
cairo_destroy(c); cairo_destroy(c);
@ -724,9 +724,9 @@ void set_panel_background(Panel *p)
if (panel_autohide) { if (panel_autohide) {
if (p->hidden_pixmap) if (p->hidden_pixmap)
XFreePixmap(server.dsp, p->hidden_pixmap); XFreePixmap(server.display, p->hidden_pixmap);
p->hidden_pixmap = XCreatePixmap(server.dsp, server.root_win, p->hidden_width, p->hidden_height, server.depth); p->hidden_pixmap = XCreatePixmap(server.display, server.root_win, p->hidden_width, p->hidden_height, server.depth);
XCopyArea(server.dsp, XCopyArea(server.display,
p->area.pix, p->area.pix,
p->hidden_pixmap, p->hidden_pixmap,
server.gc, server.gc,
@ -750,10 +750,10 @@ void set_panel_background(Panel *p)
taskbar = &p->taskbar[i]; taskbar = &p->taskbar[i];
for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) { for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (taskbar->state_pix[k]) if (taskbar->state_pix[k])
XFreePixmap(server.dsp, taskbar->state_pix[k]); XFreePixmap(server.display, taskbar->state_pix[k]);
taskbar->state_pix[k] = 0; taskbar->state_pix[k] = 0;
if (taskbar->bar_name.state_pix[k]) if (taskbar->bar_name.state_pix[k])
XFreePixmap(server.dsp, taskbar->bar_name.state_pix[k]); XFreePixmap(server.display, taskbar->bar_name.state_pix[k]);
taskbar->bar_name.state_pix[k] = 0; taskbar->bar_name.state_pix[k] = 0;
} }
taskbar->area.pix = 0; taskbar->area.pix = 0;
@ -941,12 +941,12 @@ void autohide_show(void *p)
stop_autohide_timeout(panel); stop_autohide_timeout(panel);
panel->is_hidden = 0; panel->is_hidden = 0;
XMapSubwindows(server.dsp, panel->main_win); // systray windows XMapSubwindows(server.display, panel->main_win); // systray windows
if (panel_horizontal) { if (panel_horizontal) {
if (panel_position & TOP) if (panel_position & TOP)
XResizeWindow(server.dsp, panel->main_win, panel->area.width, panel->area.height); XResizeWindow(server.display, panel->main_win, panel->area.width, panel->area.height);
else else
XMoveResizeWindow(server.dsp, XMoveResizeWindow(server.display,
panel->main_win, panel->main_win,
panel->posx, panel->posx,
panel->posy, panel->posy,
@ -954,9 +954,9 @@ void autohide_show(void *p)
panel->area.height); panel->area.height);
} else { } else {
if (panel_position & LEFT) if (panel_position & LEFT)
XResizeWindow(server.dsp, panel->main_win, panel->area.width, panel->area.height); XResizeWindow(server.display, panel->main_win, panel->area.width, panel->area.height);
else else
XMoveResizeWindow(server.dsp, XMoveResizeWindow(server.display,
panel->main_win, panel->main_win,
panel->posx, panel->posx,
panel->posy, panel->posy,
@ -977,14 +977,14 @@ void autohide_hide(void *p)
if (panel_strut_policy == STRUT_FOLLOW_SIZE) if (panel_strut_policy == STRUT_FOLLOW_SIZE)
update_strut(panel); update_strut(panel);
XUnmapSubwindows(server.dsp, panel->main_win); // systray windows XUnmapSubwindows(server.display, panel->main_win); // systray windows
int diff = (panel_horizontal ? panel->area.height : panel->area.width) - panel_autohide_height; int diff = (panel_horizontal ? panel->area.height : panel->area.width) - panel_autohide_height;
// printf("autohide_hide : diff %d, w %d, h %d\n", diff, panel->hidden_width, panel->hidden_height); // printf("autohide_hide : diff %d, w %d, h %d\n", diff, panel->hidden_width, panel->hidden_height);
if (panel_horizontal) { if (panel_horizontal) {
if (panel_position & TOP) if (panel_position & TOP)
XResizeWindow(server.dsp, panel->main_win, panel->hidden_width, panel->hidden_height); XResizeWindow(server.display, panel->main_win, panel->hidden_width, panel->hidden_height);
else else
XMoveResizeWindow(server.dsp, XMoveResizeWindow(server.display,
panel->main_win, panel->main_win,
panel->posx, panel->posx,
panel->posy + diff, panel->posy + diff,
@ -992,9 +992,9 @@ void autohide_hide(void *p)
panel->hidden_height); panel->hidden_height);
} else { } else {
if (panel_position & LEFT) if (panel_position & LEFT)
XResizeWindow(server.dsp, panel->main_win, panel->hidden_width, panel->hidden_height); XResizeWindow(server.display, panel->main_win, panel->hidden_width, panel->hidden_height);
else else
XMoveResizeWindow(server.dsp, XMoveResizeWindow(server.display,
panel->main_win, panel->main_win,
panel->posx + diff, panel->posx + diff,
panel->posy, panel->posy,
@ -1019,7 +1019,7 @@ void autohide_trigger_hide(Panel *p)
Window root, child; Window root, child;
int xr, yr, xw, yw; int xr, yr, xw, yw;
unsigned int mask; unsigned int mask;
if (XQueryPointer(server.dsp, p->main_win, &root, &child, &xr, &yr, &xw, &yw, &mask)) if (XQueryPointer(server.display, p->main_win, &root, &child, &xr, &yr, &xw, &yw, &mask))
if (child) if (child)
return; // mouse over one of the system tray icons return; // mouse over one of the system tray icons

202
src/server.c
View file

@ -39,94 +39,94 @@ void server_catch_error(Display *d, XErrorEvent *ev)
void server_init_atoms() void server_init_atoms()
{ {
server.atom._XROOTPMAP_ID = XInternAtom(server.dsp, "_XROOTPMAP_ID", False); server.atom._XROOTPMAP_ID = XInternAtom(server.display, "_XROOTPMAP_ID", False);
server.atom._XROOTMAP_ID = XInternAtom(server.dsp, "_XROOTMAP_ID", False); server.atom._XROOTMAP_ID = XInternAtom(server.display, "_XROOTMAP_ID", False);
server.atom._NET_CURRENT_DESKTOP = XInternAtom(server.dsp, "_NET_CURRENT_DESKTOP", False); server.atom._NET_CURRENT_DESKTOP = XInternAtom(server.display, "_NET_CURRENT_DESKTOP", False);
server.atom._NET_NUMBER_OF_DESKTOPS = XInternAtom(server.dsp, "_NET_NUMBER_OF_DESKTOPS", False); server.atom._NET_NUMBER_OF_DESKTOPS = XInternAtom(server.display, "_NET_NUMBER_OF_DESKTOPS", False);
server.atom._NET_DESKTOP_NAMES = XInternAtom(server.dsp, "_NET_DESKTOP_NAMES", False); server.atom._NET_DESKTOP_NAMES = XInternAtom(server.display, "_NET_DESKTOP_NAMES", False);
server.atom._NET_DESKTOP_GEOMETRY = XInternAtom(server.dsp, "_NET_DESKTOP_GEOMETRY", False); server.atom._NET_DESKTOP_GEOMETRY = XInternAtom(server.display, "_NET_DESKTOP_GEOMETRY", False);
server.atom._NET_DESKTOP_VIEWPORT = XInternAtom(server.dsp, "_NET_DESKTOP_VIEWPORT", False); server.atom._NET_DESKTOP_VIEWPORT = XInternAtom(server.display, "_NET_DESKTOP_VIEWPORT", False);
server.atom._NET_WORKAREA = XInternAtom(server.dsp, "_NET_WORKAREA", False); server.atom._NET_WORKAREA = XInternAtom(server.display, "_NET_WORKAREA", False);
server.atom._NET_ACTIVE_WINDOW = XInternAtom(server.dsp, "_NET_ACTIVE_WINDOW", False); server.atom._NET_ACTIVE_WINDOW = XInternAtom(server.display, "_NET_ACTIVE_WINDOW", False);
server.atom._NET_WM_WINDOW_TYPE = XInternAtom(server.dsp, "_NET_WM_WINDOW_TYPE", False); server.atom._NET_WM_WINDOW_TYPE = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE", False);
server.atom._NET_WM_STATE_SKIP_PAGER = XInternAtom(server.dsp, "_NET_WM_STATE_SKIP_PAGER", 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.dsp, "_NET_WM_STATE_SKIP_TASKBAR", 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.dsp, "_NET_WM_STATE_STICKY", False); server.atom._NET_WM_STATE_STICKY = XInternAtom(server.display, "_NET_WM_STATE_STICKY", False);
server.atom._NET_WM_STATE_DEMANDS_ATTENTION = XInternAtom(server.dsp, "_NET_WM_STATE_DEMANDS_ATTENTION", 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.dsp, "_NET_WM_WINDOW_TYPE_DOCK", 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.dsp, "_NET_WM_WINDOW_TYPE_DESKTOP", 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.dsp, "_NET_WM_WINDOW_TYPE_TOOLBAR", 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.dsp, "_NET_WM_WINDOW_TYPE_MENU", 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.dsp, "_NET_WM_WINDOW_TYPE_SPLASH", 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.dsp, "_NET_WM_WINDOW_TYPE_DIALOG", 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.dsp, "_NET_WM_WINDOW_TYPE_NORMAL", False); server.atom._NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(server.display, "_NET_WM_WINDOW_TYPE_NORMAL", False);
server.atom._NET_WM_DESKTOP = XInternAtom(server.dsp, "_NET_WM_DESKTOP", False); server.atom._NET_WM_DESKTOP = XInternAtom(server.display, "_NET_WM_DESKTOP", False);
server.atom.WM_STATE = XInternAtom(server.dsp, "WM_STATE", False); server.atom.WM_STATE = XInternAtom(server.display, "WM_STATE", False);
server.atom._NET_WM_STATE = XInternAtom(server.dsp, "_NET_WM_STATE", False); server.atom._NET_WM_STATE = XInternAtom(server.display, "_NET_WM_STATE", False);
server.atom._NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(server.dsp, "_NET_WM_STATE_MAXIMIZED_VERT", 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.dsp, "_NET_WM_STATE_MAXIMIZED_HORZ", 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.dsp, "_NET_WM_STATE_SHADED", False); server.atom._NET_WM_STATE_SHADED = XInternAtom(server.display, "_NET_WM_STATE_SHADED", False);
server.atom._NET_WM_STATE_HIDDEN = XInternAtom(server.dsp, "_NET_WM_STATE_HIDDEN", False); server.atom._NET_WM_STATE_HIDDEN = XInternAtom(server.display, "_NET_WM_STATE_HIDDEN", False);
server.atom._NET_WM_STATE_BELOW = XInternAtom(server.dsp, "_NET_WM_STATE_BELOW", False); server.atom._NET_WM_STATE_BELOW = XInternAtom(server.display, "_NET_WM_STATE_BELOW", False);
server.atom._NET_WM_STATE_ABOVE = XInternAtom(server.dsp, "_NET_WM_STATE_ABOVE", False); server.atom._NET_WM_STATE_ABOVE = XInternAtom(server.display, "_NET_WM_STATE_ABOVE", False);
server.atom._NET_WM_STATE_MODAL = XInternAtom(server.dsp, "_NET_WM_STATE_MODAL", False); server.atom._NET_WM_STATE_MODAL = XInternAtom(server.display, "_NET_WM_STATE_MODAL", False);
server.atom._NET_CLIENT_LIST = XInternAtom(server.dsp, "_NET_CLIENT_LIST", False); server.atom._NET_CLIENT_LIST = XInternAtom(server.display, "_NET_CLIENT_LIST", False);
server.atom._NET_WM_VISIBLE_NAME = XInternAtom(server.dsp, "_NET_WM_VISIBLE_NAME", False); server.atom._NET_WM_VISIBLE_NAME = XInternAtom(server.display, "_NET_WM_VISIBLE_NAME", False);
server.atom._NET_WM_NAME = XInternAtom(server.dsp, "_NET_WM_NAME", False); server.atom._NET_WM_NAME = XInternAtom(server.display, "_NET_WM_NAME", False);
server.atom._NET_WM_STRUT = XInternAtom(server.dsp, "_NET_WM_STRUT", False); server.atom._NET_WM_STRUT = XInternAtom(server.display, "_NET_WM_STRUT", False);
server.atom._NET_WM_ICON = XInternAtom(server.dsp, "_NET_WM_ICON", False); server.atom._NET_WM_ICON = XInternAtom(server.display, "_NET_WM_ICON", False);
server.atom._NET_WM_ICON_GEOMETRY = XInternAtom(server.dsp, "_NET_WM_ICON_GEOMETRY", False); server.atom._NET_WM_ICON_GEOMETRY = XInternAtom(server.display, "_NET_WM_ICON_GEOMETRY", False);
server.atom._NET_WM_ICON_NAME = XInternAtom(server.dsp, "_NET_WM_ICON_NAME", False); server.atom._NET_WM_ICON_NAME = XInternAtom(server.display, "_NET_WM_ICON_NAME", False);
server.atom._NET_CLOSE_WINDOW = XInternAtom(server.dsp, "_NET_CLOSE_WINDOW", False); server.atom._NET_CLOSE_WINDOW = XInternAtom(server.display, "_NET_CLOSE_WINDOW", False);
server.atom.UTF8_STRING = XInternAtom(server.dsp, "UTF8_STRING", False); server.atom.UTF8_STRING = XInternAtom(server.display, "UTF8_STRING", False);
server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.dsp, "_NET_SUPPORTING_WM_CHECK", False); server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.display, "_NET_SUPPORTING_WM_CHECK", False);
server.atom._NET_WM_CM_S0 = XInternAtom(server.dsp, "_NET_WM_CM_S0", False); server.atom._NET_WM_CM_S0 = XInternAtom(server.display, "_NET_WM_CM_S0", False);
server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.dsp, "_NET_WM_NAME", False); server.atom._NET_SUPPORTING_WM_CHECK = XInternAtom(server.display, "_NET_WM_NAME", False);
server.atom._NET_WM_STRUT_PARTIAL = XInternAtom(server.dsp, "_NET_WM_STRUT_PARTIAL", False); server.atom._NET_WM_STRUT_PARTIAL = XInternAtom(server.display, "_NET_WM_STRUT_PARTIAL", False);
server.atom.WM_NAME = XInternAtom(server.dsp, "WM_NAME", False); server.atom.WM_NAME = XInternAtom(server.display, "WM_NAME", False);
server.atom.__SWM_VROOT = XInternAtom(server.dsp, "__SWM_VROOT", False); server.atom.__SWM_VROOT = XInternAtom(server.display, "__SWM_VROOT", False);
server.atom._MOTIF_WM_HINTS = XInternAtom(server.dsp, "_MOTIF_WM_HINTS", False); server.atom._MOTIF_WM_HINTS = XInternAtom(server.display, "_MOTIF_WM_HINTS", False);
server.atom.WM_HINTS = XInternAtom(server.dsp, "WM_HINTS", False); server.atom.WM_HINTS = XInternAtom(server.display, "WM_HINTS", False);
gchar *name = g_strdup_printf("_XSETTINGS_S%d", DefaultScreen(server.dsp)); gchar *name = g_strdup_printf("_XSETTINGS_S%d", DefaultScreen(server.display));
server.atom._XSETTINGS_SCREEN = XInternAtom(server.dsp, name, False); server.atom._XSETTINGS_SCREEN = XInternAtom(server.display, name, False);
g_free(name); g_free(name);
server.atom._XSETTINGS_SETTINGS = XInternAtom(server.dsp, "_XSETTINGS_SETTINGS", False); server.atom._XSETTINGS_SETTINGS = XInternAtom(server.display, "_XSETTINGS_SETTINGS", False);
// systray protocol // systray protocol
name = g_strdup_printf("_NET_SYSTEM_TRAY_S%d", DefaultScreen(server.dsp)); name = g_strdup_printf("_NET_SYSTEM_TRAY_S%d", DefaultScreen(server.display));
server.atom._NET_SYSTEM_TRAY_SCREEN = XInternAtom(server.dsp, name, False); server.atom._NET_SYSTEM_TRAY_SCREEN = XInternAtom(server.display, name, False);
g_free(name); g_free(name);
server.atom._NET_SYSTEM_TRAY_OPCODE = XInternAtom(server.dsp, "_NET_SYSTEM_TRAY_OPCODE", False); server.atom._NET_SYSTEM_TRAY_OPCODE = XInternAtom(server.display, "_NET_SYSTEM_TRAY_OPCODE", False);
server.atom.MANAGER = XInternAtom(server.dsp, "MANAGER", False); server.atom.MANAGER = XInternAtom(server.display, "MANAGER", False);
server.atom._NET_SYSTEM_TRAY_MESSAGE_DATA = XInternAtom(server.dsp, "_NET_SYSTEM_TRAY_MESSAGE_DATA", 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.dsp, "_NET_SYSTEM_TRAY_ORIENTATION", False); server.atom._NET_SYSTEM_TRAY_ORIENTATION = XInternAtom(server.display, "_NET_SYSTEM_TRAY_ORIENTATION", False);
server.atom._NET_SYSTEM_TRAY_ICON_SIZE = XInternAtom(server.dsp, "_NET_SYSTEM_TRAY_ICON_SIZE", 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.dsp, "_NET_SYSTEM_TRAY_PADDING", False); server.atom._NET_SYSTEM_TRAY_PADDING = XInternAtom(server.display, "_NET_SYSTEM_TRAY_PADDING", False);
server.atom._XEMBED = XInternAtom(server.dsp, "_XEMBED", False); server.atom._XEMBED = XInternAtom(server.display, "_XEMBED", False);
server.atom._XEMBED_INFO = XInternAtom(server.dsp, "_XEMBED_INFO", False); server.atom._XEMBED_INFO = XInternAtom(server.display, "_XEMBED_INFO", False);
server.atom._NET_WM_PID = XInternAtom(server.dsp, "_NET_WM_PID", True); server.atom._NET_WM_PID = XInternAtom(server.display, "_NET_WM_PID", True);
// drag 'n' drop // drag 'n' drop
server.atom.XdndAware = XInternAtom(server.dsp, "XdndAware", False); server.atom.XdndAware = XInternAtom(server.display, "XdndAware", False);
server.atom.XdndEnter = XInternAtom(server.dsp, "XdndEnter", False); server.atom.XdndEnter = XInternAtom(server.display, "XdndEnter", False);
server.atom.XdndPosition = XInternAtom(server.dsp, "XdndPosition", False); server.atom.XdndPosition = XInternAtom(server.display, "XdndPosition", False);
server.atom.XdndStatus = XInternAtom(server.dsp, "XdndStatus", False); server.atom.XdndStatus = XInternAtom(server.display, "XdndStatus", False);
server.atom.XdndDrop = XInternAtom(server.dsp, "XdndDrop", False); server.atom.XdndDrop = XInternAtom(server.display, "XdndDrop", False);
server.atom.XdndLeave = XInternAtom(server.dsp, "XdndLeave", False); server.atom.XdndLeave = XInternAtom(server.display, "XdndLeave", False);
server.atom.XdndSelection = XInternAtom(server.dsp, "XdndSelection", False); server.atom.XdndSelection = XInternAtom(server.display, "XdndSelection", False);
server.atom.XdndTypeList = XInternAtom(server.dsp, "XdndTypeList", False); server.atom.XdndTypeList = XInternAtom(server.display, "XdndTypeList", False);
server.atom.XdndActionCopy = XInternAtom(server.dsp, "XdndActionCopy", False); server.atom.XdndActionCopy = XInternAtom(server.display, "XdndActionCopy", False);
server.atom.XdndFinished = XInternAtom(server.dsp, "XdndFinished", False); server.atom.XdndFinished = XInternAtom(server.display, "XdndFinished", False);
server.atom.TARGETS = XInternAtom(server.dsp, "TARGETS", False); server.atom.TARGETS = XInternAtom(server.display, "TARGETS", False);
} }
void cleanup_server() void cleanup_server()
{ {
if (server.colormap) if (server.colormap)
XFreeColormap(server.dsp, server.colormap); XFreeColormap(server.display, server.colormap);
server.colormap = 0; server.colormap = 0;
if (server.colormap32) if (server.colormap32)
XFreeColormap(server.dsp, server.colormap32); XFreeColormap(server.display, server.colormap32);
server.colormap32 = 0; server.colormap32 = 0;
if (server.monitors) { if (server.monitors) {
for (int i = 0; i < server.num_monitors; ++i) { for (int i = 0; i < server.num_monitors; ++i) {
@ -137,7 +137,7 @@ void cleanup_server()
server.monitors = NULL; server.monitors = NULL;
} }
if (server.gc) if (server.gc)
XFreeGC(server.dsp, server.gc); XFreeGC(server.display, server.gc);
server.gc = NULL; server.gc = NULL;
server.disable_transparency = FALSE; server.disable_transparency = FALSE;
} }
@ -149,7 +149,7 @@ void send_event32(Window win, Atom at, long data1, long data2, long data3)
event.xclient.type = ClientMessage; event.xclient.type = ClientMessage;
event.xclient.serial = 0; event.xclient.serial = 0;
event.xclient.send_event = True; event.xclient.send_event = True;
event.xclient.display = server.dsp; event.xclient.display = server.display;
event.xclient.window = win; event.xclient.window = win;
event.xclient.message_type = at; event.xclient.message_type = at;
@ -160,7 +160,7 @@ void send_event32(Window win, Atom at, long data1, long data2, long data3)
event.xclient.data.l[3] = 0; event.xclient.data.l[3] = 0;
event.xclient.data.l[4] = 0; event.xclient.data.l[4] = 0;
XSendEvent(server.dsp, server.root_win, False, SubstructureRedirectMask | SubstructureNotifyMask, &event); XSendEvent(server.display, server.root_win, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
} }
int get_property32(Window win, Atom at, Atom type) int get_property32(Window win, Atom at, Atom type)
@ -175,7 +175,7 @@ int get_property32(Window win, Atom at, Atom type)
if (!win) if (!win)
return 0; return 0;
result = XGetWindowProperty(server.dsp, result = XGetWindowProperty(server.display,
win, win,
at, at,
0, 0,
@ -206,7 +206,7 @@ void *server_get_property(Window win, Atom at, Atom type, int *num_results)
if (!win) if (!win)
return NULL; return NULL;
int result = XGetWindowProperty(server.dsp, int result = XGetWindowProperty(server.display,
win, win,
at, at,
0, 0,
@ -254,7 +254,7 @@ void get_root_pixmap()
uint mask = GCTileStipXOrigin | GCTileStipYOrigin | GCFillStyle | GCTile; uint mask = GCTileStipXOrigin | GCTileStipYOrigin | GCFillStyle | GCTile;
gcv.tile = server.root_pmap; gcv.tile = server.root_pmap;
XChangeGC(server.dsp, server.gc, mask, &gcv); XChangeGC(server.display, server.gc, mask, &gcv);
} }
} }
@ -299,11 +299,11 @@ int monitor_includes_monitor(const void *monitor1, const void *monitor2)
void get_monitors() void get_monitors()
{ {
if (XineramaIsActive(server.dsp)) { if (XineramaIsActive(server.display)) {
int num_monitors; int num_monitors;
XineramaScreenInfo *info = XineramaQueryScreens(server.dsp, &num_monitors); XineramaScreenInfo *info = XineramaQueryScreens(server.display, &num_monitors);
XRRScreenResources *res = XRRGetScreenResourcesCurrent(server.dsp, server.root_win); XRRScreenResources *res = XRRGetScreenResourcesCurrent(server.display, server.root_win);
RROutput primary_output = XRRGetOutputPrimary(server.dsp, server.root_win); RROutput primary_output = XRRGetOutputPrimary(server.display, server.root_win);
if (res && res->ncrtc >= num_monitors) { if (res && res->ncrtc >= num_monitors) {
// use xrandr to identify monitors (does not work with proprietery nvidia drivers) // use xrandr to identify monitors (does not work with proprietery nvidia drivers)
@ -312,7 +312,7 @@ void get_monitors()
// on some recent configs, XRRGetScreenResourcesCurrent returns a fantom monitor at last position // on some recent configs, XRRGetScreenResourcesCurrent returns a fantom monitor at last position
{ {
int i = res->ncrtc - 1; int i = res->ncrtc - 1;
XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(server.dsp, res, res->crtcs[i]); XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(server.display, res, res->crtcs[i]);
if (!(crtc_info->x || crtc_info->y || crtc_info->width || crtc_info->height)) { if (!(crtc_info->x || crtc_info->y || crtc_info->width || crtc_info->height)) {
res->ncrtc -= 1; res->ncrtc -= 1;
} }
@ -322,14 +322,14 @@ void get_monitors()
printf("xRandr: Found crtc's: %d\n", res->ncrtc); printf("xRandr: Found crtc's: %d\n", res->ncrtc);
server.monitors = calloc(res->ncrtc, sizeof(Monitor)); server.monitors = calloc(res->ncrtc, sizeof(Monitor));
for (int i = 0; i < res->ncrtc; ++i) { for (int i = 0; i < res->ncrtc; ++i) {
XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(server.dsp, res, res->crtcs[i]); XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(server.display, res, res->crtcs[i]);
server.monitors[i].x = crtc_info->x; server.monitors[i].x = crtc_info->x;
server.monitors[i].y = crtc_info->y; server.monitors[i].y = crtc_info->y;
server.monitors[i].width = crtc_info->width; server.monitors[i].width = crtc_info->width;
server.monitors[i].height = crtc_info->height; server.monitors[i].height = crtc_info->height;
server.monitors[i].names = calloc((crtc_info->noutput + 1), sizeof(gchar *)); server.monitors[i].names = calloc((crtc_info->noutput + 1), sizeof(gchar *));
for (int j = 0; j < crtc_info->noutput; ++j) { for (int j = 0; j < crtc_info->noutput; ++j) {
XRROutputInfo *output_info = XRRGetOutputInfo(server.dsp, res, crtc_info->outputs[j]); XRROutputInfo *output_info = XRRGetOutputInfo(server.display, res, crtc_info->outputs[j]);
printf("xRandr: Linking output %s with crtc %d\n", output_info->name, i); printf("xRandr: Linking output %s with crtc %d\n", output_info->name, i);
server.monitors[i].names[j] = g_strdup(output_info->name); server.monitors[i].names[j] = g_strdup(output_info->name);
XRRFreeOutputInfo(output_info); XRRFreeOutputInfo(output_info);
@ -380,8 +380,8 @@ void get_monitors()
server.num_monitors = 1; server.num_monitors = 1;
server.monitors = calloc(1, sizeof(Monitor)); server.monitors = calloc(1, sizeof(Monitor));
server.monitors[0].x = server.monitors[0].y = 0; server.monitors[0].x = server.monitors[0].y = 0;
server.monitors[0].width = DisplayWidth(server.dsp, server.screen); server.monitors[0].width = DisplayWidth(server.display, server.screen);
server.monitors[0].height = DisplayHeight(server.dsp, server.screen); server.monitors[0].height = DisplayHeight(server.display, server.screen);
server.monitors[0].names = 0; server.monitors[0].names = 0;
} }
} }
@ -544,13 +544,13 @@ void server_init_visual()
// inspired by freedesktops fdclock ;) // inspired by freedesktops fdclock ;)
XVisualInfo templ = {.screen = server.screen, .depth = 32, .class = TrueColor}; XVisualInfo templ = {.screen = server.screen, .depth = 32, .class = TrueColor};
int nvi; int nvi;
XVisualInfo *xvi = XGetVisualInfo(server.dsp, VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi); XVisualInfo *xvi = XGetVisualInfo(server.display, VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi);
Visual *visual = NULL; Visual *visual = NULL;
if (xvi) { if (xvi) {
XRenderPictFormat *format; XRenderPictFormat *format;
for (int i = 0; i < nvi; i++) { for (int i = 0; i < nvi; i++) {
format = XRenderFindVisualFormat(server.dsp, xvi[i].visual); format = XRenderFindVisualFormat(server.display, xvi[i].visual);
if (format->type == PictTypeDirect && format->direct.alphaMask) { if (format->type == PictTypeDirect && format->direct.alphaMask) {
visual = xvi[i].visual; visual = xvi[i].visual;
break; break;
@ -560,33 +560,33 @@ void server_init_visual()
XFree(xvi); XFree(xvi);
// check composite manager // check composite manager
server.composite_manager = XGetSelectionOwner(server.dsp, server.atom._NET_WM_CM_S0); server.composite_manager = XGetSelectionOwner(server.display, server.atom._NET_WM_CM_S0);
if (server.colormap) if (server.colormap)
XFreeColormap(server.dsp, server.colormap); XFreeColormap(server.display, server.colormap);
if (server.colormap32) if (server.colormap32)
XFreeColormap(server.dsp, server.colormap32); XFreeColormap(server.display, server.colormap32);
if (visual) { if (visual) {
server.visual32 = visual; server.visual32 = visual;
server.colormap32 = XCreateColormap(server.dsp, server.root_win, visual, AllocNone); server.colormap32 = XCreateColormap(server.display, server.root_win, visual, AllocNone);
} }
if (!server.disable_transparency && visual && server.composite_manager != None && !snapshot_path) { if (!server.disable_transparency && visual && server.composite_manager != None && !snapshot_path) {
XSetWindowAttributes attrs; XSetWindowAttributes attrs;
attrs.event_mask = StructureNotifyMask; attrs.event_mask = StructureNotifyMask;
XChangeWindowAttributes(server.dsp, server.composite_manager, CWEventMask, &attrs); XChangeWindowAttributes(server.display, server.composite_manager, CWEventMask, &attrs);
server.real_transparency = TRUE; server.real_transparency = TRUE;
server.depth = 32; server.depth = 32;
printf("real transparency on... depth: %d\n", server.depth); printf("real transparency on... depth: %d\n", server.depth);
server.colormap = XCreateColormap(server.dsp, server.root_win, visual, AllocNone); server.colormap = XCreateColormap(server.display, server.root_win, visual, AllocNone);
server.visual = visual; server.visual = visual;
} else { } else {
// no composite manager or snapshot mode => fake transparency // no composite manager or snapshot mode => fake transparency
server.real_transparency = FALSE; server.real_transparency = FALSE;
server.depth = DefaultDepth(server.dsp, server.screen); server.depth = DefaultDepth(server.display, server.screen);
printf("real transparency off.... depth: %d\n", server.depth); printf("real transparency off.... depth: %d\n", server.depth);
server.colormap = DefaultColormap(server.dsp, server.screen); server.colormap = DefaultColormap(server.display, server.screen);
server.visual = DefaultVisual(server.dsp, server.screen); server.visual = DefaultVisual(server.display, server.screen);
} }
} }

4
src/server.h
View file

@ -110,7 +110,7 @@ typedef struct Viewport {
} Viewport; } Viewport;
typedef struct Server { typedef struct Server {
Display *dsp; Display *display;
Window root_win; Window root_win;
Window composite_manager; Window composite_manager;
gboolean real_transparency; gboolean real_transparency;
@ -136,7 +136,7 @@ typedef struct Server {
Colormap colormap32; Colormap colormap32;
Global_atom atom; Global_atom atom;
#ifdef HAVE_SN #ifdef HAVE_SN
SnDisplay *sn_dsp; SnDisplay *sn_display;
GTree *pids; GTree *pids;
#endif // HAVE_SN #endif // HAVE_SN
} Server; } Server;

180
src/systray/systraybar.c
View file

@ -87,7 +87,7 @@ void cleanup_systray()
systray.area.on_screen = FALSE; systray.area.on_screen = FALSE;
free_area(&systray.area); free_area(&systray.area);
if (render_background) { if (render_background) {
XFreePixmap(server.dsp, render_background); XFreePixmap(server.display, render_background);
render_background = 0; render_background = 0;
} }
} }
@ -138,7 +138,7 @@ gboolean resize_systray(void *obj)
if (systray.icon_size > 0) { if (systray.icon_size > 0) {
long icon_size = systray.icon_size; long icon_size = systray.icon_size;
XChangeProperty(server.dsp, XChangeProperty(server.display,
net_sel_win, net_sel_win,
server.atom._NET_SYSTEM_TRAY_ICON_SIZE, server.atom._NET_SYSTEM_TRAY_ICON_SIZE,
XA_CARDINAL, XA_CARDINAL,
@ -192,10 +192,10 @@ void draw_systray(void *obj, cairo_t *c)
fprintf(stderr, BLUE "[%f] %s:%d\n" RESET, profiling_get_time(), __FUNCTION__, __LINE__); fprintf(stderr, BLUE "[%f] %s:%d\n" RESET, profiling_get_time(), __FUNCTION__, __LINE__);
if (systray_composited) { if (systray_composited) {
if (render_background) if (render_background)
XFreePixmap(server.dsp, render_background); XFreePixmap(server.display, render_background);
render_background = render_background =
XCreatePixmap(server.dsp, server.root_win, systray.area.width, systray.area.height, server.depth); XCreatePixmap(server.display, server.root_win, systray.area.width, systray.area.height, server.depth);
XCopyArea(server.dsp, XCopyArea(server.display,
systray.area.pix, systray.area.pix,
render_background, render_background,
server.gc, server.gc,
@ -274,20 +274,20 @@ void on_change_systray(void *obj)
int xpos, ypos; int xpos, ypos;
unsigned int width, height, depth; unsigned int width, height, depth;
Window root; Window root;
if (!XGetGeometry(server.dsp, traywin->parent, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) { if (!XGetGeometry(server.display, traywin->parent, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) {
fprintf(stderr, RED "Couldn't get geometry of window!\n" RESET); fprintf(stderr, RED "Couldn't get geometry of window!\n" RESET);
} }
if (width != traywin->width || height != traywin->height || xpos != traywin->x || ypos != traywin->y) { if (width != traywin->width || height != traywin->height || xpos != traywin->x || ypos != traywin->y) {
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XMoveResizeWindow(server.dsp, traywin->parent = %ld, traywin->x = %d, traywin->y = %d, " "XMoveResizeWindow(server.display, traywin->parent = %ld, traywin->x = %d, traywin->y = %d, "
"traywin->width = %d, traywin->height = %d)\n", "traywin->width = %d, traywin->height = %d)\n",
traywin->parent, traywin->parent,
traywin->x, traywin->x,
traywin->y, traywin->y,
traywin->width, traywin->width,
traywin->height); traywin->height);
XMoveResizeWindow(server.dsp, traywin->parent, traywin->x, traywin->y, traywin->width, traywin->height); XMoveResizeWindow(server.display, traywin->parent, traywin->x, traywin->y, traywin->width, traywin->height);
} }
if (!traywin->reparented) if (!traywin->reparented)
reparent_icon(traywin); reparent_icon(traywin);
@ -312,7 +312,7 @@ void start_net()
return; return;
} }
Window win = XGetSelectionOwner(server.dsp, server.atom._NET_SYSTEM_TRAY_SCREEN); Window win = XGetSelectionOwner(server.display, server.atom._NET_SYSTEM_TRAY_SCREEN);
// freedesktop systray specification // freedesktop systray specification
if (win != None) { if (win != None) {
@ -324,8 +324,8 @@ void start_net()
unsigned char *prop = 0; unsigned char *prop = 0;
int pid; int pid;
_NET_WM_PID = XInternAtom(server.dsp, "_NET_WM_PID", True); _NET_WM_PID = XInternAtom(server.display, "_NET_WM_PID", True);
int ret = XGetWindowProperty(server.dsp, int ret = XGetWindowProperty(server.display,
win, win,
_NET_WM_PID, _NET_WM_PID,
0, 0,
@ -349,13 +349,13 @@ void start_net()
} }
// init systray protocol // init systray protocol
net_sel_win = XCreateSimpleWindow(server.dsp, server.root_win, -1, -1, 1, 1, 0, 0, 0); net_sel_win = XCreateSimpleWindow(server.display, server.root_win, -1, -1, 1, 1, 0, 0, 0);
fprintf(stderr, "systray window %ld\n", net_sel_win); fprintf(stderr, "systray window %ld\n", net_sel_win);
// v0.3 trayer specification. tint2 always horizontal. // v0.3 trayer specification. tint2 always horizontal.
// Vertical panel will draw the systray horizontal. // Vertical panel will draw the systray horizontal.
long orientation = 0; long orientation = 0;
XChangeProperty(server.dsp, XChangeProperty(server.display,
net_sel_win, net_sel_win,
server.atom._NET_SYSTEM_TRAY_ORIENTATION, server.atom._NET_SYSTEM_TRAY_ORIENTATION,
XA_CARDINAL, XA_CARDINAL,
@ -365,7 +365,7 @@ void start_net()
1); 1);
if (systray.icon_size > 0) { if (systray.icon_size > 0) {
long icon_size = systray.icon_size; long icon_size = systray.icon_size;
XChangeProperty(server.dsp, XChangeProperty(server.display,
net_sel_win, net_sel_win,
server.atom._NET_SYSTEM_TRAY_ICON_SIZE, server.atom._NET_SYSTEM_TRAY_ICON_SIZE,
XA_CARDINAL, XA_CARDINAL,
@ -375,7 +375,7 @@ void start_net()
1); 1);
} }
long padding = 0; long padding = 0;
XChangeProperty(server.dsp, XChangeProperty(server.display,
net_sel_win, net_sel_win,
server.atom._NET_SYSTEM_TRAY_PADDING, server.atom._NET_SYSTEM_TRAY_PADDING,
XA_CARDINAL, XA_CARDINAL,
@ -389,17 +389,17 @@ void start_net()
vid = XVisualIDFromVisual(server.visual32); vid = XVisualIDFromVisual(server.visual32);
else else
vid = XVisualIDFromVisual(server.visual); vid = XVisualIDFromVisual(server.visual);
XChangeProperty(server.dsp, XChangeProperty(server.display,
net_sel_win, net_sel_win,
XInternAtom(server.dsp, "_NET_SYSTEM_TRAY_VISUAL", False), XInternAtom(server.display, "_NET_SYSTEM_TRAY_VISUAL", False),
XA_VISUALID, XA_VISUALID,
32, 32,
PropModeReplace, PropModeReplace,
(unsigned char *)&vid, (unsigned char *)&vid,
1); 1);
XSetSelectionOwner(server.dsp, server.atom._NET_SYSTEM_TRAY_SCREEN, net_sel_win, CurrentTime); XSetSelectionOwner(server.display, server.atom._NET_SYSTEM_TRAY_SCREEN, net_sel_win, CurrentTime);
if (XGetSelectionOwner(server.dsp, server.atom._NET_SYSTEM_TRAY_SCREEN) != net_sel_win) { if (XGetSelectionOwner(server.display, server.atom._NET_SYSTEM_TRAY_SCREEN) != net_sel_win) {
stop_net(); stop_net();
fprintf(stderr, RED "tint2 : can't get systray manager\n" RESET); fprintf(stderr, RED "tint2 : can't get systray manager\n" RESET);
return; return;
@ -418,7 +418,7 @@ void start_net()
ev.data.l[2] = net_sel_win; ev.data.l[2] = net_sel_win;
ev.data.l[3] = 0; ev.data.l[3] = 0;
ev.data.l[4] = 0; ev.data.l[4] = 0;
XSendEvent(server.dsp, server.root_win, False, StructureNotifyMask, (XEvent *)&ev); XSendEvent(server.display, server.root_win, False, StructureNotifyMask, (XEvent *)&ev);
} }
void net_message(XClientMessageEvent *e) void net_message(XClientMessageEvent *e)
@ -463,7 +463,7 @@ void stop_net()
} }
if (net_sel_win != None) { if (net_sel_win != None) {
XDestroyWindow(server.dsp, net_sel_win); XDestroyWindow(server.display, net_sel_win);
net_sel_win = None; net_sel_win = None;
} }
} }
@ -509,7 +509,7 @@ gboolean add_icon(Window win)
{ {
XTextProperty xname; XTextProperty xname;
char *name; char *name;
if (XGetWMName(server.dsp, win, &xname)) { if (XGetWMName(server.display, win, &xname)) {
name = strdup((char *)xname.value); name = strdup((char *)xname.value);
XFree(xname.value); XFree(xname.value);
} else { } else {
@ -529,7 +529,7 @@ gboolean add_icon(Window win)
unsigned long nitems; unsigned long nitems;
unsigned long bytes_after; unsigned long bytes_after;
unsigned char *prop = 0; unsigned char *prop = 0;
int ret = XGetWindowProperty(server.dsp, int ret = XGetWindowProperty(server.display,
win, win,
server.atom._NET_WM_PID, server.atom._NET_WM_PID,
0, 0,
@ -632,8 +632,8 @@ gboolean add_icon(Window win)
// Create the parent window that will embed the icon // Create the parent window that will embed the icon
XWindowAttributes attr; XWindowAttributes attr;
if (systray_profile) if (systray_profile)
fprintf(stderr, "XGetWindowAttributes(server.dsp, win = %ld, &attr)\n", win); fprintf(stderr, "XGetWindowAttributes(server.display, win = %ld, &attr)\n", win);
if (XGetWindowAttributes(server.dsp, win, &attr) == False) { if (XGetWindowAttributes(server.display, win, &attr) == False) {
free(name); free(name);
return FALSE; return FALSE;
} }
@ -673,7 +673,7 @@ gboolean add_icon(Window win)
} }
if (systray_profile) if (systray_profile)
fprintf(stderr, "XCreateWindow(...)\n"); fprintf(stderr, "XCreateWindow(...)\n");
Window parent = XCreateWindow(server.dsp, Window parent = XCreateWindow(server.display,
panel->main_win, panel->main_win,
0, 0,
0, 0,
@ -710,8 +710,8 @@ gboolean add_icon(Window win)
if (!traywin->hide && !panel->is_hidden) { if (!traywin->hide && !panel->is_hidden) {
if (systray_profile) if (systray_profile)
fprintf(stderr, "XMapRaised(server.dsp, traywin->parent)\n"); fprintf(stderr, "XMapRaised(server.display, traywin->parent)\n");
XMapRaised(server.dsp, traywin->parent); XMapRaised(server.display, traywin->parent);
} }
if (systray_profile) if (systray_profile)
@ -742,22 +742,22 @@ gboolean reparent_icon(TrayWindow *traywin)
return TRUE; return TRUE;
// Watch for the icon trying to resize itself / closing again // Watch for the icon trying to resize itself / closing again
XSync(server.dsp, False); XSync(server.display, False);
error = FALSE; error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler); XErrorHandler old = XSetErrorHandler(window_error_handler);
if (systray_profile) if (systray_profile)
fprintf(stderr, "XSelectInput(server.dsp, traywin->win, ...)\n"); fprintf(stderr, "XSelectInput(server.display, traywin->win, ...)\n");
XSelectInput(server.dsp, traywin->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask); XSelectInput(server.display, traywin->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask);
XWithdrawWindow(server.dsp, traywin->win, server.screen); XWithdrawWindow(server.display, traywin->win, server.screen);
XReparentWindow(server.dsp, traywin->win, traywin->parent, 0, 0); XReparentWindow(server.display, traywin->win, traywin->parent, 0, 0);
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XMoveResizeWindow(server.dsp, traywin->win = %ld, 0, 0, traywin->width = %d, traywin->height = %d)\n", "XMoveResizeWindow(server.display, traywin->win = %ld, 0, 0, traywin->width = %d, traywin->height = %d)\n",
traywin->win, traywin->win,
traywin->width, traywin->width,
traywin->height); traywin->height);
XMoveResizeWindow(server.dsp, traywin->win, 0, 0, traywin->width, traywin->height); XMoveResizeWindow(server.display, traywin->win, 0, 0, traywin->width, traywin->height);
// Embed into parent // Embed into parent
{ {
@ -774,11 +774,11 @@ gboolean reparent_icon(TrayWindow *traywin)
e.xclient.data.l[3] = traywin->parent; e.xclient.data.l[3] = traywin->parent;
e.xclient.data.l[4] = 0; e.xclient.data.l[4] = 0;
if (systray_profile) if (systray_profile)
fprintf(stderr, "XSendEvent(server.dsp, traywin->win, False, NoEventMask, &e)\n"); fprintf(stderr, "XSendEvent(server.display, traywin->win, False, NoEventMask, &e)\n");
XSendEvent(server.dsp, traywin->win, False, NoEventMask, &e); XSendEvent(server.display, traywin->win, False, NoEventMask, &e);
} }
XSync(server.dsp, False); XSync(server.display, False);
XSetErrorHandler(old); XSetErrorHandler(old);
if (error != FALSE) { if (error != FALSE) {
fprintf(stderr, fprintf(stderr,
@ -821,7 +821,7 @@ gboolean embed_icon(TrayWindow *traywin)
Panel *panel = systray.area.panel; Panel *panel = systray.area.panel;
XSync(server.dsp, False); XSync(server.display, False);
error = FALSE; error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler); XErrorHandler old = XSetErrorHandler(window_error_handler);
@ -834,9 +834,9 @@ gboolean embed_icon(TrayWindow *traywin)
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XGetWindowProperty(server.dsp, traywin->win, server.atom._XEMBED_INFO, 0, 2, False, " "XGetWindowProperty(server.display, traywin->win, server.atom._XEMBED_INFO, 0, 2, False, "
"server.atom._XEMBED_INFO, &acttype, &actfmt, &nbitem, &bytes, &data)\n"); "server.atom._XEMBED_INFO, &acttype, &actfmt, &nbitem, &bytes, &data)\n");
ret = XGetWindowProperty(server.dsp, ret = XGetWindowProperty(server.display,
traywin->win, traywin->win,
server.atom._XEMBED_INFO, server.atom._XEMBED_INFO,
0, 0,
@ -879,30 +879,30 @@ gboolean embed_icon(TrayWindow *traywin)
// Redirect rendering when using compositing // Redirect rendering when using compositing
if (systray_composited) { if (systray_composited) {
if (systray_profile) if (systray_profile)
fprintf(stderr, "XDamageCreate(server.dsp, traywin->parent, XDamageReportRawRectangles)\n"); fprintf(stderr, "XDamageCreate(server.display, traywin->parent, XDamageReportRawRectangles)\n");
traywin->damage = XDamageCreate(server.dsp, traywin->parent, XDamageReportRawRectangles); traywin->damage = XDamageCreate(server.display, traywin->parent, XDamageReportRawRectangles);
if (systray_profile) if (systray_profile)
fprintf(stderr, "XCompositeRedirectWindow(server.dsp, traywin->parent, CompositeRedirectManual)\n"); fprintf(stderr, "XCompositeRedirectWindow(server.display, traywin->parent, CompositeRedirectManual)\n");
XCompositeRedirectWindow(server.dsp, traywin->parent, CompositeRedirectManual); XCompositeRedirectWindow(server.display, traywin->parent, CompositeRedirectManual);
} }
XRaiseWindow(server.dsp, traywin->win); XRaiseWindow(server.display, traywin->win);
// Make the icon visible // Make the icon visible
if (!traywin->hide) { if (!traywin->hide) {
if (systray_profile) if (systray_profile)
fprintf(stderr, "XMapWindow(server.dsp, traywin->win)\n"); fprintf(stderr, "XMapWindow(server.display, traywin->win)\n");
XMapWindow(server.dsp, traywin->win); XMapWindow(server.display, traywin->win);
} }
if (!traywin->hide && !panel->is_hidden) { if (!traywin->hide && !panel->is_hidden) {
if (systray_profile) if (systray_profile)
fprintf(stderr, "XMapRaised(server.dsp, traywin->parent)\n"); fprintf(stderr, "XMapRaised(server.display, traywin->parent)\n");
XMapRaised(server.dsp, traywin->parent); XMapRaised(server.display, traywin->parent);
} }
if (systray_profile) if (systray_profile)
fprintf(stderr, "XSync(server.dsp, False)\n"); fprintf(stderr, "XSync(server.display, False)\n");
XSync(server.dsp, False); XSync(server.display, False);
XSetErrorHandler(old); XSetErrorHandler(old);
if (error != FALSE) { if (error != FALSE) {
fprintf(stderr, fprintf(stderr,
@ -946,19 +946,19 @@ void remove_icon(TrayWindow *traywin)
systray.list_icons = g_slist_remove(systray.list_icons, traywin); systray.list_icons = g_slist_remove(systray.list_icons, traywin);
fprintf(stderr, YELLOW "remove_icon: %lu (%s)\n" RESET, traywin->win, traywin->name); fprintf(stderr, YELLOW "remove_icon: %lu (%s)\n" RESET, traywin->win, traywin->name);
XSelectInput(server.dsp, traywin->win, NoEventMask); XSelectInput(server.display, traywin->win, NoEventMask);
if (traywin->damage) if (traywin->damage)
XDamageDestroy(server.dsp, traywin->damage); XDamageDestroy(server.display, traywin->damage);
// reparent to root // reparent to root
XSync(server.dsp, False); XSync(server.display, False);
error = FALSE; error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler); XErrorHandler old = XSetErrorHandler(window_error_handler);
if (!traywin->hide) if (!traywin->hide)
XUnmapWindow(server.dsp, traywin->win); XUnmapWindow(server.display, traywin->win);
XReparentWindow(server.dsp, traywin->win, server.root_win, 0, 0); XReparentWindow(server.display, traywin->win, server.root_win, 0, 0);
XDestroyWindow(server.dsp, traywin->parent); XDestroyWindow(server.display, traywin->parent);
XSync(server.dsp, False); XSync(server.display, False);
XSetErrorHandler(old); XSetErrorHandler(old);
stop_timeout(traywin->render_timeout); stop_timeout(traywin->render_timeout);
stop_timeout(traywin->resize_timeout); stop_timeout(traywin->resize_timeout);
@ -1000,26 +1000,26 @@ void systray_resize_icon(void *t)
int xpos, ypos; int xpos, ypos;
unsigned int width, height, depth; unsigned int width, height, depth;
Window root; Window root;
if (!XGetGeometry(server.dsp, traywin->win, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) { if (!XGetGeometry(server.display, traywin->win, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) {
return; return;
} else { } else {
if (1 || xpos != 0 || ypos != 0 || width != traywin->width || height != traywin->height) { if (1 || xpos != 0 || ypos != 0 || width != traywin->width || height != traywin->height) {
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XMoveResizeWindow(server.dsp, traywin->win = %ld, 0, 0, traywin->width = %d, traywin->height " "XMoveResizeWindow(server.display, traywin->win = %ld, 0, 0, traywin->width = %d, traywin->height "
"= %d)\n", "= %d)\n",
traywin->win, traywin->win,
traywin->width, traywin->width,
traywin->height); traywin->height);
if (0) { if (0) {
XMoveResizeWindow(server.dsp, traywin->win, 0, 0, traywin->width, traywin->height); XMoveResizeWindow(server.display, traywin->win, 0, 0, traywin->width, traywin->height);
} }
if (0) { if (0) {
XWindowChanges changes; XWindowChanges changes;
changes.x = changes.y = 0; changes.x = changes.y = 0;
changes.width = traywin->width; changes.width = traywin->width;
changes.height = traywin->height; changes.height = traywin->height;
XConfigureWindow(server.dsp, traywin->win, CWX | CWY | CWWidth | CWHeight, &changes); XConfigureWindow(server.display, traywin->win, CWX | CWY | CWWidth | CWHeight, &changes);
} }
if (1) { if (1) {
XConfigureEvent ev; XConfigureEvent ev;
@ -1035,9 +1035,9 @@ void systray_resize_icon(void *t)
ev.border_width = 0; ev.border_width = 0;
ev.above = None; ev.above = None;
ev.override_redirect = False; ev.override_redirect = False;
XSendEvent(server.dsp, traywin->win, False, StructureNotifyMask, (XEvent *)&ev); XSendEvent(server.display, traywin->win, False, StructureNotifyMask, (XEvent *)&ev);
} }
XSync(server.dsp, False); XSync(server.display, False);
} }
} }
} }
@ -1260,48 +1260,48 @@ void systray_render_icon_composited(void *t)
// Very ugly hack, but somehow imlib2 is not able to get the image from the traywindow itself, // Very ugly hack, but somehow imlib2 is not able to get the image from the traywindow itself,
// so we first render the tray window onto a pixmap, and then we tell imlib2 to use this pixmap as // so we first render the tray window onto a pixmap, and then we tell imlib2 to use this pixmap as
// drawable. If someone knows why it does not work with the traywindow itself, please tell me ;) // drawable. If someone knows why it does not work with the traywindow itself, please tell me ;)
Pixmap tmp_pmap = XCreatePixmap(server.dsp, traywin->win, traywin->width, traywin->height, 32); Pixmap tmp_pmap = XCreatePixmap(server.display, traywin->win, traywin->width, traywin->height, 32);
if (!tmp_pmap) { if (!tmp_pmap) {
goto on_systray_error; goto on_systray_error;
} }
XRenderPictFormat *f; XRenderPictFormat *f;
if (traywin->depth == 24) { if (traywin->depth == 24) {
f = XRenderFindStandardFormat(server.dsp, PictStandardRGB24); f = XRenderFindStandardFormat(server.display, PictStandardRGB24);
} else if (traywin->depth == 32) { } else if (traywin->depth == 32) {
f = XRenderFindStandardFormat(server.dsp, PictStandardARGB32); f = XRenderFindStandardFormat(server.display, PictStandardARGB32);
} else { } else {
fprintf(stderr, RED "Strange tray icon found with depth: %d\n" RESET, traywin->depth); fprintf(stderr, RED "Strange tray icon found with depth: %d\n" RESET, traywin->depth);
XFreePixmap(server.dsp, tmp_pmap); XFreePixmap(server.display, tmp_pmap);
return; return;
} }
XRenderPictFormat *f32 = XRenderFindVisualFormat(server.dsp, server.visual32); XRenderPictFormat *f32 = XRenderFindVisualFormat(server.display, server.visual32);
if (!f || !f32) { if (!f || !f32) {
XFreePixmap(server.dsp, tmp_pmap); XFreePixmap(server.display, tmp_pmap);
goto on_systray_error; goto on_systray_error;
} }
XSync(server.dsp, False); XSync(server.display, False);
error = FALSE; error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler); XErrorHandler old = XSetErrorHandler(window_error_handler);
// if (server.real_transparency) // if (server.real_transparency)
// Picture pict_image = XRenderCreatePicture(server.dsp, traywin->parent, f, 0, 0); // Picture pict_image = XRenderCreatePicture(server.display, traywin->parent, f, 0, 0);
// reverted Rev 407 because here it's breaking alls icon with systray + xcompmgr // reverted Rev 407 because here it's breaking alls icon with systray + xcompmgr
Picture pict_image = XRenderCreatePicture(server.dsp, traywin->win, f, 0, 0); Picture pict_image = XRenderCreatePicture(server.display, traywin->win, f, 0, 0);
if (!pict_image) { if (!pict_image) {
XFreePixmap(server.dsp, tmp_pmap); XFreePixmap(server.display, tmp_pmap);
XSetErrorHandler(old); XSetErrorHandler(old);
goto on_error; goto on_error;
} }
Picture pict_drawable = Picture pict_drawable =
XRenderCreatePicture(server.dsp, tmp_pmap, XRenderFindVisualFormat(server.dsp, server.visual32), 0, 0); XRenderCreatePicture(server.display, tmp_pmap, XRenderFindVisualFormat(server.display, server.visual32), 0, 0);
if (!pict_drawable) { if (!pict_drawable) {
XRenderFreePicture(server.dsp, pict_image); XRenderFreePicture(server.display, pict_image);
XFreePixmap(server.dsp, tmp_pmap); XFreePixmap(server.display, tmp_pmap);
XSetErrorHandler(old); XSetErrorHandler(old);
goto on_error; goto on_error;
} }
XRenderComposite(server.dsp, XRenderComposite(server.display,
PictOpSrc, PictOpSrc,
pict_image, pict_image,
None, None,
@ -1314,8 +1314,8 @@ void systray_render_icon_composited(void *t)
0, 0,
traywin->width, traywin->width,
traywin->height); traywin->height);
XRenderFreePicture(server.dsp, pict_image); XRenderFreePicture(server.display, pict_image);
XRenderFreePicture(server.dsp, pict_drawable); XRenderFreePicture(server.display, pict_drawable);
// end of the ugly hack and we can continue as before // end of the ugly hack and we can continue as before
imlib_context_set_visual(server.visual32); imlib_context_set_visual(server.visual32);
@ -1324,7 +1324,7 @@ void systray_render_icon_composited(void *t)
Imlib_Image image = imlib_create_image_from_drawable(0, 0, 0, traywin->width, traywin->height, 1); Imlib_Image image = imlib_create_image_from_drawable(0, 0, 0, traywin->width, traywin->height, 1);
imlib_context_set_visual(server.visual); imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap); imlib_context_set_colormap(server.colormap);
XFreePixmap(server.dsp, tmp_pmap); XFreePixmap(server.display, tmp_pmap);
if (!image) { if (!image) {
imlib_context_set_visual(server.visual); imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap); imlib_context_set_colormap(server.colormap);
@ -1360,8 +1360,8 @@ void systray_render_icon_composited(void *t)
systray_render_icon_from_image(traywin); systray_render_icon_from_image(traywin);
if (traywin->damage) if (traywin->damage)
XDamageSubtract(server.dsp, traywin->damage, None, None); XDamageSubtract(server.display, traywin->damage, None, None);
XSync(server.dsp, False); XSync(server.display, False);
XSetErrorHandler(old); XSetErrorHandler(old);
if (error) if (error)
@ -1446,7 +1446,7 @@ void systray_render_icon(void *t)
} }
if (systray_composited) { if (systray_composited) {
XSync(server.dsp, False); XSync(server.display, False);
error = FALSE; error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler); XErrorHandler old = XSetErrorHandler(window_error_handler);
@ -1454,7 +1454,7 @@ void systray_render_icon(void *t)
int xpos, ypos; int xpos, ypos;
unsigned int width, height, depth; unsigned int width, height, depth;
Window root; Window root;
if (!XGetGeometry(server.dsp, traywin->win, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) { if (!XGetGeometry(server.display, traywin->win, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) {
stop_timeout(traywin->render_timeout); stop_timeout(traywin->render_timeout);
if (!traywin->resize_timeout) if (!traywin->resize_timeout)
traywin->render_timeout = traywin->render_timeout =
@ -1493,14 +1493,14 @@ void systray_render_icon(void *t)
// Trigger window repaint // Trigger window repaint
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XClearArea(server.dsp, traywin->parent = %ld, 0, 0, traywin->width, traywin->height, True)\n", "XClearArea(server.display, traywin->parent = %ld, 0, 0, traywin->width, traywin->height, True)\n",
traywin->parent); traywin->parent);
XClearArea(server.dsp, traywin->parent, 0, 0, 0, 0, True); XClearArea(server.display, traywin->parent, 0, 0, 0, 0, True);
if (systray_profile) if (systray_profile)
fprintf(stderr, fprintf(stderr,
"XClearArea(server.dsp, traywin->win = %ld, 0, 0, traywin->width, traywin->height, True)\n", "XClearArea(server.display, traywin->win = %ld, 0, 0, traywin->width, traywin->height, True)\n",
traywin->win); traywin->win);
XClearArea(server.dsp, traywin->win, 0, 0, 0, 0, True); XClearArea(server.display, traywin->win, 0, 0, 0, 0, True);
} }
} }

16
src/taskbar/task.c
View file

@ -53,8 +53,8 @@ Task *add_task(Window win)
return NULL; return NULL;
} }
XSelectInput(server.dsp, win, PropertyChangeMask | StructureNotifyMask); XSelectInput(server.display, win, PropertyChangeMask | StructureNotifyMask);
XFlush(server.dsp); XFlush(server.display);
int monitor = 0; int monitor = 0;
if (num_panels > 1) { if (num_panels > 1) {
@ -180,7 +180,7 @@ void remove_task(Task *task)
task->icon_press[k] = 0; task->icon_press[k] = 0;
} }
if (task->state_pix[k]) if (task->state_pix[k])
XFreePixmap(server.dsp, task->state_pix[k]); XFreePixmap(server.display, task->state_pix[k]);
} }
GPtrArray *task_group = g_hash_table_lookup(win_to_task, &win); GPtrArray *task_group = g_hash_table_lookup(win_to_task, &win);
@ -281,7 +281,7 @@ void get_icon(Task *task)
#endif #endif
} else { } else {
// get Pixmap icon // get Pixmap icon
hints = XGetWMHints(server.dsp, task->win); hints = XGetWMHints(server.display, task->win);
if (hints) { if (hints) {
if (hints->flags & IconPixmapHint && hints->icon_pixmap != 0) { if (hints->flags & IconPixmapHint && hints->icon_pixmap != 0) {
// get width, height and depth for the pixmap // get width, height and depth for the pixmap
@ -291,7 +291,7 @@ void get_icon(Task *task)
uint w, h; uint w, h;
// printf(" get pixmap\n"); // printf(" get pixmap\n");
XGetGeometry(server.dsp, hints->icon_pixmap, &root, &icon_x, &icon_y, &w, &h, &border_width, &bpp); XGetGeometry(server.display, hints->icon_pixmap, &root, &icon_x, &icon_y, &w, &h, &border_width, &bpp);
imlib_context_set_drawable(hints->icon_pixmap); imlib_context_set_drawable(hints->icon_pixmap);
img = imlib_create_image_from_drawable(hints->icon_mask, 0, 0, w, h, 0); img = imlib_create_image_from_drawable(hints->icon_mask, 0, 0, w, h, 0);
} }
@ -446,7 +446,7 @@ void on_change_task(void *obj)
Panel *panel = (Panel *)task->area.panel; Panel *panel = (Panel *)task->area.panel;
long value[] = {panel->posx + task->area.posx, panel->posy + task->area.posy, task->area.width, task->area.height}; long value[] = {panel->posx + task->area.posx, panel->posy + task->area.posy, task->area.width, task->area.height};
XChangeProperty(server.dsp, XChangeProperty(server.display,
task->win, task->win,
server.atom._NET_WM_ICON_GEOMETRY, server.atom._NET_WM_ICON_GEOMETRY,
XA_CARDINAL, XA_CARDINAL,
@ -540,7 +540,7 @@ void reset_active_task()
if (w1) { if (w1) {
if (!task_get_tasks(w1)) { if (!task_get_tasks(w1)) {
Window w2; Window w2;
while (XGetTransientForHint(server.dsp, w1, &w2)) while (XGetTransientForHint(server.display, w1, &w2))
w1 = w2; w1 = w2;
} }
set_task_state((active_task = task_get_task(w1)), TASK_ACTIVE); set_task_state((active_task = task_get_task(w1)), TASK_ACTIVE);
@ -617,7 +617,7 @@ void set_task_redraw(Task *task)
{ {
for (int k = 0; k < TASK_STATE_COUNT; ++k) { for (int k = 0; k < TASK_STATE_COUNT; ++k) {
if (task->state_pix[k]) if (task->state_pix[k])
XFreePixmap(server.dsp, task->state_pix[k]); XFreePixmap(server.display, task->state_pix[k]);
task->state_pix[k] = 0; task->state_pix[k] = 0;
} }
task->area.pix = 0; task->area.pix = 0;

4
src/taskbar/taskbar.c
View file

@ -101,7 +101,7 @@ void cleanup_taskbar()
Taskbar *taskbar = &panel->taskbar[j]; Taskbar *taskbar = &panel->taskbar[j];
for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) { for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (taskbar->state_pix[k]) if (taskbar->state_pix[k])
XFreePixmap(server.dsp, taskbar->state_pix[k]); XFreePixmap(server.display, taskbar->state_pix[k]);
taskbar->state_pix[k] = 0; taskbar->state_pix[k] = 0;
} }
free_area(&taskbar->area); free_area(&taskbar->area);
@ -425,7 +425,7 @@ void on_change_taskbar(void *obj)
// reset Pixmap when position/size changed // reset Pixmap when position/size changed
for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) { for (int k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (taskbar->state_pix[k]) if (taskbar->state_pix[k])
XFreePixmap(server.dsp, taskbar->state_pix[k]); XFreePixmap(server.display, taskbar->state_pix[k]);
taskbar->state_pix[k] = 0; taskbar->state_pix[k] = 0;
} }
taskbar->area.pix = 0; taskbar->area.pix = 0;

2
src/taskbar/taskbarname.c
View file

@ -127,7 +127,7 @@ void cleanup_taskbarname()
free_area(&taskbar->bar_name.area); free_area(&taskbar->bar_name.area);
for (k = 0; k < TASKBAR_STATE_COUNT; ++k) { for (k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (taskbar->bar_name.state_pix[k]) if (taskbar->bar_name.state_pix[k])
XFreePixmap(server.dsp, taskbar->bar_name.state_pix[k]); XFreePixmap(server.display, taskbar->bar_name.state_pix[k]);
taskbar->bar_name.state_pix[k] = 0; taskbar->bar_name.state_pix[k] = 0;
} }
remove_area((Area *)&taskbar->bar_name); remove_area((Area *)&taskbar->bar_name);

138
src/tint.c
View file

@ -78,7 +78,7 @@ void detect_compositor(void *arg)
} }
// No compositor, check for one // No compositor, check for one
if (XGetSelectionOwner(server.dsp, server.atom._NET_WM_CM_S0) != None) { if (XGetSelectionOwner(server.display, server.atom._NET_WM_CM_S0) != None) {
stop_timeout(detect_compositor_timer); stop_timeout(detect_compositor_timer);
// Restart tint2 // Restart tint2
fprintf(stderr, "Detected compositor, restarting tint2...\n"); fprintf(stderr, "Detected compositor, restarting tint2...\n");
@ -236,14 +236,14 @@ static void sigchld_handler_async()
void init_X11_pre_config() void init_X11_pre_config()
{ {
server.dsp = XOpenDisplay(NULL); server.display = XOpenDisplay(NULL);
if (!server.dsp) { if (!server.display) {
fprintf(stderr, "tint2 exit : could not open display.\n"); fprintf(stderr, "tint2 exit : could not open display.\n");
exit(0); exit(0);
} }
server_init_atoms(); server_init_atoms();
server.screen = DefaultScreen(server.dsp); server.screen = DefaultScreen(server.display);
server.root_win = RootWindow(server.dsp, server.screen); server.root_win = RootWindow(server.display, server.screen);
server.desktop = get_current_desktop(); server.desktop = get_current_desktop();
setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
@ -251,7 +251,7 @@ void init_X11_pre_config()
setlocale(LC_NUMERIC, "POSIX"); setlocale(LC_NUMERIC, "POSIX");
/* Catch events */ /* Catch events */
XSelectInput(server.dsp, server.root_win, PropertyChangeMask | StructureNotifyMask); XSelectInput(server.display, server.root_win, PropertyChangeMask | StructureNotifyMask);
// get monitor and desktop config // get monitor and desktop config
get_monitors(); get_monitors();
@ -259,7 +259,7 @@ void init_X11_pre_config()
server.disable_transparency = 0; server.disable_transparency = 0;
xsettings_client = xsettings_client_new(server.dsp, server.screen, xsettings_notify_cb, NULL, NULL); xsettings_client = xsettings_client_new(server.display, server.screen, xsettings_notify_cb, NULL, NULL);
} }
void init_X11_post_config() void init_X11_post_config()
@ -270,7 +270,7 @@ void init_X11_post_config()
#ifdef HAVE_SN #ifdef HAVE_SN
// Initialize startup-notification // Initialize startup-notification
if (startup_notifications) { if (startup_notifications) {
server.sn_dsp = sn_display_new(server.dsp, error_trap_push, error_trap_pop); server.sn_display = sn_display_new(server.display, error_trap_push, error_trap_pop);
server.pids = g_tree_new(cmp_ptr); server.pids = g_tree_new(cmp_ptr);
// Setup a handler for child termination // Setup a handler for child termination
if (pipe(sn_pipe) != 0) { if (pipe(sn_pipe) != 0) {
@ -289,7 +289,7 @@ void init_X11_post_config()
} }
#endif // HAVE_SN #endif // HAVE_SN
imlib_context_set_display(server.dsp); imlib_context_set_display(server.display);
imlib_context_set_visual(server.visual); imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap); imlib_context_set_colormap(server.colormap);
@ -328,9 +328,9 @@ void cleanup()
cleanup_server(); cleanup_server();
cleanup_timeout(); cleanup_timeout();
if (server.dsp) if (server.display)
XCloseDisplay(server.dsp); XCloseDisplay(server.display);
server.dsp = NULL; server.display = NULL;
#ifdef HAVE_SN #ifdef HAVE_SN
if (startup_notifications) { if (startup_notifications) {
@ -352,7 +352,7 @@ void get_snapshot(const char *path)
if (panel->area.width > server.monitors[0].width) if (panel->area.width > server.monitors[0].width)
panel->area.width = server.monitors[0].width; panel->area.width = server.monitors[0].width;
panel->temp_pmap = XCreatePixmap(server.dsp, server.root_win, panel->area.width, panel->area.height, server.depth); panel->temp_pmap = XCreatePixmap(server.display, server.root_win, panel->area.width, panel->area.height, server.depth);
render_panel(panel); render_panel(panel);
Imlib_Image img = NULL; Imlib_Image img = NULL;
@ -383,11 +383,11 @@ void window_action(Task *task, MouseAction action)
activate_window(task->win); activate_window(task->win);
break; break;
case ICONIFY: case ICONIFY:
XIconifyWindow(server.dsp, task->win, server.screen); XIconifyWindow(server.display, task->win, server.screen);
break; break;
case TOGGLE_ICONIFY: case TOGGLE_ICONIFY:
if (active_task && task->win == active_task->win) if (active_task && task->win == active_task->win)
XIconifyWindow(server.dsp, task->win, server.screen); XIconifyWindow(server.display, task->win, server.screen);
else else
activate_window(task->win); activate_window(task->win);
break; break;
@ -481,15 +481,15 @@ int tint2_handles_click(Panel *panel, XButtonEvent *e)
void forward_click(XEvent *e) void forward_click(XEvent *e)
{ {
// forward the click to the desktop window (thanks conky) // forward the click to the desktop window (thanks conky)
XUngrabPointer(server.dsp, e->xbutton.time); XUngrabPointer(server.display, e->xbutton.time);
e->xbutton.window = server.root_win; e->xbutton.window = server.root_win;
// icewm doesn't open under the mouse. // icewm doesn't open under the mouse.
// and xfce doesn't open at all. // and xfce doesn't open at all.
e->xbutton.x = e->xbutton.x_root; e->xbutton.x = e->xbutton.x_root;
e->xbutton.y = e->xbutton.y_root; e->xbutton.y = e->xbutton.y_root;
// printf("**** %d, %d\n", e->xbutton.x, e->xbutton.y); // printf("**** %d, %d\n", e->xbutton.x, e->xbutton.y);
// XSetInputFocus(server.dsp, e->xbutton.window, RevertToParent, e->xbutton.time); // XSetInputFocus(server.display, e->xbutton.window, RevertToParent, e->xbutton.time);
XSendEvent(server.dsp, e->xbutton.window, False, ButtonPressMask, e); XSendEvent(server.display, e->xbutton.window, False, ButtonPressMask, e);
} }
void event_button_press(XEvent *e) void event_button_press(XEvent *e)
@ -505,7 +505,7 @@ void event_button_press(XEvent *e)
task_drag = click_task(panel, e->xbutton.x, e->xbutton.y); task_drag = click_task(panel, e->xbutton.x, e->xbutton.y);
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
} }
void event_button_motion_notify(XEvent *e) void event_button_motion_notify(XEvent *e)
@ -581,7 +581,7 @@ void event_button_release(XEvent *e)
if (wm_menu && !tint2_handles_click(panel, &e->xbutton)) { if (wm_menu && !tint2_handles_click(panel, &e->xbutton)) {
forward_click(e); forward_click(e);
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
task_drag = 0; task_drag = 0;
return; return;
} }
@ -614,7 +614,7 @@ void event_button_release(XEvent *e)
if (click_clock(panel, e->xbutton.x, e->xbutton.y)) { if (click_clock(panel, e->xbutton.x, e->xbutton.y)) {
clock_action(e->xbutton.button); clock_action(e->xbutton.button);
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
task_drag = 0; task_drag = 0;
return; return;
} }
@ -623,7 +623,7 @@ void event_button_release(XEvent *e)
if (click_battery(panel, e->xbutton.x, e->xbutton.y)) { if (click_battery(panel, e->xbutton.x, e->xbutton.y)) {
battery_action(e->xbutton.button); battery_action(e->xbutton.button);
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
task_drag = 0; task_drag = 0;
return; return;
} }
@ -633,7 +633,7 @@ void event_button_release(XEvent *e)
if (execp) { if (execp) {
execp_action(execp, e->xbutton.button); execp_action(execp, e->xbutton.button);
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
task_drag = 0; task_drag = 0;
return; return;
} }
@ -651,7 +651,7 @@ void event_button_release(XEvent *e)
if (!(taskbar = click_taskbar(panel, e->xbutton.x, e->xbutton.y))) { if (!(taskbar = click_taskbar(panel, e->xbutton.x, e->xbutton.y))) {
// TODO: check better solution to keep window below // TODO: check better solution to keep window below
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
task_drag = 0; task_drag = 0;
return; return;
} }
@ -689,7 +689,7 @@ void event_button_release(XEvent *e)
// to keep window below // to keep window below
if (panel_layer == BOTTOM_LAYER) if (panel_layer == BOTTOM_LAYER)
XLowerWindow(server.dsp, panel->main_win); XLowerWindow(server.display, panel->main_win);
} }
void update_desktop_names() void update_desktop_names()
@ -745,7 +745,7 @@ void event_property_notify(XEvent *e)
xsettings_client_process_event(xsettings_client, e); xsettings_client_process_event(xsettings_client, e);
if (win == server.root_win) { if (win == server.root_win) {
if (!server.got_root_win) { if (!server.got_root_win) {
XSelectInput(server.dsp, server.root_win, PropertyChangeMask | StructureNotifyMask); XSelectInput(server.display, server.root_win, PropertyChangeMask | StructureNotifyMask);
server.got_root_win = TRUE; server.got_root_win = TRUE;
} }
@ -871,7 +871,7 @@ void event_property_notify(XEvent *e)
} else { } else {
Task *task = task_get_task(win); Task *task = task_get_task(win);
if (debug) { if (debug) {
char *atom_name = XGetAtomName(server.dsp, at); char *atom_name = XGetAtomName(server.display, at);
fprintf(stderr, "%s %d: win = %ld, task = %s, atom = %s\n", __FUNCTION__, __LINE__, win, task ? (task->title ? task->title : "??") : "null", atom_name); fprintf(stderr, "%s %d: win = %ld, task = %s, atom = %s\n", __FUNCTION__, __LINE__, win, task ? (task->title ? task->title : "??") : "null", atom_name);
XFree(atom_name); XFree(atom_name);
} }
@ -882,7 +882,7 @@ void event_property_notify(XEvent *e)
// xfce4 sends _NET_WM_STATE after minimized to tray, so we need to check if window is mapped // xfce4 sends _NET_WM_STATE after minimized to tray, so we need to check if window is mapped
// if it is mapped and not set as skip_taskbar, we must add it to our task list // if it is mapped and not set as skip_taskbar, we must add it to our task list
XWindowAttributes wa; XWindowAttributes wa;
XGetWindowAttributes(server.dsp, win, &wa); XGetWindowAttributes(server.display, win, &wa);
if (wa.map_state == IsViewable && !window_is_skip_taskbar(win)) { if (wa.map_state == IsViewable && !window_is_skip_taskbar(win)) {
if ((task = add_task(win))) if ((task = add_task(win)))
panel_refresh = TRUE; panel_refresh = TRUE;
@ -890,7 +890,7 @@ void event_property_notify(XEvent *e)
} }
return; return;
} }
// printf("atom root_win = %s, %s\n", XGetAtomName(server.dsp, at), task->title); // printf("atom root_win = %s, %s\n", XGetAtomName(server.display, at), task->title);
// Window title changed // Window title changed
if (at == server.atom._NET_WM_VISIBLE_NAME || at == server.atom._NET_WM_NAME || at == server.atom.WM_NAME) { if (at == server.atom._NET_WM_VISIBLE_NAME || at == server.atom._NET_WM_NAME || at == server.atom.WM_NAME) {
@ -910,7 +910,7 @@ void event_property_notify(XEvent *e)
int count; int count;
Atom *atom_state = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count); Atom *atom_state = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
char *atom_state_name = XGetAtomName(server.dsp, atom_state[j]); char *atom_state_name = XGetAtomName(server.display, atom_state[j]);
fprintf(stderr, "%s %d: _NET_WM_STATE = %s\n", __FUNCTION__, __LINE__, atom_state_name); fprintf(stderr, "%s %d: _NET_WM_STATE = %s\n", __FUNCTION__, __LINE__, atom_state_name);
XFree(atom_state_name); XFree(atom_state_name);
} }
@ -945,7 +945,7 @@ void event_property_notify(XEvent *e)
update_task_desktop(task); update_task_desktop(task);
} }
} else if (at == server.atom.WM_HINTS) { } else if (at == server.atom.WM_HINTS) {
XWMHints *wmhints = XGetWMHints(server.dsp, win); XWMHints *wmhints = XGetWMHints(server.display, win);
if (wmhints && wmhints->flags & XUrgencyHint) { if (wmhints && wmhints->flags & XUrgencyHint) {
add_urgent(task); add_urgent(task);
} }
@ -953,7 +953,7 @@ void event_property_notify(XEvent *e)
} }
if (!server.got_root_win) if (!server.got_root_win)
server.root_win = RootWindow(server.dsp, server.screen); server.root_win = RootWindow(server.display, server.screen);
} }
} }
@ -1154,24 +1154,24 @@ void dnd_enter(XClientMessageEvent *e)
fprintf(stderr, "DnD %s:%d: DnDEnter\n", __FILE__, __LINE__); fprintf(stderr, "DnD %s:%d: DnDEnter\n", __FILE__, __LINE__);
fprintf(stderr, "DnD %s:%d: DnDEnter. Supports > 3 types = %s\n", __FILE__, __LINE__, more_than_3 ? "yes" : "no"); fprintf(stderr, "DnD %s:%d: DnDEnter. Supports > 3 types = %s\n", __FILE__, __LINE__, more_than_3 ? "yes" : "no");
fprintf(stderr, "DnD %s:%d: Protocol version = %d\n", __FILE__, __LINE__, dnd_version); fprintf(stderr, "DnD %s:%d: Protocol version = %d\n", __FILE__, __LINE__, dnd_version);
fprintf(stderr, "DnD %s:%d: Type 1 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e->data.l[2])); fprintf(stderr, "DnD %s:%d: Type 1 = %s\n", __FILE__, __LINE__, GetAtomName(server.display, e->data.l[2]));
fprintf(stderr, "DnD %s:%d: Type 2 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e->data.l[3])); fprintf(stderr, "DnD %s:%d: Type 2 = %s\n", __FILE__, __LINE__, GetAtomName(server.display, e->data.l[3]));
fprintf(stderr, "DnD %s:%d: Type 3 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e->data.l[4])); fprintf(stderr, "DnD %s:%d: Type 3 = %s\n", __FILE__, __LINE__, GetAtomName(server.display, e->data.l[4]));
// Query which conversions are available and pick the best // Query which conversions are available and pick the best
if (more_than_3) { if (more_than_3) {
// Fetch the list of possible conversions // Fetch the list of possible conversions
// Notice the similarity to TARGETS with paste. // Notice the similarity to TARGETS with paste.
Property p = read_property(server.dsp, dnd_source_window, server.atom.XdndTypeList); Property p = read_property(server.display, dnd_source_window, server.atom.XdndTypeList);
dnd_atom = pick_target_from_targets(server.dsp, p); dnd_atom = pick_target_from_targets(server.display, p);
XFree(p.data); XFree(p.data);
} else { } else {
// Use the available list // Use the available list
dnd_atom = pick_target_from_atoms(server.dsp, e->data.l[2], e->data.l[3], e->data.l[4]); dnd_atom = pick_target_from_atoms(server.display, e->data.l[2], e->data.l[3], e->data.l[4]);
} }
fprintf(stderr, "DnD %s:%d: Requested type = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, dnd_atom)); fprintf(stderr, "DnD %s:%d: Requested type = %s\n", __FILE__, __LINE__, GetAtomName(server.display, dnd_atom));
} }
void dnd_position(XClientMessageEvent *e) void dnd_position(XClientMessageEvent *e)
@ -1183,7 +1183,7 @@ void dnd_position(XClientMessageEvent *e)
Window child; Window child;
x = (e->data.l[2] >> 16) & 0xFFFF; x = (e->data.l[2] >> 16) & 0xFFFF;
y = e->data.l[2] & 0xFFFF; y = e->data.l[2] & 0xFFFF;
XTranslateCoordinates(server.dsp, server.root_win, e->window, x, y, &mapX, &mapY, &child); XTranslateCoordinates(server.display, server.root_win, e->window, x, y, &mapX, &mapY, &child);
Task *task = click_task(panel, mapX, mapY); Task *task = click_task(panel, mapX, mapY);
if (task) { if (task) {
if (task->desktop != server.desktop) if (task->desktop != server.desktop)
@ -1215,21 +1215,21 @@ void dnd_position(XClientMessageEvent *e)
se.data.l[4] = None; // None = drop will not be accepted se.data.l[4] = None; // None = drop will not be accepted
} }
XSendEvent(server.dsp, e->data.l[0], False, NoEventMask, (XEvent *)&se); XSendEvent(server.display, e->data.l[0], False, NoEventMask, (XEvent *)&se);
} }
void dnd_drop(XClientMessageEvent *e) void dnd_drop(XClientMessageEvent *e)
{ {
if (dnd_target_window && dnd_launcher_exec) { if (dnd_target_window && dnd_launcher_exec) {
if (dnd_version >= 1) { if (dnd_version >= 1) {
XConvertSelection(server.dsp, XConvertSelection(server.display,
server.atom.XdndSelection, server.atom.XdndSelection,
XA_STRING, XA_STRING,
dnd_selection, dnd_selection,
dnd_target_window, dnd_target_window,
e->data.l[2]); e->data.l[2]);
} else { } else {
XConvertSelection(server.dsp, XConvertSelection(server.display,
server.atom.XdndSelection, server.atom.XdndSelection,
XA_STRING, XA_STRING,
dnd_selection, dnd_selection,
@ -1249,7 +1249,7 @@ void dnd_drop(XClientMessageEvent *e)
m.data.l[0] = dnd_target_window; m.data.l[0] = dnd_target_window;
m.data.l[1] = 0; m.data.l[1] = 0;
m.data.l[2] = None; // Failed. m.data.l[2] = None; // Failed.
XSendEvent(server.dsp, e->data.l[0], False, NoEventMask, (XEvent *)&m); XSendEvent(server.display, e->data.l[0], False, NoEventMask, (XEvent *)&m);
} }
} }
@ -1278,15 +1278,15 @@ start:
} }
int damage_event, damage_error; int damage_event, damage_error;
XDamageQueryExtension(server.dsp, &damage_event, &damage_error); XDamageQueryExtension(server.display, &damage_event, &damage_error);
int x11_fd = ConnectionNumber(server.dsp); int x11_fd = ConnectionNumber(server.display);
XSync(server.dsp, False); XSync(server.display, False);
// XDND initialization // XDND initialization
dnd_source_window = 0; dnd_source_window = 0;
dnd_target_window = 0; dnd_target_window = 0;
dnd_version = 0; dnd_version = 0;
dnd_selection = XInternAtom(server.dsp, "PRIMARY", 0); dnd_selection = XInternAtom(server.display, "PRIMARY", 0);
dnd_atom = None; dnd_atom = None;
dnd_sent_request = 0; dnd_sent_request = 0;
dnd_launcher_exec = 0; dnd_launcher_exec = 0;
@ -1304,7 +1304,7 @@ start:
Panel *panel = &panels[i]; Panel *panel = &panels[i];
if (panel->is_hidden) { if (panel->is_hidden) {
XCopyArea(server.dsp, XCopyArea(server.display,
panel->hidden_pixmap, panel->hidden_pixmap,
panel->main_win, panel->main_win,
server.gc, server.gc,
@ -1314,21 +1314,21 @@ start:
panel->hidden_height, panel->hidden_height,
0, 0,
0); 0);
XSetWindowBackgroundPixmap(server.dsp, panel->main_win, panel->hidden_pixmap); XSetWindowBackgroundPixmap(server.display, panel->main_win, panel->hidden_pixmap);
} else { } else {
if (panel->temp_pmap) if (panel->temp_pmap)
XFreePixmap(server.dsp, panel->temp_pmap); XFreePixmap(server.display, panel->temp_pmap);
panel->temp_pmap = panel->temp_pmap =
XCreatePixmap(server.dsp, server.root_win, panel->area.width, panel->area.height, server.depth); XCreatePixmap(server.display, server.root_win, panel->area.width, panel->area.height, server.depth);
render_panel(panel); render_panel(panel);
if (panel == (Panel *)systray.area.panel) { if (panel == (Panel *)systray.area.panel) {
if (refresh_systray && panel && !panel->is_hidden) { if (refresh_systray && panel && !panel->is_hidden) {
refresh_systray = FALSE; refresh_systray = FALSE;
XSetWindowBackgroundPixmap(server.dsp, panel->main_win, panel->temp_pmap); XSetWindowBackgroundPixmap(server.display, panel->main_win, panel->temp_pmap);
refresh_systray_icons(); refresh_systray_icons();
} }
} }
XCopyArea(server.dsp, XCopyArea(server.display,
panel->temp_pmap, panel->temp_pmap,
panel->main_win, panel->main_win,
server.gc, server.gc,
@ -1340,7 +1340,7 @@ start:
0); 0);
} }
} }
XFlush(server.dsp); XFlush(server.display);
} }
// Create a File Description Set containing x11_fd // Create a File Description Set containing x11_fd
@ -1368,7 +1368,7 @@ start:
struct timeval *select_timeout = (next_timeout.tv_sec >= 0 && next_timeout.tv_usec >= 0) ? &next_timeout : NULL; struct timeval *select_timeout = (next_timeout.tv_sec >= 0 && next_timeout.tv_usec >= 0) ? &next_timeout : NULL;
// Wait for X Event or a Timer // Wait for X Event or a Timer
if (XPending(server.dsp) > 0 || select(maxfd + 1, &fdset, 0, 0, select_timeout) >= 0) { if (XPending(server.display) > 0 || select(maxfd + 1, &fdset, 0, 0, select_timeout) >= 0) {
uevent_handler(); uevent_handler();
if (sn_pipe_valid) { if (sn_pipe_valid) {
@ -1388,12 +1388,12 @@ start:
} }
} }
} }
if (XPending(server.dsp) > 0) { if (XPending(server.display) > 0) {
XEvent e; XEvent e;
XNextEvent(server.dsp, &e); XNextEvent(server.display, &e);
#if HAVE_SN #if HAVE_SN
if (startup_notifications) if (startup_notifications)
sn_display_process_event(server.sn_dsp, &e); sn_display_process_event(server.sn_display, &e);
#endif // HAVE_SN #endif // HAVE_SN
Panel *panel = get_panel(e.xany.window); Panel *panel = get_panel(e.xany.window);
@ -1560,32 +1560,32 @@ start:
"DnD %s:%d: Selection atom = %s\n", "DnD %s:%d: Selection atom = %s\n",
__FILE__, __FILE__,
__LINE__, __LINE__,
GetAtomName(server.dsp, e.xselection.selection)); GetAtomName(server.display, e.xselection.selection));
fprintf(stderr, fprintf(stderr,
"DnD %s:%d: Target atom = %s\n", "DnD %s:%d: Target atom = %s\n",
__FILE__, __FILE__,
__LINE__, __LINE__,
GetAtomName(server.dsp, target)); GetAtomName(server.display, target));
fprintf(stderr, fprintf(stderr,
"DnD %s:%d: Property atom = %s\n", "DnD %s:%d: Property atom = %s\n",
__FILE__, __FILE__,
__LINE__, __LINE__,
GetAtomName(server.dsp, e.xselection.property)); GetAtomName(server.display, e.xselection.property));
if (e.xselection.property != None && dnd_launcher_exec) { if (e.xselection.property != None && dnd_launcher_exec) {
Property prop = read_property(server.dsp, dnd_target_window, dnd_selection); Property prop = read_property(server.display, dnd_target_window, dnd_selection);
// If we're being given a list of targets (possible conversions) // If we're being given a list of targets (possible conversions)
if (target == server.atom.TARGETS && !dnd_sent_request) { if (target == server.atom.TARGETS && !dnd_sent_request) {
dnd_sent_request = 1; dnd_sent_request = 1;
dnd_atom = pick_target_from_targets(server.dsp, prop); dnd_atom = pick_target_from_targets(server.display, prop);
if (dnd_atom == None) { if (dnd_atom == None) {
fprintf(stderr, "No matching datatypes.\n"); fprintf(stderr, "No matching datatypes.\n");
} else { } else {
// Request the data type we are able to select // Request the data type we are able to select
fprintf(stderr, "Now requsting type %s", GetAtomName(server.dsp, dnd_atom)); fprintf(stderr, "Now requsting type %s", GetAtomName(server.display, dnd_atom));
XConvertSelection(server.dsp, XConvertSelection(server.display,
dnd_selection, dnd_selection,
dnd_atom, dnd_atom,
dnd_selection, dnd_selection,
@ -1656,15 +1656,15 @@ start:
XClientMessageEvent m; XClientMessageEvent m;
memset(&m, 0, sizeof(m)); memset(&m, 0, sizeof(m));
m.type = ClientMessage; m.type = ClientMessage;
m.display = server.dsp; m.display = server.display;
m.window = dnd_source_window; m.window = dnd_source_window;
m.message_type = server.atom.XdndFinished; m.message_type = server.atom.XdndFinished;
m.format = 32; m.format = 32;
m.data.l[0] = dnd_target_window; m.data.l[0] = dnd_target_window;
m.data.l[1] = 1; m.data.l[1] = 1;
m.data.l[2] = server.atom.XdndActionCopy; // We only ever copy. m.data.l[2] = server.atom.XdndActionCopy; // We only ever copy.
XSendEvent(server.dsp, dnd_source_window, False, NoEventMask, (XEvent *)&m); XSendEvent(server.display, dnd_source_window, False, NoEventMask, (XEvent *)&m);
XSync(server.dsp, False); XSync(server.display, False);
} }
XFree(prop.data); XFree(prop.data);

22
src/tooltip/tooltip.c
View file

@ -57,7 +57,7 @@ void cleanup_tooltip()
tooltip_hide(NULL); tooltip_hide(NULL);
tooltip_copy_text(NULL); tooltip_copy_text(NULL);
if (g_tooltip.window) if (g_tooltip.window)
XDestroyWindow(server.dsp, g_tooltip.window); XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = 0; g_tooltip.window = 0;
pango_font_description_free(g_tooltip.font_desc); pango_font_description_free(g_tooltip.font_desc);
g_tooltip.font_desc = NULL; g_tooltip.font_desc = NULL;
@ -77,8 +77,8 @@ void init_tooltip()
attr.border_pixel = 0; attr.border_pixel = 0;
unsigned long mask = CWEventMask | CWColormap | CWBorderPixel | CWBackPixel | CWOverrideRedirect; unsigned long mask = CWEventMask | CWColormap | CWBorderPixel | CWBackPixel | CWOverrideRedirect;
if (g_tooltip.window) if (g_tooltip.window)
XDestroyWindow(server.dsp, g_tooltip.window); XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = XCreateWindow(server.dsp, g_tooltip.window = XCreateWindow(server.display,
server.root_win, server.root_win,
0, 0,
0, 0,
@ -131,15 +131,15 @@ void tooltip_show(void *arg)
{ {
int mx, my; int mx, my;
Window w; Window w;
XTranslateCoordinates(server.dsp, server.root_win, g_tooltip.panel->main_win, x, y, &mx, &my, &w); XTranslateCoordinates(server.display, server.root_win, g_tooltip.panel->main_win, x, y, &mx, &my, &w);
Area *area; Area *area;
area = click_area(g_tooltip.panel, mx, my); area = click_area(g_tooltip.panel, mx, my);
if (!g_tooltip.mapped && area->_get_tooltip_text) { if (!g_tooltip.mapped && area->_get_tooltip_text) {
tooltip_copy_text(area); tooltip_copy_text(area);
g_tooltip.mapped = True; g_tooltip.mapped = True;
XMapWindow(server.dsp, g_tooltip.window); XMapWindow(server.display, g_tooltip.window);
tooltip_update(); tooltip_update();
XFlush(server.dsp); XFlush(server.display);
} }
} }
@ -148,7 +148,7 @@ void tooltip_update_geometry()
cairo_surface_t *cs; cairo_surface_t *cs;
cairo_t *c; cairo_t *c;
PangoLayout *layout; PangoLayout *layout;
cs = cairo_xlib_surface_create(server.dsp, g_tooltip.window, server.visual, width, height); cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
c = cairo_create(cs); c = cairo_create(cs);
layout = pango_cairo_create_layout(c); layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, g_tooltip.font_desc); pango_layout_set_font_description(layout, g_tooltip.font_desc);
@ -233,13 +233,13 @@ void tooltip_update()
just_shown = 0; just_shown = 0;
} }
tooltip_adjust_geometry(); tooltip_adjust_geometry();
XMoveResizeWindow(server.dsp, g_tooltip.window, x, y, width, height); XMoveResizeWindow(server.display, g_tooltip.window, x, y, width, height);
// Stuff for drawing the tooltip // Stuff for drawing the tooltip
cairo_surface_t *cs; cairo_surface_t *cs;
cairo_t *c; cairo_t *c;
PangoLayout *layout; PangoLayout *layout;
cs = cairo_xlib_surface_create(server.dsp, g_tooltip.window, server.visual, width, height); cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
c = cairo_create(cs); c = cairo_create(cs);
Color bc = g_tooltip.bg->fill_color; Color bc = g_tooltip.bg->fill_color;
Border b = g_tooltip.bg->border; Border b = g_tooltip.bg->border;
@ -297,8 +297,8 @@ void tooltip_hide(void *arg)
{ {
if (g_tooltip.mapped) { if (g_tooltip.mapped) {
g_tooltip.mapped = False; g_tooltip.mapped = False;
XUnmapWindow(server.dsp, g_tooltip.window); XUnmapWindow(server.display, g_tooltip.window);
XFlush(server.dsp); XFlush(server.display);
} }
} }

20
src/util/area.c
View file

@ -228,7 +228,7 @@ void draw_tree(Area *a)
} }
if (a->pix) if (a->pix)
XCopyArea(server.dsp, a->pix, ((Panel *)a->panel)->temp_pmap, server.gc, 0, 0, a->width, a->height, a->posx, a->posy); XCopyArea(server.display, a->pix, ((Panel *)a->panel)->temp_pmap, server.gc, 0, 0, a->width, a->height, a->posx, a->posy);
for (GList *l = a->children; l; l = l->next) for (GList *l = a->children; l; l = l->next)
draw_tree((Area *)l->data); draw_tree((Area *)l->data);
@ -329,13 +329,13 @@ void schedule_redraw(Area *a)
if (a->has_mouse_over_effect) { if (a->has_mouse_over_effect) {
for (int i = 0; i < MOUSE_STATE_COUNT; i++) { for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
XFreePixmap(server.dsp, a->pix_by_state[i]); XFreePixmap(server.display, a->pix_by_state[i]);
if (a->pix == a->pix_by_state[i]) if (a->pix == a->pix_by_state[i])
a->pix = None; a->pix = None;
a->pix_by_state[i] = None; a->pix_by_state[i] = None;
} }
if (a->pix) { if (a->pix) {
XFreePixmap(server.dsp, a->pix); XFreePixmap(server.display, a->pix);
a->pix = None; a->pix = None;
} }
} }
@ -371,19 +371,19 @@ void show(Area *a)
void draw(Area *a) void draw(Area *a)
{ {
if (a->pix) { if (a->pix) {
XFreePixmap(server.dsp, a->pix); XFreePixmap(server.display, a->pix);
if (a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] != a->pix) if (a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] != a->pix)
XFreePixmap(server.dsp, a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0]); XFreePixmap(server.display, a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0]);
} }
a->pix = XCreatePixmap(server.dsp, server.root_win, a->width, a->height, server.depth); a->pix = XCreatePixmap(server.display, server.root_win, a->width, a->height, server.depth);
a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] = a->pix; a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] = a->pix;
// Add layer of root pixmap (or clear pixmap if real_transparency==true) // Add layer of root pixmap (or clear pixmap if real_transparency==true)
if (server.real_transparency) if (server.real_transparency)
clear_pixmap(a->pix, 0, 0, a->width, a->height); clear_pixmap(a->pix, 0, 0, a->width, a->height);
XCopyArea(server.dsp, ((Panel *)a->panel)->temp_pmap, a->pix, server.gc, a->posx, a->posy, a->width, a->height, 0, 0); XCopyArea(server.display, ((Panel *)a->panel)->temp_pmap, a->pix, server.gc, a->posx, a->posy, a->width, a->height, 0, 0);
cairo_surface_t *cs = cairo_xlib_surface_create(server.dsp, a->pix, server.visual, a->width, a->height); cairo_surface_t *cs = cairo_xlib_surface_create(server.display, a->pix, server.visual, a->width, a->height);
cairo_t *c = cairo_create(cs); cairo_t *c = cairo_create(cs);
draw_background(a, c); draw_background(a, c);
@ -502,14 +502,14 @@ void free_area(Area *a)
a->children = NULL; a->children = NULL;
} }
for (int i = 0; i < MOUSE_STATE_COUNT; i++) { for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
XFreePixmap(server.dsp, a->pix_by_state[i]); XFreePixmap(server.display, a->pix_by_state[i]);
if (a->pix == a->pix_by_state[i]) { if (a->pix == a->pix_by_state[i]) {
a->pix = None; a->pix = None;
} }
a->pix_by_state[i] = None; a->pix_by_state[i] = None;
} }
if (a->pix) { if (a->pix) {
XFreePixmap(server.dsp, a->pix); XFreePixmap(server.display, a->pix);
a->pix = None; a->pix = None;
} }
if (mouse_over_area == a) { if (mouse_over_area == a) {

34
src/util/common.c
View file

@ -419,26 +419,26 @@ void render_image(Drawable d, int x, int y)
int w = imlib_image_get_width(), h = imlib_image_get_height(); int w = imlib_image_get_width(), h = imlib_image_get_height();
Pixmap pixmap = XCreatePixmap(server.dsp, server.root_win, w, h, 32); Pixmap pixmap = XCreatePixmap(server.display, server.root_win, w, h, 32);
imlib_context_set_drawable(pixmap); imlib_context_set_drawable(pixmap);
imlib_context_set_blend(0); imlib_context_set_blend(0);
imlib_render_image_on_drawable(0, 0); imlib_render_image_on_drawable(0, 0);
Pixmap mask = XCreatePixmap(server.dsp, server.root_win, w, h, 32); Pixmap mask = XCreatePixmap(server.display, server.root_win, w, h, 32);
imlib_context_set_drawable(mask); imlib_context_set_drawable(mask);
imlib_context_set_blend(0); imlib_context_set_blend(0);
imlib_render_image_on_drawable(0, 0); imlib_render_image_on_drawable(0, 0);
Picture pict = XRenderCreatePicture(server.dsp, pixmap, XRenderFindStandardFormat(server.dsp, PictStandardARGB32), 0, 0); Picture pict = XRenderCreatePicture(server.display, pixmap, XRenderFindStandardFormat(server.display, PictStandardARGB32), 0, 0);
Picture pict_drawable = XRenderCreatePicture(server.dsp, d, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0); Picture pict_drawable = XRenderCreatePicture(server.display, d, XRenderFindVisualFormat(server.display, server.visual), 0, 0);
Picture pict_mask = XRenderCreatePicture(server.dsp, mask, XRenderFindStandardFormat(server.dsp, PictStandardARGB32), 0, 0); Picture pict_mask = XRenderCreatePicture(server.display, mask, XRenderFindStandardFormat(server.display, PictStandardARGB32), 0, 0);
XRenderComposite(server.dsp, PictOpOver, pict, pict_mask, pict_drawable, 0, 0, 0, 0, x, y, w, h); XRenderComposite(server.display, PictOpOver, pict, pict_mask, pict_drawable, 0, 0, 0, 0, x, y, w, h);
XRenderFreePicture(server.dsp, pict_mask); XRenderFreePicture(server.display, pict_mask);
XRenderFreePicture(server.dsp, pict_drawable); XRenderFreePicture(server.display, pict_drawable);
XRenderFreePicture(server.dsp, pict); XRenderFreePicture(server.display, pict);
XFreePixmap(server.dsp, mask); XFreePixmap(server.display, mask);
XFreePixmap(server.dsp, pixmap); XFreePixmap(server.display, pixmap);
} }
void draw_text(PangoLayout *layout, cairo_t *c, int posx, int posy, Color *color, int font_shadow) void draw_text(PangoLayout *layout, cairo_t *c, int posx, int posy, Color *color, int font_shadow)
@ -557,11 +557,11 @@ void draw_rect(cairo_t *c, double x, double y, double w, double h, double r)
void clear_pixmap(Pixmap p, int x, int y, int w, int h) void clear_pixmap(Pixmap p, int x, int y, int w, int h)
{ {
Picture pict = XRenderCreatePicture(server.dsp, p, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0); Picture pict = XRenderCreatePicture(server.display, p, XRenderFindVisualFormat(server.display, server.visual), 0, 0);
XRenderColor col; XRenderColor col;
col.red = col.green = col.blue = col.alpha = 0; col.red = col.green = col.blue = col.alpha = 0;
XRenderFillRectangle(server.dsp, PictOpSrc, pict, &col, x, y, w, h); XRenderFillRectangle(server.display, PictOpSrc, pict, &col, x, y, w, h);
XRenderFreePicture(server.dsp, pict); XRenderFreePicture(server.display, pict);
} }
void get_text_size2(PangoFontDescription *font, void get_text_size2(PangoFontDescription *font,
@ -578,9 +578,9 @@ void get_text_size2(PangoFontDescription *font,
{ {
PangoRectangle rect_ink, rect; PangoRectangle rect_ink, rect;
Pixmap pmap = XCreatePixmap(server.dsp, server.root_win, panel_height, panel_width, server.depth); Pixmap pmap = XCreatePixmap(server.display, server.root_win, panel_height, panel_width, server.depth);
cairo_surface_t *cs = cairo_xlib_surface_create(server.dsp, pmap, server.visual, panel_height, panel_width); cairo_surface_t *cs = cairo_xlib_surface_create(server.display, pmap, server.visual, panel_height, panel_width);
cairo_t *c = cairo_create(cs); cairo_t *c = cairo_create(cs);
PangoLayout *layout = pango_cairo_create_layout(c); PangoLayout *layout = pango_cairo_create_layout(c);
@ -603,7 +603,7 @@ void get_text_size2(PangoFontDescription *font,
g_object_unref(layout); g_object_unref(layout);
cairo_destroy(c); cairo_destroy(c);
cairo_surface_destroy(cs); cairo_surface_destroy(cs);
XFreePixmap(server.dsp, pmap); XFreePixmap(server.display, pmap);
} }
#if !GLIB_CHECK_VERSION (2, 33, 4) #if !GLIB_CHECK_VERSION (2, 33, 4)

8
src/util/window.c
View file

@ -74,7 +74,7 @@ gboolean window_is_hidden(Window win)
} }
// do not add transient_for windows if the transient window is already in the taskbar // do not add transient_for windows if the transient window is already in the taskbar
window = win; window = win;
while (XGetTransientForHint(server.dsp, window, &window)) { while (XGetTransientForHint(server.display, window, &window)) {
if (task_get_tasks(window)) { if (task_get_tasks(window)) {
XFree(at); XFree(at);
return TRUE; return TRUE;
@ -162,7 +162,7 @@ int get_window_monitor(Window win)
int i, x, y; int i, x, y;
Window src; Window src;
XTranslateCoordinates(server.dsp, win, server.root_win, 0, 0, &x, &y, &src); XTranslateCoordinates(server.display, win, server.root_win, 0, 0, &x, &y, &src);
int best_match = -1; int best_match = -1;
int match_right = 0; int match_right = 0;
int match_bottom = 0; int match_bottom = 0;
@ -190,8 +190,8 @@ void get_window_coordinates(Window win, int *x, int *y, int *w, int *h)
int dummy_int; int dummy_int;
unsigned ww, wh, bw, bh; unsigned ww, wh, bw, bh;
Window src; Window src;
XTranslateCoordinates(server.dsp, win, server.root_win, 0, 0, x, y, &src); XTranslateCoordinates(server.display, win, server.root_win, 0, 0, x, y, &src);
XGetGeometry(server.dsp, win, &src, &dummy_int, &dummy_int, &ww, &wh, &bw, &bh); XGetGeometry(server.display, win, &src, &dummy_int, &dummy_int, &ww, &wh, &bw, &bh);
*w = ww + bw; *w = ww + bw;
*h = wh + bh; *h = wh + bh;
} }