You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
libtdevnc/x11vnc/solid.c

774 lines
16 KiB

/* -- solid.c -- */
#include "x11vnc.h"
#include "win_utils.h"
#include "xwrappers.h"
#include "connections.h"
char *guess_desktop(void);
void solid_bg(int restore);
static void usr_bin_path(int restore);
static int dt_cmd(char *cmd);
static char *cmd_output(char *cmd);
static void solid_root(char *color);
static void solid_cde(char *color);
static void solid_gnome(char *color);
static void solid_kde(char *color);
static void usr_bin_path(int restore) {
static char *oldpath = NULL;
char *newpath;
char addpath[] = "/usr/bin:/bin:";
if (restore) {
if (oldpath) {
set_env("PATH", oldpath);
free(oldpath);
oldpath = NULL;
}
return;
}
if (getenv("PATH")) {
oldpath = strdup(getenv("PATH"));
} else {
oldpath = strdup("/usr/bin");
}
newpath = (char *) malloc(strlen(oldpath) + strlen(addpath) + 1);
newpath[0] = '\0';
strcat(newpath, addpath);
strcat(newpath, oldpath);
set_env("PATH", newpath);
free(newpath);
}
static int dt_cmd(char *cmd) {
int rc;
RAWFB_RET(0)
if (!cmd || *cmd == '\0') {
return 0;
}
/* dt */
if (no_external_cmds || !cmd_ok("dt")) {
rfbLog("cannot run external commands in -nocmds mode:\n");
rfbLog(" \"%s\"\n", cmd);
rfbLog(" dt_cmd: returning 1\n");
return 1;
}
if (getenv("DISPLAY") == NULL) {
set_env("DISPLAY", DisplayString(dpy));
}
rfbLog("running command:\n %s\n", cmd);
usr_bin_path(0);
rc = system(cmd);
usr_bin_path(1);
if (rc >= 256) {
rc = rc/256;
}
return rc;
}
static char *cmd_output(char *cmd) {
FILE *p;
static char output[50000];
char line[1024];
int rc;
if (!cmd || *cmd == '\0') {
return "";
}
if (no_external_cmds) {
rfbLog("cannot run external commands in -nocmds mode:\n");
rfbLog(" \"%s\"\n", cmd);
rfbLog(" cmd_output: null string.\n");
return "";
}
rfbLog("running pipe:\n %s\n", cmd);
usr_bin_path(0);
p = popen(cmd, "r");
usr_bin_path(1);
output[0] = '\0';
while (fgets(line, 1024, p) != NULL) {
if (strlen(output) + strlen(line) + 1 < 50000) {
strcat(output, line);
}
}
rc = pclose(p);
return(output);
}
static void solid_root(char *color) {
Window expose;
static XImage *image = NULL;
Pixmap pixmap;
XGCValues gcv;
GC gc;
XSetWindowAttributes swa;
Visual visual;
unsigned long mask, pixel;
XColor cdef;
Colormap cmap;
RAWFB_RET_VOID
#if NO_X11
return;
#else
if (subwin || window != rootwin) {
rfbLog("cannot set subwin to solid color, must be rootwin\n");
return;
}
/* create the "clear" window just for generating exposures */
swa.override_redirect = True;
swa.backing_store = NotUseful;
swa.save_under = False;
swa.background_pixmap = None;
visual.visualid = CopyFromParent;
mask = (CWOverrideRedirect|CWBackingStore|CWSaveUnder|CWBackPixmap);
expose = XCreateWindow(dpy, window, 0, 0, wdpy_x, wdpy_y, 0, depth,
InputOutput, &visual, mask, &swa);
if (! color) {
/* restore the root window from the XImage snapshot */
pixmap = XCreatePixmap(dpy, window, wdpy_x, wdpy_y, depth);
if (! image) {
/* whoops */
XDestroyWindow(dpy, expose);
rfbLog("no root snapshot available.\n");
return;
}
/* draw the image to a pixmap: */
gcv.function = GXcopy;
gcv.plane_mask = AllPlanes;
gc = XCreateGC(dpy, window, GCFunction|GCPlaneMask, &gcv);
XPutImage(dpy, pixmap, gc, image, 0, 0, 0, 0, wdpy_x, wdpy_y);
gcv.foreground = gcv.background = BlackPixel(dpy, scr);
gc = XCreateGC(dpy, window, GCForeground|GCBackground, &gcv);
rfbLog("restoring root snapshot...\n");
/* set the pixmap as the bg: */
XSetWindowBackgroundPixmap(dpy, window, pixmap);
XFreePixmap(dpy, pixmap);
XClearWindow(dpy, window);
XFlush_wr(dpy);
/* generate exposures */
XMapWindow(dpy, expose);
XSync(dpy, False);
XDestroyWindow(dpy, expose);
return;
}
if (! image) {
/* need to retrieve a snapshot of the root background: */
Window iwin;
XSetWindowAttributes iswa;
/* create image window: */
iswa.override_redirect = True;
iswa.backing_store = NotUseful;
iswa.save_under = False;
iswa.background_pixmap = ParentRelative;
iwin = XCreateWindow(dpy, window, 0, 0, wdpy_x, wdpy_y, 0,
depth, InputOutput, &visual, mask, &iswa);
rfbLog("snapshotting background...\n");
XMapWindow(dpy, iwin);
XSync(dpy, False);
image = XGetImage(dpy, iwin, 0, 0, wdpy_x, wdpy_y, AllPlanes,
ZPixmap);
XSync(dpy, False);
XDestroyWindow(dpy, iwin);
}
/* use black for low colors or failure */
pixel = BlackPixel(dpy, scr);
if (depth > 8 || strcmp(color, solid_default)) {
cmap = DefaultColormap (dpy, scr);
if (XParseColor(dpy, cmap, color, &cdef) &&
XAllocColor(dpy, cmap, &cdef)) {
pixel = cdef.pixel;
} else {
rfbLog("error parsing/allocing color: %s\n", color);
}
}
rfbLog("setting solid background...\n");
XSetWindowBackground(dpy, window, pixel);
XMapWindow(dpy, expose);
XSync(dpy, False);
XDestroyWindow(dpy, expose);
#endif /* NO_X11 */
}
static void solid_cde(char *color) {
int wsmax = 16;
static XImage *image[16];
static Window ws_wins[16];
static int nws = -1;
Window expose;
Pixmap pixmap;
XGCValues gcv;
GC gc;
XSetWindowAttributes swa;
Visual visual;
unsigned long mask, pixel;
XColor cdef;
Colormap cmap;
int n;
RAWFB_RET_VOID
#if NO_X11
return;
#else
if (subwin || window != rootwin) {
rfbLog("cannot set subwin to solid color, must be rootwin\n");
return;
}
/* create the "clear" window just for generating exposures */
swa.override_redirect = True;
swa.backing_store = NotUseful;
swa.save_under = False;
swa.background_pixmap = None;
visual.visualid = CopyFromParent;
mask = (CWOverrideRedirect|CWBackingStore|CWSaveUnder|CWBackPixmap);
expose = XCreateWindow(dpy, window, 0, 0, wdpy_x, wdpy_y, 0, depth,
InputOutput, &visual, mask, &swa);
if (! color) {
/* restore the backdrop windows from the XImage snapshots */
for (n=0; n < nws; n++) {
Window twin;
if (! image[n]) {
continue;
}
twin = ws_wins[n];
if (! twin) {
twin = rootwin;
}
if (! valid_window(twin, NULL, 0)) {
continue;
}
pixmap = XCreatePixmap(dpy, twin, wdpy_x, wdpy_y,
depth);
/* draw the image to a pixmap: */
gcv.function = GXcopy;
gcv.plane_mask = AllPlanes;
gc = XCreateGC(dpy, twin, GCFunction|GCPlaneMask, &gcv);
XPutImage(dpy, pixmap, gc, image[n], 0, 0, 0, 0,
wdpy_x, wdpy_y);
gcv.foreground = gcv.background = BlackPixel(dpy, scr);
gc = XCreateGC(dpy, twin, GCForeground|GCBackground,
&gcv);
rfbLog("restoring CDE ws%d snapshot to 0x%lx\n",
n, twin);
/* set the pixmap as the bg: */
XSetWindowBackgroundPixmap(dpy, twin, pixmap);
XFreePixmap(dpy, pixmap);
XClearWindow(dpy, twin);
XFlush_wr(dpy);
}
/* generate exposures */
XMapWindow(dpy, expose);
XSync(dpy, False);
XDestroyWindow(dpy, expose);
return;
}
if (nws < 0) {
/* need to retrieve snapshots of the ws backgrounds: */
Window iwin, wm_win;
XSetWindowAttributes iswa;
Atom dt_list, wm_info, type;
int format;
unsigned long length, after;
unsigned char *data;
unsigned long *dp; /* crash on 64bit with int */
nws = 0;
/* extract the hidden wm properties about backdrops: */
wm_info = XInternAtom(dpy, "_MOTIF_WM_INFO", True);
if (wm_info == None) {
return;
}
XGetWindowProperty(dpy, rootwin, wm_info, 0L, 10L, False,
AnyPropertyType, &type, &format, &length, &after, &data);
/*
* xprop -notype -root _MOTIF_WM_INFO
* _MOTIF_WM_INFO = 0x2, 0x580028
*/
if (length < 2 || format != 32 || after != 0) {
return;
}
dp = (unsigned long *) data;
wm_win = (Window) *(dp+1); /* 2nd item. */
dt_list = XInternAtom(dpy, "_DT_WORKSPACE_LIST", True);
if (dt_list == None) {
return;
}
XGetWindowProperty(dpy, wm_win, dt_list, 0L, 10L, False,
AnyPropertyType, &type, &format, &length, &after, &data);
nws = length;
if (nws > wsmax) {
nws = wsmax;
}
if (nws < 0) {
nws = 0;
}
rfbLog("special CDE win: 0x%lx, %d workspaces\n", wm_win, nws);
if (nws == 0) {
return;
}
for (n=0; n<nws; n++) {
Atom ws_atom;
char tmp[32];
Window twin;
XWindowAttributes attr;
int i, cnt;
image[n] = NULL;
ws_wins[n] = 0x0;
sprintf(tmp, "_DT_WORKSPACE_INFO_ws%d", n);
ws_atom = XInternAtom(dpy, tmp, False);
if (ws_atom == None) {
continue;
}
XGetWindowProperty(dpy, wm_win, ws_atom, 0L, 100L,
False, AnyPropertyType, &type, &format, &length,
&after, &data);
if (format != 8 || after != 0) {
continue;
}
/*
* xprop -notype -id wm_win
* _DT_WORKSPACE_INFO_ws0 = "One", "3", "0x2f2f4a",
* "0x63639c", "0x103", "1", "0x58044e"
*/
cnt = 0;
twin = 0x0;
for (i=0; i< (int) length; i++) {
if (*(data+i) != '\0') {
continue;
}
cnt++; /* count nulls to indicate field */
if (cnt == 6) {
/* one past the null: */
char *q = (char *) (data+i+1);
unsigned long in;
if (sscanf(q, "0x%lx", &in) == 1) {
twin = (Window) in;
break;
}
}
}
ws_wins[n] = twin;
if (! twin) {
twin = rootwin;
}
XGetWindowAttributes(dpy, twin, &attr);
if (twin != rootwin) {
if (attr.map_state != IsViewable) {
XMapWindow(dpy, twin);
}
XRaiseWindow(dpy, twin);
}
XSync(dpy, False);
/* create image window: */
iswa.override_redirect = True;
iswa.backing_store = NotUseful;
iswa.save_under = False;
iswa.background_pixmap = ParentRelative;
visual.visualid = CopyFromParent;
iwin = XCreateWindow(dpy, twin, 0, 0, wdpy_x, wdpy_y,
0, depth, InputOutput, &visual, mask, &iswa);
rfbLog("snapshotting CDE backdrop ws%d 0x%lx -> "
"0x%lx ...\n", n, twin, iwin);
XMapWindow(dpy, iwin);
XSync(dpy, False);
image[n] = XGetImage(dpy, iwin, 0, 0, wdpy_x, wdpy_y,
AllPlanes, ZPixmap);
XSync(dpy, False);
XDestroyWindow(dpy, iwin);
if (twin != rootwin) {
XLowerWindow(dpy, twin);
if (attr.map_state != IsViewable) {
XUnmapWindow(dpy, twin);
}
}
}
}
if (nws == 0) {
return;
}
/* use black for low colors or failure */
pixel = BlackPixel(dpy, scr);
if (depth > 8 || strcmp(color, solid_default)) {
cmap = DefaultColormap (dpy, scr);
if (XParseColor(dpy, cmap, color, &cdef) &&
XAllocColor(dpy, cmap, &cdef)) {
pixel = cdef.pixel;
} else {
rfbLog("error parsing/allocing color: %s\n", color);
}
}
rfbLog("setting solid backgrounds...\n");
for (n=0; n < nws; n++) {
Window twin = ws_wins[n];
if (image[n] == NULL) {
continue;
}
if (! twin) {
twin = rootwin;
}
XSetWindowBackground(dpy, twin, pixel);
}
XMapWindow(dpy, expose);
XSync(dpy, False);
XDestroyWindow(dpy, expose);
#endif /* NO_X11 */
}
static void solid_gnome(char *color) {
char get_color[] = "gconftool-2 --get "
"/desktop/gnome/background/primary_color";
char set_color[] = "gconftool-2 --set "
"/desktop/gnome/background/primary_color --type string '%s'";
char get_option[] = "gconftool-2 --get "
"/desktop/gnome/background/picture_options";
char set_option[] = "gconftool-2 --set "
"/desktop/gnome/background/picture_options --type string '%s'";
static char *orig_color = NULL;
static char *orig_option = NULL;
char *cmd;
RAWFB_RET_VOID
#if NO_X11
return;
#else
if (! color) {
if (! orig_color) {
orig_color = strdup("#FFFFFF");
}
if (! orig_option) {
orig_option = strdup("stretched");
}
if (strstr(orig_color, "'") != NULL) {
rfbLog("invalid color: %s\n", orig_color);
return;
}
if (strstr(orig_option, "'") != NULL) {
rfbLog("invalid option: %s\n", orig_option);
return;
}
cmd = (char *) malloc(strlen(set_option) - 2 +
strlen(orig_option) + 1);
sprintf(cmd, set_option, orig_option);
dt_cmd(cmd);
free(cmd);
cmd = (char *) malloc(strlen(set_color) - 2 +
strlen(orig_color) + 1);
sprintf(cmd, set_color, orig_color);
dt_cmd(cmd);
free(cmd);
return;
}
if (! orig_color) {
char *q;
if (cmd_ok("dt")) {
orig_color = strdup(cmd_output(get_color));
} else {
orig_color = "";
}
if (*orig_color == '\0') {
orig_color = strdup("#FFFFFF");
}
if ((q = strchr(orig_color, '\n')) != NULL) {
*q = '\0';
}
}
if (! orig_option) {
char *q;
if (cmd_ok("dt")) {
orig_option = strdup(cmd_output(get_option));
} else {
orig_color = "";
}
if (*orig_option == '\0') {
orig_option = strdup("stretched");
}
if ((q = strchr(orig_option, '\n')) != NULL) {
*q = '\0';
}
}
if (strstr(color, "'") != NULL) {
rfbLog("invalid color: %s\n", color);
return;
}
cmd = (char *) malloc(strlen(set_color) + strlen(color) + 1);
sprintf(cmd, set_color, color);
dt_cmd(cmd);
free(cmd);
cmd = (char *) malloc(strlen(set_option) + strlen("none") + 1);
sprintf(cmd, set_option, "none");
dt_cmd(cmd);
free(cmd);
#endif /* NO_X11 */
}
static void solid_kde(char *color) {
char set_color[] =
"dcop --user '%s' kdesktop KBackgroundIface setColor '%s' 1";
char bg_off[] =
"dcop --user '%s' kdesktop KBackgroundIface setBackgroundEnabled 0";
char bg_on[] =
"dcop --user '%s' kdesktop KBackgroundIface setBackgroundEnabled 1";
char *cmd, *user = NULL;
int len;
RAWFB_RET_VOID
#if NO_X11
return;
#else
user = get_user_name();
if (strstr(user, "'") != NULL) {
rfbLog("invalid user: %s\n", user);
free(user);
return;
}
if (! color) {
len = strlen(bg_on) + strlen(user) + 1;
cmd = (char *) malloc(len);
sprintf(cmd, bg_on, user);
dt_cmd(cmd);
free(cmd);
free(user);
return;
}
if (strstr(color, "'") != NULL) {
rfbLog("invalid color: %s\n", color);
return;
}
len = strlen(set_color) + strlen(user) + strlen(color) + 1;
cmd = (char *) malloc(len);
sprintf(cmd, set_color, user, color);
dt_cmd(cmd);
free(cmd);
len = strlen(bg_off) + strlen(user) + 1;
cmd = (char *) malloc(len);
sprintf(cmd, bg_off, user);
dt_cmd(cmd);
free(cmd);
free(user);
#endif /* NO_X11 */
}
char *guess_desktop(void) {
Atom prop;
RAWFB_RET("root")
#if NO_X11
return "root";
#else
if (wmdt_str && *wmdt_str != '\0') {
char *s = wmdt_str;
lowercase(s);
if (strstr(s, "xfce")) {
return "xfce";
}
if (strstr(s, "gnome") || strstr(s, "metacity")) {
return "gnome";
}
if (strstr(s, "kde") || strstr(s, "kwin")) {
return "kde";
}
if (strstr(s, "cde")) {
return "cde";
}
return "root";
}
if (! dpy) {
return "";
}
prop = XInternAtom(dpy, "XFCE_DESKTOP_WINDOW", True);
if (prop != None) return "xfce";
/* special case windowmaker */
prop = XInternAtom(dpy, "_WINDOWMAKER_WM_PROTOCOLS", True);
if (prop != None) return "root";
prop = XInternAtom(dpy, "_WINDOWMAKER_COMMAND", True);
if (prop != None) return "root";
prop = XInternAtom(dpy, "NAUTILUS_DESKTOP_WINDOW_ID", True);
if (prop != None) return "gnome";
prop = XInternAtom(dpy, "KWIN_RUNNING", True);
if (prop != None) {
prop = XInternAtom(dpy, "_KDE_RUNNING", True);
if (prop != None) {
prop = XInternAtom(dpy, "KDE_DESKTOP_WINDOW", True);
if (prop != None) return "kde";
}
}
prop = XInternAtom(dpy, "_MOTIF_WM_INFO", True);
if (prop != None) {
prop = XInternAtom(dpy, "_DT_WORKSPACE_LIST", True);
if (prop != None) return "cde";
}
return "root";
#endif /* NO_X11 */
}
void solid_bg(int restore) {
static int desktop = -1;
static int solid_on = 0;
static char *prev_str;
char *dtname, *color;
RAWFB_RET_VOID
if (started_as_root == 1 && users_list) {
/* we are still root, don't try. */
return;
}
if (restore) {
if (! solid_on) {
return;
}
if (desktop == 0) {
solid_root(NULL);
} else if (desktop == 1) {
solid_gnome(NULL);
} else if (desktop == 2) {
solid_kde(NULL);
} else if (desktop == 3) {
solid_cde(NULL);
}
solid_on = 0;
return;
}
if (! solid_str) {
return;
}
if (solid_on && !strcmp(prev_str, solid_str)) {
return;
}
if (strstr(solid_str, "guess:") == solid_str
|| !strchr(solid_str, ':')) {
dtname = guess_desktop();
rfbLog("guessed desktop: %s\n", dtname);
} else {
if (strstr(solid_str, "gnome:") == solid_str) {
dtname = "gnome";
} else if (strstr(solid_str, "kde:") == solid_str) {
dtname = "kde";
} else if (strstr(solid_str, "cde:") == solid_str) {
dtname = "cde";
} else {
dtname = "root";
}
}
color = strchr(solid_str, ':');
if (! color) {
color = solid_str;
} else {
color++;
if (*color == '\0') {
color = solid_default;
}
}
if (!strcmp(dtname, "gnome")) {
desktop = 1;
solid_gnome(color);
} else if (!strcmp(dtname, "kde")) {
desktop = 2;
solid_kde(color);
} else if (!strcmp(dtname, "cde")) {
desktop = 3;
solid_cde(color);
} else {
desktop = 0;
solid_root(color);
}
if (prev_str) {
free(prev_str);
}
prev_str = strdup(solid_str);
solid_on = 1;
}