AppX11::AppX11(QObject *parent) : QObject(parent), d(new Data) { d->xssTimer.setInterval(20000); connect(&d->xssTimer, &QTimer::timeout, this, [this] () { if (d->xss && d->display) { _Trace("Call XResetScreenSaver()."); XResetScreenSaver(d->display); } else _Error("Cannot run XResetScreenSaver()."); }); connect(&d->hbTimer, &QTimer::timeout, this, [this] () { if (!d->hbCommand.isEmpty()) { if (QProcess::startDetached(d->hbCommand)) _Trace("Run command: %%", d->hbCommand); else _Error("Cannot run command: %%", d->hbCommand); } else _Error("No command for heartbeat"); }); d->connection = QX11Info::connection(); d->display = QX11Info::display(); d->root = QX11Info::appRootWindow(); d->aNetWmState = d->getAtom("_NET_WM_STATE"); d->aNetWmStateAbove = d->getAtom("_NET_WM_STATE_ABOVE"); d->aNetWmStateStaysOnTop = d->getAtom("_NET_WM_STATE_STAYS_ON_TOP"); }
EXPORT_C_(void) PADupdate(int pad) { // Gamepad inputs don't count as an activity. Therefore screensaver will // be fired after a couple of minute. // Emulate an user activity static int count = 0; count++; if ((count & 0xFFF) == 0) { // 1 call every 4096 Vsync is enough XResetScreenSaver(GSdsp); } // Actually PADupdate is always call with pad == 0. So you need to update both // pads -- Gregory // Poll keyboard/mouse event. There is currently no way to separate pad0 from pad1 event. // So we will populate both pad in the same time for (int cpad = 0; cpad < GAMEPAD_NUMBER; cpad++) { key_status->keyboard_state_acces(cpad); } PollForX11KeyboardInput(); // Get joystick state + Commit for (int cpad = 0; cpad < GAMEPAD_NUMBER; cpad++) { key_status->joystick_state_acces(cpad); PollForJoystickInput(cpad); key_status->commit_status(cpad); } }
void ScreenSaverX11::Reset(void) { bool need_xsync = false; Display *dsp = NULL; if (d->m_display) dsp = d->m_display->GetDisplay(); if (dsp) { XResetScreenSaver(dsp); need_xsync = true; } if (d->IsScreenSaverRunning()) resetSlot(); if (Asleep() && dsp) { DPMSForceLevel(dsp, DPMSModeOn); need_xsync = true; } if (need_xsync && d->m_display) d->m_display->Sync(); }
void X11_SuspendScreenSaver(_THIS) { #if SDL_VIDEO_DRIVER_X11_XSCRNSAVER SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; int dummy; int major_version, minor_version; if (SDL_X11_HAVE_XSS) { /* XScreenSaverSuspend was introduced in MIT-SCREEN-SAVER 1.1 */ if (!XScreenSaverQueryExtension(data->display, &dummy, &dummy) || !XScreenSaverQueryVersion(data->display, &major_version, &minor_version) || major_version < 1 || (major_version == 1 && minor_version < 1)) { return; } XScreenSaverSuspend(data->display, _this->suspend_screensaver); XResetScreenSaver(data->display); } #endif #if SDL_USE_LIBDBUS if (_this->suspend_screensaver) { SDL_dbus_screensaver_tickle(_this); } #endif }
void X11_SuspendScreenSaver(_THIS) { #if SDL_VIDEO_DRIVER_X11_SCRNSAVER SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; int dummy; int major_version, minor_version; if (SDL_X11_HAVE_XSS) { /* XScreenSaverSuspend was introduced in MIT-SCREEN-SAVER 1.1 */ if (!XScreenSaverQueryExtension(data->display, &dummy, &dummy) || !XScreenSaverQueryVersion(data->display, &major_version, &minor_version) || major_version < 1 || (major_version == 1 && minor_version < 1)) { return; } XScreenSaverSuspend(data->display, _this->suspend_screensaver); XResetScreenSaver(data->display); } #endif #ifdef GNOME_SCREENSAVER_HACK if (_this->suspend_screensaver) { gnome_screensaver_disable(); } else { gnome_screensaver_enable(); } #endif }
void MainWindowImpl::PokeScreensaver(void) { XResetScreenSaver (QX11Info::display ()); if( pProxy ) { dbus_g_proxy_call_no_reply (pProxy, "SimulateUserActivity",G_TYPE_INVALID); } }
void ScreenSaverX11::Restore(void) { d->RestoreScreenSaver(); d->RestoreDPMS(); // One must reset after the restore XResetScreenSaver(qt_xdisplay()); if (d->IsScreenSaverRunning()) d->StopTimer(); }
void ScreenSaverX11::Disable(void) { d->SaveScreenSaver(); XResetScreenSaver(qt_xdisplay()); XSetScreenSaver(qt_xdisplay(), 0, 0, 0, 0); d->DisableDPMS(); if (d->IsScreenSaverRunning()) d->ResetTimer(); }
void ScreenSaverX11::Reset(void) { XResetScreenSaver(qt_xdisplay()); if (d->IsScreenSaverRunning()) resetSlot(); if (Asleep()) { DPMSForceLevel(qt_xdisplay(), DPMSModeOn); // Calling XSync is necessary for the case when Myth executes // another application before the event loop regains control XSync(qt_xdisplay(), false); } }
void ScreenSaverX11::Restore(void) { d->RestoreScreenSaver(); d->RestoreDPMS(); // One must reset after the restore if (d->m_display) { XResetScreenSaver(d->m_display->GetDisplay()); d->m_display->Sync(); } if (d->IsScreenSaverRunning()) d->StopTimer(); }
void ScreenSaverX11::Disable(void) { d->SaveScreenSaver(); if (d->m_display) { XResetScreenSaver(d->m_display->GetDisplay()); XSetScreenSaver(d->m_display->GetDisplay(), 0, 0, 0, 0); d->m_display->Sync(); } d->DisableDPMS(); if (d->IsScreenSaverRunning()) d->ResetTimer(); }
AppX11::AppX11(QObject *parent) : QObject(parent), d(new Data) { d->ss_timer.setInterval(20000); connect(&d->ss_timer, &QTimer::timeout, [this] () { if (d->xss && d->display) { _Trace("Call XResetScreenSaver()."); XResetScreenSaver(d->display); } else _Error("Cannot run XResetScreenSaver()."); }); d->connection = QX11Info::connection(); d->display = QX11Info::display(); d->root = QX11Info::appRootWindow(); d->aNetWmState = d->getAtom("_NET_WM_STATE"); d->aNetWmStateAbove = d->getAtom("_NET_WM_STATE_ABOVE"); d->aNetWmStateStaysOnTop = d->getAtom("_NET_WM_STATE_STAYS_ON_TOP"); }
int XForceScreenSaver(Display *display, int mode) { // https://tronche.com/gui/x/xlib/window-and-session-manager/XForceScreenSaver.html // https://www.libsdl.org/tmp/docs-1.3/_s_d_l__video_8h.html#6e5293ce67509a49c1ead749fc4547d9 SET_X_SERVER_REQUEST(display, X_ForceScreenSaver); switch (mode) { case ScreenSaverActive: // Activate the screen saver now SDL_EnableScreenSaver(); break; case ScreenSaverReset: XResetScreenSaver(display); break; default: handleError(0, display, None, 0, BadValue, 0); return 0; } return 1; }
void CWinSystemX11::ResetOSScreensaver() { if (m_bFullScreen) { //disallow the screensaver when we're fullscreen by periodically calling XResetScreenSaver(), //normally SDL does this but we disable that in CApplication::Create() //for some reason setting a 0 timeout with XSetScreenSaver doesn't work with gnome if (!m_screensaverReset.IsRunning() || m_screensaverReset.GetElapsedSeconds() > 5.0f) { m_screensaverReset.StartZero(); XResetScreenSaver(m_dpy); } } else { m_screensaverReset.Stop(); } }
void X11_PumpEvents(_THIS) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; /* Update activity every 30 seconds to prevent screensaver */ if (_this->suspend_screensaver) { Uint32 now = SDL_GetTicks(); if (!data->screensaver_activity || (int) (now - data->screensaver_activity) >= 30000) { XResetScreenSaver(data->display); data->screensaver_activity = now; } } /* Keep processing pending events */ while (X11_Pending(data->display)) { X11_DispatchEvent(_this); } }
void DGA_PumpEvents(_THIS) { /* Keep processing pending events */ LOCK_DISPLAY(); /* Update activity every five seconds to prevent screensaver. --ryan. */ if (!allow_screensaver) { static Uint32 screensaverTicks; Uint32 nowTicks = SDL_GetTicks(); if ((nowTicks - screensaverTicks) > 5000) { XResetScreenSaver(DGA_Display); screensaverTicks = nowTicks; } } while ( X11_Pending(DGA_Display) ) { DGA_DispatchEvent(this); } UNLOCK_DISPLAY(); }
void screensaver_deactivate(Display *dpy, uint32_t types) { if (types & SST_XSCREENSAVER) deactivate_xscreensaver(dpy); // reset internal X screen saver timer XResetScreenSaver(dpy); #if HAVE_GLIB_DBUS if (types & SST_FDO_SCREENSAVER) deactivate_dbus_based_screensaver(FDOS_SERVICE, FDOS_PATH, FDOS_INTERFACE); if (types & SST_GNOME_SCREENSAVER) deactivate_dbus_based_screensaver(GS_SERVICE, GS_PATH, GS_INTERFACE); if (types & SST_KDE_SCREENSAVER) deactivate_dbus_based_screensaver(KS_SERVICE, KS_PATH, KS_INTERFACE); if (types & SST_CINNAMON_SCREENSAVER) deactivate_dbus_based_screensaver(CINNAMON_SERVICE, CINNAMON_PATH, CINNAMON_INTERFACE); #endif // HAVE_GLIB_DBUS }
void Tk_ResetUserInactiveTime( Display *dpy) { XResetScreenSaver(dpy); }
void X11_PumpEvents(_THIS) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; /* Update activity every 30 seconds to prevent screensaver */ if (_this->suspend_screensaver) { Uint32 now = SDL_GetTicks(); if (!data->screensaver_activity || (int) (now - data->screensaver_activity) >= 30000) { XResetScreenSaver(data->display); data->screensaver_activity = now; } } /* Keep processing pending events */ while (X11_Pending(data->display)) { X11_DispatchEvent(_this); } #ifdef SDL_INPUT_LINUXEV /* Process Touch events - TODO When X gets touch support, use that instead*/ int i = 0,rd; char name[256]; struct input_event ev[64]; int size = sizeof (struct input_event); for(i = 0;i < SDL_GetNumTouch();++i) { SDL_Touch* touch = SDL_GetTouchIndex(i); if(!touch) printf("Touch %i/%i DNE\n",i,SDL_GetNumTouch()); EventTouchData* data; data = (EventTouchData*)(touch->driverdata); if(data == NULL) { printf("No driver data\n"); continue; } if(data->eventStream <= 0) printf("Error: Couldn't open stream\n"); rd = read(data->eventStream, ev, size * 64); //printf("Got %i/%i bytes\n",rd,size); if(rd >= size) { for (i = 0; i < rd / sizeof(struct input_event); i++) { switch (ev[i].type) { case EV_ABS: //printf("Got position x: %i!\n",data->x); switch (ev[i].code) { case ABS_X: data->x = ev[i].value; break; case ABS_Y: data->y = ev[i].value; break; case ABS_PRESSURE: data->pressure = ev[i].value; if(data->pressure < 0) data->pressure = 0; break; case ABS_MISC: if(ev[i].value == 0) data->up = SDL_TRUE; break; } break; case EV_MSC: if(ev[i].code == MSC_SERIAL) data->finger = ev[i].value; break; case EV_SYN: //printf("Id: %i\n",touch->id); if(data->up) { SDL_SendFingerDown(touch->id,data->finger, SDL_FALSE,data->x,data->y, data->pressure); } else if(data->x >= 0 || data->y >= 0) SDL_SendTouchMotion(touch->id,data->finger, SDL_FALSE,data->x,data->y, data->pressure); //printf("Synched: %i tx: %i, ty: %i\n", // data->finger,data->x,data->y); data->x = -1; data->y = -1; data->pressure = -1; data->finger = 0; data->up = SDL_FALSE; break; } } } } #endif }
void gl_handle_events () { XEvent event; while (XPending(_gl_display) > 0) { XNextEvent(_gl_display, &event); #ifdef XDLG if (handle_xdlg_event(_gl_display, &event)) continue; #endif #ifdef XFIB if (x_fib_handle_events (_gl_display, &event)) { if (x_fib_status () > 0) { char *fn = x_fib_filename (); xapi_open (fn); free (fn); } } #endif if (event.xany.window != _gl_win) { continue; } #ifdef DND if (handle_dnd_event(_gl_display, _gl_win, &event)) continue; #endif switch (event.type) { case MapNotify: loop_run=1; break; case UnmapNotify: loop_run=0; break; case ConfigureNotify: if ( (event.xconfigure.width > 1 && event.xconfigure.height > 1) && (event.xconfigure.width != _gl_width || event.xconfigure.height != _gl_height) ) { gl_reshape(event.xconfigure.width, event.xconfigure.height); } break; case Expose: if (event.xexpose.count != 0) { break; } _gl_reexpose = true; break; case MotionNotify: if (osd_seeking && ui_syncsource() == SYNC_NONE && OSD_mode & OSD_POS) { const float sk = calc_slider (event.xmotion.x, event.xmotion.y); if (sk >= 0) ui_sync_manual (sk); } break; case ButtonPress: if (event.xbutton.button == 1 && ui_syncsource() == SYNC_NONE && OSD_mode & OSD_POS) { const float sk = calc_slider (event.xbutton.x, event.xbutton.y); if (sk >= 0) { ui_sync_manual (sk); osd_seeking = 1; force_redraw = 1; } } break; case ButtonRelease: if (osd_seeking) { osd_seeking = 0; force_redraw = 1; } else #ifdef XDLG if (event.xbutton.button == 3) { if (event.xbutton.x >= 0 && event.xbutton.x < _gl_width && event.xbutton.y >= 0 && event.xbutton.y < _gl_height) show_x_dialog(_gl_display, _gl_win, event.xbutton.x_root, event.xbutton.y_root ); } else #endif xjglButton(event.xbutton.button); break; case ReparentNotify: break; case KeyPress: { KeySym sym; char buf[6] = {0,0,0,0,0,0}; static XComposeStatus stat; int n = XLookupString(&event.xkey, buf, sizeof(buf), &sym, &stat); if (event.xkey.state & ControlMask && n == 1 && sym == XK_o) { #ifdef XFIB if (!(interaction_override & OVR_LOADFILE)) { x_fib_cfg_filter_callback(fib_filter_movie_filename); x_fib_show (_gl_display, _gl_win, 0, 0); } #endif } else if (event.xkey.state & ControlMask && n == 1 && sym == XK_w) { if (!(interaction_override & OVR_LOADFILE)) xapi_close (NULL); } else if (event.xkey.state & ControlMask && n == 1 && sym == XK_q) { if (!(interaction_override&OVR_QUIT_WMG)) loop_flag = 0; } else if (n == 1) { xjglKeyPress(sym, buf); } } break; case ClientMessage: if (!strcmp(XGetAtomName(_gl_display, event.xclient.message_type), "WM_PROTOCOLS")) { if ((interaction_override&OVR_QUIT_WMG) == 0) loop_flag=0; } break; default: break; } } if (_gl_reexpose) { _gl_reexpose = false; force_redraw = true; } static int periodic = 10; if (--periodic == 0) { periodic = 50 * framerate; // we should use 1/delay if delay > 0 XResetScreenSaver(_gl_display); // ..or spawn `xdg-screensaver` } }
void X11_PumpEvents(_THIS) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; /* Update activity every 30 seconds to prevent screensaver */ if (_this->suspend_screensaver) { Uint32 now = SDL_GetTicks(); if (!data->screensaver_activity || (int) (now - data->screensaver_activity) >= 30000) { XResetScreenSaver(data->display); #if SDL_USE_LIBDBUS SDL_dbus_screensaver_tickle(_this); #endif data->screensaver_activity = now; } } /* Keep processing pending events */ while (X11_Pending(data->display)) { X11_DispatchEvent(_this); } /* FIXME: Only need to do this when there are pending focus changes */ X11_HandleFocusChanges(_this); /*Dont process evtouch events if XInput2 multitouch is supported*/ if(X11_Xinput2IsMultitouchSupported()) { return; } #ifdef SDL_INPUT_LINUXEV /* Process Touch events*/ int i = 0,rd; struct input_event ev[64]; int size = sizeof (struct input_event); /* !!! FIXME: clean the tabstops out of here. */ for(i = 0;i < SDL_GetNumTouch();++i) { SDL_Touch* touch = SDL_GetTouchIndex(i); if(!touch) printf("Touch %i/%i DNE\n",i,SDL_GetNumTouch()); EventTouchData* data; data = (EventTouchData*)(touch->driverdata); if(data == NULL) { printf("No driver data\n"); continue; } if(data->eventStream <= 0) printf("Error: Couldn't open stream\n"); rd = read(data->eventStream, ev, size * 64); if(rd >= size) { for (i = 0; i < rd / sizeof(struct input_event); i++) { switch (ev[i].type) { case EV_ABS: switch (ev[i].code) { case ABS_X: data->x = ev[i].value; break; case ABS_Y: data->y = ev[i].value; break; case ABS_PRESSURE: data->pressure = ev[i].value; if(data->pressure < 0) data->pressure = 0; break; case ABS_MISC: if(ev[i].value == 0) data->up = SDL_TRUE; break; } break; case EV_MSC: if(ev[i].code == MSC_SERIAL) data->finger = ev[i].value; break; case EV_KEY: if(ev[i].code == BTN_TOUCH) if(ev[i].value == 0) data->up = SDL_TRUE; break; case EV_SYN: if(!data->down) { data->down = SDL_TRUE; SDL_SendFingerDown(touch->id,data->finger, data->down, data->x, data->y, data->pressure); } else if(!data->up) SDL_SendTouchMotion(touch->id,data->finger, SDL_FALSE, data->x,data->y, data->pressure); else { data->down = SDL_FALSE; SDL_SendFingerDown(touch->id,data->finger, data->down, data->x,data->y, data->pressure); data->x = -1; data->y = -1; data->pressure = -1; data->finger = 0; data->up = SDL_FALSE; } break; } } } } #endif }
void COSScreenSaverX11::ResetScreenSaver() { XResetScreenSaver(m_dpy); }
void x_gram_create(Display *dpy, x_gram *gram, int xalign, int yalign, int xpos, int ypos, int xsize, int ysize, int beepcount) { Window w; XSizeHints sizehints; XWMHints wmhints; XSetWindowAttributes attributes; unsigned long all_desktops = 0xFFFFFFFF; /* * Adjust xpos, ypos based on the alignments xalign, yalign and the sizes: */ if (xalign < 0) xpos = WidthOfScreen(DefaultScreenOfDisplay(dpy)) - xpos - xsize - 2 * border_width; else if (xalign == 0) xpos = ((WidthOfScreen(DefaultScreenOfDisplay(dpy)) - xsize - 2 * border_width) >> 1) + xpos; if (yalign<0) ypos = HeightOfScreen(DefaultScreenOfDisplay(dpy)) - ypos - ysize - 2 * border_width; else if (yalign == 0) ypos = ((HeightOfScreen(DefaultScreenOfDisplay(dpy)) - ysize - 2 * border_width) >> 1) + ypos; /* * Create the window: */ attributes = xattributes; attributes.background_pixel = gram->bgcolor; gram->w = w = XCreateWindow (dpy, DefaultRootWindow (dpy), xpos, ypos, xsize, ysize, border_width, 0, CopyFromParent, CopyFromParent, xattributes_mask, &attributes); sizehints.x = xpos; sizehints.y = ypos; sizehints.width = xsize; sizehints.height = ysize; sizehints.win_gravity = x_calc_gravity(xalign, yalign); sizehints.flags = USPosition | USSize | PWinGravity; wmhints.input = False; wmhints.initial_state = NormalState; if (set_transient) { wmhints.window_group = group_leader; wmhints.flags = InputHint | StateHint | WindowGroupHint; x_set_icccm_hints(dpy, w, title_name, icon_name, &sizehints, &wmhints, group_leader); } else { wmhints.flags = InputHint | StateHint; x_set_icccm_hints(dpy, w, title_name, icon_name, &sizehints, &wmhints, 0); } if (net_wm_window_type != None && net_wm_window_type_utility != None) XChangeProperty(dpy, w, net_wm_window_type, XA_ATOM, 32, PropModeReplace, (unsigned char *) &net_wm_window_type_utility, 1); if (set_all_desktops && net_wm_desktop != None) XChangeProperty(dpy, w, net_wm_desktop, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &all_desktops, 1); XSaveContext(dpy, w, desc_context, (XPointer)gram); gram->can_die.tv_sec = 0; XMapWindow(dpy, w); if (beepcount) XBell(dpy, 0); xerror_happened = 0; if (reverse_stack && bottom_gram) { XWindowChanges winchanges; winchanges.sibling = bottom_gram->w; winchanges.stack_mode = Below; /* Metacity may use border_width even if it's not specified in * the value mask, so we must initialize it. See: * http://bugzilla.gnome.org/show_bug.cgi?id=305257 */ winchanges.border_width = border_width; begin_xerror_trap (dpy); XReconfigureWMWindow (dpy, w, DefaultScreen (dpy), CWSibling | CWStackMode, &winchanges); end_xerror_trap (dpy); if (xerror_happened) { /* The event didn't go. Print an error message, and continue. */ ERROR ("Error configuring window to the bottom of the stack.\n"); } } /* we always need to keep a linked list of windows */ add_to_bottom(gram); if (xerror_happened) pull_to_top(gram); if (reset_saver) XResetScreenSaver(dpy); XFlush(dpy); /* Because the flushing/syncing/etc with the error trapping can cause events to be read into the Xlib queue, we need to go through the queue here before exiting so that any pending events get processed. */ x_get_input(dpy); }
static void xglx_background_thread(_AL_THREAD *self, void *arg) { ALLEGRO_SYSTEM_XGLX *s = arg; XEvent event; double last_reset_screensaver_time = 0.0; while (!_al_get_thread_should_stop(self)) { /* Note: * Most older X11 implementations are not thread-safe no matter what, so * we simply cannot sit inside a blocking XNextEvent from another thread * if another thread also uses X11 functions. * * The usual use of XNextEvent is to only call it from the main thread. We * could of course do this for A5, just needs some slight adjustments to * the events system (polling for an Allegro event would call a function * of the system driver). * * As an alternative, we can use locking. This however can never fully * work, as for example OpenGL implementations also will access X11, in a * way we cannot know and cannot control (and we can't require users to * only call graphics functions inside a lock). * * However, most X11 implementations are somewhat thread safe, and do * use locking quite a bit themselves, so locking mostly does work. * * (Yet another alternative might be to use a separate X11 display * connection for graphics output.) * */ _al_mutex_lock(&s->lock); while (XEventsQueued(s->x11display, QueuedAfterFlush)) { XNextEvent(s->x11display, &event); process_x11_event(s, event); } /* The Xlib manual is particularly useless about the XResetScreenSaver() * function. Nevertheless, this does seem to work to inhibit the native * screensaver facility. Probably it won't do anything for other * systems, though. */ if (s->inhibit_screensaver) { double now = al_current_time(); if (now - last_reset_screensaver_time > 10.0) { XResetScreenSaver(s->x11display); last_reset_screensaver_time = now; } } _al_mutex_unlock(&s->lock); /* If no X11 events are there, unlock so other threads can run. We use * a select call to wake up when as soon as anything is available on * the X11 connection - and just for safety also wake up 10 times * a second regardless. */ int x11_fd = ConnectionNumber(s->x11display); fd_set fdset; FD_ZERO(&fdset); FD_SET(x11_fd, &fdset); struct timeval small_time = {0, 100000}; /* 10 times a second */ select(x11_fd + 1, &fdset, NULL, NULL, &small_time); } }
void XScreensaverBasedPoller::simulateUserActivity() { stopCatchingIdleEvents(); XResetScreenSaver(QX11Info::display()); emit resumingFromIdle(); }
void cs_screen_reset_screensaver (void) { XResetScreenSaver (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())); }