23 |
|
|
24 |
int raise_counter = -1; |
int raise_counter = -1; |
25 |
|
|
26 |
void handleKeyPress(XKeyEvent * ev) |
void |
27 |
|
handleKeyPress (XKeyEvent * ev) |
28 |
{ |
{ |
29 |
Client *c; |
Client *c; |
30 |
int state, key; |
int state, key; |
31 |
XEvent e; |
XEvent e; |
32 |
|
|
33 |
#ifdef DEBUG |
#ifdef DEBUG |
34 |
printf("entering handleKeyEvent\n"); |
printf ("entering handleKeyEvent\n"); |
35 |
#endif |
#endif |
36 |
|
|
37 |
c = clientGetFocus(); |
c = clientGetFocus (); |
38 |
state = ev->state & (Mod1Mask | ControlMask | ShiftMask); |
state = ev->state & (Mod1Mask | ControlMask | ShiftMask); |
39 |
for(key = 0; key < KEY_COUNT; key++) |
for (key = 0; key < KEY_COUNT; key++) |
40 |
if(keys[key].keycode == ev->keycode && keys[key].modifier == state) |
if (keys[key].keycode == ev->keycode && keys[key].modifier == state) |
41 |
break; |
break; |
42 |
|
|
43 |
if(c) |
if (c) |
44 |
{ |
{ |
45 |
switch (key) |
switch (key) |
46 |
{ |
{ |
47 |
case KEY_QUIT: |
case KEY_QUIT: |
48 |
quit = True; |
quit = True; |
49 |
break; |
break; |
50 |
case KEY_MOVE_UP: |
case KEY_MOVE_UP: |
51 |
case KEY_MOVE_DOWN: |
case KEY_MOVE_DOWN: |
52 |
case KEY_MOVE_LEFT: |
case KEY_MOVE_LEFT: |
53 |
case KEY_MOVE_RIGHT: |
case KEY_MOVE_RIGHT: |
54 |
clientMove(c, (XEvent *) ev); |
clientMove (c, (XEvent *) ev); |
55 |
if(!click_to_focus) |
if (!click_to_focus) |
56 |
XWarpPointer (dpy, None, c->window, 0, 0, 0, 0, frameWidth(c) / 2, frameHeight(c) / 2); |
XWarpPointer (dpy, None, c->window, 0, 0, 0, 0, |
57 |
break; |
frameWidth (c) / 2, frameHeight (c) / 2); |
58 |
case KEY_RESIZE_UP: |
break; |
59 |
case KEY_RESIZE_DOWN: |
case KEY_RESIZE_UP: |
60 |
case KEY_RESIZE_LEFT: |
case KEY_RESIZE_DOWN: |
61 |
case KEY_RESIZE_RIGHT: |
case KEY_RESIZE_LEFT: |
62 |
clientResize(c, (XEvent *) ev); |
case KEY_RESIZE_RIGHT: |
63 |
break; |
clientResize (c, (XEvent *) ev); |
64 |
case KEY_CYCLE_WINDOWS: |
break; |
65 |
clientCycle(c); |
case KEY_CYCLE_WINDOWS: |
66 |
break; |
clientCycle (c); |
67 |
case KEY_CLOSE_WINDOW: |
break; |
68 |
clientClose(c); |
case KEY_CLOSE_WINDOW: |
69 |
break; |
clientClose (c); |
70 |
case KEY_HIDE_WINDOW: |
break; |
71 |
clientHide(c, True); |
case KEY_HIDE_WINDOW: |
72 |
break; |
clientHide (c, True); |
73 |
case KEY_MAXIMIZE_WINDOW: |
break; |
74 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED); |
case KEY_MAXIMIZE_WINDOW: |
75 |
break; |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED); |
76 |
case KEY_MAXIMIZE_VERT: |
break; |
77 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED_VERT); |
case KEY_MAXIMIZE_VERT: |
78 |
break; |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_VERT); |
79 |
case KEY_MAXIMIZE_HORIZ: |
break; |
80 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED_HORIZ); |
case KEY_MAXIMIZE_HORIZ: |
81 |
break; |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_HORIZ); |
82 |
case KEY_SHADE_WINDOW: |
break; |
83 |
clientToggleShaded(c); |
case KEY_SHADE_WINDOW: |
84 |
break; |
clientToggleShaded (c); |
85 |
case KEY_RAISE_WINDOW_LAYER: |
break; |
86 |
clientSetLayer(c, c->win_layer + 1); |
case KEY_RAISE_WINDOW_LAYER: |
87 |
break; |
clientSetLayer (c, c->win_layer + 1); |
88 |
case KEY_LOWER_WINDOW_LAYER: |
break; |
89 |
clientSetLayer(c, c->win_layer - 1); |
case KEY_LOWER_WINDOW_LAYER: |
90 |
break; |
clientSetLayer (c, c->win_layer - 1); |
91 |
case KEY_NEXT_WORKSPACE: |
break; |
92 |
workspaceSwitch(workspace + 1, NULL); |
case KEY_NEXT_WORKSPACE: |
93 |
break; |
workspaceSwitch (workspace + 1, NULL); |
94 |
case KEY_PREV_WORKSPACE: |
break; |
95 |
workspaceSwitch(workspace - 1, NULL); |
case KEY_PREV_WORKSPACE: |
96 |
break; |
workspaceSwitch (workspace - 1, NULL); |
97 |
case KEY_ADD_WORKSPACE: |
break; |
98 |
workspaceSetCount(workspace_count + 1); |
case KEY_ADD_WORKSPACE: |
99 |
break; |
workspaceSetCount (workspace_count + 1); |
100 |
case KEY_DEL_WORKSPACE: |
break; |
101 |
workspaceSetCount(workspace_count - 1); |
case KEY_DEL_WORKSPACE: |
102 |
break; |
workspaceSetCount (workspace_count - 1); |
103 |
case KEY_STICK_WINDOW: |
break; |
104 |
clientToggleSticky(c); |
case KEY_STICK_WINDOW: |
105 |
break; |
clientToggleSticky (c); |
106 |
case KEY_WORKSPACE_1: |
break; |
107 |
workspaceSwitch(0, NULL); |
case KEY_WORKSPACE_1: |
108 |
break; |
workspaceSwitch (0, NULL); |
109 |
case KEY_WORKSPACE_2: |
break; |
110 |
workspaceSwitch(1, NULL); |
case KEY_WORKSPACE_2: |
111 |
break; |
workspaceSwitch (1, NULL); |
112 |
case KEY_WORKSPACE_3: |
break; |
113 |
workspaceSwitch(2, NULL); |
case KEY_WORKSPACE_3: |
114 |
break; |
workspaceSwitch (2, NULL); |
115 |
case KEY_WORKSPACE_4: |
break; |
116 |
workspaceSwitch(3, NULL); |
case KEY_WORKSPACE_4: |
117 |
break; |
workspaceSwitch (3, NULL); |
118 |
case KEY_WORKSPACE_5: |
break; |
119 |
workspaceSwitch(4, NULL); |
case KEY_WORKSPACE_5: |
120 |
break; |
workspaceSwitch (4, NULL); |
121 |
case KEY_WORKSPACE_6: |
break; |
122 |
workspaceSwitch(5, NULL); |
case KEY_WORKSPACE_6: |
123 |
break; |
workspaceSwitch (5, NULL); |
124 |
case KEY_WORKSPACE_7: |
break; |
125 |
workspaceSwitch(6, NULL); |
case KEY_WORKSPACE_7: |
126 |
break; |
workspaceSwitch (6, NULL); |
127 |
case KEY_WORKSPACE_8: |
break; |
128 |
workspaceSwitch(7, NULL); |
case KEY_WORKSPACE_8: |
129 |
break; |
workspaceSwitch (7, NULL); |
130 |
case KEY_WORKSPACE_9: |
break; |
131 |
workspaceSwitch(8, NULL); |
case KEY_WORKSPACE_9: |
132 |
break; |
workspaceSwitch (8, NULL); |
133 |
case KEY_MOVE_NEXT_WORKSPACE: |
break; |
134 |
workspaceSwitch(workspace + 1, c); |
case KEY_MOVE_NEXT_WORKSPACE: |
135 |
break; |
workspaceSwitch (workspace + 1, c); |
136 |
case KEY_MOVE_PREV_WORKSPACE: |
break; |
137 |
workspaceSwitch(workspace - 1, c); |
case KEY_MOVE_PREV_WORKSPACE: |
138 |
break; |
workspaceSwitch (workspace - 1, c); |
139 |
case KEY_MOVE_WORKSPACE_1: |
break; |
140 |
workspaceSwitch(0, c); |
case KEY_MOVE_WORKSPACE_1: |
141 |
break; |
workspaceSwitch (0, c); |
142 |
case KEY_MOVE_WORKSPACE_2: |
break; |
143 |
workspaceSwitch(1, c); |
case KEY_MOVE_WORKSPACE_2: |
144 |
break; |
workspaceSwitch (1, c); |
145 |
case KEY_MOVE_WORKSPACE_3: |
break; |
146 |
workspaceSwitch(2, c); |
case KEY_MOVE_WORKSPACE_3: |
147 |
break; |
workspaceSwitch (2, c); |
148 |
case KEY_MOVE_WORKSPACE_4: |
break; |
149 |
workspaceSwitch(3, c); |
case KEY_MOVE_WORKSPACE_4: |
150 |
break; |
workspaceSwitch (3, c); |
151 |
case KEY_MOVE_WORKSPACE_5: |
break; |
152 |
workspaceSwitch(4, c); |
case KEY_MOVE_WORKSPACE_5: |
153 |
break; |
workspaceSwitch (4, c); |
154 |
case KEY_MOVE_WORKSPACE_6: |
break; |
155 |
workspaceSwitch(5, c); |
case KEY_MOVE_WORKSPACE_6: |
156 |
break; |
workspaceSwitch (5, c); |
157 |
case KEY_MOVE_WORKSPACE_7: |
break; |
158 |
workspaceSwitch(6, c); |
case KEY_MOVE_WORKSPACE_7: |
159 |
break; |
workspaceSwitch (6, c); |
160 |
case KEY_MOVE_WORKSPACE_8: |
break; |
161 |
workspaceSwitch(7, c); |
case KEY_MOVE_WORKSPACE_8: |
162 |
break; |
workspaceSwitch (7, c); |
163 |
case KEY_MOVE_WORKSPACE_9: |
break; |
164 |
workspaceSwitch(8, c); |
case KEY_MOVE_WORKSPACE_9: |
165 |
break; |
workspaceSwitch (8, c); |
166 |
} |
break; |
167 |
} |
} |
168 |
else |
} |
169 |
{ |
else |
170 |
switch (key) |
{ |
171 |
{ |
switch (key) |
172 |
case KEY_QUIT: |
{ |
173 |
quit = True; |
case KEY_QUIT: |
174 |
break; |
quit = True; |
175 |
case KEY_CYCLE_WINDOWS: |
break; |
176 |
if (clients) |
case KEY_CYCLE_WINDOWS: |
177 |
clientCycle(clients->prev); |
if (clients) |
178 |
break; |
clientCycle (clients->prev); |
179 |
case KEY_NEXT_WORKSPACE: |
break; |
180 |
workspaceSwitch(workspace + 1, NULL); |
case KEY_NEXT_WORKSPACE: |
181 |
break; |
workspaceSwitch (workspace + 1, NULL); |
182 |
case KEY_PREV_WORKSPACE: |
break; |
183 |
workspaceSwitch(workspace - 1, NULL); |
case KEY_PREV_WORKSPACE: |
184 |
break; |
workspaceSwitch (workspace - 1, NULL); |
185 |
case KEY_ADD_WORKSPACE: |
break; |
186 |
workspaceSetCount(workspace_count + 1); |
case KEY_ADD_WORKSPACE: |
187 |
break; |
workspaceSetCount (workspace_count + 1); |
188 |
case KEY_DEL_WORKSPACE: |
break; |
189 |
workspaceSetCount(workspace_count - 1); |
case KEY_DEL_WORKSPACE: |
190 |
break; |
workspaceSetCount (workspace_count - 1); |
191 |
case KEY_WORKSPACE_1: |
break; |
192 |
workspaceSwitch(0, NULL); |
case KEY_WORKSPACE_1: |
193 |
break; |
workspaceSwitch (0, NULL); |
194 |
case KEY_WORKSPACE_2: |
break; |
195 |
workspaceSwitch(1, NULL); |
case KEY_WORKSPACE_2: |
196 |
break; |
workspaceSwitch (1, NULL); |
197 |
case KEY_WORKSPACE_3: |
break; |
198 |
workspaceSwitch(2, NULL); |
case KEY_WORKSPACE_3: |
199 |
break; |
workspaceSwitch (2, NULL); |
200 |
case KEY_WORKSPACE_4: |
break; |
201 |
workspaceSwitch(3, NULL); |
case KEY_WORKSPACE_4: |
202 |
break; |
workspaceSwitch (3, NULL); |
203 |
case KEY_WORKSPACE_5: |
break; |
204 |
workspaceSwitch(4, NULL); |
case KEY_WORKSPACE_5: |
205 |
break; |
workspaceSwitch (4, NULL); |
206 |
case KEY_WORKSPACE_6: |
break; |
207 |
workspaceSwitch(5, NULL); |
case KEY_WORKSPACE_6: |
208 |
break; |
workspaceSwitch (5, NULL); |
209 |
case KEY_WORKSPACE_7: |
break; |
210 |
workspaceSwitch(6, NULL); |
case KEY_WORKSPACE_7: |
211 |
break; |
workspaceSwitch (6, NULL); |
212 |
case KEY_WORKSPACE_8: |
break; |
213 |
workspaceSwitch(7, NULL); |
case KEY_WORKSPACE_8: |
214 |
break; |
workspaceSwitch (7, NULL); |
215 |
case KEY_WORKSPACE_9: |
break; |
216 |
workspaceSwitch(8, NULL); |
case KEY_WORKSPACE_9: |
217 |
break; |
workspaceSwitch (8, NULL); |
218 |
} |
break; |
219 |
} |
} |
220 |
|
} |
221 |
while(XCheckTypedEvent(dpy, EnterNotify, &e)); |
|
222 |
} |
while (XCheckTypedEvent (dpy, EnterNotify, &e)); |
223 |
|
} |
224 |
void handleButtonPress(XButtonEvent * ev) |
|
225 |
{ |
void |
226 |
Client *c; |
handleButtonPress (XButtonEvent * ev) |
227 |
Window win; |
{ |
228 |
int state, replay = False; |
Client *c; |
229 |
static Time last_button_time; |
Window win; |
230 |
|
int state, replay = False; |
231 |
#ifdef DEBUG |
static Time last_button_time; |
232 |
printf("entering handleButtonPress\n"); |
|
233 |
#endif |
#ifdef DEBUG |
234 |
|
printf ("entering handleButtonPress\n"); |
235 |
while(XCheckTypedEvent(dpy, ButtonPress, (XEvent *) ev)); |
#endif |
236 |
|
|
237 |
state = ev->state & (Mod1Mask | ShiftMask | ControlMask); |
while (XCheckTypedEvent (dpy, ButtonPress, (XEvent *) ev)); |
238 |
|
|
239 |
c = clientGetFromWindow(ev->window, FRAME); |
state = ev->state & (Mod1Mask | ShiftMask | ControlMask); |
240 |
if(c) |
|
241 |
{ |
c = clientGetFromWindow (ev->window, FRAME); |
242 |
state = ev->state & (Mod1Mask | ShiftMask | ControlMask); |
if (c) |
243 |
win = getMouseWindow(dpy, c->frame); |
{ |
244 |
|
state = ev->state & (Mod1Mask | ShiftMask | ControlMask); |
245 |
clientSetFocus(c, True); |
win = getMouseWindow (dpy, c->frame); |
246 |
|
|
247 |
if(win == c->buttons[HIDE_BUTTON] || |
clientSetFocus (c, True); |
248 |
win == c->buttons[CLOSE_BUTTON] || |
|
249 |
win == c->buttons[MAXIMIZE_BUTTON] || |
if (win == c->buttons[HIDE_BUTTON] || |
250 |
win == c->buttons[SHADE_BUTTON]) |
win == c->buttons[CLOSE_BUTTON] || |
251 |
{ |
win == c->buttons[MAXIMIZE_BUTTON] || |
252 |
clientRaise(c); |
win == c->buttons[SHADE_BUTTON]) |
253 |
clientButtonPress(c, win, ev); |
{ |
254 |
} |
clientRaise (c); |
255 |
else if(((win == c->title || win == c->sides[SIDE_BOTTOM] || |
clientButtonPress (c, win, ev); |
256 |
win == c->sides[SIDE_LEFT] || win == c->sides[SIDE_RIGHT]) && |
} |
257 |
ev->button == Button1 && state == 0) || (ev->button == Button1 |
else if (((win == c->title || win == c->sides[SIDE_BOTTOM] || |
258 |
&& state == |
win == c->sides[SIDE_LEFT] || win == c->sides[SIDE_RIGHT]) && |
259 |
(Mod1Mask | |
ev->button == Button1 && state == 0) || (ev->button == Button1 |
260 |
ControlMask))) |
&& state == |
261 |
{ |
(Mod1Mask | |
262 |
clientRaise(c); |
ControlMask))) |
263 |
if(ev->time - last_button_time <= 250 && last_button_time != 0) |
{ |
264 |
{ |
clientRaise (c); |
265 |
switch (double_click_action) |
if (ev->time - last_button_time <= 250 && last_button_time != 0) |
266 |
{ |
{ |
267 |
case ACTION_MAXIMIZE: |
switch (double_click_action) |
268 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED); |
{ |
269 |
break; |
case ACTION_MAXIMIZE: |
270 |
case ACTION_SHADE: |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED); |
271 |
clientToggleShaded(c); |
break; |
272 |
break; |
case ACTION_SHADE: |
273 |
case ACTION_HIDE: |
clientToggleShaded (c); |
274 |
clientHide(c, True); |
break; |
275 |
break; |
case ACTION_HIDE: |
276 |
} |
clientHide (c, True); |
277 |
last_button_time = 0; |
break; |
278 |
} |
} |
279 |
else |
last_button_time = 0; |
280 |
{ |
} |
281 |
clientMove(c, (XEvent *) ev); |
else |
282 |
last_button_time = ev->time; |
{ |
283 |
} |
clientMove (c, (XEvent *) ev); |
284 |
} |
last_button_time = ev->time; |
285 |
else if((win == c->corners[CORNER_TOP_LEFT] || |
} |
286 |
win == c->corners[CORNER_TOP_RIGHT] || |
} |
287 |
win == c->corners[CORNER_BOTTOM_LEFT] || |
else if ((win == c->corners[CORNER_TOP_LEFT] || |
288 |
win == c->corners[CORNER_BOTTOM_RIGHT]) && |
win == c->corners[CORNER_TOP_RIGHT] || |
289 |
ev->button == Button1 && state == 0) |
win == c->corners[CORNER_BOTTOM_LEFT] || |
290 |
{ |
win == c->corners[CORNER_BOTTOM_RIGHT]) && |
291 |
clientRaise(c); |
ev->button == Button1 && state == 0) |
292 |
clientResize(c, (XEvent *) ev); |
{ |
293 |
} |
clientRaise (c); |
294 |
else if(win != c->window && ev->button == Button2 && state == 0) |
clientResize (c, (XEvent *) ev); |
295 |
{ |
} |
296 |
clientRaise(c); |
else if (win != c->window && ev->button == Button2 && state == 0) |
297 |
clientToggleSticky(c); |
{ |
298 |
} |
clientRaise (c); |
299 |
else if(ev->button == Button2 && state == (Mod1Mask | ControlMask)) |
clientToggleSticky (c); |
300 |
{ |
} |
301 |
clientRaise(c); |
else if (ev->button == Button2 && state == (Mod1Mask | ControlMask)) |
302 |
clientResize(c, (XEvent *) ev); |
{ |
303 |
} |
clientRaise (c); |
304 |
else if((win != c->window && ev->button == Button3 && state == 0) || |
clientResize (c, (XEvent *) ev); |
305 |
(ev->button == Button3 && state == (Mod1Mask | ControlMask))) |
} |
306 |
clientLower(c); |
else if ((win != c->window && ev->button == Button3 && state == 0) || |
307 |
else if(win != c->window && ev->button == Button1 && state == Mod1Mask) |
(ev->button == Button3 && state == (Mod1Mask | ControlMask))) |
308 |
clientSetLayer(c, c->win_layer + 1); |
clientLower (c); |
309 |
else if(win != c->window && ev->button == Button3 && state == Mod1Mask) |
else if (win != c->window && ev->button == Button1 && state == Mod1Mask) |
310 |
clientSetLayer(c, c->win_layer - 1); |
clientSetLayer (c, c->win_layer + 1); |
311 |
else |
else if (win != c->window && ev->button == Button3 && state == Mod1Mask) |
312 |
{ |
clientSetLayer (c, c->win_layer - 1); |
313 |
clientRaise(c); |
else |
314 |
if(win == c->window) |
{ |
315 |
replay = True; |
clientRaise (c); |
316 |
} |
if (win == c->window) |
317 |
|
replay = True; |
318 |
if(replay) |
} |
319 |
XAllowEvents(dpy, ReplayPointer, CurrentTime); |
|
320 |
else |
if (replay) |
321 |
XAllowEvents(dpy, SyncPointer, CurrentTime); |
XAllowEvents (dpy, ReplayPointer, CurrentTime); |
322 |
|
else |
323 |
raise_counter = -1; |
XAllowEvents (dpy, SyncPointer, CurrentTime); |
324 |
} |
|
325 |
else |
raise_counter = -1; |
326 |
{ |
} |
327 |
XUngrabPointer(dpy, CurrentTime); |
else |
328 |
XSendEvent(dpy, gnome_win, False, SubstructureNotifyMask, |
{ |
329 |
(XEvent *) ev); |
XUngrabPointer (dpy, CurrentTime); |
330 |
} |
XSendEvent (dpy, gnome_win, False, SubstructureNotifyMask, |
331 |
} |
(XEvent *) ev); |
332 |
|
} |
333 |
void handleButtonRelease(XButtonEvent * ev) |
} |
334 |
{ |
|
335 |
#ifdef DEBUG |
void |
336 |
printf("entering handleButtonRelease\n"); |
handleButtonRelease (XButtonEvent * ev) |
337 |
#endif |
{ |
338 |
|
#ifdef DEBUG |
339 |
XSendEvent(dpy, gnome_win, False, SubstructureNotifyMask, (XEvent *) ev); |
printf ("entering handleButtonRelease\n"); |
340 |
} |
#endif |
341 |
|
|
342 |
void handleDestroyNotify(XDestroyWindowEvent * ev) |
XSendEvent (dpy, gnome_win, False, SubstructureNotifyMask, (XEvent *) ev); |
343 |
{ |
} |
344 |
Client *c; |
|
345 |
|
void |
346 |
#ifdef DEBUG |
handleDestroyNotify (XDestroyWindowEvent * ev) |
347 |
printf("entering handleDestroyNotify\n"); |
{ |
348 |
#endif |
Client *c; |
349 |
|
|
350 |
c = clientGetFromWindow(ev->window, WINDOW); |
#ifdef DEBUG |
351 |
if(c) |
printf ("entering handleDestroyNotify\n"); |
352 |
{ |
#endif |
353 |
clientUnframe(c, False); |
|
354 |
if(clients) |
c = clientGetFromWindow (ev->window, WINDOW); |
355 |
clientSetFocus(clientGetNext(clients->prev, 0), True); |
if (c) |
356 |
else |
{ |
357 |
clientSetFocus(NULL, True); |
clientUnframe (c, False); |
358 |
} |
if (clients) |
359 |
} |
clientSetFocus (clientGetNext (clients->prev, 0), True); |
360 |
|
else |
361 |
void handleUnmapNotify(XUnmapEvent * ev) |
clientSetFocus (NULL, True); |
362 |
{ |
} |
363 |
Client *c; |
} |
364 |
|
|
365 |
#ifdef DEBUG |
void |
366 |
printf("entering handleUnmapNotify\n"); |
handleUnmapNotify (XUnmapEvent * ev) |
367 |
#endif |
{ |
368 |
|
Client *c; |
369 |
c = clientGetFromWindow(ev->window, WINDOW); |
|
370 |
if(c) |
#ifdef DEBUG |
371 |
{ |
printf ("entering handleUnmapNotify\n"); |
372 |
if(c->ignore_unmap) |
#endif |
373 |
c->ignore_unmap--; |
|
374 |
else |
c = clientGetFromWindow (ev->window, WINDOW); |
375 |
{ |
if (c) |
376 |
clientUnframe(c, False); |
{ |
377 |
if(clients) |
if (c->ignore_unmap) |
378 |
clientSetFocus(clientGetNext(clients->prev, 0), True); |
c->ignore_unmap--; |
379 |
else |
else |
380 |
clientSetFocus(NULL, True); |
{ |
381 |
} |
clientUnframe (c, False); |
382 |
} |
if (clients) |
383 |
} |
clientSetFocus (clientGetNext (clients->prev, 0), True); |
384 |
|
else |
385 |
void handleMapRequest(XMapRequestEvent * ev) |
clientSetFocus (NULL, True); |
386 |
{ |
} |
387 |
Client *c; |
} |
388 |
|
} |
389 |
#ifdef DEBUG |
|
390 |
printf("entering handleMapRequest\n"); |
void |
391 |
#endif |
handleMapRequest (XMapRequestEvent * ev) |
392 |
|
{ |
393 |
c = clientGetFromWindow(ev->window, WINDOW); |
Client *c; |
394 |
if(c) |
|
395 |
clientShow(c, True); |
#ifdef DEBUG |
396 |
else |
printf ("entering handleMapRequest\n"); |
397 |
clientFrame(ev->window); |
#endif |
398 |
} |
|
399 |
|
c = clientGetFromWindow (ev->window, WINDOW); |
400 |
void handleConfigureRequest(XConfigureRequestEvent * ev) |
if (c) |
401 |
{ |
clientShow (c, True); |
402 |
Client *c; |
else |
403 |
XWindowChanges wc; |
clientFrame (ev->window); |
404 |
|
} |
405 |
#ifdef DEBUG |
|
406 |
printf("entering handleConfigureRequest\n"); |
void |
407 |
#endif |
handleConfigureRequest (XConfigureRequestEvent * ev) |
408 |
|
{ |
409 |
wc.x = ev->x; |
Client *c; |
410 |
wc.y = ev->y; |
XWindowChanges wc; |
411 |
wc.width = ev->width; |
|
412 |
wc.height = ev->height; |
#ifdef DEBUG |
413 |
wc.sibling = ev->above; |
printf ("entering handleConfigureRequest\n"); |
414 |
wc.stack_mode = ev->detail; |
#endif |
415 |
wc.border_width = ev->border_width; |
|
416 |
|
wc.x = ev->x; |
417 |
c = clientGetFromWindow(ev->window, WINDOW); |
wc.y = ev->y; |
418 |
if(c) |
wc.width = ev->width; |
419 |
clientConfigure(c, &wc, ev->value_mask); |
wc.height = ev->height; |
420 |
else |
wc.sibling = ev->above; |
421 |
XConfigureWindow(dpy, ev->window, ev->value_mask, &wc); |
wc.stack_mode = ev->detail; |
422 |
} |
wc.border_width = ev->border_width; |
423 |
|
|
424 |
void handleEnterNotify(XCrossingEvent * ev) |
c = clientGetFromWindow (ev->window, WINDOW); |
425 |
{ |
if (c) |
426 |
Client *c; |
clientConfigure (c, &wc, ev->value_mask); |
427 |
|
else |
428 |
#ifdef DEBUG |
XConfigureWindow (dpy, ev->window, ev->value_mask, &wc); |
429 |
printf("entering handleEnterNotify\n"); |
} |
430 |
#endif |
|
431 |
|
void |
432 |
while(XCheckTypedEvent(dpy, EnterNotify, (XEvent *) ev)); |
handleEnterNotify (XCrossingEvent * ev) |
433 |
|
{ |
434 |
c = clientGetFromWindow(ev->window, FRAME); |
Client *c; |
435 |
if(c && !click_to_focus) |
|
436 |
clientSetFocus(c, True); |
#ifdef DEBUG |
437 |
} |
printf ("entering handleEnterNotify\n"); |
438 |
|
#endif |
439 |
void handleFocusIn(XFocusChangeEvent * ev) |
|
440 |
{ |
while (XCheckTypedEvent (dpy, EnterNotify, (XEvent *) ev)); |
441 |
Client *c; |
|
442 |
|
c = clientGetFromWindow (ev->window, FRAME); |
443 |
#ifdef DEBUG |
if (c && !click_to_focus) |
444 |
printf("entering handleFocusIn\n"); |
clientSetFocus (c, True); |
445 |
#endif |
} |
446 |
|
|
447 |
c = clientGetFromWindow(ev->window, WINDOW); |
void |
448 |
if(c) |
handleFocusIn (XFocusChangeEvent * ev) |
449 |
{ |
{ |
450 |
frameDraw(c); |
Client *c; |
451 |
if(raise_on_focus) |
|
452 |
raise_counter = raise_delay; |
#ifdef DEBUG |
453 |
} |
printf ("entering handleFocusIn\n"); |
454 |
else if(clients) |
#endif |
455 |
clientSetFocus(clientGetNext(clients->prev, 0), True); |
|
456 |
else |
c = clientGetFromWindow (ev->window, WINDOW); |
457 |
clientSetFocus(NULL, True); |
if (c) |
458 |
} |
{ |
459 |
|
frameDraw (c); |
460 |
void handleFocusOut(XFocusChangeEvent * ev) |
if (raise_on_focus) |
461 |
{ |
raise_counter = raise_delay; |
462 |
Client *c; |
} |
463 |
|
else if (clients) |
464 |
#ifdef DEBUG |
clientSetFocus (clientGetNext (clients->prev, 0), True); |
465 |
printf("entering handleFocusOut\n"); |
else |
466 |
#endif |
clientSetFocus (NULL, True); |
467 |
|
} |
468 |
c = clientGetFromWindow(ev->window, WINDOW); |
|
469 |
if(c) |
void |
470 |
frameDraw(c); |
handleFocusOut (XFocusChangeEvent * ev) |
471 |
} |
{ |
472 |
|
Client *c; |
473 |
void handlePropertyNotify(XPropertyEvent * ev) |
|
474 |
{ |
#ifdef DEBUG |
475 |
Client *c; |
printf ("entering handleFocusOut\n"); |
476 |
long dummy; |
#endif |
477 |
|
|
478 |
#ifdef DEBUG |
c = clientGetFromWindow (ev->window, WINDOW); |
479 |
printf("entering handlePropertyNotify\n"); |
if (c) |
480 |
#endif |
frameDraw (c); |
481 |
|
} |
482 |
c = clientGetFromWindow(ev->window, WINDOW); |
|
483 |
if(c) |
void |
484 |
{ |
handlePropertyNotify (XPropertyEvent * ev) |
485 |
if(ev->atom == XA_WM_NORMAL_HINTS) |
{ |
486 |
XGetWMNormalHints(dpy, c->window, c->size, &dummy); |
Client *c; |
487 |
else if(ev->atom == XA_WM_NAME) |
long dummy; |
488 |
{ |
|
489 |
if(c->name) |
#ifdef DEBUG |
490 |
free(c->name); |
printf ("entering handlePropertyNotify\n"); |
491 |
getWindowName(dpy, c->window, &c->name); |
#endif |
492 |
frameDraw(c); |
|
493 |
} |
c = clientGetFromWindow (ev->window, WINDOW); |
494 |
else if(ev->atom == win_hints) |
if (c) |
495 |
getGnomeHint(dpy, c->window, win_hints, &c->win_hints); |
{ |
496 |
else if(ev->atom == win_layer) |
if (ev->atom == XA_WM_NORMAL_HINTS) |
497 |
{ |
XGetWMNormalHints (dpy, c->window, c->size, &dummy); |
498 |
getGnomeHint(dpy, c->window, win_layer, &dummy); |
else if (ev->atom == XA_WM_NAME) |
499 |
clientSetLayer(c, dummy); |
{ |
500 |
} |
if (c->name) |
501 |
else if(ev->atom == win_workspace) |
free (c->name); |
502 |
{ |
getWindowName (dpy, c->window, &c->name); |
503 |
getGnomeHint(dpy, c->window, win_workspace, &dummy); |
frameDraw (c); |
504 |
clientSetWorkspace(c, dummy); |
} |
505 |
} |
else if (ev->atom == win_hints) |
506 |
} |
getGnomeHint (dpy, c->window, win_hints, &c->win_hints); |
507 |
else |
else if (ev->atom == win_layer) |
508 |
{ |
{ |
509 |
if(ev->atom == win_workspace_count) |
getGnomeHint (dpy, c->window, win_layer, &dummy); |
510 |
{ |
clientSetLayer (c, dummy); |
511 |
getGnomeHint(dpy, root, win_workspace_count, &dummy); |
} |
512 |
workspaceSetCount(dummy); |
else if (ev->atom == win_workspace) |
513 |
} |
{ |
514 |
else if(ev->atom == gnome_panel_desktop_area) |
getGnomeHint (dpy, c->window, win_workspace, &dummy); |
515 |
getGnomeDesktopMargins(dpy, margins); |
clientSetWorkspace (c, dummy); |
516 |
} |
} |
517 |
} |
} |
518 |
|
else |
519 |
void handleClientMessage(XClientMessageEvent * ev) |
{ |
520 |
{ |
if (ev->atom == win_workspace_count) |
521 |
Client *c; |
{ |
522 |
|
getGnomeHint (dpy, root, win_workspace_count, &dummy); |
523 |
#ifdef DEBUG |
workspaceSetCount (dummy); |
524 |
printf("entering handleClientMessage\n"); |
} |
525 |
#endif |
else if (ev->atom == gnome_panel_desktop_area) |
526 |
|
getGnomeDesktopMargins (dpy, margins); |
527 |
c = clientGetFromWindow(ev->window, WINDOW); |
} |
528 |
if(c) |
} |
529 |
{ |
|
530 |
if(ev->message_type == wm_change_state && ev->format == 32 && |
void |
531 |
ev->data.l[0] == IconicState) |
handleClientMessage (XClientMessageEvent * ev) |
532 |
clientHide(c, True); |
{ |
533 |
else if(ev->message_type == win_layer && ev->format == 32) |
Client *c; |
534 |
{ |
|
535 |
setGnomeHint(dpy, c->window, ev->data.l[0], win_hints); |
#ifdef DEBUG |
536 |
clientRaise(c); |
printf ("entering handleClientMessage\n"); |
537 |
} |
#endif |
538 |
else if(ev->message_type == win_state && ev->format == 32) |
|
539 |
clientSetState(c, ev->data.l[0], ev->data.l[1]); |
c = clientGetFromWindow (ev->window, WINDOW); |
540 |
else if(ev->message_type == win_layer && ev->format == 32) |
if (c) |
541 |
clientSetLayer(c, ev->data.l[0]); |
{ |
542 |
else if(ev->message_type == win_workspace && ev->format == 32) |
if (ev->message_type == wm_change_state && ev->format == 32 && |
543 |
clientSetWorkspace(c, ev->data.l[0]); |
ev->data.l[0] == IconicState) |
544 |
} |
clientHide (c, True); |
545 |
else |
else if (ev->message_type == win_layer && ev->format == 32) |
546 |
{ |
{ |
547 |
if(ev->message_type == win_workspace && ev->format == 32) |
setGnomeHint (dpy, c->window, ev->data.l[0], win_hints); |
548 |
workspaceSwitch(ev->data.l[0], NULL); |
clientRaise (c); |
549 |
else if(ev->message_type == win_workspace_count && ev->format == 32) |
} |
550 |
workspaceSetCount(ev->data.l[0]); |
else if (ev->message_type == win_state && ev->format == 32) |
551 |
} |
clientSetState (c, ev->data.l[0], ev->data.l[1]); |
552 |
} |
else if (ev->message_type == win_layer && ev->format == 32) |
553 |
|
clientSetLayer (c, ev->data.l[0]); |
554 |
void handleShape(XShapeEvent * ev) |
else if (ev->message_type == win_workspace && ev->format == 32) |
555 |
{ |
clientSetWorkspace (c, ev->data.l[0]); |
556 |
Client *c; |
} |
557 |
|
else |
558 |
#ifdef DEBUG |
{ |
559 |
printf("entering handleShape\n"); |
if (ev->message_type == win_workspace && ev->format == 32) |
560 |
#endif |
workspaceSwitch (ev->data.l[0], NULL); |
561 |
|
else if (ev->message_type == win_workspace_count && ev->format == 32) |
562 |
c = clientGetFromWindow(ev->window, WINDOW); |
workspaceSetCount (ev->data.l[0]); |
563 |
if(c) |
} |
564 |
frameDraw(c); |
} |
565 |
} |
|
566 |
|
void |
567 |
void handleEvent(XEvent * ev) |
handleShape (XShapeEvent * ev) |
568 |
{ |
{ |
569 |
#ifdef DEBUG |
Client *c; |
570 |
printf("entering handleEvent\n"); |
|
571 |
#endif |
#ifdef DEBUG |
572 |
|
printf ("entering handleShape\n"); |
573 |
switch (ev->type) |
#endif |
574 |
{ |
|
575 |
case KeyPress: |
c = clientGetFromWindow (ev->window, WINDOW); |
576 |
handleKeyPress((XKeyEvent *) ev); |
if (c) |
577 |
break; |
frameDraw (c); |
578 |
case ButtonPress: |
} |
579 |
handleButtonPress((XButtonEvent *) ev); |
|
580 |
break; |
void |
581 |
case ButtonRelease: |
handleEvent (XEvent * ev) |
582 |
handleButtonRelease((XButtonEvent *) ev); |
{ |
583 |
break; |
#ifdef DEBUG |
584 |
case DestroyNotify: |
printf ("entering handleEvent\n"); |
585 |
handleDestroyNotify((XDestroyWindowEvent *) ev); |
#endif |
586 |
break; |
|
587 |
case UnmapNotify: |
switch (ev->type) |
588 |
handleUnmapNotify((XUnmapEvent *) ev); |
{ |
589 |
break; |
case KeyPress: |
590 |
case MapRequest: |
handleKeyPress ((XKeyEvent *) ev); |
591 |
handleMapRequest((XMapRequestEvent *) ev); |
break; |
592 |
break; |
case ButtonPress: |
593 |
case ConfigureRequest: |
handleButtonPress ((XButtonEvent *) ev); |
594 |
handleConfigureRequest((XConfigureRequestEvent *) ev); |
break; |
595 |
break; |
case ButtonRelease: |
596 |
case EnterNotify: |
handleButtonRelease ((XButtonEvent *) ev); |
597 |
handleEnterNotify((XCrossingEvent *) ev); |
break; |
598 |
break; |
case DestroyNotify: |
599 |
case FocusIn: |
handleDestroyNotify ((XDestroyWindowEvent *) ev); |
600 |
handleFocusIn((XFocusChangeEvent *) ev); |
break; |
601 |
break; |
case UnmapNotify: |
602 |
case FocusOut: |
handleUnmapNotify ((XUnmapEvent *) ev); |
603 |
handleFocusOut((XFocusChangeEvent *) ev); |
break; |
604 |
break; |
case MapRequest: |
605 |
case PropertyNotify: |
handleMapRequest ((XMapRequestEvent *) ev); |
606 |
handlePropertyNotify((XPropertyEvent *) ev); |
break; |
607 |
break; |
case ConfigureRequest: |
608 |
case ClientMessage: |
handleConfigureRequest ((XConfigureRequestEvent *) ev); |
609 |
handleClientMessage((XClientMessageEvent *) ev); |
break; |
610 |
break; |
case EnterNotify: |
611 |
default: |
handleEnterNotify ((XCrossingEvent *) ev); |
612 |
if(shape && ev->type == shape_event) |
break; |
613 |
handleShape((XShapeEvent *) ev); |
case FocusIn: |
614 |
} |
handleFocusIn ((XFocusChangeEvent *) ev); |
615 |
} |
break; |
616 |
|
case FocusOut: |
617 |
void eventLoop() |
handleFocusOut ((XFocusChangeEvent *) ev); |
618 |
{ |
break; |
619 |
XEvent ev; |
case PropertyNotify: |
620 |
|
handlePropertyNotify ((XPropertyEvent *) ev); |
621 |
#ifdef DEBUG |
break; |
622 |
printf("entering eventLoop\n"); |
case ClientMessage: |
623 |
#endif |
handleClientMessage ((XClientMessageEvent *) ev); |
624 |
|
break; |
625 |
while(!quit) |
default: |
626 |
{ |
if (shape && ev->type == shape_event) |
627 |
while(XPending(dpy)) |
handleShape ((XShapeEvent *) ev); |
628 |
{ |
} |
629 |
XNextEvent(dpy, &ev); |
} |
630 |
handleEvent(&ev); |
|
631 |
} |
void |
632 |
if(reload) |
eventLoop () |
633 |
{ |
{ |
634 |
cleanUp(); |
XEvent ev; |
635 |
#ifdef DEBUG |
|
636 |
printf("executing: %s\n",progname); |
#ifdef DEBUG |
637 |
#endif |
printf ("entering eventLoop\n"); |
638 |
execvp(progname, stat_argv); |
#endif |
639 |
} |
|
640 |
if(raise_counter > 0) |
while (!quit) |
641 |
raise_counter--; |
{ |
642 |
else if(raise_counter == 0) |
while (XPending (dpy)) |
643 |
{ |
{ |
644 |
if(clientGetFocus()) |
XNextEvent (dpy, &ev); |
645 |
clientRaise(clientGetFocus()); |
handleEvent (&ev); |
646 |
raise_counter = -1; |
} |
647 |
} |
if (reload) |
648 |
usleep(1000); |
{ |
649 |
|
cleanUp (); |
650 |
|
#ifdef DEBUG |
651 |
|
printf ("executing: %s\n", progname); |
652 |
|
#endif |
653 |
|
execvp (progname, stat_argv); |
654 |
|
} |
655 |
|
if (raise_counter > 0) |
656 |
|
raise_counter--; |
657 |
|
else if (raise_counter == 0) |
658 |
|
{ |
659 |
|
if (clientGetFocus ()) |
660 |
|
clientRaise (clientGetFocus ()); |
661 |
|
raise_counter = -1; |
662 |
|
} |
663 |
|
usleep (1000); |
664 |
} |
} |
665 |
|
|
666 |
#ifdef DEBUG |
#ifdef DEBUG |
667 |
printf("leaving eventLoop\n"); |
printf ("leaving eventLoop\n"); |
668 |
#endif |
#endif |
669 |
} |
} |