obt/xqueue.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    obt/display.c for the Openbox window manager
   4    Copyright (c) 2007        Dana Jansens
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    See the COPYING file for a copy of the GNU General Public License.
  17 */
  18
  19 #include "obt/xqueue.h"
  20 #include "obt/display.h"
  21
  22 #define MINSZ 16
  23
  24 static XEvent *q = NULL;
  25 static gulong qsz = 0;
  26 static gulong qstart; /* the first event in the queue */
  27 static gulong qend; /* the last event in the queue */
  28 static gulong qnum = 0;
  29
  30 static inline void shrink(void) {
  31     if (qsz > MINSZ && qnum < qsz / 4) {
  32         const gulong newsz = qsz/2;
  33         gulong i;
  34
  35         if (qnum == 0) {
  36             qstart = 0;
  37             qend = -1;
  38         }
  39
  40         /* all in the shinking part, move it to pos 0 */
  41         else if (qstart >= newsz && qend >= newsz) {
  42             for (i = 0; i < qnum; ++i)
  43                 q[i] = q[qstart+i];
  44             qstart = 0;
  45             qend = qnum - 1;
  46         }
  47
  48         /* it wraps around to 0 right now, move the part between newsz and qsz
  49            to be before newsz */
  50         else if (qstart >= newsz) {
  51             const gulong n = qsz - qstart;
  52             for (i = 0; i < n; ++i)
  53                 q[newsz-n+i] = q[qstart+i];
  54             qstart = newsz-n;
  55         }
  56
  57         /* it needs to wrap around to 0, move the stuff after newsz to pos 0 */
  58         else if (qend >= newsz) {
  59             const gulong n = qend + 1 - newsz;
  60             for (i = 0; i < n; ++i)
  61                 q[i] = q[newsz+i];
  62             qend = n - 1;
  63         }
  64
  65         q = g_renew(XEvent, q, newsz);
  66         qsz = newsz;
  67     }
  68 }
  69
  70 static inline void grow(void) {
  71     if (qnum == qsz) {
  72         const gulong newsz = qsz*2;
  73         gulong i;
  74
  75         q = g_renew(XEvent, q, newsz);
  76
  77         g_assert(qnum > 0);
  78
  79         if (qend < qstart) { /* it wraps around to 0 right now */
  80             for (i = 0; i <= qend; ++i)
  81                 q[qsz+i] = q[i];
  82             qend = qsz + qend;
  83         }
  84
  85         qsz = newsz;
  86     }
  87 }
  88
  89 /* Grab all pending X events */
  90 static gboolean read_events(gboolean block)
  91 {
  92     gint sth, n;
  93
  94     n = XEventsQueued(obt_display, QueuedAfterFlush) > 0;
  95     sth = FALSE;
  96
  97     while ((block && !sth) || n > 0) {
  98         XEvent e;
  99
 100         if (XNextEvent(obt_display, &e) != Success)
 101             return FALSE;
 102
 103         grow(); /* make sure there is room */
 104
 105         ++qnum;
 106         qend = (qend + 1) % qsz; /* move the end */
 107         q[qend] = e; /* stick the event at the end */
 108
 109         --n;
 110         sth = TRUE;
 111     }
 112
 113     return sth; /* return if we read anything */
 114 }
 115
 116 static void pop(const gulong p)
 117 {
 118     /* remove the event */
 119     --qnum;
 120     if (qnum == 0) {
 121         qstart = 0;
 122         qend = -1;
 123     }
 124     else if (p == qstart)
 125         qstart = (qstart + 1) % qsz;
 126     else {
 127         gulong pi;
 128
 129         /* is it cheaper to move the start or the end ? */
 130         if ((p >= qstart && p < qstart + qnum/2) ||
 131             (p < qstart && p < (qstart + qnum/2) % qsz))
 132         {
 133             /* move the start */
 134             pi = p;
 135             while (pi != qstart) {
 136                 const gulong pi_next = (pi == 0 ? qsz-1 : pi-1);
 137
 138                 q[pi] = q[pi_next];
 139                 pi = pi_next;
 140             }
 141             qstart = (qstart + 1) % qsz;
 142         }
 143         else {
 144             /* move the end */
 145             pi = p;
 146             while (pi != qend) {
 147                 const gulong pi_next = (pi + 1) % qsz;
 148
 149                 q[pi] = q[pi_next];
 150                 pi = pi_next;
 151             }
 152             qend = (qend == 0 ? qsz-1 : qend-1);
 153         }
 154     }
 155
 156     shrink(); /* shrink the q if too little in it */
 157 }
 158
 159 void xqueue_init(void)
 160 {
 161     if (q != NULL) return;
 162     qsz = MINSZ;
 163     q = g_new(XEvent, qsz);
 164     qstart = 0;
 165     qend = -1;
 166 }
 167
 168 void xqueue_destroy(void)
 169 {
 170     if (q == NULL) return;
 171     g_free(q);
 172     q = NULL;
 173     qsz = 0;
 174 }
 175
 176 gboolean xqueue_match_window(XEvent *e, gpointer data)
 177 {
 178     const Window w = *(Window*)data;
 179     return e->xany.window == w;
 180 }
 181
 182 gboolean xqueue_match_type(XEvent *e, gpointer data)
 183 {
 184     return e->type == GPOINTER_TO_INT(data);
 185 }
 186
 187 gboolean xqueue_match_window_type(XEvent *e, gpointer data)
 188 {
 189     const ObtXQueueWindowType x = *(ObtXQueueWindowType*)data;
 190     return e->xany.window == x.window && e->type == x.type;
 191 }
 192
 193 gboolean xqueue_match_window_message(XEvent *e, gpointer data)
 194 {
 195     const ObtXQueueWindowMessage x = *(ObtXQueueWindowMessage*)data;
 196     return e->xany.window == x.window && e->type == ClientMessage &&
 197         e->xclient.message_type == x.message;
 198 }
 199
 200 gboolean xqueue_peek(XEvent *event_return)
 201 {
 202     g_return_val_if_fail(q != NULL, FALSE);
 203     g_return_val_if_fail(event_return != NULL, FALSE);
 204
 205     if (!qnum) read_events(TRUE);
 206     if (!qnum) return FALSE;
 207     *event_return = q[qstart]; /* get the head */
 208     return TRUE;
 209 }
 210
 211 gboolean xqueue_peek_local(XEvent *event_return)
 212 {
 213     g_return_val_if_fail(q != NULL, FALSE);
 214     g_return_val_if_fail(event_return != NULL, FALSE);
 215
 216     if (!qnum) read_events(FALSE);
 217     if (!qnum) return FALSE;
 218     *event_return = q[qstart]; /* get the head */
 219     return TRUE;
 220 }
 221
 222 gboolean xqueue_next(XEvent *event_return)
 223 {
 224     g_return_val_if_fail(q != NULL, FALSE);
 225     g_return_val_if_fail(event_return != NULL, FALSE);
 226
 227     if (!qnum) read_events(TRUE);
 228     if (qnum) {
 229         *event_return = q[qstart]; /* get the head */
 230         pop(qstart);
 231         return TRUE;
 232     }
 233
 234     return FALSE;
 235 }
 236
 237 gboolean xqueue_next_local(XEvent *event_return)
 238 {
 239     g_return_val_if_fail(q != NULL, FALSE);
 240     g_return_val_if_fail(event_return != NULL, FALSE);
 241
 242     if (!qnum) read_events(FALSE);
 243     if (qnum) {
 244         *event_return = q[qstart]; /* get the head */
 245         pop(qstart);
 246         return TRUE;
 247     }
 248
 249     return FALSE;
 250 }
 251
 252 gboolean xqueue_exists(xqueue_match_func match, gpointer data)
 253 {
 254     gulong i, checked;
 255
 256     g_return_val_if_fail(q != NULL, FALSE);
 257     g_return_val_if_fail(match != NULL, FALSE);
 258
 259     checked = 0;
 260     while (TRUE) {
 261         for (i = checked; i < qnum; ++i, ++checked) {
 262             const gulong p = (qstart + i) % qsz;
 263             if (match(&q[p], data))
 264                 return TRUE;
 265         }
 266         if (!read_events(TRUE)) break; /* error */
 267     }
 268     return FALSE;
 269 }
 270
 271 gboolean xqueue_exists_local(xqueue_match_func match, gpointer data)
 272 {
 273     gulong i, checked;
 274
 275     g_return_val_if_fail(q != NULL, FALSE);
 276     g_return_val_if_fail(match != NULL, FALSE);
 277
 278     checked = 0;
 279     while (TRUE) {
 280         for (i = checked; i < qnum; ++i, ++checked) {
 281             const gulong p = (qstart + i) % qsz;
 282             if (match(&q[p], data))
 283                 return TRUE;
 284         }
 285         if (!read_events(FALSE)) break;
 286     }
 287     return FALSE;
 288 }
 289
 290 gboolean xqueue_remove_local(XEvent *event_return,
 291                              xqueue_match_func match, gpointer data)
 292 {
 293     gulong i, checked;
 294
 295     g_return_val_if_fail(q != NULL, FALSE);
 296     g_return_val_if_fail(event_return != NULL, FALSE);
 297     g_return_val_if_fail(match != NULL, FALSE);
 298
 299     checked = 0;
 300     while (TRUE) {
 301         for (i = checked; i < qnum; ++i, ++checked) {
 302             const gulong p = (qstart + i) % qsz;
 303             if (match(&q[p], data)) {
 304                 *event_return = q[p];
 305                 pop(p);
 306                 return TRUE;
 307             }
 308         }
 309         if (!read_events(FALSE)) break;
 310     }
 311     return FALSE;
 312 }
 313
 314 gboolean xqueue_pending_local(void)
 315 {
 316     g_return_val_if_fail(q != NULL, FALSE);
 317
 318     if (!qnum) read_events(FALSE);
 319     return qnum != 0;
 320 }
 321
 322 typedef struct _ObtXQueueCB {
 323     ObtXQueueFunc func;
 324     gpointer data;
 325 } ObtXQueueCB;
 326
 327 static ObtXQueueCB *callbacks = NULL;
 328 static guint n_callbacks = 0;
 329
 330 static gboolean event_read(GSource *source, GSourceFunc callback,
 331                            gpointer data)
 332 {
 333     XEvent ev;
 334
 335     while (xqueue_next_local(&ev)) {
 336         guint i;
 337         for (i = 0; i < n_callbacks; ++i)
 338             callbacks[i].func(&ev, callbacks[i].data);
 339     }
 340
 341     return TRUE; /* repeat */
 342 }
 343
 344 static gboolean x_source_prepare(GSource *source, gint *timeout)
 345 {
 346     *timeout = -1;
 347     return XPending(obt_display);
 348 }
 349
 350 static gboolean x_source_check(GSource *source)
 351 {
 352     return XPending(obt_display);
 353 }
 354
 355 struct x_source {
 356     GSource source;
 357
 358     GPollFD pfd;
 359 };
 360
 361 static GSourceFuncs x_source_funcs = {
 362     x_source_prepare,
 363     x_source_check,
 364     event_read,
 365     NULL
 366 };
 367
 368 void xqueue_listen(void)
 369 {
 370     GSource *source = g_source_new(&x_source_funcs, sizeof(struct x_source));
 371     struct x_source *x_source = (struct x_source *)source;
 372     GPollFD *pfd = &x_source->pfd;
 373
 374     *pfd = (GPollFD){ ConnectionNumber(obt_display), G_IO_IN, G_IO_IN };
 375     g_source_add_poll(source, pfd);
 376     g_source_attach(source, NULL);
 377 }
 378
 379 void xqueue_add_callback(ObtXQueueFunc f, gpointer data)
 380 {
 381     guint i;
 382
 383     g_return_if_fail(f != NULL);
 384
 385     for (i = 0; i < n_callbacks; ++i)
 386         if (callbacks[i].func == f && callbacks[i].data == data)
 387             return;
 388
 389     callbacks = g_renew(ObtXQueueCB, callbacks, n_callbacks + 1);
 390     callbacks[n_callbacks].func = f;
 391     callbacks[n_callbacks].data = data;
 392     ++n_callbacks;
 393 }
 394
 395 void xqueue_remove_callback(ObtXQueueFunc f, gpointer data)
 396 {
 397     guint i;
 398
 399     g_return_if_fail(f != NULL);
 400
 401     for (i = 0; i < n_callbacks; ++i) {
 402         if (callbacks[i].func == f && callbacks[i].data == data) {
 403             /* remove it */
 404             for (; i < n_callbacks - 1; ++i)
 405                 callbacks[i] = callbacks[i+1];
 406             callbacks = g_renew(ObtXQueueCB, callbacks, n_callbacks - 1);
 407             --n_callbacks;
 408             break;
 409         }
 410     }
 411 }