GuiCalibratorX11::GuiCalibratorX11(Calibrator* calibrator0)
: calibrator(calibrator0), time_elapsed(0)
{
display = XOpenDisplay(NULL);
if (display == NULL) {
throw std::runtime_error("Unable to connect to X server");
}
screen_num = DefaultScreen(display);
// Load font and get font information structure
font_info = XLoadQueryFont(display, "9x15");
if (font_info == NULL) {
// fall back to native font
font_info = XLoadQueryFont(display, "fixed");
if (font_info == NULL) {
XCloseDisplay(display);
throw std::runtime_error("Unable to open neither '9x15' nor 'fixed' font");
}
}
#ifdef HAVE_X11_XRANDR
// get screensize from xrandr
int nsizes;
XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
if (nsizes != 0) {
Rotation current = 0;
XRRRotations(display, screen_num, ¤t);
bool rot = current & RR_Rotate_90 || current & RR_Rotate_270;
int width = rot ? randrsize->height : randrsize->width;
int height = rot ? randrsize->width : randrsize->height;
set_display_size(width, height);
} else {
set_display_size(DisplayWidth(display, screen_num),
DisplayHeight(display, screen_num));
}
# else
set_display_size(DisplayWidth(display, screen_num),
DisplayHeight(display, screen_num));
#endif
// parse geometry string
const char* geo = calibrator->get_geometry();
if (geo != NULL) {
int gw,gh;
int res = sscanf(geo,"%dx%d",&gw,&gh);
if (res != 2) {
fprintf(stderr,"Warning: error parsing geometry string - using defaults.\n");
} else {
set_display_size( gw, gh );
}
}
// Register events on the window
XSetWindowAttributes attributes;
attributes.override_redirect = True;
attributes.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
win = XCreateWindow(display, RootWindow(display, screen_num),
0, 0, display_width, display_height, 0,
CopyFromParent, InputOutput, CopyFromParent,
CWOverrideRedirect | CWEventMask,
&attributes);
XMapWindow(display, win);
// Listen to events
XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
CurrentTime);
XGrabPointer(display, win, False, ButtonPressMask, GrabModeAsync,
GrabModeAsync, None, None, CurrentTime);
Colormap colormap = DefaultColormap(display, screen_num);
XColor color;
for (int i = 0; i != NUM_COLORS; i++) {
XParseColor(display, colormap, colors[i], &color);
XAllocColor(display, colormap, &color);
pixel[i] = color.pixel;
}
XSetWindowBackground(display, win, pixel[GRAY]);
XClearWindow(display, win);
gc = XCreateGC(display, win, 0, NULL);
XSetFont(display, gc, font_info->fid);
// Setup timer for animation
#ifdef HAVE_TIMERFD
struct itimerspec timer;
unsigned int period = time_step * 1000; // microseconds
unsigned int sec = period/1000000;
unsigned int ns = (period - (sec * 1000000)) * 1000;
timer.it_value.tv_sec = sec;
timer.it_value.tv_nsec = ns;
timer.it_interval = timer.it_value;
timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
timerfd_settime(timer_fd, 0, &timer, NULL);
#else
signal(SIGALRM, sigalarm_handler);
struct itimerval timer;
timer.it_value.tv_sec = time_step/1000;
timer.it_value.tv_usec = (time_step % 1000) * 1000;
timer.it_interval = timer.it_value;
setitimer(ITIMER_REAL, &timer, NULL);
#endif
}
static bool gfx_ctx_x_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
XEvent event;
bool true_full = false, windowed_full;
int val, x_off = 0, y_off = 0;
XVisualInfo *vi = NULL;
XSetWindowAttributes swa = {0};
int (*old_handler)(Display*, XErrorEvent*) = NULL;
settings_t *settings = config_get_ptr();
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
x11_install_sighandlers();
if (!x)
return false;
windowed_full = settings->video.windowed_fullscreen;
true_full = false;
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
vi = glXGetVisualFromFBConfig(g_x11_dpy, x->g_fbc);
if (!vi)
goto error;
#endif
break;
case GFX_CTX_NONE:
default:
{
XVisualInfo vi_template;
/* For default case, just try to obtain a visual from template. */
int nvisuals = 0;
memset(&vi_template, 0, sizeof(vi_template));
vi_template.screen = DefaultScreen(g_x11_dpy);
vi = XGetVisualInfo(g_x11_dpy, VisualScreenMask, &vi_template, &nvisuals);
if (!vi || nvisuals < 1)
goto error;
}
break;
}
swa.colormap = g_x11_cmap = XCreateColormap(g_x11_dpy,
RootWindow(g_x11_dpy, vi->screen), vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
ButtonReleaseMask | ButtonPressMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_x11_dpy, width, height, &x->g_desktop_mode))
{
x->g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[GLX]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (settings->video.monitor_index)
g_x11_screen = settings->video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_x11_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_x11_dpy, g_x11_screen,
&x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[GLX]: Using Xinerama on screen #%u.\n", g_x11_screen);
else
RARCH_LOG("[GLX]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[GLX]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_x11_win = XCreateWindow(g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask |
(true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_x11_dpy, g_x11_win, 0);
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
x->g_glx_win = glXCreateWindow(g_x11_dpy, x->g_fbc, g_x11_win, 0);
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
x11_set_window_attr(g_x11_dpy, g_x11_win);
x11_update_window_title(NULL);
if (fullscreen)
x11_show_mouse(g_x11_dpy, g_x11_win, false);
if (true_full)
{
RARCH_LOG("[GLX]: Using true fullscreen.\n");
XMapRaised(g_x11_dpy, g_x11_win);
}
else if (fullscreen)
{
/* We attempted true fullscreen, but failed.
* Attempt using windowed fullscreen. */
XMapRaised(g_x11_dpy, g_x11_win);
RARCH_LOG("[GLX]: Using windowed fullscreen.\n");
/* We have to move the window to the screen we want
* to go fullscreen on first.
* x_off and y_off usually get ignored in XCreateWindow().
*/
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_x11_dpy, g_x11_win);
}
else
{
XMapWindow(g_x11_dpy, g_x11_win);
/* If we want to map the window on a different screen,
* we'll have to do it by force.
* Otherwise, we should try to let the window manager sort it out.
* x_off and y_off usually get ignored in XCreateWindow(). */
if (g_x11_screen)
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
}
x11_event_queue_check(&event);
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
if (!x->g_ctx)
{
if (x->g_core_es || x->g_debug)
{
int attribs[16];
int *aptr = attribs;
if (x->g_core_es)
{
*aptr++ = GLX_CONTEXT_MAJOR_VERSION_ARB;
*aptr++ = g_major;
*aptr++ = GLX_CONTEXT_MINOR_VERSION_ARB;
*aptr++ = g_minor;
if (x->g_core_es_core)
{
/* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending on
* GL_ARB_compatibility.
*/
*aptr++ = GLX_CONTEXT_PROFILE_MASK_ARB;
#ifdef HAVE_OPENGLES2
*aptr++ = GLX_CONTEXT_ES_PROFILE_BIT_EXT;
#else
*aptr++ = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
#endif
}
}
if (x->g_debug)
{
*aptr++ = GLX_CONTEXT_FLAGS_ARB;
*aptr++ = GLX_CONTEXT_DEBUG_BIT_ARB;
}
*aptr = None;
x->g_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, NULL, True, attribs);
if (x->g_use_hw_ctx)
{
RARCH_LOG("[GLX]: Creating shared HW context.\n");
x->g_hw_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, x->g_ctx, True, attribs);
if (!x->g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n");
}
}
else
{
x->g_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc,
GLX_RGBA_TYPE, 0, True);
if (x->g_use_hw_ctx)
{
x->g_hw_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc,
GLX_RGBA_TYPE, x->g_ctx, True);
if (!x->g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n");
}
}
if (!x->g_ctx)
{
RARCH_ERR("[GLX]: Failed to create new context.\n");
goto error;
}
}
else
{
video_driver_ctl(RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT_ACK, NULL);
RARCH_LOG("[GLX]: Using cached GL context.\n");
}
glXMakeContextCurrent(g_x11_dpy,
x->g_glx_win, x->g_glx_win, x->g_ctx);
#endif
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN
{
bool quit, resize;
unsigned width, height;
x11_check_window(x, &quit, &resize, &width, &height, 0);
/* Use XCB surface since it's the most supported WSI.
* We can obtain the XCB connection directly from X11. */
if (!vulkan_surface_create(&x->vk, VULKAN_WSI_XCB,
g_x11_dpy, &g_x11_win,
width, height, x->g_interval))
goto error;
}
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
XSync(g_x11_dpy, False);
x11_install_quit_atom();
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
glXGetConfig(g_x11_dpy, vi, GLX_DOUBLEBUFFER, &val);
x->g_is_double = val;
if (x->g_is_double)
{
const char *swap_func = NULL;
g_pglSwapIntervalEXT = (void (*)(Display*, GLXDrawable, int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");
g_pglSwapIntervalSGI = (int (*)(int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalSGI");
g_pglSwapInterval = (int (*)(int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
if (g_pglSwapIntervalEXT)
swap_func = "glXSwapIntervalEXT";
else if (g_pglSwapInterval)
swap_func = "glXSwapIntervalMESA";
else if (g_pglSwapIntervalSGI)
swap_func = "glXSwapIntervalSGI";
if (!g_pglSwapInterval && !g_pglSwapIntervalEXT && !g_pglSwapIntervalSGI)
RARCH_WARN("[GLX]: Cannot find swap interval call.\n");
else
RARCH_LOG("[GLX]: Found swap function: %s.\n", swap_func);
}
else
RARCH_WARN("[GLX]: Context is not double buffered!.\n");
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
gfx_ctx_x_swap_interval(data, x->g_interval);
/* This can blow up on some drivers.
* It's not fatal, so override errors for this call. */
old_handler = XSetErrorHandler(x_nul_handler);
XSetInputFocus(g_x11_dpy, g_x11_win, RevertToNone, CurrentTime);
XSync(g_x11_dpy, False);
XSetErrorHandler(old_handler);
XFree(vi);
vi = NULL;
if (!x11_input_ctx_new(true_full))
goto error;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_x_destroy_resources(x);
if (x)
free(x);
g_x11_screen = 0;
return false;
}
static bool gfx_ctx_xegl_set_video_mode(void *data,
video_frame_info_t *video_info,
unsigned width, unsigned height,
bool fullscreen)
{
XEvent event;
EGLint egl_attribs[16];
EGLint vid, num_visuals;
EGLint *attr = NULL;
bool true_full = false;
int x_off = 0;
int y_off = 0;
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
char *wm_name = NULL;
xegl_ctx_data_t *xegl = (xegl_ctx_data_t*)data;
settings_t *settings = config_get_ptr();
int (*old_handler)(Display*, XErrorEvent*) = NULL;
frontend_driver_install_signal_handler();
attr = egl_attribs;
attr = xegl_fill_attribs(xegl, attr);
#ifdef HAVE_EGL
if (!egl_get_native_visual_id(&xegl->egl, &vid))
goto error;
#endif
temp.visualid = vid;
vi = XGetVisualInfo(g_x11_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
swa.colormap = g_x11_cmap = XCreateColormap(
g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask |
ButtonPressMask | ButtonReleaseMask | KeyReleaseMask;
swa.override_redirect = False;
if (fullscreen && !video_info->windowed_fullscreen)
{
if (x11_enter_fullscreen(video_info, g_x11_dpy, width, height))
{
xegl->should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[X/EGL]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
wm_name = x11_get_wm_name(g_x11_dpy);
if (wm_name)
{
RARCH_LOG("[X/EGL]: Window manager is %s.\n", wm_name);
if (true_full && strcasestr(wm_name, "xfwm"))
{
RARCH_LOG("[X/EGL]: Using override-redirect workaround.\n");
swa.override_redirect = True;
}
free(wm_name);
}
if (!x11_has_net_wm_fullscreen(g_x11_dpy) && true_full)
swa.override_redirect = True;
if (video_info->monitor_index)
g_x11_screen = video_info->monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_x11_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (xinerama_get_coord(g_x11_dpy, g_x11_screen,
&x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_x11_screen);
else
RARCH_LOG("[X/EGL]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[X/EGL]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_x11_win = XCreateWindow(g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,
&swa);
XSetWindowBackground(g_x11_dpy, g_x11_win, 0);
if (fullscreen && settings && settings->bools.video_disable_composition)
{
uint32_t value = 1;
Atom cardinal = XInternAtom(g_x11_dpy, "CARDINAL", False);
Atom net_wm_bypass_compositor = XInternAtom(g_x11_dpy, "_NET_WM_BYPASS_COMPOSITOR", False);
RARCH_LOG("[X/EGL]: Requesting compositor bypass.\n");
XChangeProperty(g_x11_dpy, g_x11_win, net_wm_bypass_compositor, cardinal, 32, PropModeReplace, (const unsigned char*)&value, 1);
}
if (!egl_create_context(&xegl->egl, (attr != egl_attribs) ? egl_attribs : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface(&xegl->egl, (void*)g_x11_win))
goto error;
x11_set_window_attr(g_x11_dpy, g_x11_win);
x11_update_title(NULL, video_info);
if (fullscreen)
x11_show_mouse(g_x11_dpy, g_x11_win, false);
if (true_full)
{
RARCH_LOG("[X/EGL]: Using true fullscreen.\n");
XMapRaised(g_x11_dpy, g_x11_win);
x11_set_net_wm_fullscreen(g_x11_dpy, g_x11_win);
}
else if (fullscreen)
{
/* We attempted true fullscreen, but failed.
* Attempt using windowed fullscreen. */
XMapRaised(g_x11_dpy, g_x11_win);
RARCH_LOG("[X/EGL]: Using windowed fullscreen.\n");
/* We have to move the window to the screen we
* want to go fullscreen on first.
* x_off and y_off usually get ignored in XCreateWindow().
*/
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
x11_set_net_wm_fullscreen(g_x11_dpy, g_x11_win);
}
else
{
XMapWindow(g_x11_dpy, g_x11_win);
/* If we want to map the window on a different screen,
* we'll have to do it by force.
*
* Otherwise, we should try to let the window manager sort it out.
* x_off and y_off usually get ignored in XCreateWindow().
*/
if (g_x11_screen)
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
}
x11_event_queue_check(&event);
x11_install_quit_atom();
#ifdef HAVE_EGL
gfx_ctx_xegl_set_swap_interval(&xegl->egl, xegl->egl.interval);
#endif
/* This can blow up on some drivers. It's not fatal,
* so override errors for this call.
*/
old_handler = XSetErrorHandler(x_nul_handler);
XSetInputFocus(g_x11_dpy, g_x11_win, RevertToNone, CurrentTime);
XSync(g_x11_dpy, False);
XSetErrorHandler(old_handler);
XFree(vi);
g_egl_inited = true;
if (!x11_input_ctx_new(true_full))
goto error;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_xegl_destroy(data);
return false;
}
GuiCalibratorX11::GuiCalibratorX11(Calibrator* calibrator0)
: calibrator(calibrator0), time_elapsed(0)
{
display = XOpenDisplay(NULL);
if (display == NULL) {
throw std::runtime_error("Unable to connect to X server");
}
screen_num = DefaultScreen(display);
// Load font and get font information structure
font_info = XLoadQueryFont(display, "9x15");
if (font_info == NULL) {
// fall back to native font
font_info = XLoadQueryFont(display, "fixed");
if (font_info == NULL) {
XCloseDisplay(display);
throw std::runtime_error("Unable to open neither '9x15' nor 'fixed' font");
}
}
#ifdef HAVE_X11_XRANDR
// get screensize from xrandr
int nsizes;
XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
if (nsizes != 0) {
set_display_size(randrsize->width, randrsize->height);
} else {
set_display_size(DisplayWidth(display, screen_num),
DisplayHeight(display, screen_num));
}
# else
set_display_size(DisplayWidth(display, screen_num),
DisplayHeight(display, screen_num));
#endif
// Register events on the window
XSetWindowAttributes attributes;
attributes.override_redirect = True;
attributes.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
win = XCreateWindow(display, RootWindow(display, screen_num),
0, 0, display_width, display_height, 0,
CopyFromParent, InputOutput, CopyFromParent,
CWOverrideRedirect | CWEventMask,
&attributes);
XMapWindow(display, win);
// Listen to events
XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
CurrentTime);
calib_input = calibrator->register_events();
if (!calib_input) {
XGrabPointer(display, win, False, ButtonPressMask, GrabModeAsync,
GrabModeAsync, None, None, CurrentTime);
}
Colormap colormap = DefaultColormap(display, screen_num);
XColor color;
for (int i = 0; i != nr_colors; i++) {
XParseColor(display, colormap, colors[i], &color);
XAllocColor(display, colormap, &color);
pixel[i] = color.pixel;
}
XSetWindowBackground(display, win, pixel[GRAY]);
XClearWindow(display, win);
gc = XCreateGC(display, win, 0, NULL);
XSetFont(display, gc, font_info->fid);
// Setup timer for animation
signal(SIGALRM, sigalarm_handler);
struct itimerval timer;
timer.it_value.tv_sec = time_step/1000;
timer.it_value.tv_usec = (time_step % 1000) * 1000;
timer.it_interval = timer.it_value;
setitimer(ITIMER_REAL, &timer, NULL);
}
static Lock *
lockscreen(Display *dpy, int screen) {
char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
unsigned int len;
Lock *lock;
XColor color;
XSetWindowAttributes wa;
Cursor invisible;
int hue1, hue2;
if(dpy == NULL || screen < 0)
return NULL;
lock = malloc(sizeof(Lock));
if(lock == NULL)
return NULL;
lock->screen = screen;
lock->root = RootWindow(dpy, lock->screen);
/* init */
wa.override_redirect = 1;
lock->win = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen),
0, DefaultDepth(dpy, lock->screen), CopyFromParent,
DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa);
/* locked color */
hue1 = rand() % 360;
gen_random_pastel(&color, hue1);
XAllocColor(dpy, DefaultColormap(dpy, lock->screen), &color);
lock->colors[0] = color.pixel;
XSetWindowBackground(dpy, lock->win, lock->colors[0]);
/* trying to unlock color */
hue2 = hue1 + 180;
if (hue2 >= 360) {
hue2 -= 360;
}
gen_random_pastel(&color, hue2);
XAllocColor(dpy, DefaultColormap(dpy, lock->screen), &color);
lock->colors[1] = color.pixel;
lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8);
invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &color, &color, 0, 0);
XDefineCursor(dpy, lock->win, invisible);
XMapRaised(dpy, lock->win);
for(len = 1000; len; len--) {
if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
break;
usleep(1000);
}
if(running && (len > 0)) {
for(len = 1000; len; len--) {
if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
break;
usleep(1000);
}
}
running &= (len > 0);
if(!running) {
unlockscreen(dpy, lock);
lock = NULL;
}
else
XSelectInput(dpy, lock->root, SubstructureNotifyMask);
return lock;
}
void
make_splash_dialog (saver_info *si)
{
int x, y, bw;
XSetWindowAttributes attrs;
unsigned long attrmask = 0;
splash_dialog_data *sp;
saver_screen_info *ssi;
Colormap cmap;
char *f;
if (si->sp_data)
return;
if (!si->prefs.splash_p ||
si->prefs.splash_duration <= 0)
return;
ssi = &si->screens[mouse_screen (si)];
if (!ssi || !ssi->screen)
return; /* WTF? Trying to splash while no screens connected? */
cmap = DefaultColormapOfScreen (ssi->screen);
sp = (splash_dialog_data *) calloc (1, sizeof(*sp));
sp->prompt_screen = ssi;
sp->heading_label = get_string_resource (si->dpy,
"splash.heading.label",
"Dialog.Label.Label");
sp->body_label = get_string_resource (si->dpy,
"splash.body.label",
"Dialog.Label.Label");
sp->body2_label = get_string_resource (si->dpy,
"splash.body2.label",
"Dialog.Label.Label");
sp->demo_label = get_string_resource (si->dpy,
"splash.demo.label",
"Dialog.Button.Label");
#ifdef PREFS_BUTTON
sp->prefs_label = get_string_resource (si->dpy,
"splash.prefs.label",
"Dialog.Button.Label");
#endif /* PREFS_BUTTON */
sp->help_label = get_string_resource (si->dpy,
"splash.help.label",
"Dialog.Button.Label");
if (!sp->heading_label)
sp->heading_label = strdup("ERROR: REESOURCES NOT INSTALLED CORRECTLY");
if (!sp->body_label)
sp->body_label = strdup("ERROR: REESOURCES NOT INSTALLED CORRECTLY");
if (!sp->body2_label)
sp->body2_label = strdup("ERROR: REESOURCES NOT INSTALLED CORRECTLY");
if (!sp->demo_label) sp->demo_label = strdup("ERROR");
#ifdef PREFS_BUTTON
if (!sp->prefs_label) sp->prefs_label = strdup("ERROR");
#endif /* PREFS_BUTTON */
if (!sp->help_label) sp->help_label = strdup("ERROR");
/* Put the version number in the label. */
{
char *s = (char *) malloc (strlen(sp->heading_label) + 20);
sprintf(s, sp->heading_label, si->version);
free (sp->heading_label);
sp->heading_label = s;
}
f = get_string_resource (si->dpy, "splash.headingFont", "Dialog.Font");
sp->heading_font = XLoadQueryFont (si->dpy, (f ? f : "fixed"));
if (!sp->heading_font) sp->heading_font = XLoadQueryFont (si->dpy, "fixed");
if (f) free (f);
f = get_string_resource(si->dpy, "splash.bodyFont", "Dialog.Font");
sp->body_font = XLoadQueryFont (si->dpy, (f ? f : "fixed"));
if (!sp->body_font) sp->body_font = XLoadQueryFont (si->dpy, "fixed");
if (f) free (f);
f = get_string_resource(si->dpy, "splash.buttonFont", "Dialog.Font");
sp->button_font = XLoadQueryFont (si->dpy, (f ? f : "fixed"));
if (!sp->button_font) sp->button_font = XLoadQueryFont (si->dpy, "fixed");
if (f) free (f);
sp->foreground = get_pixel_resource (si->dpy, cmap,
"splash.foreground",
"Dialog.Foreground");
sp->background = get_pixel_resource (si->dpy, cmap,
"splash.background",
"Dialog.Background");
if (sp->foreground == sp->background)
{
/* Make sure the error messages show up. */
sp->foreground = BlackPixelOfScreen (ssi->screen);
sp->background = WhitePixelOfScreen (ssi->screen);
}
sp->button_foreground = get_pixel_resource (si->dpy, cmap,
"splash.Button.foreground",
"Dialog.Button.Foreground");
sp->button_background = get_pixel_resource (si->dpy, cmap,
"splash.Button.background",
"Dialog.Button.Background");
sp->shadow_top = get_pixel_resource (si->dpy, cmap,
"splash.topShadowColor",
"Dialog.Foreground");
sp->shadow_bottom = get_pixel_resource (si->dpy, cmap,
"splash.bottomShadowColor",
"Dialog.Background");
sp->logo_width = get_integer_resource (si->dpy,
"splash.logo.width",
"Dialog.Logo.Width");
sp->logo_height = get_integer_resource (si->dpy,
"splash.logo.height",
"Dialog.Logo.Height");
sp->internal_border = get_integer_resource (si->dpy,
"splash.internalBorderWidth",
"Dialog.InternalBorderWidth");
sp->shadow_width = get_integer_resource (si->dpy,
"splash.shadowThickness",
"Dialog.ShadowThickness");
if (sp->logo_width == 0) sp->logo_width = 150;
if (sp->logo_height == 0) sp->logo_height = 150;
if (sp->internal_border == 0) sp->internal_border = 15;
if (sp->shadow_width == 0) sp->shadow_width = 4;
{
int direction, ascent, descent;
XCharStruct overall;
sp->width = 0;
sp->height = 0;
/* Measure the heading_label. */
XTextExtents (sp->heading_font,
sp->heading_label, strlen(sp->heading_label),
&direction, &ascent, &descent, &overall);
if (overall.width > sp->width) sp->width = overall.width;
sp->height += ascent + descent;
/* Measure the body_label. */
XTextExtents (sp->body_font,
sp->body_label, strlen(sp->body_label),
&direction, &ascent, &descent, &overall);
if (overall.width > sp->width) sp->width = overall.width;
sp->height += ascent + descent;
/* Measure the body2_label. */
XTextExtents (sp->body_font,
sp->body2_label, strlen(sp->body2_label),
&direction, &ascent, &descent, &overall);
if (overall.width > sp->width) sp->width = overall.width;
sp->height += ascent + descent;
{
Dimension w2 = 0, w3 = 0, w4 = 0;
Dimension h2 = 0, h3 = 0, h4 = 0;
/* Measure the Demo button. */
XTextExtents (sp->button_font,
sp->demo_label, strlen(sp->demo_label),
&direction, &ascent, &descent, &overall);
w2 = overall.width;
h2 = ascent + descent;
#ifdef PREFS_BUTTON
/* Measure the Prefs button. */
XTextExtents (sp->button_font,
sp->prefs_label, strlen(sp->prefs_label),
&direction, &ascent, &descent, &overall);
w3 = overall.width;
h3 = ascent + descent;
#else /* !PREFS_BUTTON */
w3 = 0;
h3 = 0;
#endif /* !PREFS_BUTTON */
/* Measure the Help button. */
XTextExtents (sp->button_font,
sp->help_label, strlen(sp->help_label),
&direction, &ascent, &descent, &overall);
w4 = overall.width;
h4 = ascent + descent;
w2 = MAX(w2, w3); w2 = MAX(w2, w4);
h2 = MAX(h2, h3); h2 = MAX(h2, h4);
/* Add some horizontal padding inside the buttons. */
w2 += ascent;
w2 += ((ascent + descent) / 2) + (sp->shadow_width * 2);
h2 += ((ascent + descent) / 2) + (sp->shadow_width * 2);
sp->button_width = w2;
sp->button_height = h2;
#ifdef PREFS_BUTTON
w2 *= 3;
#else /* !PREFS_BUTTON */
w2 *= 2;
#endif /* !PREFS_BUTTON */
w2 += ((ascent + descent) * 2); /* for space between buttons */
if (w2 > sp->width) sp->width = w2;
sp->height += h2;
}
sp->width += (sp->internal_border * 2);
sp->height += (sp->internal_border * 3);
if (sp->logo_height > sp->height)
sp->height = sp->logo_height;
else if (sp->height > sp->logo_height)
sp->logo_height = sp->height;
sp->logo_width = sp->logo_height;
sp->width += sp->logo_width;
}
attrmask |= CWOverrideRedirect; attrs.override_redirect = True;
attrmask |= CWEventMask;
attrs.event_mask = (ExposureMask | ButtonPressMask | ButtonReleaseMask);
{
int sx = 0, sy = 0, w, h;
int mouse_x = 0, mouse_y = 0;
{
Window pointer_root, pointer_child;
int root_x, root_y, win_x, win_y;
unsigned int mask;
if (XQueryPointer (si->dpy,
RootWindowOfScreen (ssi->screen),
&pointer_root, &pointer_child,
&root_x, &root_y, &win_x, &win_y, &mask))
{
mouse_x = root_x;
mouse_y = root_y;
}
}
x = ssi->x;
y = ssi->y;
w = ssi->width;
h = ssi->height;
if (si->prefs.debug_p) w /= 2;
x = sx + (((w + sp->width) / 2) - sp->width);
y = sy + (((h + sp->height) / 2) - sp->height);
if (x < sx) x = sx;
if (y < sy) y = sy;
}
bw = get_integer_resource (si->dpy,
"splash.borderWidth",
"Dialog.BorderWidth");
si->splash_dialog =
XCreateWindow (si->dpy,
RootWindowOfScreen(ssi->screen),
x, y, sp->width, sp->height, bw,
DefaultDepthOfScreen (ssi->screen), InputOutput,
DefaultVisualOfScreen(ssi->screen),
attrmask, &attrs);
XSetWindowBackground (si->dpy, si->splash_dialog, sp->background);
sp->logo_pixmap = xscreensaver_logo (ssi->screen,
/* same visual as si->splash_dialog */
DefaultVisualOfScreen (ssi->screen),
si->splash_dialog, cmap,
sp->background,
&sp->logo_pixels, &sp->logo_npixels,
&sp->logo_clipmask, True);
XMapRaised (si->dpy, si->splash_dialog);
XSync (si->dpy, False);
si->sp_data = sp;
sp->timer = XtAppAddTimeOut (si->app, si->prefs.splash_duration,
unsplash_timer, (XtPointer) si);
draw_splash_window (si);
XSync (si->dpy, False);
}
int main (int argc, char **argv) {
Cursor cursor;
Display *display;
Window root, blub, *blubs = NULL;
unsigned clients;
unsigned long pixel;
char *cname;
XColor color;
int cnt;
Atom prop;
Pixmap save_pixmap = (Pixmap)None;
display = XOpenDisplay(NULL);
if(!display) return 1;
cname = argc == 2 ? argv[1] : "black";
screen = DefaultScreen(display);
root = RootWindow(display, screen);
pixel = BlackPixel(display, screen);
if(XParseColor(display, DefaultColormap(display, screen), cname, &color)) {
if(XAllocColor(display, DefaultColormap(display, screen), &color)) {
pixel = color.pixel;
}
}
XSetWindowBackground(display, root, pixel);
XClearWindow(display, root);
cursor = CreateCursorFromName(display,"watch");
if (cursor) {
XDefineCursor (display, root, cursor);
XFreeCursor (display, cursor);
}
if (fork() == 0) {
Window win;
XEvent xev;
close(0); close(1); close(2);
chdir("/");
display = XOpenDisplay(NULL);
// open a client...
if (display) {
win = XCreateSimpleWindow (
display, root, 0, 0, 1, 1, 0, 0, pixel
);
XSync(display, False);
}
// wait within event loop...
for(;;) XNextEvent(display, &xev);
}
// wait until the child has opened a client
cnt = 100;
do {
if (!XQueryTree (display, root, &blub, &blub, &blubs, &clients)) {
XCloseDisplay(display);
return 0;
}
usleep(50000);
} while(clients < 1 && cnt--);
save_pixmap = XCreatePixmap (display, root, 1, 1, 1);
prop = XInternAtom (display, "_XSETROOT_ID", False);
XChangeProperty (
display, root, prop, XA_PIXMAP, 32,
PropModeReplace, (unsigned char *) &save_pixmap, 1
);
XSetCloseDownMode (display, RetainPermanent);
// enable accessX
// XAccess (display,NULL);
XCloseDisplay(display);
RunWindowManager();
return 0;
}
static struct starfish *
reset_starfish (struct state *st)
{
XGCValues gcv;
unsigned int flags = 0;
XWindowAttributes xgwa;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->cmap = xgwa.colormap;
if (st->done_once)
{
if (st->colors && st->ncolors)
free_colors (xgwa.screen, st->cmap, st->colors, st->ncolors);
if (st->colors)
free (st->colors);
st->colors = 0;
XFreeGC (st->dpy, st->gc);
st->gc = 0;
}
//st->ncolors = get_integer_resource (st->dpy, "colors", "Colors");
st->ncolors = colors;
if (st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
if (mono_p)
st->colors = 0;
else
st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));
if (mono_p)
;
else if (random() % 3)
make_smooth_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
else
make_uniform_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
if (st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
st->fg_index = 0;
if (!mono_p && !st->blob_p)
{
flags |= GCForeground;
gcv.foreground = st->colors[st->fg_index].pixel;
XSetWindowBackground (st->dpy, st->window, gcv.foreground);
}
if (!st->done_once)
{
XClearWindow (st->dpy, st->window);
st->done_once = 1;
}
flags |= GCFillRule;
gcv.fill_rule = EvenOddRule;
st->gc = XCreateGC (st->dpy, st->window, flags, &gcv);
return make_window_starfish (st);
}
static void
set_window_color (int idx, const char *color)
{
const char *const msg = "can't load color \"%s\"";
XColor xcol;
int i;
if (color == NULL || *color == '\0')
return;
/* handle color aliases */
if (isdigit (*color))
{
i = atoi (color);
if (i >= 8 && i <= 15) /* bright colors */
{
i -= 8;
#ifndef NO_BRIGHTCOLOR
PixColors[idx] = PixColors[minBright + i];
goto Done;
#endif
}
if (i >= 0 && i <= 7) /* normal colors */
{
PixColors[idx] = PixColors[minColor + i];
goto Done;
}
}
if (!XParseColor (Xdisplay, Xcmap, color, &xcol) ||
!XAllocColor (Xdisplay, Xcmap, &xcol))
{
print_error (msg, color);
return;
}
/* XStoreColor (Xdisplay, Xcmap, XColor*); */
/*
* FIXME: should free colors here, but no idea how to do it so instead,
* so just keep gobbling up the colormap
*/
#if 0
for (i = blackColor; i <= whiteColor; i++)
if (PixColors[idx] == PixColors[i])
break;
if (i > whiteColor)
{
/* fprintf (stderr, "XFreeColors: PixColors [%d] = %lu\n", idx, PixColors [idx]); */
XFreeColors (Xdisplay, Xcmap, (PixColors + idx), 1,
DisplayPlanes (Xdisplay, Xscreen));
}
#endif
PixColors[idx] = xcol.pixel;
/* XSetWindowAttributes attr; */
/* Cursor cursor; */
Done:
if (idx == bgColor)
XSetWindowBackground (Xdisplay, TermWin.vt, PixColors[bgColor]);
/* handle colorBD, scrollbar background, etc. */
set_colorfgbg ();
{
XColor fg, bg;
fg.pixel = PixColors[fgColor];
XQueryColor (Xdisplay, Xcmap, &fg);
bg.pixel = PixColors[bgColor];
XQueryColor (Xdisplay, Xcmap, &bg);
XRecolorCursor (Xdisplay, TermWin_cursor, &fg, &bg);
}
/* the only reasonable way to enforce a clean update */
scr_poweron ();
}
/*
* create and map window,
* allocate colors and (shared) memory
*/
static int reconfig(struct vo *vo, struct mp_image_params *params)
{
struct vo_x11_state *x11 = vo->x11;
struct xvctx *ctx = vo->priv;
int i;
mp_image_unrefp(&ctx->original_image);
ctx->image_height = params->h;
ctx->image_width = params->w;
ctx->image_format = params->imgfmt;
if ((ctx->max_width != 0 && ctx->max_height != 0)
&& (ctx->image_width > ctx->max_width
|| ctx->image_height > ctx->max_height)) {
MP_ERR(vo, "Source image dimensions are too high: %ux%u (maximum is %ux%u)\n",
ctx->image_width, ctx->image_height, ctx->max_width,
ctx->max_height);
return -1;
}
/* check image formats */
ctx->xv_format = 0;
for (i = 0; i < ctx->formats; i++) {
MP_VERBOSE(vo, "Xvideo image format: 0x%x (%4.4s) %s\n",
ctx->fo[i].id, (char *) &ctx->fo[i].id,
(ctx->fo[i].format == XvPacked) ? "packed" : "planar");
if (ctx->fo[i].id == find_xv_format(ctx->image_format))
ctx->xv_format = ctx->fo[i].id;
}
if (!ctx->xv_format)
return -1;
vo_x11_config_vo_window(vo);
if (!ctx->f_gc && !ctx->vo_gc) {
ctx->f_gc = XCreateGC(x11->display, x11->window, 0, 0);
ctx->vo_gc = XCreateGC(x11->display, x11->window, 0, NULL);
XSetForeground(x11->display, ctx->f_gc, 0);
}
if (ctx->xv_ck_info.method == CK_METHOD_BACKGROUND)
XSetWindowBackground(x11->display, x11->window, ctx->xv_colorkey);
MP_VERBOSE(vo, "using Xvideo port %d for hw scaling\n", ctx->xv_port);
// In case config has been called before
for (i = 0; i < ctx->num_buffers; i++)
deallocate_xvimage(vo, i);
ctx->num_buffers = ctx->cfg_buffers;
for (i = 0; i < ctx->num_buffers; i++) {
if (!allocate_xvimage(vo, i)) {
MP_FATAL(vo, "could not allocate Xv image data\n");
return -1;
}
}
ctx->current_buf = 0;
ctx->current_ip_buf = 0;
int is_709 = params->colorspace == MP_CSP_BT_709;
xv_set_eq(vo, ctx->xv_port, "bt_709", is_709 * 200 - 100);
read_xv_csp(vo);
resize(vo);
return 0;
}
static bool gfx_ctx_set_video_mode(
unsigned width, unsigned height,
bool fullscreen)
{
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
bool windowed_full = g_settings.video.windowed_fullscreen;
bool true_full = false;
int x_off = 0;
int y_off = 0;
EGLint vid;
if (!eglGetConfigAttrib(g_egl_dpy, g_config, EGL_NATIVE_VISUAL_ID, &vid))
goto error;
temp.visualid = vid;
EGLint num_visuals;
vi = XGetVisualInfo(g_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
swa.colormap = g_cmap = XCreateColormap(g_dpy, RootWindow(g_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_dpy, width, height, &g_desktop_mode))
{
g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[X/EGL]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (g_settings.video.monitor_index)
g_screen = g_settings.video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_screen);
else
RARCH_LOG("[X/EGL]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[X/EGL]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_win = XCreateWindow(g_dpy, RootWindow(g_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_dpy, g_win, 0);
// GLES 2.0. Don't use for any other API.
static const EGLint egl_ctx_gles_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE,
};
g_egl_ctx = eglCreateContext(g_egl_dpy, g_config, EGL_NO_CONTEXT,
(g_api == GFX_CTX_OPENGL_ES_API) ? egl_ctx_gles_attribs : NULL);
if (!g_egl_ctx)
goto error;
g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, (EGLNativeWindowType)g_win, NULL);
if (!g_egl_surf)
goto error;
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
goto error;
gfx_ctx_update_window_title(true);
x11_set_window_attr(g_dpy, g_win);
if (fullscreen)
x11_hide_mouse(g_dpy, g_win);
if (true_full)
{
RARCH_LOG("[GLX]: Using true fullscreen.\n");
XMapRaised(g_dpy, g_win);
}
else if (fullscreen) // We attempted true fullscreen, but failed. Attempt using windowed fullscreen.
{
XMapRaised(g_dpy, g_win);
RARCH_LOG("[X/EGL]: Using windowed fullscreen.\n");
// We have to move the window to the screen we want to go fullscreen on first.
// x_off and y_off usually get ignored in XCreateWindow().
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_dpy, g_win);
}
else
{
XMapWindow(g_dpy, g_win);
// If we want to map the window on a different screen, we'll have to do it by force.
// Otherwise, we should try to let the window manager sort it out.
// x_off and y_off usually get ignored in XCreateWindow().
if (g_screen)
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
}
XEvent event;
XIfEvent(g_dpy, &event, egl_wait_notify, NULL);
XSetInputFocus(g_dpy, g_win, RevertToNone, CurrentTime);
g_quit_atom = XInternAtom(g_dpy, "WM_DELETE_WINDOW", False);
if (g_quit_atom)
XSetWMProtocols(g_dpy, g_win, &g_quit_atom, 1);
gfx_ctx_swap_interval(g_interval);
XFree(vi);
g_has_focus = true;
g_inited = true;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)g_dpy;
driver.video_window = (uintptr_t)g_win;
g_true_full = true_full;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_destroy();
return false;
}
static void readpw(Display *dpy, const char *pws)
{
char buf[32], passwd[256];
int num, screen;
unsigned int len, llen;
KeySym ksym;
XEvent ev;
len = llen = 0;
running = True;
while(running && !XNextEvent(dpy, &ev)) {
if(ev.type == KeyPress) {
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter) {
ksym = XK_Return;
} else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) {
ksym = (ksym - XK_KP_0) + XK_0;
}
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym) ||
IsMiscFunctionKey(ksym) || IsPFKey(ksym) ||
IsPrivateKeypadKey(ksym)) {
continue;
}
switch(ksym) {
case XK_Return:
if (strcmp(" v", passwd) == 0) {
system("shutdown -h now");
} else {
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = !!strcmp(crypt(passwd, pws), pws);
}
#endif
if(running)
XBell(dpy, 100);
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
}
break;
}
if(llen == 0 && len != 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
XClearWindow(dpy, locks[screen]->win);
}
} else if(llen != 0 && len == 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
XClearWindow(dpy, locks[screen]->win);
}
}
llen = len;
}
else for(screen = 0; screen < nscreens; screen++)
XRaiseWindow(dpy, locks[screen]->win);
}
}
// ----------------------------------------------------------------------------------------------
// Set window background to 'color'.
// ----------------------------------------------------------------------------------------------
void wsSetBackground( wsTWindow * win,int color )
{ XSetWindowBackground( wsDisplay,win->WindowID,color ); }
struct lowWindow *lowWindowInit( int w, int h )
{
#ifdef _GLDEBUG
printf("lowWindowInit\n");
#endif
struct lowWindow *window = NULL;
window = (struct lowWindow*)malloc(sizeof(struct lowWindow));
XInitThreads();
window->dpy = XOpenDisplay(NULL);
window->screen = DefaultScreen(window->dpy);
Window root;
unsigned long valuemask;
XWindowAttributes attr1;
XSetWindowAttributes attr;
attr.event_mask = ExposureMask | ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask;
root = RootWindow(window->dpy,window->screen);
XGetWindowAttributes(window->dpy,root,&attr1);
valuemask = CWEventMask;
#ifdef _OVERRIDE_REDIRECT
valuemask += CWOverrideRedirect;
attr.override_redirect = True;
#endif
window->id = XCreateWindow(
window->dpy,
root,
0,0,
w, h,
1, DefaultDepth(window->dpy,window->screen),
CopyFromParent,
DefaultVisual(window->dpy,window->screen),
valuemask, &attr
);
window->surface = (unsigned char*)malloc(w*h*4);
int count = 0;
XPixmapFormatValues *formats = NULL;
XPixmapFormatValues *format = NULL;
formats = XListPixmapFormats(window->dpy,&count);
for(format = formats; count > 0; count--, format++)
{
if (format->depth == DefaultDepth(window->dpy,window->screen))
{
window->ximage = XCreateImage(
window->dpy,
DefaultVisual(window->dpy,window->screen),
DefaultDepth(window->dpy,window->screen),
ZPixmap,
0,
(char*)window->surface,
w,h,
format->scanline_pad,
0
);
}
}
XSetWindowBackground(window->dpy,window->id,
BlackPixel(window->dpy,window->screen));
XSelectInput(window->dpy,window->id,
ExposureMask|ButtonPressMask|ButtonReleaseMask|ButtonMotionMask);
XMapWindow(window->dpy,window->id);
return window;
}
int
XMenuActivate(
register Display *display, /* Display to put menu on. */
register XMenu *menu, /* Menu to activate. */
int *p_num, /* Pane number selected. */
int *s_num, /* Selection number selected. */
int x_pos, /* X coordinate of menu position. */
int y_pos, /* Y coordinate of menu position. */
unsigned int event_mask, /* Mouse button event mask. */
char **data, /* Pointer to return data value. */
void (*help_callback) (char const *, int, int)) /* Help callback. */
{
int status; /* X routine call status. */
int orig_x; /* Upper left menu origin X coord. */
int orig_y; /* Upper left menu origin Y coord. */
int ret_val; /* Return value. */
register XMPane *p_ptr; /* Current XMPane. */
register XMPane *event_xmp; /* Event XMPane pointer. */
register XMPane *cur_p; /* Current pane. */
register XMSelect *cur_s; /* Current selection. */
XMWindow *event_xmw; /* Event XMWindow pointer. */
XEvent event; /* X input event. */
XEvent peek_event; /* X input peek ahead event. */
Bool selection = False; /* Selection has been made. */
Bool forward = True; /* Moving forward in the pane list. */
Window root, child;
int root_x, root_y, win_x, win_y;
unsigned int mask;
KeySym keysym;
/*
* Define and allocate a foreign event queue to hold events
* that don't belong to XMenu. These events are later restored
* to the X event queue.
*/
typedef struct _xmeventque {
XEvent event;
struct _xmeventque *next;
} XMEventQue;
XMEventQue *feq = NULL; /* Foreign event queue. */
XMEventQue *feq_tmp; /* Foreign event queue temporary. */
/*
* If there are no panes in the menu then return failure
* because the menu is not initialized.
*/
if (menu->p_count == 0) {
_XMErrorCode = XME_NOT_INIT;
return(XM_FAILURE);
}
/*
* Find the desired current pane.
*/
cur_p = _XMGetPanePtr(menu, *p_num);
if (cur_p == NULL) {
return(XM_FAILURE);
}
cur_p->activated = cur_p->active;
/*
* Find the desired current selection.
* If the current selection index is out of range a null current selection
* will be assumed and the cursor will be placed in the current pane
* header.
*/
cur_s = _XMGetSelectionPtr(cur_p, *s_num);
/*
* Compute origin of menu so that cursor is in
* Correct pane and selection.
*/
_XMTransToOrigin(display,
menu,
cur_p, cur_s,
x_pos, y_pos,
&orig_x, &orig_y);
menu->x_pos = orig_x; /* Store X and Y coords of menu. */
menu->y_pos = orig_y;
if (XMenuRecompute(display, menu) == XM_FAILURE) {
return(XM_FAILURE);
}
/*
* Flush the window creation queue.
* This batches all window creates since lazy evaluation
* is more efficient than individual evaluation.
* This routine also does an XFlush().
*/
if (_XMWinQueFlush(display, menu, cur_p, cur_s) == _FAILURE) {
return(XM_FAILURE);
}
/*
* Make sure windows are in correct order (in case we were passed
* an already created menu in incorrect order.)
*/
for(p_ptr = menu->p_list->next; p_ptr != cur_p; p_ptr = p_ptr->next)
XRaiseWindow(display, p_ptr->window);
for(p_ptr = menu->p_list->prev; p_ptr != cur_p->prev; p_ptr = p_ptr->prev)
XRaiseWindow(display, p_ptr->window);
/*
* Make sure all selection windows are mapped.
*/
for (
p_ptr = menu->p_list->next;
p_ptr != menu->p_list;
p_ptr = p_ptr->next
){
XMapSubwindows(display, p_ptr->window);
}
/*
* Synchronize the X buffers and the event queue.
* From here on, all events in the queue that don't belong to
* XMenu are sent back to the application via an application
* provided event handler or discarded if the application has
* not provided an event handler.
*/
XSync(display, 0);
/*
* Grab the mouse for menu input.
*/
status = XGrabPointer(
display,
menu->parent,
True,
event_mask,
GrabModeAsync,
GrabModeAsync,
None,
menu->mouse_cursor,
CurrentTime
);
if (status == Success && x_menu_grab_keyboard)
{
status = XGrabKeyboard (display,
menu->parent,
False,
GrabModeAsync,
GrabModeAsync,
CurrentTime);
if (status != Success)
XUngrabPointer(display, CurrentTime);
}
if (status == _X_FAILURE) {
_XMErrorCode = XME_GRAB_MOUSE;
return(XM_FAILURE);
}
/*
* Map the menu panes.
*/
XMapWindow(display, cur_p->window);
for (p_ptr = menu->p_list->next;
p_ptr != cur_p;
p_ptr = p_ptr->next)
XMapWindow(display, p_ptr->window);
for (p_ptr = cur_p->next;
p_ptr != menu->p_list;
p_ptr = p_ptr->next)
XMapWindow(display, p_ptr->window);
XRaiseWindow(display, cur_p->window); /* Make sure current */
/* pane is on top. */
cur_s = NULL; /* Clear current selection. */
/*
* Begin event processing loop.
*/
while (1) {
if (wait_func) (*wait_func) (wait_data);
XNextEvent(display, &event); /* Get next event. */
switch (event.type) { /* Dispatch on the event type. */
case Expose:
event_xmp = (XMPane *)XLookUpAssoc(display,
menu->assoc_tab,
event.xexpose.window);
if (event_xmp == NULL) {
/*
* If AEQ mode is enabled then queue the event.
*/
if (menu->aeq) {
feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
if (feq_tmp == NULL) {
_XMErrorCode = XME_CALLOC;
return(XM_FAILURE);
}
feq_tmp->event = event;
feq_tmp->next = feq;
feq = feq_tmp;
}
else if (_XMEventHandler) (*_XMEventHandler)(&event);
break;
}
if (event_xmp->activated) {
XSetWindowBackground(display,
event_xmp->window,
menu->bkgnd_color);
}
else {
XSetWindowBackgroundPixmap(display,
event_xmp->window,
menu->inact_pixmap);
}
_XMRefreshPane(display, menu, event_xmp);
break;
case EnterNotify:
/*
* First wait a small period of time, and see
* if another EnterNotify event follows hard on the
* heels of this one. i.e., the user is simply
* "passing through". If so, ignore this one.
*/
event_xmw = (XMWindow *)XLookUpAssoc(display,
menu->assoc_tab,
event.xcrossing.window);
if (event_xmw == NULL) break;
if (event_xmw->type == SELECTION) {
/*
* We have entered a selection.
*/
/* if (XPending(display) == 0) usleep(150000); */
if (XPending(display) != 0) {
XPeekEvent(display, &peek_event);
if(peek_event.type == LeaveNotify) {
break;
}
}
cur_s = (XMSelect *)event_xmw;
help_callback (cur_s->help_string,
cur_p->serial, cur_s->serial);
/*
* If the pane we are in is active and the
* selection entered is active then activate
* the selection.
*/
if (cur_p->active && cur_s->active > 0) {
cur_s->activated = 1;
_XMRefreshSelection(display, menu, cur_s);
}
}
else {
/*
* We have entered a pane.
*/
/* if (XPending(display) == 0) usleep(150000); */
if (XPending(display) != 0) {
XPeekEvent(display, &peek_event);
if (peek_event.type == EnterNotify) break;
}
XQueryPointer(display,
menu->parent,
&root, &child,
&root_x, &root_y,
&win_x, &win_y,
&mask);
event_xmp = (XMPane *)XLookUpAssoc(display,
menu->assoc_tab,
child);
if (event_xmp == NULL) break;
if (event_xmp == cur_p) break;
if (event_xmp->serial > cur_p->serial) forward = True;
else forward = False;
p_ptr = cur_p;
while (p_ptr != event_xmp) {
if (forward) p_ptr = p_ptr->next;
else p_ptr = p_ptr->prev;
XRaiseWindow(display, p_ptr->window);
}
if (cur_p->activated) {
cur_p->activated = False;
XSetWindowBackgroundPixmap(display,
cur_p->window,
menu->inact_pixmap);
_XMRefreshPane(display, menu, cur_p);
}
if (event_xmp->active) event_xmp->activated = True;
#if 1
/*
* i suspect the we don't get an EXPOSE event when backing
* store is enabled; the menu windows content is probably
* not drawn in when it should be in that case.
* in that case, this is probably an ugly fix!
* i hope someone more familiar with this code would
* take it from here. -- [email protected].
*/
XSetWindowBackground(display,
event_xmp->window,
menu->bkgnd_color);
_XMRefreshPane(display, menu, event_xmp);
#endif
cur_p = event_xmp;
}
break;
case LeaveNotify:
event_xmw = (XMWindow *)XLookUpAssoc(
display,
menu->assoc_tab,
event.xcrossing.window
);
if (event_xmw == NULL) break;
if(cur_s == NULL) break;
/*
* If the current selection was activated then
* deactivate it.
*/
if (cur_s->activated) {
cur_s->activated = False;
_XMRefreshSelection(display, menu, cur_s);
}
cur_s = NULL;
break;
case ButtonPress:
case ButtonRelease:
*p_num = cur_p->serial;
/*
* Check to see if there is a current selection.
*/
if (cur_s != NULL) {
/*
* Set the selection number to the current selection.
*/
*s_num = cur_s->serial;
/*
* If the current selection was activated then
* we have a valid selection otherwise we have
* an inactive selection.
*/
if (cur_s->activated) {
*data = cur_s->data;
ret_val = XM_SUCCESS;
}
else {
ret_val = XM_IA_SELECT;
}
}
else {
/*
* No selection was current.
*/
ret_val = XM_NO_SELECT;
}
selection = True;
break;
case KeyPress:
case KeyRelease:
keysym = XLookupKeysym (&event.xkey, 0);
/* Pop down on C-g and Escape. */
if ((keysym == XK_g && (event.xkey.state & ControlMask) != 0)
|| keysym == XK_Escape) /* Any escape, ignore modifiers. */
{
ret_val = XM_NO_SELECT;
selection = True;
}
break;
default:
/*
* If AEQ mode is enabled then queue the event.
*/
if (menu->aeq) {
feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
if (feq_tmp == NULL) {
_XMErrorCode = XME_CALLOC;
return(XM_FAILURE);
}
feq_tmp->event = event;
feq_tmp->next = feq;
feq = feq_tmp;
}
else if (_XMEventHandler) (*_XMEventHandler)(&event);
}
/*
* If a selection has been made, break out of the event loop.
*/
if (selection == True) break;
}
/*
* Unmap the menu.
*/
for ( p_ptr = menu->p_list->next;
p_ptr != menu->p_list;
p_ptr = p_ptr->next)
{
XUnmapWindow(display, p_ptr->window);
}
/*
* Ungrab the mouse.
*/
XUngrabPointer(display, CurrentTime);
XUngrabKeyboard(display, CurrentTime);
/*
* Restore bits under where the menu was if we managed
* to save them and free the pixmap.
*/
/*
* If there is a current selection deactivate it.
*/
if (cur_s != NULL) cur_s->activated = 0;
/*
* Deactivate the current pane.
*/
cur_p->activated = 0;
XSetWindowBackgroundPixmap(display, cur_p->window, menu->inact_pixmap);
/*
* Synchronize the X buffers and the X event queue.
*/
XSync(display, 0);
/*
* Dispatch any events remaining on the queue.
*/
while (QLength(display)) {
/*
* Fetch the next event.
*/
XNextEvent(display, &event);
/*
* Discard any events left on the queue that belong to XMenu.
* All others are held and then returned to the event queue.
*/
switch (event.type) {
case Expose:
case EnterNotify:
case LeaveNotify:
case ButtonPress:
case ButtonRelease:
/*
* Does this event belong to one of XMenu's windows?
* If so, discard it and process the next event.
* If not fall through and treat it as a foreign event.
*/
event_xmp = (XMPane *)XLookUpAssoc(
display,
menu->assoc_tab,
event.xbutton.window
);
if (event_xmp != NULL) continue;
default:
/*
* This is a foreign event.
* Queue it for later return to the X event queue.
*/
feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
if (feq_tmp == NULL) {
_XMErrorCode = XME_CALLOC;
return(XM_FAILURE);
}
feq_tmp->event = event;
feq_tmp->next = feq;
feq = feq_tmp;
}
}
/*
* Return any foreign events that were queued to the X event queue.
*/
while (feq != NULL) {
feq_tmp = feq;
XPutBackEvent(display, &feq_tmp->event);
feq = feq_tmp->next;
free((char *)feq_tmp);
}
wait_func = 0;
/*
* Return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(ret_val);
}
static void
initcolors(GRAPH *graph)
{
int i;
static char *colornames[] = { "black", /* white */
"white", "red", "blue",
"orange", "green", "pink",
"brown", "khaki", "plum",
"orchid", "violet", "maroon",
"turquoise", "sienna", "coral",
"cyan", "magenta", "gold",
"yellow", ""
};
XColor visualcolor, exactcolor;
char buf[BSIZE_SP], colorstring[BSIZE_SP];
int xmaxcolors = NUMCOLORS; /* note: can we get rid of this? */
if (numdispplanes == 1) {
/* black and white */
xmaxcolors = 2;
graph->colors[0] = DEVDEP(graph).view->core.background_pixel;
if (graph->colors[0] == WhitePixel(display, DefaultScreen(display)))
graph->colors[1] = BlackPixel(display, DefaultScreen(display));
else
graph->colors[1] = WhitePixel(display, DefaultScreen(display));
} else {
if (numdispplanes < NXPLANES)
xmaxcolors = 1 << numdispplanes;
for (i = 0; i < xmaxcolors; i++) {
(void) sprintf(buf, "color%d", i);
if (!cp_getvar(buf, VT_STRING, colorstring))
(void) strcpy(colorstring, colornames[i]);
if (!XAllocNamedColor(display,
DefaultColormap(display, DefaultScreen(display)),
colorstring, &visualcolor, &exactcolor)) {
(void) sprintf(ErrorMessage,
"can't get color %s\n", colorstring);
externalerror(ErrorMessage);
graph->colors[i] = i ? BlackPixel(display,
DefaultScreen(display))
: WhitePixel(display, DefaultScreen(display));
continue;
}
graph->colors[i] = visualcolor.pixel;
/* MW. I don't need this, everyone must know what he is doing
if (i > 0 &&
graph->colors[i] == DEVDEP(graph).view->core.background_pixel) {
graph->colors[i] = graph->colors[0];
} */
}
/* MW. Set Beackgroound here */
XSetWindowBackground(display, DEVDEP(graph).window, graph->colors[0]);
/* if (graph->colors[0] != DEVDEP(graph).view->core.background_pixel) {
graph->colors[0] = DEVDEP(graph).view->core.background_pixel;
} */
}
for (i = xmaxcolors; i < NUMCOLORS; i++) {
graph->colors[i] = graph->colors[i + 1 - xmaxcolors];
}
}
static bool gfx_ctx_xegl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
EGLint egl_attribs[16];
EGLint *attr;
EGLint vid, num_visuals;
bool windowed_full;
bool true_full = false;
int x_off = 0;
int y_off = 0;
struct sigaction sa = {{0}};
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
sa.sa_handler = egl_sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
windowed_full = g_settings.video.windowed_fullscreen;
true_full = false;
int (*old_handler)(Display*, XErrorEvent*) = NULL;
attr = egl_attribs;
attr = xegl_fill_attribs(attr);
if (!eglGetConfigAttrib(g_egl_dpy, g_config, EGL_NATIVE_VISUAL_ID, &vid))
goto error;
temp.visualid = vid;
vi = XGetVisualInfo(g_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
swa.colormap = g_cmap = XCreateColormap(g_dpy, RootWindow(g_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_dpy, width, height, &g_desktop_mode))
{
g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[X/EGL]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (g_settings.video.monitor_index)
g_screen = g_settings.video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_screen);
else
RARCH_LOG("[X/EGL]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[X/EGL]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_win = XCreateWindow(g_dpy, RootWindow(g_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_dpy, g_win, 0);
g_egl_ctx = eglCreateContext(g_egl_dpy, g_config, EGL_NO_CONTEXT,
attr != egl_attribs ? egl_attribs : NULL);
RARCH_LOG("[X/EGL]: Created context: %p.\n", (void*)g_egl_ctx);
if (g_egl_ctx == EGL_NO_CONTEXT)
goto error;
if (g_use_hw_ctx)
{
g_egl_hw_ctx = eglCreateContext(g_egl_dpy, g_config, g_egl_ctx,
attr != egl_attribs ? egl_attribs : NULL);
RARCH_LOG("[X/EGL]: Created shared context: %p.\n", (void*)g_egl_hw_ctx);
if (g_egl_hw_ctx == EGL_NO_CONTEXT)
goto error;
}
g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, (EGLNativeWindowType)g_win, NULL);
if (!g_egl_surf)
goto error;
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
goto error;
RARCH_LOG("[X/EGL]: Current context: %p.\n", (void*)eglGetCurrentContext());
x11_set_window_attr(g_dpy, g_win);
if (fullscreen)
x11_show_mouse(g_dpy, g_win, false);
if (true_full)
{
RARCH_LOG("[X/EGL]: Using true fullscreen.\n");
XMapRaised(g_dpy, g_win);
}
else if (fullscreen)
{
/* We attempted true fullscreen, but failed.
* Attempt using windowed fullscreen. */
XMapRaised(g_dpy, g_win);
RARCH_LOG("[X/EGL]: Using windowed fullscreen.\n");
/* We have to move the window to the screen we
* want to go fullscreen on first.
* x_off and y_off usually get ignored in XCreateWindow().
*/
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_dpy, g_win);
}
else
{
XMapWindow(g_dpy, g_win);
/* If we want to map the window on a different screen,
* we'll have to do it by force.
*
* Otherwise, we should try to let the window manager sort it out.
* x_off and y_off usually get ignored in XCreateWindow().
*/
if (g_screen)
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
}
XEvent event;
XIfEvent(g_dpy, &event, egl_wait_notify, NULL);
g_quit_atom = XInternAtom(g_dpy, "WM_DELETE_WINDOW", False);
if (g_quit_atom)
XSetWMProtocols(g_dpy, g_win, &g_quit_atom, 1);
gfx_ctx_xegl_swap_interval(data, g_interval);
/* This can blow up on some drivers. It's not fatal,
* so override errors for this call.
*/
old_handler = XSetErrorHandler(egl_nul_handler);
XSetInputFocus(g_dpy, g_win, RevertToNone, CurrentTime);
XSync(g_dpy, False);
XSetErrorHandler(old_handler);
XFree(vi);
g_has_focus = true;
g_inited = true;
if (!x11_create_input_context(g_dpy, g_win, &g_xim, &g_xic))
goto error;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)g_dpy;
driver.video_window = (uintptr_t)g_win;
g_true_full = true_full;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_xegl_destroy(data);
return false;
}
readpw(Display *dpy, const char *pws)
#endif
{
char buf[32], passwd[256];
int num, screen;
#if !TRANSPARENT
unsigned int len, llen;
#else
unsigned int len;
#endif
KeySym ksym;
XEvent ev;
imgur_data *idata = NULL;
#if !TRANSPARENT
len = llen = 0;
#else
len = 0;
#endif
running = True;
/* As "slock" stands for "Simple X display locker", the DPMS settings
* had been removed and you can set it with "xset" or some other
* utility. This way the user can easily set a customized DPMS
* timeout. */
while(running && !XNextEvent(dpy, &ev)) {
if(ev.type == KeyPress) {
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter)
ksym = XK_Return;
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
ksym = (ksym - XK_KP_0) + XK_0;
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|| IsPrivateKeypadKey(ksym))
continue;
switch(ksym) {
case XK_Return:
passwd[len] = 0;
if(g_pw) {
running = !!strcmp(passwd, g_pw);
} else {
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = !!strcmp(crypt(passwd, pws), pws);
#endif
}
if(running) {
XBell(dpy, 100);
lock_tries++;
// Poweroff if there are more than 5 bad attempts.
if(lock_tries > 5) {
// Disable alt+sysrq and crtl+alt+backspace
disable_kill();
// Take a webcam shot of whoever is tampering with our machine:
webcam_shot(0);
// Upload the image:
idata = imgur_upload();
// Send an SMS/MMS via twilio:
twilio_send("Bad screenlock password.", idata, 0);
// Delete the image from imgur:
imgur_delete(idata);
// Immediately poweroff:
poweroff();
// If we failed, simply resume:
len = 0;
break;
} else {
// Take a webcam shot of whoever is tampering with our machine:
webcam_shot(1);
// Send an SMS via twilio:
twilio_send("Bad screenlock password.", NULL, 1);
}
// Play a siren if there are more than 2 bad
// passwords, a beep if a correct password:
if(lock_tries > 2) {
play_alarm(0);
} else {
play_beep(0);
}
#if 0
} else {
play_beep(1);
#endif
}
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_Delete:
case XK_BackSpace:
if(len)
--len;
break;
case XK_Alt_L:
case XK_Alt_R:
case XK_Control_L:
case XK_Control_R:
case XK_Meta_L:
case XK_Meta_R:
case XK_Super_L:
case XK_Super_R:
case XK_F1:
case XK_F2:
case XK_F3:
case XK_F4:
case XK_F5:
case XK_F6:
case XK_F7:
case XK_F8:
case XK_F9:
case XK_F10:
case XK_F11:
case XK_F12:
case XK_F13:
// case XK_BackSpace:
// Disable alt+sysrq and crtl+alt+backspace
disable_kill();
// Take a webcam shot of whoever is tampering with our machine:
webcam_shot(0);
// Upload our image:
idata = imgur_upload();
// Send an SMS/MMS via twilio:
twilio_send("Bad screenlock key.", idata, 0);
// Delete the image from imgur:
imgur_delete(idata);
// Immediately poweroff:
poweroff();
; // fall-through if we fail
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
}
break;
}
#if !TRANSPARENT
if(llen == 0 && len != 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
XClearWindow(dpy, locks[screen]->win);
}
} else if(llen != 0 && len == 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
XClearWindow(dpy, locks[screen]->win);
}
}
llen = len;
#endif
}
else for(screen = 0; screen < nscreens; screen++)
XRaiseWindow(dpy, locks[screen]->win);
}
}
/*
* connect to server, create and map window,
* allocate colors and (shared) memory
*/
static int config(struct vo *vo, uint32_t width, uint32_t height,
uint32_t d_width, uint32_t d_height, uint32_t flags,
uint32_t format)
{
struct vo_x11_state *x11 = vo->x11;
struct xvctx *ctx = vo->priv;
int i;
mp_image_unrefp(&ctx->original_image);
ctx->image_height = height;
ctx->image_width = width;
ctx->image_format = format;
if ((ctx->max_width != 0 && ctx->max_height != 0)
&& (ctx->image_width > ctx->max_width
|| ctx->image_height > ctx->max_height)) {
MP_ERR(vo, "Source image dimensions are too high: %ux%u (maximum is %ux%u)\n",
ctx->image_width, ctx->image_height, ctx->max_width,
ctx->max_height);
return -1;
}
/* check image formats */
ctx->xv_format = 0;
for (i = 0; i < ctx->formats; i++) {
MP_VERBOSE(vo, "Xvideo image format: 0x%x (%4.4s) %s\n",
ctx->fo[i].id, (char *) &ctx->fo[i].id,
(ctx->fo[i].format == XvPacked) ? "packed" : "planar");
if (ctx->fo[i].id == find_xv_format(format))
ctx->xv_format = ctx->fo[i].id;
}
if (!ctx->xv_format)
return -1;
vo_x11_config_vo_window(vo, NULL, vo->dwidth, vo->dheight, flags, "xv");
if (ctx->xv_ck_info.method == CK_METHOD_BACKGROUND)
XSetWindowBackground(x11->display, x11->window, ctx->xv_colorkey);
MP_VERBOSE(vo, "using Xvideo port %d for hw scaling\n", ctx->xv_port);
// In case config has been called before
for (i = 0; i < ctx->num_buffers; i++)
deallocate_xvimage(vo, i);
ctx->num_buffers = 2;
for (i = 0; i < ctx->num_buffers; i++) {
if (!allocate_xvimage(vo, i)) {
MP_FATAL(vo, "could not allocate Xv image data\n");
return -1;
}
}
ctx->current_buf = 0;
ctx->current_ip_buf = 0;
resize(vo);
return 0;
}
int main(int argc, char** argv)
{
Cursor cursor;
Display *display;
Window root;
unsigned long pixel;
char* cname;
XColor color;
Atom prop;
Pixmap save_pixmap = (Pixmap)None;
//============================================
// open display and check if we got a display
//--------------------------------------------
display = XOpenDisplay(NULL);
if (!display) {
exit (1);
}
if ((argc == 2) && (strcmp(argv[1], "--fast") == 0)) {
XCloseDisplay(display);
exit (0);
}
//============================================
// install color map for background pixels
//--------------------------------------------
cname = argc == 2 ? argv[1] : "black";
screen = DefaultScreen(display);
root = RootWindow(display, screen);
pixel = BlackPixel(display, screen);
if (XParseColor(display, DefaultColormap(display, screen), cname, &color)) {
if (XAllocColor(display, DefaultColormap(display, screen), &color)) {
pixel = color.pixel;
}
}
XSetWindowBackground(display, root, pixel);
XClearWindow(display, root);
//============================================
// set watch cursor
//--------------------------------------------
cursor = CreateCursorFromName(display, "top_left_arrow");
if (cursor) {
XDefineCursor(display, root, cursor);
XFreeCursor(display, cursor);
}
//============================================
// run the windowmanager (FVWM)
//--------------------------------------------
RunWindowManager();
//============================================
// save background as pixmap
//--------------------------------------------
save_pixmap = XCreatePixmap(display, root, 1, 1, 1);
prop = XInternAtom(display, "_XSETROOT_ID", False);
XChangeProperty(display, root, prop, XA_PIXMAP, 32, PropModeReplace,
(unsigned char*) &save_pixmap, 1);
XSetCloseDownMode(display, RetainPermanent);
//============================================
// close display and exit
//--------------------------------------------
XCloseDisplay(display);
exit (0);
}
int main(int argc, char **argv)
{
int state_count = 0;
Atom states[10];
Atom type = 0;
int i,x_r,y_r;
unsigned int h_r,w_r;
int ret;
int ewmh_state_arg = 0;
int ewmh_type_arg = 0;
int mwm_func_arg = 0;
int mwm_decor_arg = 0;
int has_ewmh_desktop = 0;
Atom ewmh_desktop = 0;
XSizeHints hints;
XClassHint classhints;
XWMHints wm_hints;
PropMwmHints mwm_hints;
Window trans_win = 0;
if (!(dpy = XOpenDisplay("")))
{
fprintf(stderr, "can't open display\n");
exit(1);
}
screen = DefaultScreen(dpy);
Root = RootWindow(dpy, screen);
InitAtom();
hints.width = 170;
hints.height = 100;
hints.x = 0;
hints.y = 0;
hints.flags = 0;
wm_hints.flags = 0;
mwm_hints.props[0] = 0;
mwm_hints.props[1] = 0;
mwm_hints.props[2] = 0;
mwm_hints.props[3] = 0;
win = XCreateSimpleWindow(
dpy, Root, 0, 0, hints.width, hints.height, 0, 0, 0);
for (i = 1; i < argc; i++)
{
char *error_arg = NULL;
if (strcasecmp(argv[i], "--help") == 0)
{
show_usage();
exit(0);
}
else if (strcasecmp(argv[i], "--ewmh-state") == 0)
{
ewmh_state_arg = 1;
ewmh_type_arg = 0;
mwm_func_arg = 0;
mwm_decor_arg = 0;
}
else if (strcasecmp(argv[i], "--ewmh-type") == 0)
{
ewmh_state_arg = 0;
ewmh_type_arg = 1;
mwm_func_arg = 0;
mwm_decor_arg = 0;
}
else if (strcasecmp(argv[i], "--mwm-func") == 0)
{
ewmh_state_arg = 0;
ewmh_type_arg = 0;
mwm_func_arg = 1;
mwm_decor_arg = 0;
}
else if (strcasecmp(argv[i], "--mwm-decor") == 0)
{
ewmh_state_arg = 0;
ewmh_type_arg = 0;
mwm_func_arg = 0;
mwm_decor_arg = 1;
}
else if (strcasecmp(argv[i], "--min-size") == 0)
{
i++;
hints.min_width = atoi(argv[i]);
i++;
hints.min_height = atoi(argv[i]);
hints.flags |= PMinSize;
}
else if (strcasecmp(argv[i], "--max-size") == 0)
{
i++;
hints.max_width = atoi(argv[i]);
i++;
hints.max_height = atoi(argv[i]);
hints.flags |= PMaxSize;
}
else if (strcasecmp(argv[i], "--inc-size") == 0)
{
i++;
hints.width_inc = atoi(argv[i]);
i++;
hints.height_inc = atoi(argv[i]);
hints.flags |= PResizeInc;
}
else if (strcasecmp(argv[i], "--p-geometry") == 0)
{
i++;
ret = XParseGeometry(argv[i], &x_r, &y_r, &w_r, &h_r);
if ((ret & WidthValue) && (ret & HeightValue))
{
hints.width = w_r;
hints.height = h_r;
hints.flags |= PSize;
}
if ((ret & XValue) && (ret & YValue))
{
hints.x = x_r;
hints.y = y_r;
hints.win_gravity = NorthWestGravity;
if (ret & XNegative)
{
hints.x += XDisplayWidth(dpy, screen) -
hints.width;
hints.win_gravity = NorthEastGravity;
}
if (ret & YNegative)
{
hints.y += XDisplayHeight(dpy, screen) -
hints.height;
if (ret & XNegative)
{
hints.win_gravity =
SouthEastGravity;
}
else
{
hints.win_gravity =
SouthWestGravity;
}
hints.flags |= PWinGravity;
}
hints.flags |= PPosition;
}
}
else if (strcasecmp(argv[i], "--us-geometry") == 0)
{
i++;
ret = XParseGeometry(argv[i], &x_r, &y_r, &w_r, &h_r);
if ((ret & WidthValue) && (ret & HeightValue))
{
hints.width = w_r;
hints.height = h_r;
hints.flags |= USSize;
}
if ((ret & XValue) && (ret & YValue))
{
hints.x = x_r;
hints.y = y_r;
hints.win_gravity=NorthWestGravity;
if (ret & XNegative)
{
hints.x += XDisplayWidth(dpy,screen) -
hints.width;
hints.win_gravity=NorthEastGravity;
}
if (ret & YNegative)
{
hints.y += XDisplayHeight(dpy,screen) -
hints.height;
if (ret & XNegative)
{
hints.win_gravity =
SouthEastGravity;
}
else
{
hints.win_gravity =
SouthWestGravity;
}
}
hints.flags |= USPosition | PWinGravity;
}
}
else if (strcasecmp(argv[i], "--input") == 0)
{
i++;
if (strcasecmp(argv[i], "true") == 0)
{
wm_hints.input = input_mode = True;
wm_hints.flags |= InputHint;
}
else if (strcasecmp(argv[i], "false") == 0)
{
wm_hints.input = input_mode = False;
wm_hints.flags |= InputHint;
}
else
{
error_arg = "--input";
}
}
else if (strcasecmp(argv[i], "--focus-proto") == 0)
{
has_focus_proto = 1;
}
else if (strcasecmp(argv[i], "--no-delete-proto") == 0)
{
has_delete_proto = 0;
}
else if (strcasecmp(argv[i], "--wm-state") == 0)
{
wm_hints.flags |= StateHint;
i++;
if (strcasecmp(argv[i], "withdrawn") == 0)
{
wm_hints.initial_state = WithdrawnState;
}
else if (strcasecmp(argv[i], "normal") == 0)
{
wm_hints.initial_state = NormalState;
}
else if (strcasecmp(argv[i], "iconic") == 0)
{
wm_hints.initial_state = IconicState;
}
else
{
error_arg = "--wm-state";
}
}
else if (strcasecmp(argv[i], "--wm-urgency") == 0)
{
wm_hints.flags |= XUrgencyHint;
}
else if (strcasecmp(argv[i], "--wm-group") == 0)
{
wm_hints.flags |= WindowGroupHint;
i++;
if (strcasecmp(argv[i], "window") == 0)
{
wm_hints.window_group = win;
}
else if (strcasecmp(argv[i], "root") == 0)
{
wm_hints.window_group = Root;
}
else
{
wm_hints.window_group =
strtoul(argv[i], NULL, 0);
}
}
else if (strcasecmp(argv[i], "--transient") == 0)
{
i++;
if (strcasecmp(argv[i],"root") == 0)
{
trans_win = Root;
}
else
{
trans_win = strtoul(argv[i], NULL, 0);
}
}
else if (strcasecmp(argv[i], "--mwm-input") == 0)
{
mwm_hints.props[0] |= MWM_HINTS_INPUT_MODE;
i++;
if (strcasecmp(argv[i], "modless") == 0)
{
mwm_hints.props[3] = MWM_INPUT_MODELESS;
}
else if (strcasecmp(argv[i], "app_modal") == 0)
{
mwm_hints.props[3] =
MWM_INPUT_PRIMARY_APPLICATION_MODAL;
}
else if (strcasecmp(argv[i], "sys_modal") == 0)
{
mwm_hints.props[3] =
MWM_INPUT_SYSTEM_MODAL;
}
else if (strcasecmp(argv[i], "full_app_modal") == 0)
{
mwm_hints.props[3] =
MWM_INPUT_FULL_APPLICATION_MODAL;
}
else
{
error_arg = "--mwm-input";
}
}
else if (strcasecmp(argv[i], "--ewmh-desktop") == 0)
{
has_ewmh_desktop = 1;
i++;
ewmh_desktop = atol(argv[i]);
}
else if (ewmh_state_arg && state_count < 10)
{
if (strcasecmp(argv[i], "hidden") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_HIDDEN;
}
else if (strcasecmp(argv[i], "shaded") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_SHADED;
}
else if (strcasecmp(argv[i], "sticky") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_STICKY;
}
else if (strcasecmp(argv[i], "skippager") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_SKIP_PAGER;
}
else if (strcasecmp(argv[i], "skiptaskbar") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_SKIP_TASKBAR;
}
else if (strcasecmp(argv[i], "maxhoriz") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_MAXIMIZED_HORIZ;
}
else if (strcasecmp(argv[i], "maxvert") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_MAXIMIZED_VERT;
}
else if (strcasecmp(argv[i], "modal") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_MODAL;
}
else if (strcasecmp(argv[i], "staysontop") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_STAYS_ON_TOP;
}
else if (strcasecmp(argv[i], "fullscreen") == 0)
{
states[state_count++] =
ATOM_NET_WM_STATE_FULLSCREEN;
}
else
{
error_arg = "--ewmh-state";
}
}
else if (ewmh_type_arg)
{
if (strcasecmp(argv[i], "normal") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_NORMAL;
}
else if (strcasecmp(argv[i], "dock") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_DOCK;
}
else if (strcasecmp(argv[i], "toolbar") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_TOOLBAR;
}
else if (strcasecmp(argv[i], "desktop") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_DESKTOP;
}
else if (strcasecmp(argv[i], "menu") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_MENU;
}
else if (strcasecmp(argv[i], "dialog") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_DIALOG;
}
else if (strcasecmp(argv[i], "splash") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_SPLASH;
}
else if (strcasecmp(argv[i], "utility") == 0)
{
type = ATOM_NET_WM_WINDOW_TYPE_UTILITY;
}
else
{
error_arg = "--ewmh-type";
}
}
else if (mwm_func_arg)
{
mwm_hints.props[0] |= MWM_HINTS_FUNCTIONS;
if (strcasecmp(argv[i], "all") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_ALL;
}
else if (strcasecmp(argv[i], "resize") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_RESIZE;
}
else if (strcasecmp(argv[i], "move") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_MOVE;
}
else if (strcasecmp(argv[i], "minimize") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_MINIMIZE;
}
else if (strcasecmp(argv[i], "maximize") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_MAXIMIZE;
}
else if (strcasecmp(argv[i], "close") == 0)
{
mwm_hints.props[1] |= MWM_FUNC_CLOSE;
}
else
{
error_arg = "--mwm-func";
}
}
else if (mwm_decor_arg)
{
mwm_hints.props[0] |= MWM_HINTS_DECORATIONS;
if (strcasecmp(argv[i], "all") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_ALL;
}
else if (strcasecmp(argv[i], "border") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_BORDER;
}
else if (strcasecmp(argv[i], "resizeh") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_RESIZEH;
}
else if (strcasecmp(argv[i], "title") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_TITLE;
}
else if (strcasecmp(argv[i], "menu") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_MENU;
}
else if (strcasecmp(argv[i], "minimize") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_MINIMIZE;
}
else if (strcasecmp(argv[i], "maximize") == 0)
{
mwm_hints.props[2] |= MWM_DECOR_MAXIMIZE;
}
else
{
error_arg = "--mwm-decor";
}
}
else
{
error_arg = "regular";
}
if (error_arg)
{
show_usage();
printf("Invalid %s argument: %s\n", error_arg, argv[i]);
exit(1);
}
}
XSelectInput(dpy, win, StructureNotifyMask);
if (wm_hints.flags)
{
XSetWMHints(dpy, win, &wm_hints);
}
if (state_count != 0)
{
XChangeProperty(
dpy, win, ATOM_NET_WM_STATE, XA_ATOM, 32,
PropModeReplace, (unsigned char *)states, state_count);
}
if (type != 0)
{
XChangeProperty(
dpy, win, ATOM_NET_WM_WINDOW_TYPE, XA_ATOM, 32,
PropModeReplace, (unsigned char *)&type, 1);
}
if (has_ewmh_desktop)
{
XChangeProperty(
dpy, win, ATOM_NET_WM_DESKTOP, XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&ewmh_desktop, 1);
}
if (has_delete_proto || has_focus_proto)
{
Atom proto[2];
int j = 0;
if (has_delete_proto)
proto[j++] = ATOM_WM_DELETE_WINDOW;
if (has_focus_proto)
proto[j++] = ATOM_WM_TAKE_FOCUS;
XSetWMProtocols(dpy, win, proto, j);
}
{
XTextProperty nametext;
char *list[] = { NULL, NULL };
list[0] = "Hints Test";
classhints.res_name = strdup("hints_test");
classhints.res_class = strdup("HintsTest");
if (!XStringListToTextProperty(list, 1, &nametext))
{
fprintf(stderr, "Failed to convert name to XText\n");
exit(1);
}
XSetWMProperties(
dpy, win, &nametext, &nametext, NULL, 0, &hints, NULL,
&classhints);
XFree(nametext.value);
}
if (mwm_hints.props[0] != 0)
{
XChangeProperty(
dpy, win, ATOM_MOTIF_WM_HINTS, ATOM_MOTIF_WM_HINTS, 32,
PropModeReplace,(unsigned char *)&mwm_hints,
PROP_MWM_HINTS_ELEMENTS);
}
if (trans_win !=0)
XSetTransientForHint(dpy, win, trans_win);
XMapWindow(dpy, win);
XSetWindowBackground(dpy, win, 0);
Xloop();
return 1;
}
void framerender_frame(ObFrame *self)
{
if (frame_iconify_animating(self))
return; /* delay redrawing until the animation is done */
if (!self->need_render)
return;
if (!self->visible)
return;
self->need_render = FALSE;
{
gulong px;
px = (self->focused ?
RrColorPixel(ob_rr_theme->cb_focused_color) :
RrColorPixel(ob_rr_theme->cb_unfocused_color));
XSetWindowBackground(obt_display, self->backback, px);
XClearWindow(obt_display, self->backback);
XSetWindowBackground(obt_display, self->innerleft, px);
XClearWindow(obt_display, self->innerleft);
XSetWindowBackground(obt_display, self->innertop, px);
XClearWindow(obt_display, self->innertop);
XSetWindowBackground(obt_display, self->innerright, px);
XClearWindow(obt_display, self->innerright);
XSetWindowBackground(obt_display, self->innerbottom, px);
XClearWindow(obt_display, self->innerbottom);
XSetWindowBackground(obt_display, self->innerbll, px);
XClearWindow(obt_display, self->innerbll);
XSetWindowBackground(obt_display, self->innerbrr, px);
XClearWindow(obt_display, self->innerbrr);
XSetWindowBackground(obt_display, self->innerblb, px);
XClearWindow(obt_display, self->innerblb);
XSetWindowBackground(obt_display, self->innerbrb, px);
XClearWindow(obt_display, self->innerbrb);
px = (self->focused ?
RrColorPixel(ob_rr_theme->frame_focused_border_color) :
RrColorPixel(ob_rr_theme->frame_unfocused_border_color));
XSetWindowBackground(obt_display, self->left, px);
XClearWindow(obt_display, self->left);
XSetWindowBackground(obt_display, self->right, px);
XClearWindow(obt_display, self->right);
XSetWindowBackground(obt_display, self->titleleft, px);
XClearWindow(obt_display, self->titleleft);
XSetWindowBackground(obt_display, self->titletop, px);
XClearWindow(obt_display, self->titletop);
XSetWindowBackground(obt_display, self->titletopleft, px);
XClearWindow(obt_display, self->titletopleft);
XSetWindowBackground(obt_display, self->titletopright, px);
XClearWindow(obt_display, self->titletopright);
XSetWindowBackground(obt_display, self->titleright, px);
XClearWindow(obt_display, self->titleright);
XSetWindowBackground(obt_display, self->handleleft, px);
XClearWindow(obt_display, self->handleleft);
XSetWindowBackground(obt_display, self->handletop, px);
XClearWindow(obt_display, self->handletop);
XSetWindowBackground(obt_display, self->handleright, px);
XClearWindow(obt_display, self->handleright);
XSetWindowBackground(obt_display, self->handlebottom, px);
XClearWindow(obt_display, self->handlebottom);
XSetWindowBackground(obt_display, self->lgripleft, px);
XClearWindow(obt_display, self->lgripleft);
XSetWindowBackground(obt_display, self->lgriptop, px);
XClearWindow(obt_display, self->lgriptop);
XSetWindowBackground(obt_display, self->lgripbottom, px);
XClearWindow(obt_display, self->lgripbottom);
XSetWindowBackground(obt_display, self->rgripright, px);
XClearWindow(obt_display, self->rgripright);
XSetWindowBackground(obt_display, self->rgriptop, px);
XClearWindow(obt_display, self->rgriptop);
XSetWindowBackground(obt_display, self->rgripbottom, px);
XClearWindow(obt_display, self->rgripbottom);
/* don't use the separator color for shaded windows */
if (!self->client->shaded)
px = (self->focused ?
RrColorPixel(ob_rr_theme->title_separator_focused_color) :
RrColorPixel(ob_rr_theme->title_separator_unfocused_color));
XSetWindowBackground(obt_display, self->titlebottom, px);
XClearWindow(obt_display, self->titlebottom);
}
if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
RrAppearance *t, *l, *m, *n, *i, *d, *s, *c, *clear;
if (self->focused) {
t = ob_rr_theme->a_focused_title;
l = ob_rr_theme->a_focused_label;
m = (!(self->decorations & OB_FRAME_DECOR_MAXIMIZE) ?
ob_rr_theme->btn_max->a_disabled_focused :
(self->client->max_vert || self->client->max_horz ?
(self->max_press ?
ob_rr_theme->btn_max->a_toggled_focused_pressed :
(self->max_hover ?
ob_rr_theme->btn_max->a_toggled_hover_focused :
ob_rr_theme->btn_max->a_toggled_focused_unpressed)) :
(self->max_press ?
ob_rr_theme->btn_max->a_focused_pressed :
(self->max_hover ?
ob_rr_theme->btn_max->a_hover_focused :
ob_rr_theme->btn_max->a_focused_unpressed))));
n = ob_rr_theme->a_icon;
i = (!(self->decorations & OB_FRAME_DECOR_ICONIFY) ?
ob_rr_theme->btn_iconify->a_disabled_focused :
(self->iconify_press ?
ob_rr_theme->btn_iconify->a_focused_pressed :
(self->iconify_hover ?
ob_rr_theme->btn_iconify->a_hover_focused :
ob_rr_theme->btn_iconify->a_focused_unpressed)));
d = (!(self->decorations & OB_FRAME_DECOR_ALLDESKTOPS) ?
ob_rr_theme->btn_desk->a_disabled_focused :
(self->client->desktop == DESKTOP_ALL ?
(self->desk_press ?
ob_rr_theme->btn_desk->a_toggled_focused_pressed :
(self->desk_hover ?
ob_rr_theme->btn_desk->a_toggled_hover_focused :
ob_rr_theme->btn_desk->a_toggled_focused_unpressed)) :
(self->desk_press ?
ob_rr_theme->btn_desk->a_focused_pressed :
(self->desk_hover ?
ob_rr_theme->btn_desk->a_hover_focused :
ob_rr_theme->btn_desk->a_focused_unpressed))));
s = (!(self->decorations & OB_FRAME_DECOR_SHADE) ?
ob_rr_theme->btn_shade->a_disabled_focused :
(self->client->shaded ?
(self->shade_press ?
ob_rr_theme->btn_shade->a_toggled_focused_pressed :
(self->shade_hover ?
ob_rr_theme->btn_shade->a_toggled_hover_focused :
ob_rr_theme->btn_shade->a_toggled_focused_unpressed)) :
(self->shade_press ?
ob_rr_theme->btn_shade->a_focused_pressed :
(self->shade_hover ?
ob_rr_theme->btn_shade->a_hover_focused :
ob_rr_theme->btn_shade->a_focused_unpressed))));
c = (!(self->decorations & OB_FRAME_DECOR_CLOSE) ?
ob_rr_theme->btn_close->a_disabled_focused :
(self->close_press ?
ob_rr_theme->btn_close->a_focused_pressed :
(self->close_hover ?
ob_rr_theme->btn_close->a_hover_focused :
ob_rr_theme->btn_close->a_focused_unpressed)));
} else {
t = ob_rr_theme->a_unfocused_title;
l = ob_rr_theme->a_unfocused_label;
m = (!(self->decorations & OB_FRAME_DECOR_MAXIMIZE) ?
ob_rr_theme->btn_max->a_disabled_unfocused :
(self->client->max_vert || self->client->max_horz ?
(self->max_press ?
ob_rr_theme->btn_max->a_toggled_unfocused_pressed :
(self->max_hover ?
ob_rr_theme->btn_max->a_toggled_hover_unfocused :
ob_rr_theme->btn_max->a_toggled_unfocused_unpressed)) :
(self->max_press ?
ob_rr_theme->btn_max->a_unfocused_pressed :
(self->max_hover ?
ob_rr_theme->btn_max->a_hover_unfocused :
ob_rr_theme->btn_max->a_unfocused_unpressed))));
n = ob_rr_theme->a_icon;
i = (!(self->decorations & OB_FRAME_DECOR_ICONIFY) ?
ob_rr_theme->btn_iconify->a_disabled_unfocused :
(self->iconify_press ?
ob_rr_theme->btn_iconify->a_unfocused_pressed :
(self->iconify_hover ?
ob_rr_theme->btn_iconify->a_hover_unfocused :
ob_rr_theme->btn_iconify->a_unfocused_unpressed)));
d = (!(self->decorations & OB_FRAME_DECOR_ALLDESKTOPS) ?
ob_rr_theme->btn_desk->a_disabled_unfocused :
(self->client->desktop == DESKTOP_ALL ?
(self->desk_press ?
ob_rr_theme->btn_desk->a_toggled_unfocused_pressed :
(self->desk_hover ?
ob_rr_theme->btn_desk->a_toggled_hover_unfocused :
ob_rr_theme->btn_desk->a_toggled_unfocused_unpressed)) :
(self->desk_press ?
ob_rr_theme->btn_desk->a_unfocused_pressed :
(self->desk_hover ?
ob_rr_theme->btn_desk->a_hover_unfocused :
ob_rr_theme->btn_desk->a_unfocused_unpressed))));
s = (!(self->decorations & OB_FRAME_DECOR_SHADE) ?
ob_rr_theme->btn_shade->a_disabled_unfocused :
(self->client->shaded ?
(self->shade_press ?
ob_rr_theme->btn_shade->a_toggled_unfocused_pressed :
(self->shade_hover ?
ob_rr_theme->btn_shade->a_toggled_hover_unfocused :
ob_rr_theme->btn_shade->a_toggled_unfocused_unpressed)) :
(self->shade_press ?
ob_rr_theme->btn_shade->a_unfocused_pressed :
(self->shade_hover ?
ob_rr_theme->btn_shade->a_hover_unfocused :
ob_rr_theme->btn_shade->a_unfocused_unpressed))));
c = (!(self->decorations & OB_FRAME_DECOR_CLOSE) ?
ob_rr_theme->btn_close->a_disabled_unfocused :
(self->close_press ?
ob_rr_theme->btn_close->a_unfocused_pressed :
(self->close_hover ?
ob_rr_theme->btn_close->a_hover_unfocused :
ob_rr_theme->btn_close->a_unfocused_unpressed)));
}
clear = ob_rr_theme->a_clear;
RrPaint(t, self->title, self->width, ob_rr_theme->title_height);
clear->surface.parent = t;
clear->surface.parenty = 0;
clear->surface.parentx = ob_rr_theme->grip_width;
RrPaint(clear, self->topresize,
self->width - ob_rr_theme->grip_width * 2,
ob_rr_theme->paddingy + 1);
clear->surface.parentx = 0;
if (ob_rr_theme->grip_width > 0)
RrPaint(clear, self->tltresize,
ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
if (ob_rr_theme->title_height > 0)
RrPaint(clear, self->tllresize,
ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
clear->surface.parentx = self->width - ob_rr_theme->grip_width;
if (ob_rr_theme->grip_width > 0)
RrPaint(clear, self->trtresize,
ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
clear->surface.parentx = self->width - (ob_rr_theme->paddingx + 1);
if (ob_rr_theme->title_height > 0)
RrPaint(clear, self->trrresize,
ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
/* set parents for any parent relative guys */
l->surface.parent = t;
l->surface.parentx = self->label_x;
l->surface.parenty = ob_rr_theme->paddingy;
m->surface.parent = t;
m->surface.parentx = self->max_x;
m->surface.parenty = ob_rr_theme->paddingy + 1;
n->surface.parent = t;
n->surface.parentx = self->icon_x;
n->surface.parenty = ob_rr_theme->paddingy;
i->surface.parent = t;
i->surface.parentx = self->iconify_x;
i->surface.parenty = ob_rr_theme->paddingy + 1;
d->surface.parent = t;
d->surface.parentx = self->desk_x;
d->surface.parenty = ob_rr_theme->paddingy + 1;
s->surface.parent = t;
s->surface.parentx = self->shade_x;
s->surface.parenty = ob_rr_theme->paddingy + 1;
c->surface.parent = t;
c->surface.parentx = self->close_x;
c->surface.parenty = ob_rr_theme->paddingy + 1;
framerender_label(self, l);
framerender_max(self, m);
framerender_icon(self, n);
framerender_iconify(self, i);
framerender_desk(self, d);
framerender_shade(self, s);
framerender_close(self, c);
}
if (self->decorations & OB_FRAME_DECOR_HANDLE &&
ob_rr_theme->handle_height > 0)
{
RrAppearance *h, *g;
h = (self->focused ?
ob_rr_theme->a_focused_handle : ob_rr_theme->a_unfocused_handle);
RrPaint(h, self->handle, self->width, ob_rr_theme->handle_height);
if (self->decorations & OB_FRAME_DECOR_GRIPS) {
g = (self->focused ?
ob_rr_theme->a_focused_grip : ob_rr_theme->a_unfocused_grip);
if (g->surface.grad == RR_SURFACE_PARENTREL)
g->surface.parent = h;
g->surface.parentx = 0;
g->surface.parenty = 0;
RrPaint(g, self->lgrip,
ob_rr_theme->grip_width, ob_rr_theme->handle_height);
g->surface.parentx = self->width - ob_rr_theme->grip_width;
g->surface.parenty = 0;
RrPaint(g, self->rgrip,
ob_rr_theme->grip_width, ob_rr_theme->handle_height);
}
}
XFlush(obt_display);
}
static bool gfx_ctx_set_video_mode(
unsigned width, unsigned height,
bool fullscreen)
{
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
int x_off = 0;
int y_off = 0;
bool windowed_full = g_settings.video.windowed_fullscreen;
bool true_full = false;
XSetWindowAttributes swa = {0};
XVisualInfo *vi = glXGetVisualFromFBConfig(g_dpy, g_fbc);
if (!vi)
goto error;
swa.colormap = g_cmap = XCreateColormap(g_dpy, RootWindow(g_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_dpy, width, height, &g_desktop_mode))
{
g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[GLX]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (g_settings.video.monitor_index)
g_screen = g_settings.video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[GLX]: Using Xinerama on screen #%u.\n", g_screen);
else
RARCH_LOG("[GLX]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[GLX]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_win = XCreateWindow(g_dpy, RootWindow(g_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_dpy, g_win, 0);
gfx_ctx_update_window_title(true);
x11_set_window_attr(g_dpy, g_win);
if (fullscreen)
x11_hide_mouse(g_dpy, g_win);
if (true_full)
{
RARCH_LOG("[GLX]: Using true fullscreen.\n");
XMapRaised(g_dpy, g_win);
}
else if (fullscreen) // We attempted true fullscreen, but failed. Attempt using windowed fullscreen.
{
XMapRaised(g_dpy, g_win);
RARCH_LOG("[GLX]: Using windowed fullscreen.\n");
// We have to move the window to the screen we want to go fullscreen on first.
// x_off and y_off usually get ignored in XCreateWindow().
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_dpy, g_win);
}
else
{
XMapWindow(g_dpy, g_win);
// If we want to map the window on a different screen, we'll have to do it by force.
// Otherwise, we should try to let the window manager sort it out.
// x_off and y_off usually get ignored in XCreateWindow().
if (g_screen)
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
}
XEvent event;
XIfEvent(g_dpy, &event, glx_wait_notify, NULL);
XSetInputFocus(g_dpy, g_win, RevertToNone, CurrentTime);
g_ctx = glXCreateNewContext(g_dpy, g_fbc, GLX_RGBA_TYPE, 0, True);
if (!g_ctx)
{
RARCH_ERR("[GLX]: Failed to create new context.\n");
goto error;
}
glXMakeCurrent(g_dpy, g_win, g_ctx);
XSync(g_dpy, False);
g_quit_atom = XInternAtom(g_dpy, "WM_DELETE_WINDOW", False);
if (g_quit_atom)
XSetWMProtocols(g_dpy, g_win, &g_quit_atom, 1);
int val;
glXGetConfig(g_dpy, vi, GLX_DOUBLEBUFFER, &val);
g_is_double = val;
if (g_is_double)
{
if (!g_pglSwapInterval)
g_pglSwapInterval = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapInterval");
if (!g_pglSwapInterval)
g_pglSwapInterval = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
if (!g_pglSwapInterval)
g_pglSwapInterval = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalSGI");
if (!g_pglSwapInterval)
RARCH_WARN("[GLX]: Cannot find swap interval call.\n");
}
else
RARCH_WARN("[GLX]: Context is not double buffered!.\n");
gfx_ctx_swap_interval(g_interval);
XFree(vi);
g_has_focus = true;
g_inited = true;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)g_dpy;
driver.video_window = (uintptr_t)g_win;
g_true_full = true_full;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_destroy();
return false;
}
/***********************************************************************
*
* Procedure:
* list_new_desk - displays packet contents to stderr
*
***********************************************************************/
void list_new_desk(unsigned long *body)
{
int oldDesk;
int change_cs = -1;
int change_ballooncs = -1;
int change_highcs = -1;
oldDesk = Scr.CurrentDesk;
Scr.CurrentDesk = (long)body[0];
if (fAlwaysCurrentDesk && oldDesk != Scr.CurrentDesk)
{
PagerWindow *t;
PagerStringList *item;
char line[100];
desk1 = Scr.CurrentDesk;
desk2 = Scr.CurrentDesk;
for (t = Start; t != NULL; t = t->next)
{
if (t->desk == oldDesk || t->desk == Scr.CurrentDesk)
ChangeDeskForWindow(t, t->desk);
}
item = FindDeskStrings(Scr.CurrentDesk);
if (Desks[0].label != NULL)
{
free(Desks[0].label);
Desks[0].label = NULL;
}
if (item->next != NULL && item->next->label != NULL)
{
CopyString(&Desks[0].label, item->next->label);
}
else
{
sprintf(line, "Desk %d", desk1);
CopyString(&Desks[0].label, line);
}
XStoreName(dpy, Scr.Pager_w, Desks[0].label);
XSetIconName(dpy, Scr.Pager_w, Desks[0].label);
if (Desks[0].bgPixmap != NULL)
{
DestroyPicture(dpy, Desks[0].bgPixmap);
Desks[0].bgPixmap = NULL;
}
if (Desks[0].Dcolor != NULL)
{
free (Desks[0].Dcolor);
Desks[0].Dcolor = NULL;
}
if (item->next != NULL)
{
change_cs = item->next->colorset;
change_ballooncs = item->next->ballooncolorset;
change_highcs = item->next->highcolorset;
}
if (change_cs < 0)
{
change_cs = globalcolorset;
}
Desks[0].colorset = change_cs;
if (change_cs > -1)
{
/* use our colour set if we have one */
change_colorset(change_cs);
}
else if (item->next != NULL && item->next->bgPixmap != NULL)
{
Desks[0].bgPixmap = item->next->bgPixmap;
Desks[0].bgPixmap->count++;
XSetWindowBackgroundPixmap(dpy, Desks[0].w,
Desks[0].bgPixmap->picture);
}
else if (item->next != NULL && item->next->Dcolor != NULL)
{
CopyString(&Desks[0].Dcolor, item->next->Dcolor);
XSetWindowBackground(dpy, Desks[0].w, GetColor(Desks[0].Dcolor));
}
else if (PixmapBack != NULL)
{
Desks[0].bgPixmap = PixmapBack;
Desks[0].bgPixmap->count++;
XSetWindowBackgroundPixmap(dpy, Desks[0].w,
Desks[0].bgPixmap->picture);
}
else
{
CopyString(&Desks[0].Dcolor, PagerBack);
XSetWindowBackground(dpy, Desks[0].w, GetColor(Desks[0].Dcolor));
}
if (item->next != NULL && item->next->Dcolor != NULL)
{
CopyString(&Desks[0].Dcolor, item->next->Dcolor);
}
else
{
CopyString(&Desks[0].Dcolor, PagerBack);
}
if (change_cs < 0 || Colorset[change_cs].pixmap != ParentRelative)
XSetWindowBackground(dpy, Desks[0].title_w, GetColor(Desks[0].Dcolor));
/* update the colour sets for the desk */
if (change_ballooncs < 0)
{
change_ballooncs = globalballooncolorset;
}
Desks[0].ballooncolorset = change_ballooncs;
if (change_highcs < 0)
{
change_highcs = globalhighcolorset;
}
Desks[0].highcolorset = change_highcs;
if (change_ballooncs > -1 && change_ballooncs != change_cs)
{
change_colorset(change_ballooncs);
}
if (change_highcs > -1 && change_highcs != change_cs &&
change_highcs != change_ballooncs)
{
change_colorset(change_highcs);
}
XClearWindow(dpy, Desks[0].w);
XClearWindow(dpy, Desks[0].title_w);
} /* if (fAlwaysCurrentDesk && oldDesk != Scr.CurrentDesk) */
else if (!fAlwaysCurrentDesk)
{
int i;
char *name;
char line[100];
i = Scr.CurrentDesk - desk1;
if (i >= 0 && i < ndesks && Desks[i].label != NULL)
{
name = Desks[i].label;
}
else
{
sprintf(line, "Desk %d", Scr.CurrentDesk);
name = &(line[0]);
}
XStoreName(dpy, Scr.Pager_w, name);
XSetIconName(dpy, Scr.Pager_w, name);
}
MovePage(True);
DrawGrid(oldDesk - desk1,1);
DrawGrid(Scr.CurrentDesk - desk1,1);
MoveStickyWindows();
/*
Hilight(FocusWin,False);
*/
Hilight(FocusWin,True);
}
readpw(Display *dpy, const char *pws)
#endif
{
char buf[32], passwd[256];
int num, screen;
unsigned int len, llen;
KeySym ksym;
XEvent ev;
len = llen = 0;
running = True;
/* As "slock" stands for "Simple X display locker", the DPMS settings
* had been removed and you can set it with "xset" or some other
* utility. This way the user can easily set a customized DPMS
* timeout. */
while(running && !XNextEvent(dpy, &ev)) {
if(ev.type == KeyPress) {
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter)
ksym = XK_Return;
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
ksym = (ksym - XK_KP_0) + XK_0;
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|| IsPrivateKeypadKey(ksym))
continue;
switch(ksym) {
case XK_Return:
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
passwd[len] = '\0';
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
}
break;
}
if(llen == 0 && len != 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
XClearWindow(dpy, locks[screen]->win);
}
} else if(llen != 0 && len == 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
XClearWindow(dpy, locks[screen]->win);
}
}
llen = len;
}
else for(screen = 0; screen < nscreens; screen++)
XRaiseWindow(dpy, locks[screen]->win);
}
}
void SetWSBackground()
{
unsigned char back_changed= 0;
if(TheScreen.BackPixmap[TheScreen.desktop.ActiveWorkSpace]!=None)
{
/* To set the root pixmap and properties pointing to it XGrabServer
must be called to make sure that we don't leak the pixmap if
somebody else is setting it at the same time. */
/* use our private wraparound GrabServer instead! */
GrabServer (disp);
/* ++++++++++++++++ FIXME ++++++++++++++++++++++++++
Is necessary in this case to kill the old pixmap or will it
destroy the pixmaps in the TheScreen.BackPixmap array ???
This is how i suppouse the pixmap is removed : */
/* comment by arc: this seems too agressive to me, if the user starts a
program setting this property he probably knows what he is doing.
we definitely shouldn't kill clients without user interaction! */
/*
XGetWindowProperty (disp, TheScreen.root,
XIntermAtom ("ESETROOT_PMAP_ID", FALSE),
0L, 1L, False, XA_PIXMAP,
&type, &format, &nitems, &bytes_after,
&data_esetroot);
if (type == XA_PIXMAP) {
if (format == 32 && nitems == 4)
XKillClient(disp, *((Pixmap*)data_esetroot));
XFree (data_esetroot);
}
*/
/* Some aplications, like transparent terminals, need this properties
to be set to get and update the background pixmap */
XChangeProperty (disp, TheScreen.root,
XInternAtom (disp, "ESETROOT_PMAP_ID", 0), XA_PIXMAP,
32, PropModeReplace,
(unsigned char *) \
&(TheScreen.BackPixmap[TheScreen.desktop.ActiveWorkSpace]),
1);
XChangeProperty (disp, TheScreen.root,
XInternAtom (disp, "_XROOTPMAP_ID", 0), XA_PIXMAP,
32, PropModeReplace,
(unsigned char *) \
&(TheScreen.BackPixmap[TheScreen.desktop.ActiveWorkSpace]),
1);
XSetWindowBackgroundPixmap(disp,TheScreen.root,
TheScreen.BackPixmap\
[TheScreen.desktop.ActiveWorkSpace]);
back_changed= 1;
UngrabServer (disp);
XFlush (disp);
}
else if (TheScreen.SetBackground [TheScreen.desktop.ActiveWorkSpace])
{
XSetWindowBackground(disp,TheScreen.root,
TheScreen.Background\
[TheScreen.desktop.ActiveWorkSpace]);
back_changed= 1;
}
if (back_changed)
XClearWindow(disp,TheScreen.root);
if(ScreenCommandPID>0){ /* terminate previous ScreenCommand */
kill(ScreenCommandPID,SIGTERM);
ScreenCommandPID=0;
}
if(TheScreen.BackCommand[TheScreen.desktop.ActiveWorkSpace])
ScreenCommandPID=MySystem(TheScreen.BackCommand
[TheScreen.desktop.ActiveWorkSpace]);
else ScreenCommandPID=0;
}
readpw(Display *dpy, const char *pws)
#endif
{
char buf[32], passwd[256];
int num, screen;
unsigned int len, llen;
KeySym ksym;
XEvent ev;
XIM im;
XIMStyles *im_styles;
XIMStyle im_style = 0;
char *imvalret;
XIC ic;
Status status;
im = XOpenIM(dpy, NULL, NULL, NULL);
if (im == NULL)
die("slock: XOpenIM failed");
if(im) {
imvalret = XGetIMValues(im, XNQueryInputStyle, &im_styles, NULL);
if (imvalret != NULL || im_styles == NULL) {
die("slock: input method doesn't support any styles");
}
if (im_styles) {
im_style = 0;
/* for now just pick the first style if it exists */
if (im_styles->count_styles)
im_style = im_styles->supported_styles[0];
}
if (im_style == 0) {
die("slock: input method doesn't support the styles we support");
}
XFree(im_styles);
}
if (im && im_style) {
ic = XCreateIC(im, XNInputStyle, im_style, NULL);
}
len = llen = 0;
running = True;
/* As "slock" stands for "Simple X display locker", the DPMS settings
* had been removed and you can set it with "xset" or some other
* utility. This way the user can easily set a customized DPMS
* timeout. */
while(running && !XNextEvent(dpy, &ev)) {
if(ev.type == KeyPress) {
buf[0] = 0;
num = Xutf8LookupString(ic, &ev.xkey, buf, sizeof buf, &ksym, &status);
switch (status) {
case XBufferOverflow:
die("slock: XBufferOverflow");
case XLookupNone:
continue;
case XLookupChars:
/* Add the chars to the supposed password */
if (num) {
memcpy(passwd + len, buf, num);
len += num;
if(running != False)
XBell(dpy, 100);
}
break;
case XLookupBoth:
switch(ksym) {
case XK_KP_Enter:
case XK_Return:
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
if(running != False)
XBell(dpy, 100);
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if (num) {
memcpy(passwd + len, buf, num);
len += num;
if(running != False)
XBell(dpy, 100);
}
break;
}
break;
case XLookupKeySym:
/* Check if ksym is return, enter, escape or backspace */
switch(ksym) {
case XK_KP_Enter:
case XK_Return:
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
if(running != False)
XBell(dpy, 100);
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
break;
}
}
if(llen == 0 && len != 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
XClearWindow(dpy, locks[screen]->win);
}
} else if(llen != 0 && len == 0) {
for(screen = 0; screen < nscreens; screen++) {
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
XClearWindow(dpy, locks[screen]->win);
}
}
llen = len;
}
else for(screen = 0; screen < nscreens; screen++)
XRaiseWindow(dpy, locks[screen]->win);
}
if (im != NULL)
XCloseIM(im);
}
//=========================================
// prepare when ready
//-----------------------------------------
void prepare (void) {
int count;
char disp[80] = "";
if (displayname != NULL) {
sprintf(disp,"DISPLAY=%s",displayname);
putenv (disp);
}
//=========================================
// start windowmanager...
//-----------------------------------------
wmpid = fork();
switch(wmpid) {
case -1:
perror("fork"); exit(1);
break;
case 0:
execl(FVWM,"fvwm2","-f",FVWMRC,NULL);
break;
default:
waitpid (
wmpid, NULL, WNOHANG | WUNTRACED
);
}
//=========================================
// enable accessX...
//-----------------------------------------
// .../
// disable access X because vmware doesn't support it
// XAccess(dpy,displayname);
//=========================================
// set the fashion style for all displays
// including Xinerama handling here...
//------------------------------------------
CountScreens (dpy);
for (count = 0;count < scr_count; count++) {
#if 0
int bannerpid;
#endif
int current_screen = scr[count];
Window root = RootWindow(dpy, current_screen);
int depth = DefaultDepth (dpy,current_screen);
int xpixels = XDisplayWidth (dpy,current_screen);
int ypixels = XDisplayHeight (dpy,current_screen);
char* display = (char*)malloc(sizeof(char)*128);
char* dspstr = (char*)malloc(sizeof(char)*128);
char* color = (char*)malloc(sizeof(char)*128);
char screenStr [255] = "";
char x [128] = "";
char y [128] = "";
int x1,y1,width,height;
GC mgc = DefaultGC(dpy,current_screen);
Cursor cursor;
//=========================================
// set the background...
//-----------------------------------------
if (blank) {
//=========================================
// set the background to black
//-----------------------------------------
sprintf(color,"black");
XSetWindowBackground(
dpy, root, NameToPixel(
color,BlackPixel(dpy,current_screen),dpy,current_screen
)
);
XClearWindow(dpy,root);
XSetCloseDownMode(dpy, RetainPermanent);
usleep (1000);
XFlush(dpy);
} else {
//=========================================
// set the background to a picture
//-----------------------------------------
char xsize[20] = "";
char ysize[20] = "";
char sdpy[20] = "";
sprintf (xsize,"%d",xpixels);
sprintf (ysize,"%d",ypixels);
sprintf (sdpy,"%s.%d",displayname,current_screen);
int bgpid = fork();
switch(bgpid) {
case -1:
perror("fork"); exit(1);
break;
case 0:
execl (DISPLAY,
"ximage","-xsize",xsize,"-ysize",ysize,
"-display",sdpy,"-image",BACKGROUND,NULL
);
break;
default:
waitpid (
bgpid, NULL, 0
);
}
}
//=========================================
// set the corner marks
//-----------------------------------------
if (! blank) {
setCorner ("10x15-0-0",dpy,current_screen);
setCorner ("10x15-0+0",dpy,current_screen);
setCorner ("10x15+0-0",dpy,current_screen);
setCorner ("10x15+0+0",dpy,current_screen);
//=========================================
// set the bounding rectangle
//-----------------------------------------
setBounding (dpy,current_screen);
//=========================================
// set the SuSE Linux banner
//-----------------------------------------
if (DisplayPlanes (dpy, current_screen) >= 8) {
sprintf(dspstr,"%s",displayname);
dspstr = strtok (dspstr,".");
sprintf(display,"%s.%d",dspstr,current_screen);
sprintf(x,"%d",DisplayWidth (dpy,current_screen) - 150);
sprintf(y,"%d",DisplayHeight (dpy,current_screen) - 80);
#if 0
bannerpid = fork();
switch(bannerpid) {
case -1:
perror("fork"); exit(1);
break;
case 0:
execl (
XBanner,"xbanner",
"-file",XBannerFile,"-display",display,
"-px",x,"-py",y,NULL
);
break;
default:
waitpid (
bannerpid, NULL, 0
);
}
#endif
//===================================================
// create a xlook banner on all non primary screen
// pointing out, that this screen is not the one
// the configuration program is running on
//---------------------------------------------------
if (current_screen > 0) {
int HasRender;
sprintf(screenStr,"%s %d. %s 1.",
gettext("Display"),count+1,
gettext("Configuration on display")
);
HasRender = XTestRender (dpy);
if (! HasRender) {
break;
}
img = setText (
dpy,current_screen,screenStr,&imgx,&imgy
);
}
//=========================================
// set save area of the root window to be
// restored on demand
//-----------------------------------------
x1 = DisplayWidth (dpy,current_screen) - 380;
y1 = DisplayHeight (dpy,current_screen) - 120;
width = 380; height = 120;
save[current_screen].width = width;
save[current_screen].height = height;
save[current_screen].x1 = x1;
save[current_screen].y1 = y1;
save[current_screen].bg = XCreatePixmap (
dpy,root,width,height,depth
);
XCopyArea (
dpy,root,save[current_screen].bg,mgc,x1,y1,width,height,0,0
);
}
//=========================================
// set the cursor look and feel
//-----------------------------------------
cursor = CreateCursorFromName(dpy,current_screen,"top_left_arrow");
if (cursor) {
XDefineCursor (dpy,root,cursor);
XFreeCursor (dpy,cursor);
}
}
}
//=========================================
// Enter main loop, restore and redraw
//-----------------------------------------
if (! blank) {
looppid = fork();
switch (looppid) {
case -1:
perror("fork"); exit(1);
break;
case 0:
while(1) {
usleep (50000);
RedrawWindow();
}
break;
}
}
}
static bool gfx_ctx_xegl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
XEvent event;
EGLint egl_attribs[16];
EGLint *attr;
EGLint vid, num_visuals;
bool windowed_full;
bool true_full = false;
int x_off = 0;
int y_off = 0;
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
int (*old_handler)(Display*, XErrorEvent*) = NULL;
x11_install_sighandlers();
windowed_full = settings->video.windowed_fullscreen;
attr = egl_attribs;
attr = xegl_fill_attribs(attr);
if (!eglGetConfigAttrib(g_egl_dpy, g_egl_config, EGL_NATIVE_VISUAL_ID, &vid))
goto error;
temp.visualid = vid;
vi = XGetVisualInfo(g_x11_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
swa.colormap = g_x11_cmap = XCreateColormap(g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | ButtonPressMask | ButtonReleaseMask | KeyReleaseMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_x11_dpy, width, height, &g_desktop_mode))
{
g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[X/EGL]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (settings->video.monitor_index)
g_screen = settings->video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_x11_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_screen);
else
RARCH_LOG("[X/EGL]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[X/EGL]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_x11_win = XCreateWindow(g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_x11_dpy, g_x11_win, 0);
if (!egl_create_context((attr != egl_attribs) ? egl_attribs : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface((EGLNativeWindowType)g_x11_win))
goto error;
x11_set_window_attr(g_x11_dpy, g_x11_win);
if (fullscreen)
x11_show_mouse(g_x11_dpy, g_x11_win, false);
if (true_full)
{
RARCH_LOG("[X/EGL]: Using true fullscreen.\n");
XMapRaised(g_x11_dpy, g_x11_win);
}
else if (fullscreen)
{
/* We attempted true fullscreen, but failed.
* Attempt using windowed fullscreen. */
XMapRaised(g_x11_dpy, g_x11_win);
RARCH_LOG("[X/EGL]: Using windowed fullscreen.\n");
/* We have to move the window to the screen we
* want to go fullscreen on first.
* x_off and y_off usually get ignored in XCreateWindow().
*/
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_x11_dpy, g_x11_win);
}
else
{
XMapWindow(g_x11_dpy, g_x11_win);
/* If we want to map the window on a different screen,
* we'll have to do it by force.
*
* Otherwise, we should try to let the window manager sort it out.
* x_off and y_off usually get ignored in XCreateWindow().
*/
if (g_screen)
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
}
x11_event_queue_check(&event);
x11_install_quit_atom();
egl_set_swap_interval(data, g_interval);
/* This can blow up on some drivers. It's not fatal,
* so override errors for this call.
*/
old_handler = XSetErrorHandler(egl_nul_handler);
XSetInputFocus(g_x11_dpy, g_x11_win, RevertToNone, CurrentTime);
XSync(g_x11_dpy, False);
XSetErrorHandler(old_handler);
XFree(vi);
g_egl_inited = true;
if (!x11_input_ctx_new(true_full))
goto error;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_xegl_destroy(data);
return false;
}
int main () {
Display *display;
Window win;
XEvent report;
XEvent msg;
int x=10,y=10,h=100,w=100;
display = XOpenDisplay(NULL);
if (display == NULL) {
fprintf(stderr, "couldn't connect to X server :0\n");
return 0;
}
win = XCreateWindow(display, RootWindow(display, 0),
x, y, w, h, 0, CopyFromParent, CopyFromParent,
CopyFromParent, 0, NULL);
XSetWindowBackground(display,win,WhitePixel(display,0));
XSelectInput(display, win, (ExposureMask | StructureNotifyMask |
GravityNotify));
XMapWindow(display, win);
XFlush(display);
sleep(1);
XResizeWindow(display, win, w+5, h+5);
XMoveWindow(display, win, x, y);
while (1) {
XNextEvent(display, &report);
switch (report.type) {
case MapNotify:
printf("map notify\n");
break;
case Expose:
printf("exposed\n");
break;
case GravityNotify:
printf("gravity notify event 0x%x window 0x%x x %d y %d\n",
report.xgravity.event, report.xgravity.window,
report.xgravity.x, report.xgravity.y);
break;
case ConfigureNotify: {
int se = report.xconfigure.send_event;
int event = report.xconfigure.event;
int window = report.xconfigure.window;
int x = report.xconfigure.x;
int y = report.xconfigure.y;
int w = report.xconfigure.width;
int h = report.xconfigure.height;
int bw = report.xconfigure.border_width;
int above = report.xconfigure.above;
int or = report.xconfigure.override_redirect;
printf("confignotify send %d ev 0x%x win 0x%x %i,%i-%ix%i bw %i\n"
" above 0x%x ovrd %d\n",
se,event,window,x,y,w,h,bw,above,or);
break;
}
}
}
return 1;
}
