ioncore/event.c

   1 /*
   2  * ion/ioncore/event.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <X11/Xmd.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <sys/time.h>
  13 #include <sys/signal.h>
  14
  15 #include <libmainloop/select.h>
  16 #include <libmainloop/signal.h>
  17 #include <libmainloop/defer.h>
  18
  19 #include "common.h"
  20 #include "global.h"
  21 #include "event.h"
  22 #include "eventh.h"
  23 #include "focus.h"
  24 #include "exec.h"
  25 #include "ioncore.h"
  26
  27
  28
  29 /*{{{ Hooks */
  30
  31
  32 WHook *ioncore_handle_event_alt=NULL;
  33
  34
  35 /*}}}*/
  36
  37
  38 /*{{{ Signal check */
  39
  40
  41 static void check_signals()
  42 {
  43     int kill_sig=mainloop_check_signals();
  44
  45     if(kill_sig!=0){
  46         if(kill_sig==SIGUSR1){
  47             ioncore_restart();
  48             assert(0);
  49         }
  50         if(kill_sig==SIGTERM){
  51             /* Save state if not running under a session manager. */
  52             ioncore_emergency_snapshot();
  53             ioncore_resign();
  54             /* We may still return here if running under a session manager. */
  55         }else{
  56             ioncore_emergency_snapshot();
  57             ioncore_deinit();
  58             kill(getpid(), kill_sig);
  59         }
  60     }
  61 }
  62
  63
  64 /*}}}*/
  65
  66
  67 /*{{{ Timestamp stuff */
  68
  69 #define CHKEV(E, T) case E: tm=((T*)ev)->time; break;
  70
  71 static Time last_timestamp=CurrentTime;
  72
  73 void ioncore_update_timestamp(XEvent *ev)
  74 {
  75     Time tm;
  76
  77     switch(ev->type){
  78     CHKEV(ButtonPress, XButtonPressedEvent);
  79     CHKEV(ButtonRelease, XButtonReleasedEvent);
  80     CHKEV(EnterNotify, XEnterWindowEvent);
  81     CHKEV(KeyPress, XKeyPressedEvent);
  82     CHKEV(KeyRelease, XKeyReleasedEvent);
  83     CHKEV(LeaveNotify, XLeaveWindowEvent);
  84     CHKEV(MotionNotify, XPointerMovedEvent);
  85     CHKEV(PropertyNotify, XPropertyEvent);
  86     CHKEV(SelectionClear, XSelectionClearEvent);
  87     CHKEV(SelectionNotify, XSelectionEvent);
  88     CHKEV(SelectionRequest, XSelectionRequestEvent);
  89     default:
  90         return;
  91     }
  92
  93     if(tm>last_timestamp || last_timestamp - tm > IONCORE_CLOCK_SKEW_MS)
  94         last_timestamp=tm;
  95 }
  96
  97
  98 Time ioncore_get_timestamp()
  99 {
 100     if(last_timestamp==CurrentTime){
 101         /* Idea blatantly copied from wmx */
 102         XEvent ev;
 103         Atom dummy;
 104
 105         D(fprintf(stderr, "Attempting to get time from X server."));
 106
 107         dummy=XInternAtom(ioncore_g.dpy, "_ION_TIMEREQUEST", False);
 108         if(dummy==None){
 109             warn(TR("Time request from X server failed."));
 110             return 0;
 111         }
 112         /* TODO: use some other window that should also function as a
 113          * NET_WM support check window.
 114          */
 115         XChangeProperty(ioncore_g.dpy, ioncore_g.rootwins->dummy_win,
 116                         dummy, dummy, 8, PropModeAppend,
 117                         (unsigned char*)"", 0);
 118         ioncore_get_event(&ev, PropertyChangeMask);
 119         XPutBackEvent(ioncore_g.dpy, &ev);
 120     }
 121
 122     return last_timestamp;
 123 }
 124
 125
 126 /*}}}*/
 127
 128
 129 /*{{{ Event reading */
 130
 131
 132 void ioncore_get_event(XEvent *ev, long mask)
 133 {
 134     fd_set rfds;
 135
 136     while(1){
 137         check_signals();
 138
 139         if(XCheckMaskEvent(ioncore_g.dpy, mask, ev)){
 140             ioncore_update_timestamp(ev);
 141             return;
 142         }
 143
 144         FD_ZERO(&rfds);
 145         FD_SET(ioncore_g.conn, &rfds);
 146
 147         /* Other FD:s are _not_ to be handled! */
 148         select(ioncore_g.conn+1, &rfds, NULL, NULL, NULL);
 149     }
 150 }
 151
 152
 153 /*}}}*/
 154
 155
 156 /*{{{ Flush */
 157
 158
 159 static void skip_enterwindow()
 160 {
 161     XEvent ev;
 162
 163     XSync(ioncore_g.dpy, False);
 164
 165     while(XCheckMaskEvent(ioncore_g.dpy, EnterWindowMask, &ev)){
 166         ioncore_update_timestamp(&ev);
 167     }
 168 }
 169
 170
 171 void ioncore_flushfocus()
 172 {
 173     WRegion *next;
 174     bool warp;
 175
 176     if(ioncore_g.input_mode!=IONCORE_INPUTMODE_NORMAL)
 177         return;
 178
 179     next=ioncore_g.focus_next;
 180     warp=ioncore_g.warp_next;
 181
 182     if(next==NULL)
 183         return;
 184
 185     ioncore_g.focus_next=NULL;
 186
 187     region_do_set_focus(next, warp);
 188
 189     /* Just greedily eating it all away that X has to offer
 190      * seems to be the best we can do with Xlib.
 191      */
 192     if(warp)
 193         skip_enterwindow();
 194 }
 195
 196
 197 /*}}}*/
 198
 199
 200 /*{{{ X connection FD handler */
 201
 202
 203 void ioncore_x_connection_handler(int conn, void *unused)
 204 {
 205     XEvent ev;
 206
 207     XNextEvent(ioncore_g.dpy, &ev);
 208     ioncore_update_timestamp(&ev);
 209
 210     hook_call_alt_p(ioncore_handle_event_alt, &ev, NULL);
 211 }
 212
 213
 214 /*}}}*/
 215
 216
 217 /*{{{ Mainloop */
 218
 219
 220 void ioncore_mainloop()
 221 {
 222     mainloop_trap_signals(NULL);
 223
 224     ioncore_g.opmode=IONCORE_OPMODE_NORMAL;
 225
 226     while(1){
 227         check_signals();
 228         mainloop_execute_deferred();
 229
 230         if(QLength(ioncore_g.dpy)==0){
 231             XSync(ioncore_g.dpy, False);
 232
 233             if(QLength(ioncore_g.dpy)==0){
 234                 ioncore_flushfocus();
 235                 XSync(ioncore_g.dpy, False);
 236
 237                 if(QLength(ioncore_g.dpy)==0){
 238                     mainloop_select();
 239                     continue;
 240                 }
 241             }
 242         }
 243
 244         ioncore_x_connection_handler(ioncore_g.conn, NULL);
 245     }
 246 }
 247
 248
 249 /*}}}*/
 250