Don't need to explicitly check for xft.
[mikachu/openbox.git] / openbox / ping.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    client.h for the Openbox window manager
4    Copyright (c) 2006        Mikael Magnusson
5    Copyright (c) 2003-2008   Dana Jansens
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "ping.h"
21 #include "client.h"
22 #include "event.h"
23 #include "debug.h"
24 #include "openbox.h"
25 #include "obt/mainloop.h"
26 #include "obt/prop.h"
27
28 typedef struct _ObPingTarget
29 {
30     ObClient *client;
31     ObPingEventHandler h;
32     guint32 id;
33     gint waiting;
34 } ObPingTarget;
35
36 static GHashTable *ping_ids     = NULL;
37 static guint32     ping_next_id = 1;
38
39 #define PING_TIMEOUT (G_USEC_PER_SEC * 3)
40 /*! Warn the user after this many PING_TIMEOUT intervals */
41 #define PING_TIMEOUT_WARN 2
42
43 static void     ping_send(ObPingTarget *t);
44 static void     ping_end(ObClient *client, gpointer data);
45 static gboolean ping_timeout(gpointer data);
46 static gboolean find_client(gpointer key, gpointer value, gpointer client);
47
48 void ping_startup(gboolean reconfigure)
49 {
50     if (reconfigure) return;
51
52     ping_ids = g_hash_table_new(g_int_hash, g_int_equal);
53
54     /* listen for clients to disappear */
55     client_add_destroy_notify(ping_end, NULL);
56 }
57
58 void ping_shutdown(gboolean reconfigure)
59 {
60     if (reconfigure) return;
61
62     g_hash_table_unref(ping_ids);
63     ping_ids = NULL;
64
65     client_remove_destroy_notify(ping_end);
66 }
67
68 void ping_start(struct _ObClient *client, ObPingEventHandler h)
69 {
70     ObPingTarget *t;
71
72     /* make sure the client supports ping! */
73     g_assert(client->ping == TRUE);
74
75     /* make sure we're not already pinging the client */
76     if (g_hash_table_find(ping_ids, find_client, client) != NULL) return;
77
78     t = g_new0(ObPingTarget, 1);
79     t->client = client;
80     t->h = h;
81
82     obt_main_loop_timeout_add(ob_main_loop, PING_TIMEOUT, ping_timeout,
83                               t, g_direct_equal, NULL);
84     /* act like we just timed out immediately, to start the pinging process
85        now instead of after the first delay.  this makes sure the client
86        ends up in the ping_ids hash table now. */
87     ping_timeout(t);
88
89     /* make sure we can remove the client later */
90     g_assert(g_hash_table_find(ping_ids, find_client, client) != NULL);
91 }
92
93 void ping_got_pong(guint32 id)
94 {
95     ObPingTarget *t;
96
97     if ((t = g_hash_table_lookup(ping_ids, &id))) {
98         /*ob_debug("-PONG: '%s' (id %u)", t->client->title, t->id);*/
99         if (t->waiting > PING_TIMEOUT_WARN) {
100             /* we had notified that they weren't responding, so now we
101                need to notify that they are again */
102             t->h(t->client, FALSE);
103         }
104         t->waiting = 0; /* not waiting for a reply anymore */
105
106         /* we got a pong so we're happy now */
107         ping_end(t->client, NULL);
108     }
109     else
110         ob_debug("Got PONG with id %u but not waiting for one", id);
111 }
112
113 static gboolean find_client(gpointer key, gpointer value, gpointer client)
114 {
115     ObPingTarget *t = value;
116     return t->client == client;
117 }
118
119 static void ping_send(ObPingTarget *t)
120 {
121     /* t->id is 0 when it hasn't been assigned an id ever yet.
122        we can reuse ids when t->waiting == 0, because we won't be getting a
123        pong for that id in the future again.  that way for apps that aren't
124        timing out we don't need to remove/add them from/to the hash table */
125     if (t->id == 0 || t->waiting > 0) {
126         /* pick an id, and reinsert in the hash table with the new id */
127         if (t->id) g_hash_table_remove(ping_ids, &t->id);
128         t->id = ping_next_id;
129         if (++ping_next_id == 0) ++ping_next_id; /* skip 0 on wraparound */
130         g_hash_table_insert(ping_ids, &t->id, t);
131     }
132
133     /*ob_debug("+PING: '%s' (id %u)", t->client->title, t->id);*/
134     OBT_PROP_MSG_TO(t->client->window, t->client->window, WM_PROTOCOLS,
135                     OBT_PROP_ATOM(NET_WM_PING), t->id, t->client->window, 0, 0,
136                     NoEventMask);
137 }
138
139 static gboolean ping_timeout(gpointer data)
140 {
141     ObPingTarget *t = data;
142
143     ping_send(t);
144
145     /* if the client hasn't been responding then do something about it */
146     if (t->waiting == PING_TIMEOUT_WARN)
147         t->h(t->client, TRUE); /* notify that the client isn't responding */
148
149     ++t->waiting;
150
151     return TRUE; /* repeat */
152 }
153
154 static void ping_end(ObClient *client, gpointer data)
155 {
156     ObPingTarget *t;
157
158     if ((t = g_hash_table_find(ping_ids, find_client, client))) {
159         g_hash_table_remove(ping_ids, &t->id);
160
161         obt_main_loop_timeout_remove_data(ob_main_loop, ping_timeout,
162                                           t, FALSE);
163
164         g_free(t);
165     }
166 }