21 |
|
|
22 |
#include "oroborus.h" |
#include "oroborus.h" |
23 |
|
|
24 |
void clientInitPosition(Client * c) |
void |
25 |
|
clientInitPosition (Client * c) |
26 |
{ |
{ |
27 |
int mx, my, min_x, min_y, max_x, max_y; |
int mx, my, min_x, min_y, max_x, max_y; |
28 |
|
|
29 |
#ifdef DEBUG |
#ifdef DEBUG |
30 |
printf("entering clientInitPosition\n"); |
printf ("entering clientInitPosition\n"); |
31 |
#endif |
#endif |
32 |
|
|
33 |
clientGravitate(c, APPLY); |
clientGravitate (c, APPLY); |
34 |
min_x = frameLeft(c) + margins[MARGIN_LEFT]; |
min_x = frameLeft (c) + margins[MARGIN_LEFT]; |
35 |
min_y = frameTop(c) + margins[MARGIN_TOP]; |
min_y = frameTop (c) + margins[MARGIN_TOP]; |
36 |
max_x = XDisplayWidth(dpy, screen) - frameRight(c) - margins[MARGIN_RIGHT]; |
max_x = |
37 |
max_y = |
XDisplayWidth (dpy, screen) - frameRight (c) - margins[MARGIN_RIGHT]; |
38 |
XDisplayHeight(dpy, screen) - frameBottom(c) - margins[MARGIN_BOTTOM]; |
max_y = |
39 |
|
XDisplayHeight (dpy, screen) - frameBottom (c) - margins[MARGIN_BOTTOM]; |
40 |
|
|
41 |
if(!(c->size->flags & (PPosition | USPosition))) |
if (!(c->size->flags & (PPosition | USPosition))) |
42 |
{ |
{ |
43 |
getMouseXY(dpy, root, &mx, &my); |
getMouseXY (dpy, root, &mx, &my); |
44 |
c->x = mx - c->width / 2; |
c->x = mx - c->width / 2; |
45 |
c->y = my - c->height / 2; |
c->y = my - c->height / 2; |
46 |
|
|
47 |
if(window_placement == PLACEMENT_ROOT) |
if (window_placement == PLACEMENT_ROOT) |
48 |
{ |
{ |
49 |
c->x = (max_x - min_x) / 2 - (c->width / 2) + frameLeft(c); |
c->x = (max_x - min_x) / 2 - (c->width / 2) + frameLeft (c); |
50 |
c->y = (max_y - min_y) / 2 - (c->height / 2) + frameTop(c); |
c->y = (max_y - min_y) / 2 - (c->height / 2) + frameTop (c); |
51 |
} |
} |
52 |
} |
} |
53 |
|
|
54 |
if(c->x > max_x - c->width) |
if (c->x > max_x - c->width) |
55 |
c->x = max_x - c->width; |
c->x = max_x - c->width; |
56 |
if(c->y > max_y - c->height) |
if (c->y > max_y - c->height) |
57 |
c->y = max_y - c->height; |
c->y = max_y - c->height; |
58 |
if(c->x < min_x) |
if (c->x < min_x) |
59 |
c->x = min_x; |
c->x = min_x; |
60 |
if(c->y < min_y) |
if (c->y < min_y) |
61 |
c->y = min_y; |
c->y = min_y; |
62 |
} |
} |
63 |
|
|
64 |
void clientGrabKeys(Client * c) |
void |
65 |
|
clientGrabKeys (Client * c) |
66 |
{ |
{ |
67 |
#ifdef DEBUG |
#ifdef DEBUG |
68 |
printf("entering clientGrabKeys\n"); |
printf ("entering clientGrabKeys\n"); |
69 |
printf("grabbing keys for client (%#lx)\n", c->window); |
printf ("grabbing keys for client (%#lx)\n", c->window); |
70 |
#endif |
#endif |
71 |
|
|
72 |
grabKey(dpy, &keys[KEY_MOVE_UP], c->window); |
grabKey (dpy, &keys[KEY_MOVE_UP], c->window); |
73 |
grabKey(dpy, &keys[KEY_MOVE_DOWN], c->window); |
grabKey (dpy, &keys[KEY_MOVE_DOWN], c->window); |
74 |
grabKey(dpy, &keys[KEY_MOVE_LEFT], c->window); |
grabKey (dpy, &keys[KEY_MOVE_LEFT], c->window); |
75 |
grabKey(dpy, &keys[KEY_MOVE_RIGHT], c->window); |
grabKey (dpy, &keys[KEY_MOVE_RIGHT], c->window); |
76 |
grabKey(dpy, &keys[KEY_RESIZE_UP], c->window); |
grabKey (dpy, &keys[KEY_RESIZE_UP], c->window); |
77 |
grabKey(dpy, &keys[KEY_RESIZE_DOWN], c->window); |
grabKey (dpy, &keys[KEY_RESIZE_DOWN], c->window); |
78 |
grabKey(dpy, &keys[KEY_RESIZE_LEFT], c->window); |
grabKey (dpy, &keys[KEY_RESIZE_LEFT], c->window); |
79 |
grabKey(dpy, &keys[KEY_RESIZE_RIGHT], c->window); |
grabKey (dpy, &keys[KEY_RESIZE_RIGHT], c->window); |
80 |
grabKey(dpy, &keys[KEY_CLOSE_WINDOW], c->window); |
grabKey (dpy, &keys[KEY_CLOSE_WINDOW], c->window); |
81 |
grabKey(dpy, &keys[KEY_HIDE_WINDOW], c->window); |
grabKey (dpy, &keys[KEY_HIDE_WINDOW], c->window); |
82 |
grabKey(dpy, &keys[KEY_MAXIMIZE_WINDOW], c->window); |
grabKey (dpy, &keys[KEY_MAXIMIZE_WINDOW], c->window); |
83 |
grabKey(dpy, &keys[KEY_MAXIMIZE_VERT], c->window); |
grabKey (dpy, &keys[KEY_MAXIMIZE_VERT], c->window); |
84 |
grabKey(dpy, &keys[KEY_MAXIMIZE_HORIZ], c->window); |
grabKey (dpy, &keys[KEY_MAXIMIZE_HORIZ], c->window); |
85 |
grabKey(dpy, &keys[KEY_SHADE_WINDOW], c->window); |
grabKey (dpy, &keys[KEY_SHADE_WINDOW], c->window); |
86 |
grabKey(dpy, &keys[KEY_CYCLE_WINDOWS], c->window); |
grabKey (dpy, &keys[KEY_CYCLE_WINDOWS], c->window); |
87 |
grabKey(dpy, &keys[KEY_LOWER_WINDOW_LAYER], c->window); |
grabKey (dpy, &keys[KEY_LOWER_WINDOW_LAYER], c->window); |
88 |
grabKey(dpy, &keys[KEY_RAISE_WINDOW_LAYER], c->window); |
grabKey (dpy, &keys[KEY_RAISE_WINDOW_LAYER], c->window); |
89 |
grabKey(dpy, &keys[KEY_NEXT_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_NEXT_WORKSPACE], c->window); |
90 |
grabKey(dpy, &keys[KEY_PREV_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_PREV_WORKSPACE], c->window); |
91 |
grabKey(dpy, &keys[KEY_ADD_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_ADD_WORKSPACE], c->window); |
92 |
grabKey(dpy, &keys[KEY_DEL_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_DEL_WORKSPACE], c->window); |
93 |
grabKey(dpy, &keys[KEY_STICK_WINDOW], c->window); |
grabKey (dpy, &keys[KEY_STICK_WINDOW], c->window); |
94 |
grabKey(dpy, &keys[KEY_WORKSPACE_1], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_1], c->window); |
95 |
grabKey(dpy, &keys[KEY_WORKSPACE_2], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_2], c->window); |
96 |
grabKey(dpy, &keys[KEY_WORKSPACE_3], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_3], c->window); |
97 |
grabKey(dpy, &keys[KEY_WORKSPACE_4], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_4], c->window); |
98 |
grabKey(dpy, &keys[KEY_WORKSPACE_5], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_5], c->window); |
99 |
grabKey(dpy, &keys[KEY_WORKSPACE_6], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_6], c->window); |
100 |
grabKey(dpy, &keys[KEY_WORKSPACE_7], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_7], c->window); |
101 |
grabKey(dpy, &keys[KEY_WORKSPACE_8], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_8], c->window); |
102 |
grabKey(dpy, &keys[KEY_WORKSPACE_9], c->window); |
grabKey (dpy, &keys[KEY_WORKSPACE_9], c->window); |
103 |
grabKey(dpy, &keys[KEY_MOVE_NEXT_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_MOVE_NEXT_WORKSPACE], c->window); |
104 |
grabKey(dpy, &keys[KEY_MOVE_PREV_WORKSPACE], c->window); |
grabKey (dpy, &keys[KEY_MOVE_PREV_WORKSPACE], c->window); |
105 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_1], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_1], c->window); |
106 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_2], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_2], c->window); |
107 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_3], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_3], c->window); |
108 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_4], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_4], c->window); |
109 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_5], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_5], c->window); |
110 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_6], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_6], c->window); |
111 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_7], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_7], c->window); |
112 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_8], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_8], c->window); |
113 |
grabKey(dpy, &keys[KEY_MOVE_WORKSPACE_9], c->window); |
grabKey (dpy, &keys[KEY_MOVE_WORKSPACE_9], c->window); |
114 |
grabKey(dpy, &keys[KEY_QUIT], c->window); |
grabKey (dpy, &keys[KEY_QUIT], c->window); |
115 |
} |
} |
116 |
|
|
117 |
void clientUngrabKeys(Client * c) |
void |
118 |
|
clientUngrabKeys (Client * c) |
119 |
{ |
{ |
120 |
#ifdef DEBUG |
#ifdef DEBUG |
121 |
printf("entering clientUngrabKeys\n"); |
printf ("entering clientUngrabKeys\n"); |
122 |
printf("ungrabing keys for client (%#lx)\n", c->window); |
printf ("ungrabing keys for client (%#lx)\n", c->window); |
123 |
#endif |
#endif |
124 |
|
|
125 |
ungrabKeys(dpy, c->window); |
ungrabKeys (dpy, c->window); |
126 |
} |
} |
127 |
|
|
128 |
void clientGravitate(Client * c, int mode) |
void |
129 |
|
clientGravitate (Client * c, int mode) |
130 |
{ |
{ |
131 |
int gravity, dx = 0, dy = 0; |
int gravity, dx = 0, dy = 0; |
132 |
|
|
133 |
#ifdef DEBUG |
#ifdef DEBUG |
134 |
printf("entering clientGravitate\n"); |
printf ("entering clientGravitate\n"); |
135 |
#endif |
#endif |
136 |
|
|
137 |
gravity = |
gravity = |
138 |
c->size->flags & PWinGravity ? c->size->win_gravity : NorthWestGravity; |
c->size->flags & PWinGravity ? c->size->win_gravity : NorthWestGravity; |
139 |
switch (gravity) |
switch (gravity) |
140 |
{ |
{ |
141 |
case CenterGravity: |
case CenterGravity: |
142 |
dx = (c->border_width * 2) - ((frameLeft(c) + frameRight(c)) / 2); |
dx = (c->border_width * 2) - ((frameLeft (c) + frameRight (c)) / 2); |
143 |
dy = (c->border_width * 2) - ((frameTop(c) + frameBottom(c)) / 2); |
dy = (c->border_width * 2) - ((frameTop (c) + frameBottom (c)) / 2); |
144 |
break; |
break; |
145 |
case NorthGravity: |
case NorthGravity: |
146 |
dx = (c->border_width * 2) - ((frameLeft(c) + frameRight(c)) / 2); |
dx = (c->border_width * 2) - ((frameLeft (c) + frameRight (c)) / 2); |
147 |
dy = frameTop(c); |
dy = frameTop (c); |
148 |
break; |
break; |
149 |
case SouthGravity: |
case SouthGravity: |
150 |
dx = (c->border_width * 2) - ((frameLeft(c) + frameRight(c)) / 2); |
dx = (c->border_width * 2) - ((frameLeft (c) + frameRight (c)) / 2); |
151 |
dy = (c->border_width * 2) - frameBottom(c); |
dy = (c->border_width * 2) - frameBottom (c); |
152 |
break; |
break; |
153 |
case EastGravity: |
case EastGravity: |
154 |
dx = (c->border_width * 2) - frameRight(c); |
dx = (c->border_width * 2) - frameRight (c); |
155 |
dy = (c->border_width * 2) - ((frameTop(c) + frameBottom(c)) / 2); |
dy = (c->border_width * 2) - ((frameTop (c) + frameBottom (c)) / 2); |
156 |
break; |
break; |
157 |
case WestGravity: |
case WestGravity: |
158 |
dx = frameLeft(c); |
dx = frameLeft (c); |
159 |
dy = (c->border_width * 2) - ((frameTop(c) + frameBottom(c)) / 2); |
dy = (c->border_width * 2) - ((frameTop (c) + frameBottom (c)) / 2); |
160 |
break; |
break; |
161 |
case NorthWestGravity: |
case NorthWestGravity: |
162 |
dx = frameLeft(c); |
dx = frameLeft (c); |
163 |
dy = frameTop(c); |
dy = frameTop (c); |
164 |
break; |
break; |
165 |
case NorthEastGravity: |
case NorthEastGravity: |
166 |
dx = (c->border_width * 2) - frameRight(c); |
dx = (c->border_width * 2) - frameRight (c); |
167 |
dy = frameTop(c); |
dy = frameTop (c); |
168 |
break; |
break; |
169 |
case SouthWestGravity: |
case SouthWestGravity: |
170 |
dx = frameLeft(c); |
dx = frameLeft (c); |
171 |
dy = (c->border_width * 2) - frameBottom(c); |
dy = (c->border_width * 2) - frameBottom (c); |
172 |
break; |
break; |
173 |
case SouthEastGravity: |
case SouthEastGravity: |
174 |
dx = (c->border_width * 2) - frameRight(c); |
dx = (c->border_width * 2) - frameRight (c); |
175 |
dy = (c->border_width * 2) - frameBottom(c); |
dy = (c->border_width * 2) - frameBottom (c); |
176 |
break; |
break; |
177 |
} |
} |
178 |
c->x = c->x + (dx * mode); |
c->x = c->x + (dx * mode); |
179 |
c->y = c->y + (dy * mode); |
c->y = c->y + (dy * mode); |
180 |
} |
} |
181 |
|
|
182 |
void clientAddToList(Client * c) |
void |
183 |
|
clientAddToList (Client * c) |
184 |
{ |
{ |
185 |
int i; |
int i; |
186 |
CARD32 *new; |
CARD32 *new; |
187 |
|
|
188 |
#ifdef DEBUG |
#ifdef DEBUG |
189 |
printf("entering clientAddToList\n"); |
printf ("entering clientAddToList\n"); |
190 |
#endif |
#endif |
191 |
|
|
192 |
new = malloc(sizeof(CARD32) * client_count); |
new = malloc (sizeof (CARD32) * client_count); |
193 |
if(new) |
if (new) |
194 |
{ |
{ |
195 |
for(i = 0; i < client_count - 1; i++) |
for (i = 0; i < client_count - 1; i++) |
196 |
new[i] = client_list[i]; |
new[i] = client_list[i]; |
197 |
new[i] = c->window; |
new[i] = c->window; |
198 |
XChangeProperty(dpy, root, win_client_list, XA_CARDINAL, 32, |
XChangeProperty (dpy, root, win_client_list, XA_CARDINAL, 32, |
199 |
PropModeReplace, (unsigned char *)new, client_count); |
PropModeReplace, (unsigned char *) new, client_count); |
200 |
if(client_list) |
if (client_list) |
201 |
free(client_list); |
free (client_list); |
202 |
client_list = new; |
client_list = new; |
203 |
} |
} |
204 |
} |
} |
205 |
|
|
206 |
void clientRemoveFromList(Client * c) |
void |
207 |
|
clientRemoveFromList (Client * c) |
208 |
{ |
{ |
209 |
int i, j; |
int i, j; |
210 |
CARD32 *new; |
CARD32 *new; |
211 |
|
|
212 |
#ifdef DEBUG |
#ifdef DEBUG |
213 |
printf("entering clientRemoveFromList\n"); |
printf ("entering clientRemoveFromList\n"); |
214 |
#endif |
#endif |
215 |
|
|
216 |
new = malloc(sizeof(CARD32) * client_count); |
new = malloc (sizeof (CARD32) * client_count); |
217 |
if(new) |
if (new) |
218 |
{ |
{ |
219 |
for(i = 0, j = 0; i < client_count; i++) |
for (i = 0, j = 0; i < client_count; i++) |
220 |
if(client_list[i] != c->window) |
if (client_list[i] != c->window) |
221 |
new[j++] = client_list[i]; |
new[j++] = client_list[i]; |
222 |
XChangeProperty(dpy, root, win_client_list, XA_CARDINAL, 32, |
XChangeProperty (dpy, root, win_client_list, XA_CARDINAL, 32, |
223 |
PropModeReplace, (unsigned char *)new, |
PropModeReplace, (unsigned char *) new, |
224 |
client_count - 1); |
client_count - 1); |
225 |
if(client_list) |
if (client_list) |
226 |
free(client_list); |
free (client_list); |
227 |
client_list = new; |
client_list = new; |
228 |
} |
} |
229 |
} |
} |
230 |
|
|
231 |
int clientGetWidthInc(Client * c) |
int |
232 |
|
clientGetWidthInc (Client * c) |
233 |
{ |
{ |
234 |
if(c->size->flags & PResizeInc) |
if (c->size->flags & PResizeInc) |
235 |
return c->size->width_inc; |
return c->size->width_inc; |
236 |
return 1; |
return 1; |
237 |
} |
} |
238 |
|
|
239 |
int clientGetHeightInc(Client * c) |
int |
240 |
|
clientGetHeightInc (Client * c) |
241 |
{ |
{ |
242 |
if(c->size->flags & PResizeInc) |
if (c->size->flags & PResizeInc) |
243 |
return c->size->height_inc; |
return c->size->height_inc; |
244 |
return 1; |
return 1; |
|
} |
|
|
|
|
|
void clientSetWidth(Client * c, int w1) |
|
|
{ |
|
|
int w2; |
|
|
|
|
|
if(c->size->flags & PResizeInc) |
|
|
{ |
|
|
w2 = (w1 - c->size->min_width) / c->size->width_inc; |
|
|
w1 = c->size->min_width + (w2 * c->size->width_inc); |
|
|
} |
|
|
if(c->size->flags & PMinSize) |
|
|
if(w1 < c->size->min_width) |
|
|
w1 = c->size->min_width; |
|
|
if(c->size->flags & PMaxSize) |
|
|
if(w1 > c->size->max_width) |
|
|
w1 = c->size->max_width; |
|
|
if(w1 < 1) |
|
|
w1 = 1; |
|
|
c->width = w1; |
|
245 |
} |
} |
246 |
|
|
247 |
void clientSetHeight(Client * c, int h1) |
void |
248 |
|
clientSetWidth (Client * c, int w1) |
249 |
{ |
{ |
250 |
int h2; |
int w2; |
251 |
|
|
252 |
if(c->size->flags & PResizeInc) |
if (c->size->flags & PResizeInc) |
253 |
{ |
{ |
254 |
h2 = (h1 - c->size->min_height) / c->size->height_inc; |
w2 = (w1 - c->size->min_width) / c->size->width_inc; |
255 |
h1 = c->size->min_height + (h2 * c->size->height_inc); |
w1 = c->size->min_width + (w2 * c->size->width_inc); |
256 |
} |
} |
257 |
if(c->size->flags & PMinSize) |
if (c->size->flags & PMinSize) |
258 |
if(h1 < c->size->min_height) |
if (w1 < c->size->min_width) |
259 |
h1 = c->size->min_height; |
w1 = c->size->min_width; |
260 |
if(c->size->flags & PMaxSize) |
if (c->size->flags & PMaxSize) |
261 |
if(h1 > c->size->max_height) |
if (w1 > c->size->max_width) |
262 |
h1 = c->size->max_height; |
w1 = c->size->max_width; |
263 |
if(h1 < 1) |
if (w1 < 1) |
264 |
h1 = 1; |
w1 = 1; |
265 |
c->height = h1; |
c->width = w1; |
266 |
} |
} |
267 |
|
|
268 |
Client *clientGetTopMost(int layer) |
void |
269 |
|
clientSetHeight (Client * c, int h1) |
270 |
{ |
{ |
271 |
Window w1, w2, *wins; |
int h2; |
|
unsigned int i, count; |
|
|
XWindowAttributes attr; |
|
|
Client *top = NULL, *c; |
|
|
|
|
|
#ifdef DEBUG |
|
|
printf("entering clientGetTopMost\n"); |
|
|
#endif |
|
|
|
|
|
XQueryTree(dpy, root, &w1, &w2, &wins, &count); |
|
|
for(i = 0; i < count; i++) |
|
|
{ |
|
|
XGetWindowAttributes(dpy, wins[i], &attr); |
|
|
c = clientGetFromWindow(wins[i], FRAME); |
|
|
if(c && attr.map_state == IsViewable) |
|
|
{ |
|
|
if(c->win_layer <= layer) |
|
|
top = c; |
|
|
else |
|
|
break; |
|
|
} |
|
|
} |
|
|
if(wins) |
|
|
XFree(wins); |
|
|
return top; |
|
|
} |
|
|
|
|
|
Client *clientGetBottomMost(int layer) |
|
|
{ |
|
|
Window w1, w2, *wins; |
|
|
unsigned int i, count; |
|
|
XWindowAttributes attr; |
|
|
Client *c = NULL; |
|
|
|
|
|
#ifdef DEBUG |
|
|
printf("entering clientGetBottomMost\n"); |
|
|
#endif |
|
272 |
|
|
273 |
XQueryTree(dpy, root, &w1, &w2, &wins, &count); |
if (c->size->flags & PResizeInc) |
|
for(i = 0; i < count; i++) |
|
274 |
{ |
{ |
275 |
XGetWindowAttributes(dpy, wins[i], &attr); |
h2 = (h1 - c->size->min_height) / c->size->height_inc; |
276 |
c = clientGetFromWindow(wins[i], FRAME); |
h1 = c->size->min_height + (h2 * c->size->height_inc); |
|
if(c && attr.map_state == IsViewable && !typeDesktop(dpy, c->window)) |
|
|
{ |
|
|
if(c->win_layer >= layer) |
|
|
break; |
|
|
} |
|
277 |
} |
} |
278 |
if(wins) |
if (c->size->flags & PMinSize) |
279 |
XFree(wins); |
if (h1 < c->size->min_height) |
280 |
return c; |
h1 = c->size->min_height; |
281 |
|
if (c->size->flags & PMaxSize) |
282 |
|
if (h1 > c->size->max_height) |
283 |
|
h1 = c->size->max_height; |
284 |
|
if (h1 < 1) |
285 |
|
h1 = 1; |
286 |
|
c->height = h1; |
287 |
} |
} |
288 |
|
|
289 |
void clientConfigure(Client * c, XWindowChanges * wc, int mask) |
Client * |
290 |
|
clientGetTopMost (int layer) |
291 |
{ |
{ |
292 |
XConfigureEvent ce; |
Window w1, w2, *wins; |
293 |
Client *sibling = NULL; |
unsigned int i, count; |
294 |
|
XWindowAttributes attr; |
295 |
|
Client *top = NULL, *c; |
296 |
|
|
297 |
#ifdef DEBUG |
#ifdef DEBUG |
298 |
printf("entering clientConfigure\n"); |
printf ("entering clientGetTopMost\n"); |
|
printf("configuring client (%#lx)\n", c->window); |
|
299 |
#endif |
#endif |
300 |
|
|
301 |
if(mask & CWX) |
XQueryTree (dpy, root, &w1, &w2, &wins, &count); |
302 |
c->x = wc->x; |
for (i = 0; i < count; i++) |
|
if(mask & CWY) |
|
|
c->y = wc->y; |
|
|
if(mask & CWWidth) |
|
|
clientSetWidth(c, wc->width); |
|
|
if(mask & CWHeight) |
|
|
clientSetHeight(c, wc->height); |
|
|
if(mask & CWBorderWidth) |
|
|
c->border_width = wc->border_width; |
|
|
if(mask & CWStackMode) |
|
303 |
{ |
{ |
304 |
switch (wc->stack_mode) |
XGetWindowAttributes (dpy, wins[i], &attr); |
305 |
{ |
c = clientGetFromWindow (wins[i], FRAME); |
306 |
case Above: |
if (c && attr.map_state == IsViewable) |
307 |
sibling = clientGetTopMost(c->win_layer); |
{ |
308 |
if(!sibling) |
if (c->win_layer <= layer) |
309 |
wc->stack_mode = Below; |
top = c; |
310 |
break; |
else |
311 |
case Below: |
break; |
312 |
sibling = clientGetBottomMost(c->win_layer); |
} |
|
break; |
|
|
} |
|
|
if(sibling) |
|
|
{ |
|
|
if(sibling != c) |
|
|
{ |
|
|
wc->sibling = sibling->frame; |
|
|
mask = mask | CWSibling; |
|
|
} |
|
|
else |
|
|
mask = mask & ~(CWSibling | CWStackMode); |
|
|
} |
|
|
else |
|
|
mask = mask & ~CWSibling; |
|
|
} |
|
|
|
|
|
wc->x = frameX(c); |
|
|
wc->y = frameY(c); |
|
|
wc->width = frameWidth(c); |
|
|
wc->height = frameHeight(c); |
|
|
wc->border_width = 0; |
|
|
XConfigureWindow(dpy, c->frame, mask, wc); |
|
|
wc->x = frameLeft(c); |
|
|
wc->y = frameTop(c); |
|
|
wc->width = c->width; |
|
|
wc->height = c->height; |
|
|
mask = mask & ~CWStackMode; |
|
|
mask = mask & ~CWSibling; |
|
|
XConfigureWindow(dpy, c->window, mask, wc); |
|
|
|
|
|
if(mask & (CWWidth | CWHeight)) |
|
|
frameDraw(c); |
|
|
|
|
|
if(mask) |
|
|
{ |
|
|
ce.type = ConfigureNotify; |
|
|
ce.event = c->window; |
|
|
ce.window = c->window; |
|
|
ce.x = c->x; |
|
|
ce.y = c->y; |
|
|
ce.width = c->width; |
|
|
ce.height = c->height; |
|
|
ce.border_width = 0; |
|
|
ce.above = None; |
|
|
ce.override_redirect = False; |
|
|
XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent *) & ce); |
|
313 |
} |
} |
314 |
|
if (wins) |
315 |
|
XFree (wins); |
316 |
|
return top; |
317 |
} |
} |
318 |
|
|
319 |
void clientFrame(Window w) |
Client * |
320 |
|
clientGetBottomMost (int layer) |
321 |
{ |
{ |
322 |
Client *c; |
Window w1, w2, *wins; |
323 |
XWindowAttributes attr; |
unsigned int i, count; |
324 |
XWindowChanges wc; |
XWindowAttributes attr; |
325 |
long dummy; |
Client *c = NULL; |
|
PropMwmHints *mwm_hints; |
|
|
Window transientWindow; |
|
|
int i; |
|
326 |
|
|
327 |
#ifdef DEBUG |
#ifdef DEBUG |
328 |
printf("entering clientFrame\n"); |
printf ("entering clientGetBottomMost\n"); |
|
printf("framing client (%#lx)\n", w); |
|
329 |
#endif |
#endif |
330 |
|
|
331 |
c = malloc(sizeof(*c)); |
XQueryTree (dpy, root, &w1, &w2, &wins, &count); |
332 |
if(!c) |
for (i = 0; i < count; i++) |
|
return; |
|
|
|
|
|
c->size = XAllocSizeHints(); |
|
|
XGetWMNormalHints(dpy, w, c->size, &dummy); |
|
|
XGetWindowAttributes(dpy, w, &attr); |
|
|
c->window = w; |
|
|
c->x = attr.x; |
|
|
c->y = attr.y; |
|
|
c->width = attr.width; |
|
|
c->height = attr.height; |
|
|
c->border_width = attr.border_width; |
|
|
for(i = 0; i < BUTTON_COUNT; i++) |
|
|
c->button_pressed[i] = False; |
|
|
if (!getGnomeHint(dpy, w, win_hints, &c->win_hints)) |
|
|
c->win_hints = 0; |
|
|
if (!getGnomeHint(dpy, w, win_state, &c->win_state)) |
|
|
c->win_state = 0; |
|
|
if (!getGnomeHint(dpy, w, win_layer, &c->win_layer)) |
|
|
c->win_layer = WIN_LAYER_NORMAL; |
|
|
if(!getGnomeHint(dpy, w, win_workspace, &c->win_workspace)) |
|
|
{ |
|
|
setGnomeHint(dpy, w, win_workspace, workspace); |
|
|
c->win_workspace = workspace; |
|
|
} |
|
|
if(c->win_workspace > workspace_count - 1) |
|
|
{ |
|
|
setGnomeHint(dpy, w, win_workspace, workspace_count - 1); |
|
|
c->win_workspace = workspace_count - 1; |
|
|
} |
|
|
c->has_border = True; |
|
|
c->ignore_unmap = attr.map_state == IsViewable ? 1 : 0; |
|
|
c->focus = False; |
|
|
getWindowName(dpy, c->window, &c->name); |
|
|
|
|
|
mwm_hints = getMotifHints(dpy, c->window); |
|
|
if(mwm_hints) |
|
|
{ |
|
|
if(mwm_hints->flags & MWM_HINTS_DECORATIONS && |
|
|
!(mwm_hints->decorations & MWM_DECOR_ALL)) |
|
|
c->has_border = mwm_hints->decorations & MWM_DECOR_BORDER; |
|
|
XFree(mwm_hints); |
|
|
} |
|
|
|
|
|
if(attr.map_state != IsViewable) |
|
|
clientInitPosition(c); |
|
|
else |
|
|
clientGravitate(c, APPLY); |
|
|
|
|
|
c->frame = |
|
|
XCreateSimpleWindow(dpy, root, frameX(c), frameY(c), frameWidth(c), |
|
|
frameHeight(c), 0, 0, 0); |
|
|
XSelectInput(dpy, c->frame, |
|
|
SubstructureNotifyMask | SubstructureRedirectMask | |
|
|
EnterWindowMask); |
|
|
XSelectInput(dpy, c->window, FocusChangeMask | PropertyChangeMask); |
|
|
if(shape) |
|
|
XShapeSelectInput(dpy, c->window, ShapeNotifyMask); |
|
|
XSetWindowBorderWidth(dpy, w, 0); |
|
|
XReparentWindow(dpy, w, c->frame, frameLeft(c), frameTop(c)); |
|
|
XGrabButton(dpy, AnyButton, AnyModifier, c->frame, False, ButtonPressMask, |
|
|
GrabModeSync, GrabModeAsync, None, None); |
|
|
|
|
|
c->sides[SIDE_LEFT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->sides[SIDE_RIGHT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->sides[SIDE_BOTTOM] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->corners[CORNER_BOTTOM_LEFT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->corners[CORNER_BOTTOM_RIGHT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->title = XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->corners[CORNER_TOP_LEFT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
c->corners[CORNER_TOP_RIGHT] = |
|
|
XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
for(i = 0; i < 4; i++) |
|
|
XDefineCursor(dpy, c->corners[i], resize_cursor[i]); |
|
|
|
|
|
for(i = 0; i < BUTTON_COUNT; i++) |
|
|
c->buttons[i] = XCreateSimpleWindow(dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
|
|
|
|
|
if(clients) |
|
333 |
{ |
{ |
334 |
c->prev = clients->prev; |
XGetWindowAttributes (dpy, wins[i], &attr); |
335 |
c->next = clients; |
c = clientGetFromWindow (wins[i], FRAME); |
336 |
clients->prev->next = c; |
if (c && attr.map_state == IsViewable && !typeDesktop (dpy, c->window)) |
337 |
clients->prev = c; |
{ |
338 |
|
if (c->win_layer >= layer) |
339 |
|
break; |
340 |
|
} |
341 |
} |
} |
342 |
else |
if (wins) |
343 |
{ |
XFree (wins); |
344 |
clients = c; |
return c; |
345 |
c->next = c; |
} |
346 |
c->prev = c; |
|
347 |
|
void |
348 |
|
clientConfigure (Client * c, XWindowChanges * wc, int mask) |
349 |
|
{ |
350 |
|
XConfigureEvent ce; |
351 |
|
Client *sibling = NULL; |
352 |
|
|
353 |
|
#ifdef DEBUG |
354 |
|
printf ("entering clientConfigure\n"); |
355 |
|
printf ("configuring client (%#lx)\n", c->window); |
356 |
|
#endif |
357 |
|
|
358 |
|
if (mask & CWX) |
359 |
|
c->x = wc->x; |
360 |
|
if (mask & CWY) |
361 |
|
c->y = wc->y; |
362 |
|
if (mask & CWWidth) |
363 |
|
clientSetWidth (c, wc->width); |
364 |
|
if (mask & CWHeight) |
365 |
|
clientSetHeight (c, wc->height); |
366 |
|
if (mask & CWBorderWidth) |
367 |
|
c->border_width = wc->border_width; |
368 |
|
if (mask & CWStackMode) |
369 |
|
{ |
370 |
|
switch (wc->stack_mode) |
371 |
|
{ |
372 |
|
case Above: |
373 |
|
sibling = clientGetTopMost (c->win_layer); |
374 |
|
if (!sibling) |
375 |
|
wc->stack_mode = Below; |
376 |
|
break; |
377 |
|
case Below: |
378 |
|
sibling = clientGetBottomMost (c->win_layer); |
379 |
|
break; |
380 |
|
} |
381 |
|
if (sibling) |
382 |
|
{ |
383 |
|
if (sibling != c) |
384 |
|
{ |
385 |
|
wc->sibling = sibling->frame; |
386 |
|
mask = mask | CWSibling; |
387 |
|
} |
388 |
|
else |
389 |
|
mask = mask & ~(CWSibling | CWStackMode); |
390 |
|
} |
391 |
|
else |
392 |
|
mask = mask & ~CWSibling; |
393 |
} |
} |
|
|
|
|
XGetTransientForHint(dpy, c->window, &transientWindow); |
|
|
c->transientFor = clientGetFromWindow(transientWindow, WINDOW); |
|
|
|
|
|
client_count++; |
|
|
clientAddToList(c); |
|
|
clientGrabKeys(c); |
|
|
frameDraw(c); |
|
|
wc.x = c->x; |
|
|
wc.y = c->y; |
|
|
wc.height = c->height; |
|
|
wc.width = c->width; |
|
|
wc.stack_mode = Above; |
|
|
clientConfigure(c, &wc, CWX | CWY | CWHeight | CWWidth | CWStackMode); |
|
394 |
|
|
395 |
if(getWMState(dpy, c->window) != IconicState) |
wc->x = frameX (c); |
396 |
{ |
wc->y = frameY (c); |
397 |
clientShow(c, True); |
wc->width = frameWidth (c); |
398 |
#ifdef DEBUG |
wc->height = frameHeight (c); |
399 |
printf("strcmp no. 1\n"); |
wc->border_width = 0; |
400 |
#endif |
XConfigureWindow (dpy, c->frame, mask, wc); |
401 |
if(focus_new && !(c->win_hints & WIN_HINTS_SKIP_FOCUS) && !typeDesktop(dpy, c->window)) { |
wc->x = frameLeft (c); |
402 |
clientSetFocus(c, True); |
wc->y = frameTop (c); |
403 |
|
wc->width = c->width; |
404 |
|
wc->height = c->height; |
405 |
|
mask = mask & ~CWStackMode; |
406 |
|
mask = mask & ~CWSibling; |
407 |
|
XConfigureWindow (dpy, c->window, mask, wc); |
408 |
|
|
409 |
|
if (mask & (CWWidth | CWHeight)) |
410 |
|
frameDraw (c); |
411 |
|
|
412 |
|
if (mask) |
413 |
|
{ |
414 |
|
ce.type = ConfigureNotify; |
415 |
|
ce.event = c->window; |
416 |
|
ce.window = c->window; |
417 |
|
ce.x = c->x; |
418 |
|
ce.y = c->y; |
419 |
|
ce.width = c->width; |
420 |
|
ce.height = c->height; |
421 |
|
ce.border_width = 0; |
422 |
|
ce.above = None; |
423 |
|
ce.override_redirect = False; |
424 |
|
XSendEvent (dpy, c->window, False, StructureNotifyMask, |
425 |
|
(XEvent *) & ce); |
426 |
|
} |
427 |
|
} |
428 |
|
|
429 |
|
void |
430 |
|
clientFrame (Window w) |
431 |
|
{ |
432 |
|
Client *c; |
433 |
|
XWindowAttributes attr; |
434 |
|
XWindowChanges wc; |
435 |
|
long dummy; |
436 |
|
PropMwmHints *mwm_hints; |
437 |
|
Window transientWindow; |
438 |
|
int i; |
439 |
|
|
440 |
|
#ifdef DEBUG |
441 |
|
printf ("entering clientFrame\n"); |
442 |
|
printf ("framing client (%#lx)\n", w); |
443 |
|
#endif |
444 |
|
|
445 |
|
c = malloc (sizeof (*c)); |
446 |
|
if (!c) |
447 |
|
return; |
448 |
|
|
449 |
|
c->size = XAllocSizeHints (); |
450 |
|
XGetWMNormalHints (dpy, w, c->size, &dummy); |
451 |
|
XGetWindowAttributes (dpy, w, &attr); |
452 |
|
c->window = w; |
453 |
|
c->x = attr.x; |
454 |
|
c->y = attr.y; |
455 |
|
c->width = attr.width; |
456 |
|
c->height = attr.height; |
457 |
|
c->border_width = attr.border_width; |
458 |
|
for (i = 0; i < BUTTON_COUNT; i++) |
459 |
|
c->button_pressed[i] = False; |
460 |
|
if (!getGnomeHint (dpy, w, win_hints, &c->win_hints)) |
461 |
|
c->win_hints = 0; |
462 |
|
if (!getGnomeHint (dpy, w, win_state, &c->win_state)) |
463 |
|
c->win_state = 0; |
464 |
|
if (!getGnomeHint (dpy, w, win_layer, &c->win_layer)) |
465 |
|
c->win_layer = WIN_LAYER_NORMAL; |
466 |
|
if (!getGnomeHint (dpy, w, win_workspace, &c->win_workspace)) |
467 |
|
{ |
468 |
|
setGnomeHint (dpy, w, win_workspace, workspace); |
469 |
|
c->win_workspace = workspace; |
470 |
|
} |
471 |
|
if (c->win_workspace > workspace_count - 1) |
472 |
|
{ |
473 |
|
setGnomeHint (dpy, w, win_workspace, workspace_count - 1); |
474 |
|
c->win_workspace = workspace_count - 1; |
475 |
|
} |
476 |
|
c->has_border = True; |
477 |
|
c->ignore_unmap = attr.map_state == IsViewable ? 1 : 0; |
478 |
|
c->focus = False; |
479 |
|
getWindowName (dpy, c->window, &c->name); |
480 |
|
|
481 |
|
mwm_hints = getMotifHints (dpy, c->window); |
482 |
|
if (mwm_hints) |
483 |
|
{ |
484 |
|
if (mwm_hints->flags & MWM_HINTS_DECORATIONS && |
485 |
|
!(mwm_hints->decorations & MWM_DECOR_ALL)) |
486 |
|
c->has_border = mwm_hints->decorations & MWM_DECOR_BORDER; |
487 |
|
XFree (mwm_hints); |
488 |
|
} |
489 |
|
|
490 |
|
if (attr.map_state != IsViewable) |
491 |
|
clientInitPosition (c); |
492 |
|
else |
493 |
|
clientGravitate (c, APPLY); |
494 |
|
|
495 |
|
c->frame = |
496 |
|
XCreateSimpleWindow (dpy, root, frameX (c), frameY (c), frameWidth (c), |
497 |
|
frameHeight (c), 0, 0, 0); |
498 |
|
XSelectInput (dpy, c->frame, |
499 |
|
SubstructureNotifyMask | SubstructureRedirectMask | |
500 |
|
EnterWindowMask); |
501 |
|
XSelectInput (dpy, c->window, FocusChangeMask | PropertyChangeMask); |
502 |
|
if (shape) |
503 |
|
XShapeSelectInput (dpy, c->window, ShapeNotifyMask); |
504 |
|
XSetWindowBorderWidth (dpy, w, 0); |
505 |
|
XReparentWindow (dpy, w, c->frame, frameLeft (c), frameTop (c)); |
506 |
|
XGrabButton (dpy, AnyButton, AnyModifier, c->frame, False, ButtonPressMask, |
507 |
|
GrabModeSync, GrabModeAsync, None, None); |
508 |
|
|
509 |
|
c->sides[SIDE_LEFT] = |
510 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
511 |
|
c->sides[SIDE_RIGHT] = |
512 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
513 |
|
c->sides[SIDE_BOTTOM] = |
514 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
515 |
|
c->corners[CORNER_BOTTOM_LEFT] = |
516 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
517 |
|
c->corners[CORNER_BOTTOM_RIGHT] = |
518 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
519 |
|
c->title = XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
520 |
|
c->corners[CORNER_TOP_LEFT] = |
521 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
522 |
|
c->corners[CORNER_TOP_RIGHT] = |
523 |
|
XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
524 |
|
for (i = 0; i < 4; i++) |
525 |
|
XDefineCursor (dpy, c->corners[i], resize_cursor[i]); |
526 |
|
|
527 |
|
for (i = 0; i < BUTTON_COUNT; i++) |
528 |
|
c->buttons[i] = XCreateSimpleWindow (dpy, c->frame, 0, 0, 1, 1, 0, 0, 0); |
529 |
|
|
530 |
|
if (clients) |
531 |
|
{ |
532 |
|
c->prev = clients->prev; |
533 |
|
c->next = clients; |
534 |
|
clients->prev->next = c; |
535 |
|
clients->prev = c; |
536 |
|
} |
537 |
|
else |
538 |
|
{ |
539 |
|
clients = c; |
540 |
|
c->next = c; |
541 |
|
c->prev = c; |
542 |
|
} |
543 |
|
|
544 |
|
XGetTransientForHint (dpy, c->window, &transientWindow); |
545 |
|
c->transientFor = clientGetFromWindow (transientWindow, WINDOW); |
546 |
|
|
547 |
|
client_count++; |
548 |
|
clientAddToList (c); |
549 |
|
clientGrabKeys (c); |
550 |
|
frameDraw (c); |
551 |
|
wc.x = c->x; |
552 |
|
wc.y = c->y; |
553 |
|
wc.height = c->height; |
554 |
|
wc.width = c->width; |
555 |
|
wc.stack_mode = Above; |
556 |
|
clientConfigure (c, &wc, CWX | CWY | CWHeight | CWWidth | CWStackMode); |
557 |
|
|
558 |
|
if (getWMState (dpy, c->window) != IconicState) |
559 |
|
{ |
560 |
|
clientShow (c, True); |
561 |
|
#ifdef DEBUG |
562 |
|
printf ("strcmp no. 1\n"); |
563 |
|
#endif |
564 |
|
if (focus_new && !(c->win_hints & WIN_HINTS_SKIP_FOCUS) |
565 |
|
&& !typeDesktop (dpy, c->window)) |
566 |
|
{ |
567 |
|
clientSetFocus (c, True); |
568 |
} |
} |
569 |
} |
} |
570 |
else |
else |
571 |
setWMState(dpy, c->window, IconicState); |
setWMState (dpy, c->window, IconicState); |
572 |
|
|
573 |
#ifdef DEBUG |
#ifdef DEBUG |
574 |
printf("client_count=%d\n", client_count); |
printf ("client_count=%d\n", client_count); |
575 |
#endif |
#endif |
576 |
} |
} |
577 |
|
|
578 |
void clientUnframe(Client * c, int remap) |
void |
579 |
|
clientUnframe (Client * c, int remap) |
580 |
{ |
{ |
581 |
#ifdef DEBUG |
#ifdef DEBUG |
582 |
printf("entering clientUnframe\n"); |
printf ("entering clientUnframe\n"); |
583 |
printf("unframing client (%#lx)\n", c->window); |
printf ("unframing client (%#lx)\n", c->window); |
584 |
#endif |
#endif |
585 |
|
|
586 |
clientGravitate(c, REMOVE); |
clientGravitate (c, REMOVE); |
587 |
clientUngrabKeys(c); |
clientUngrabKeys (c); |
588 |
XSetWindowBorderWidth(dpy, c->window, c->border_width); |
XSetWindowBorderWidth (dpy, c->window, c->border_width); |
589 |
XReparentWindow(dpy, c->window, root, c->x, c->y); |
XReparentWindow (dpy, c->window, root, c->x, c->y); |
590 |
if(remap) |
if (remap) |
591 |
XMapWindow(dpy, c->window); |
XMapWindow (dpy, c->window); |
592 |
else |
else |
593 |
setWMState(dpy, c->window, WithdrawnState); |
setWMState (dpy, c->window, WithdrawnState); |
594 |
XDestroyWindow(dpy, c->frame); |
XDestroyWindow (dpy, c->frame); |
595 |
|
|
596 |
clientRemoveFromList(c); |
clientRemoveFromList (c); |
597 |
if(client_count == 1) |
if (client_count == 1) |
598 |
clients = NULL; |
clients = NULL; |
599 |
else |
else |
600 |
{ |
{ |
601 |
c->next->prev = c->prev; |
c->next->prev = c->prev; |
602 |
c->prev->next = c->next; |
c->prev->next = c->next; |
603 |
if(c == clients) |
if (c == clients) |
604 |
clients = clients->next; |
clients = clients->next; |
605 |
} |
} |
606 |
|
|
607 |
if(c->name) |
if (c->name) |
608 |
free(c->name); |
free (c->name); |
609 |
if(c->size) |
if (c->size) |
610 |
XFree(c->size); |
XFree (c->size); |
611 |
free(c); |
free (c); |
612 |
client_count--; |
client_count--; |
613 |
|
|
614 |
#ifdef DEBUG |
#ifdef DEBUG |
615 |
printf("client_count=%d\n", client_count); |
printf ("client_count=%d\n", client_count); |
616 |
#endif |
#endif |
617 |
} |
} |
618 |
|
|
619 |
void clientFrameAll() |
void |
620 |
|
clientFrameAll () |
621 |
{ |
{ |
622 |
unsigned int count, i; |
unsigned int count, i; |
623 |
Window w1, w2, *wins = NULL; |
Window w1, w2, *wins = NULL; |
624 |
XWindowAttributes attr; |
XWindowAttributes attr; |
625 |
|
|
626 |
#ifdef DEBUG |
#ifdef DEBUG |
627 |
printf("entering clientFrameAll\n"); |
printf ("entering clientFrameAll\n"); |
628 |
#endif |
#endif |
629 |
|
|
630 |
XQueryTree(dpy, root, &w1, &w2, &wins, &count); |
XQueryTree (dpy, root, &w1, &w2, &wins, &count); |
631 |
for(i = 0; i < count; i++) |
for (i = 0; i < count; i++) |
632 |
{ |
{ |
633 |
XGetWindowAttributes(dpy, wins[i], &attr); |
XGetWindowAttributes (dpy, wins[i], &attr); |
634 |
if(!attr.override_redirect && attr.map_state == IsViewable) |
if (!attr.override_redirect && attr.map_state == IsViewable) |
635 |
clientFrame(wins[i]); |
clientFrame (wins[i]); |
636 |
} |
} |
637 |
if(wins) |
if (wins) |
638 |
XFree(wins); |
XFree (wins); |
639 |
} |
} |
640 |
|
|
641 |
void clientUnframeAll() |
void |
642 |
|
clientUnframeAll () |
643 |
{ |
{ |
644 |
Client *c; |
Client *c; |
645 |
unsigned int count, i; |
unsigned int count, i; |
646 |
Window w1, w2, *wins = NULL; |
Window w1, w2, *wins = NULL; |
647 |
|
|
648 |
#ifdef DEBUG |
#ifdef DEBUG |
649 |
printf("entering clientUnframeAll\n"); |
printf ("entering clientUnframeAll\n"); |
650 |
#endif |
#endif |
651 |
|
|
652 |
XQueryTree(dpy, root, &w1, &w2, &wins, &count); |
XQueryTree (dpy, root, &w1, &w2, &wins, &count); |
653 |
for(i = 0; i < count; i++) |
for (i = 0; i < count; i++) |
654 |
{ |
{ |
655 |
c = clientGetFromWindow(wins[i], FRAME); |
c = clientGetFromWindow (wins[i], FRAME); |
656 |
if(c) |
if (c) |
657 |
clientUnframe(c, True); |
clientUnframe (c, True); |
658 |
} |
} |
659 |
if(wins) |
if (wins) |
660 |
XFree(wins); |
XFree (wins); |
661 |
} |
} |
662 |
|
|
663 |
Client *clientGetFromWindow(Window w, int mode) |
Client * |
664 |
|
clientGetFromWindow (Window w, int mode) |
665 |
{ |
{ |
666 |
Client *c; |
Client *c; |
667 |
int i; |
int i; |
668 |
|
|
669 |
#ifdef DEBUG |
#ifdef DEBUG |
670 |
printf("entering clientGetFromWindow\n"); |
printf ("entering clientGetFromWindow\n"); |
671 |
#endif |
#endif |
672 |
|
|
673 |
for(c = clients, i = 0; i < client_count; c = c->next, i++) |
for (c = clients, i = 0; i < client_count; c = c->next, i++) |
674 |
{ |
{ |
675 |
if(c->window == w && mode == WINDOW) |
if (c->window == w && mode == WINDOW) |
676 |
return c; |
return c; |
677 |
if(c->frame == w && mode == FRAME) |
if (c->frame == w && mode == FRAME) |
678 |
return c; |
return c; |
679 |
} |
} |
680 |
|
|
681 |
#ifdef DEBUG |
#ifdef DEBUG |
682 |
printf("no client found\n"); |
printf ("no client found\n"); |
683 |
#endif |
#endif |
684 |
|
|
685 |
return NULL; |
return NULL; |
686 |
} |
} |
687 |
|
|
688 |
void clientShow(Client * c, int change_state) |
void |
689 |
|
clientShow (Client * c, int change_state) |
690 |
{ |
{ |
691 |
#ifdef DEBUG |
#ifdef DEBUG |
692 |
printf("entering clientShow\n"); |
printf ("entering clientShow\n"); |
693 |
printf("showing client (%#lx)\n", c->window); |
printf ("showing client (%#lx)\n", c->window); |
694 |
#endif |
#endif |
695 |
|
|
696 |
if(c->win_workspace == workspace || c->win_state & WIN_STATE_STICKY) |
if (c->win_workspace == workspace || c->win_state & WIN_STATE_STICKY) |
697 |
{ |
{ |
698 |
XMapWindow(dpy, c->window); |
XMapWindow (dpy, c->window); |
699 |
XMapWindow(dpy, c->frame); |
XMapWindow (dpy, c->frame); |
700 |
} |
} |
701 |
if(change_state) |
if (change_state) |
702 |
setWMState(dpy, c->window, NormalState); |
setWMState (dpy, c->window, NormalState); |
703 |
} |
} |
704 |
|
|
705 |
void clientHide(Client * c, int change_state) |
void |
706 |
|
clientHide (Client * c, int change_state) |
707 |
{ |
{ |
708 |
#ifdef DEBUG |
#ifdef DEBUG |
709 |
printf("entering clientHide\n"); |
printf ("entering clientHide\n"); |
710 |
printf("hiding client (%#lx)\n", c->window); |
printf ("hiding client (%#lx)\n", c->window); |
711 |
#endif |
#endif |
712 |
|
|
713 |
XUnmapWindow(dpy, c->window); |
XUnmapWindow (dpy, c->window); |
714 |
XUnmapWindow(dpy, c->frame); |
XUnmapWindow (dpy, c->frame); |
715 |
if(change_state) |
if (change_state) |
716 |
setWMState(dpy, c->window, IconicState); |
setWMState (dpy, c->window, IconicState); |
717 |
c->ignore_unmap++; |
c->ignore_unmap++; |
718 |
} |
} |
719 |
|
|
720 |
void clientClose(Client * c) |
void |
721 |
|
clientClose (Client * c) |
722 |
{ |
{ |
723 |
#ifdef DEBUG |
#ifdef DEBUG |
724 |
printf("entering clientClose\n"); |
printf ("entering clientClose\n"); |
725 |
#endif |
#endif |
726 |
|
|
727 |
sendClientMessage(dpy, c->window, wm_protocols, wm_delete_window, |
sendClientMessage (dpy, c->window, wm_protocols, wm_delete_window, |
728 |
NoEventMask); |
NoEventMask); |
729 |
} |
} |
730 |
|
|
731 |
void clientKill(Client * c) |
void |
732 |
|
clientKill (Client * c) |
733 |
{ |
{ |
734 |
#ifdef DEBUG |
#ifdef DEBUG |
735 |
printf("entering clientKill\n"); |
printf ("entering clientKill\n"); |
736 |
#endif |
#endif |
737 |
|
|
738 |
XKillClient(dpy, c->window); |
XKillClient (dpy, c->window); |
739 |
} |
} |
740 |
|
|
741 |
void clientRaise(Client * c) |
void |
742 |
|
clientRaise (Client * c) |
743 |
{ |
{ |
744 |
XWindowChanges wc; |
XWindowChanges wc; |
745 |
Client *c2; |
Client *c2; |
746 |
int i; |
int i; |
747 |
|
|
748 |
#ifdef DEBUG |
#ifdef DEBUG |
749 |
printf("entering clientRaise\n"); |
printf ("entering clientRaise\n"); |
750 |
#endif |
#endif |
751 |
|
|
752 |
if (typeDesktop(dpy, c->window)) |
if (typeDesktop (dpy, c->window)) |
753 |
{ |
{ |
754 |
#ifdef DEBUG |
#ifdef DEBUG |
755 |
printf("NOT raising client (%#lx)\n", c->window); |
printf ("NOT raising client (%#lx)\n", c->window); |
756 |
#endif |
#endif |
757 |
return; |
return; |
758 |
} |
} |
759 |
|
|
760 |
#ifdef DEBUG |
#ifdef DEBUG |
761 |
printf("raising client (%#lx)\n", c->window); |
printf ("raising client (%#lx)\n", c->window); |
762 |
#endif |
#endif |
763 |
|
|
764 |
wc.stack_mode = Above; |
wc.stack_mode = Above; |
765 |
clientConfigure(c, &wc, CWStackMode); |
clientConfigure (c, &wc, CWStackMode); |
766 |
|
|
767 |
for (c2 = clients, i = 0; i < client_count; c2 = c2->next, i++) |
for (c2 = clients, i = 0; i < client_count; c2 = c2->next, i++) |
768 |
if (c2->transientFor == c) |
if (c2->transientFor == c) |
769 |
clientRaise(c2); |
clientRaise (c2); |
770 |
} |
} |
771 |
|
|
772 |
void clientLower(Client * c) |
void |
773 |
|
clientLower (Client * c) |
774 |
{ |
{ |
775 |
XWindowChanges wc; |
XWindowChanges wc; |
776 |
|
|
777 |
#ifdef DEBUG |
#ifdef DEBUG |
778 |
printf("entering clientLower\n"); |
printf ("entering clientLower\n"); |
779 |
printf("lowering client (%#lx)\n", c->window); |
printf ("lowering client (%#lx)\n", c->window); |
780 |
#endif |
#endif |
781 |
|
|
782 |
wc.stack_mode = Below; |
wc.stack_mode = Below; |
783 |
clientConfigure(c, &wc, CWStackMode); |
clientConfigure (c, &wc, CWStackMode); |
784 |
} |
} |
785 |
|
|
786 |
void clientSetLayer(Client * c, int l) |
void |
787 |
|
clientSetLayer (Client * c, int l) |
788 |
{ |
{ |
789 |
int old_layer = c->win_layer; |
int old_layer = c->win_layer; |
790 |
|
|
791 |
#ifdef DEBUG |
#ifdef DEBUG |
792 |
printf("entering clientSetLayer\n"); |
printf ("entering clientSetLayer\n"); |
793 |
printf("setting client (%#lx) layer to %d\n", c->window, l); |
printf ("setting client (%#lx) layer to %d\n", c->window, l); |
794 |
#endif |
#endif |
795 |
|
|
796 |
if(l == old_layer) |
if (l == old_layer) |
797 |
return; |
return; |
798 |
|
|
799 |
setGnomeHint(dpy, c->window, win_layer, l); |
setGnomeHint (dpy, c->window, win_layer, l); |
800 |
c->win_layer = l; |
c->win_layer = l; |
801 |
if(l > old_layer) |
if (l > old_layer) |
802 |
clientRaise(c); |
clientRaise (c); |
803 |
else |
else |
804 |
clientLower(c); |
clientLower (c); |
805 |
} |
} |
806 |
|
|
807 |
void clientSetWorkspace(Client * c, int ws) |
void |
808 |
|
clientSetWorkspace (Client * c, int ws) |
809 |
{ |
{ |
810 |
#ifdef DEBUG |
#ifdef DEBUG |
811 |
printf("entering clientSetWorkspace\n"); |
printf ("entering clientSetWorkspace\n"); |
812 |
printf("setting client (%#lx) to workspace %d\n", ws); |
printf ("setting client (%#lx) to workspace %d\n", ws); |
813 |
#endif |
#endif |
814 |
|
|
815 |
if(c->win_workspace == ws) |
if (c->win_workspace == ws) |
816 |
return; |
return; |
817 |
|
|
818 |
setGnomeHint(dpy, c->window, win_workspace, ws); |
setGnomeHint (dpy, c->window, win_workspace, ws); |
819 |
c->win_workspace = ws; |
c->win_workspace = ws; |
820 |
if(getWMState(dpy, c->window) != IconicState) |
if (getWMState (dpy, c->window) != IconicState) |
821 |
{ |
{ |
822 |
if(c->win_state & WIN_STATE_STICKY) |
if (c->win_state & WIN_STATE_STICKY) |
823 |
clientShow(c, False); |
clientShow (c, False); |
824 |
else |
else |
825 |
{ |
{ |
826 |
if(ws == workspace) |
if (ws == workspace) |
827 |
clientShow(c, False); |
clientShow (c, False); |
828 |
else |
else |
829 |
clientHide(c, False); |
clientHide (c, False); |
830 |
} |
} |
831 |
} |
} |
832 |
} |
} |
833 |
|
|
834 |
void clientSetState(Client *c, CARD32 mask, CARD32 value) |
void |
835 |
|
clientSetState (Client * c, CARD32 mask, CARD32 value) |
836 |
{ |
{ |
837 |
XWindowChanges wc; |
XWindowChanges wc; |
838 |
|
|
839 |
#ifdef DEBUG |
#ifdef DEBUG |
840 |
printf("entering clientSetState\n"); |
printf ("entering clientSetState\n"); |
841 |
printf("changing state for client (%#lx)\n", c->window); |
printf ("changing state for client (%#lx)\n", c->window); |
842 |
#endif |
#endif |
843 |
|
|
844 |
c->win_state = (c->win_state & ~mask) | value; |
c->win_state = (c->win_state & ~mask) | value; |
845 |
setGnomeHint(dpy, c->window, win_state, c->win_state); |
setGnomeHint (dpy, c->window, win_state, c->win_state); |
846 |
if (mask & ~WIN_STATE_STICKY) |
if (mask & ~WIN_STATE_STICKY) |
847 |
{ |
{ |
848 |
wc.width = c->width; |
wc.width = c->width; |
849 |
wc.height = c->height; |
wc.height = c->height; |
850 |
clientConfigure(c, &wc, CWWidth | CWHeight); |
clientConfigure (c, &wc, CWWidth | CWHeight); |
851 |
} |
} |
852 |
} |
} |
853 |
|
|
854 |
void clientToggleShaded(Client * c) |
void |
855 |
|
clientToggleShaded (Client * c) |
856 |
{ |
{ |
857 |
XWindowChanges wc; |
XWindowChanges wc; |
858 |
|
|
859 |
#ifdef DEBUG |
#ifdef DEBUG |
860 |
printf("entering clientToggleShaded\n"); |
printf ("entering clientToggleShaded\n"); |
861 |
printf("shading/unshading client (%#lx)\n", c->window); |
printf ("shading/unshading client (%#lx)\n", c->window); |
862 |
#endif |
#endif |
863 |
|
|
864 |
c->win_state = c->win_state ^ WIN_STATE_SHADED; |
c->win_state = c->win_state ^ WIN_STATE_SHADED; |
865 |
setGnomeHint(dpy, c->window, win_state, c->win_state); |
setGnomeHint (dpy, c->window, win_state, c->win_state); |
866 |
wc.width = c->width; |
wc.width = c->width; |
867 |
wc.height = c->height; |
wc.height = c->height; |
868 |
clientConfigure(c, &wc, CWWidth | CWHeight); |
clientConfigure (c, &wc, CWWidth | CWHeight); |
869 |
} |
} |
870 |
|
|
871 |
void clientToggleSticky(Client * c) |
void |
872 |
|
clientToggleSticky (Client * c) |
873 |
{ |
{ |
874 |
#ifdef DEBUG |
#ifdef DEBUG |
875 |
printf("entering clientToggleSticky\n"); |
printf ("entering clientToggleSticky\n"); |
876 |
printf("sticking/unsticking client (%#lx)\n", c->window); |
printf ("sticking/unsticking client (%#lx)\n", c->window); |
877 |
#endif |
#endif |
878 |
|
|
879 |
c->win_state = c->win_state ^ WIN_STATE_STICKY; |
c->win_state = c->win_state ^ WIN_STATE_STICKY; |
880 |
setGnomeHint(dpy, c->window, win_state, c->win_state); |
setGnomeHint (dpy, c->window, win_state, c->win_state); |
881 |
clientSetWorkspace(c, workspace); |
clientSetWorkspace (c, workspace); |
882 |
} |
} |
883 |
|
|
884 |
void clientToggleMaximized(Client * c, int mode) |
void |
885 |
|
clientToggleMaximized (Client * c, int mode) |
886 |
{ |
{ |
887 |
XWindowChanges wc; |
XWindowChanges wc; |
888 |
|
|
889 |
#ifdef DEBUG |
#ifdef DEBUG |
890 |
printf("entering clientToggleMaximized\n"); |
printf ("entering clientToggleMaximized\n"); |
891 |
printf("maximzing/unmaximizing client (%#lx)\n", c->window); |
printf ("maximzing/unmaximizing client (%#lx)\n", c->window); |
892 |
#endif |
#endif |
893 |
|
|
894 |
if(c->size->flags & (PMinSize | PMaxSize) && |
if (c->size->flags & (PMinSize | PMaxSize) && |
895 |
c->size->min_width == c->size->max_width && |
c->size->min_width == c->size->max_width && |
896 |
c->size->min_height == c->size->max_height) |
c->size->min_height == c->size->max_height) |
897 |
return; |
return; |
898 |
|
|
899 |
if(c->win_state & WIN_STATE_MAXIMIZED) |
if (c->win_state & WIN_STATE_MAXIMIZED) |
900 |
{ |
{ |
901 |
wc.width = c->old_width; |
wc.width = c->old_width; |
902 |
wc.height = c->old_height; |
wc.height = c->old_height; |
903 |
wc.x = c->old_x; |
wc.x = c->old_x; |
904 |
wc.y = c->old_y; |
wc.y = c->old_y; |
905 |
c->win_state &= ~WIN_STATE_MAXIMIZED; |
c->win_state &= ~WIN_STATE_MAXIMIZED; |
906 |
} |
} |
907 |
else |
else |
908 |
{ |
{ |
909 |
c->old_x = c->x; |
c->old_x = c->x; |
910 |
c->old_y = c->y; |
c->old_y = c->y; |
911 |
c->old_width = c->width; |
c->old_width = c->width; |
912 |
c->old_height = c->height; |
c->old_height = c->height; |
913 |
|
|
914 |
if(mode != WIN_STATE_MAXIMIZED_VERT) |
if (mode != WIN_STATE_MAXIMIZED_VERT) |
915 |
{ |
{ |
916 |
wc.x = frameLeft(c) + margins[MARGIN_LEFT]; |
wc.x = frameLeft (c) + margins[MARGIN_LEFT]; |
917 |
wc.width = |
wc.width = |
918 |
XDisplayWidth(dpy, |
XDisplayWidth (dpy, |
919 |
screen) - frameLeft(c) - frameRight(c) - |
screen) - frameLeft (c) - frameRight (c) - |
920 |
margins[MARGIN_LEFT] - margins[MARGIN_RIGHT]; |
margins[MARGIN_LEFT] - margins[MARGIN_RIGHT]; |
921 |
c->win_state |= WIN_STATE_MAXIMIZED_HORIZ; |
c->win_state |= WIN_STATE_MAXIMIZED_HORIZ; |
922 |
} |
} |
923 |
else |
else |
924 |
{ |
{ |
925 |
wc.x = c->x; |
wc.x = c->x; |
926 |
wc.width = c->width; |
wc.width = c->width; |
927 |
} |
} |
928 |
if(mode != WIN_STATE_MAXIMIZED_HORIZ) |
if (mode != WIN_STATE_MAXIMIZED_HORIZ) |
929 |
{ |
{ |
930 |
wc.y = frameTop(c) + margins[MARGIN_TOP]; |
wc.y = frameTop (c) + margins[MARGIN_TOP]; |
931 |
wc.height = |
wc.height = |
932 |
XDisplayHeight(dpy, |
XDisplayHeight (dpy, |
933 |
screen) - frameTop(c) - frameBottom(c) - |
screen) - frameTop (c) - frameBottom (c) - |
934 |
margins[MARGIN_TOP] - margins[MARGIN_BOTTOM]; |
margins[MARGIN_TOP] - margins[MARGIN_BOTTOM]; |
935 |
c->win_state |= WIN_STATE_MAXIMIZED_VERT; |
c->win_state |= WIN_STATE_MAXIMIZED_VERT; |
936 |
} |
} |
937 |
else |
else |
938 |
{ |
{ |
939 |
wc.y = c->y; |
wc.y = c->y; |
940 |
wc.height = c->height; |
wc.height = c->height; |
941 |
} |
} |
942 |
|
|
943 |
} |
} |
944 |
setGnomeHint(dpy, c->window, win_state, c->win_state); |
setGnomeHint (dpy, c->window, win_state, c->win_state); |
945 |
clientConfigure(c, &wc, CWX | CWY | CWWidth | CWHeight); |
clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight); |
946 |
} |
} |
947 |
|
|
948 |
void clientSetFocus(Client * c, int sort) |
void |
949 |
|
clientSetFocus (Client * c, int sort) |
950 |
{ |
{ |
951 |
Client *tmp; |
Client *tmp; |
952 |
|
|
953 |
#ifdef DEBUG |
#ifdef DEBUG |
954 |
printf("entering clientSetFocus\n"); |
printf ("entering clientSetFocus\n"); |
955 |
if(c) |
if (c) |
956 |
printf("setting focus to client (%#lx)\n", c->window); |
printf ("setting focus to client (%#lx)\n", c->window); |
957 |
else |
else |
958 |
printf("setting focus to none\n"); |
printf ("setting focus to none\n"); |
959 |
#endif |
#endif |
960 |
|
|
961 |
if(c) |
if (c) |
962 |
{ |
{ |
963 |
if(c->win_hints & WIN_HINTS_SKIP_FOCUS) |
if (c->win_hints & WIN_HINTS_SKIP_FOCUS) |
964 |
return; |
return; |
|
|
|
|
if(typeDesktop(dpy, c->window)) |
|
|
return; |
|
965 |
|
|
966 |
if(sort) |
if (typeDesktop (dpy, c->window)) |
967 |
{ |
return; |
|
if(client_count > 2 && c != clients) |
|
|
{ |
|
|
tmp = c; |
|
|
c->prev->next = c->next; |
|
|
c->next->prev = c->prev; |
|
968 |
|
|
969 |
c->prev = clients->prev; |
if (sort) |
970 |
c->next = clients; |
{ |
971 |
clients->prev->next = c; |
if (client_count > 2 && c != clients) |
972 |
clients->prev = c; |
{ |
973 |
} |
tmp = c; |
974 |
clients = c; |
c->prev->next = c->next; |
975 |
} |
c->next->prev = c->prev; |
976 |
|
|
977 |
|
c->prev = clients->prev; |
978 |
|
c->next = clients; |
979 |
|
clients->prev->next = c; |
980 |
|
clients->prev = c; |
981 |
|
} |
982 |
|
clients = c; |
983 |
|
} |
984 |
|
|
985 |
XSetInputFocus(dpy, c->window, RevertToNone, CurrentTime); |
XSetInputFocus (dpy, c->window, RevertToNone, CurrentTime); |
986 |
} |
} |
987 |
else |
else |
988 |
XSetInputFocus(dpy, gnome_win, RevertToNone, CurrentTime); |
XSetInputFocus (dpy, gnome_win, RevertToNone, CurrentTime); |
989 |
} |
} |
990 |
|
|
991 |
Client *clientGetFocus() |
Client * |
992 |
|
clientGetFocus () |
993 |
{ |
{ |
994 |
Window w; |
Window w; |
995 |
int dummy, i; |
int dummy, i; |
996 |
Client *c; |
Client *c; |
997 |
|
|
998 |
#ifdef DEBUG |
#ifdef DEBUG |
999 |
printf("entering clientGetFocus\n"); |
printf ("entering clientGetFocus\n"); |
1000 |
#endif |
#endif |
1001 |
|
|
1002 |
XGetInputFocus(dpy, &w, &dummy); |
XGetInputFocus (dpy, &w, &dummy); |
1003 |
for(c = clients, i = 0; i < client_count; c = c->next, i++) |
for (c = clients, i = 0; i < client_count; c = c->next, i++) |
1004 |
if(c->window == w) |
if (c->window == w) |
1005 |
return c; |
return c; |
1006 |
#ifdef DEBUG |
#ifdef DEBUG |
1007 |
printf("exiting clientGetFocus\n"); |
printf ("exiting clientGetFocus\n"); |
1008 |
#endif |
#endif |
1009 |
return NULL; |
return NULL; |
1010 |
} |
} |
1011 |
|
|
1012 |
void clientDrawOutline(Client * c) |
void |
1013 |
|
clientDrawOutline (Client * c) |
1014 |
{ |
{ |
1015 |
#ifdef DEBUG |
#ifdef DEBUG |
1016 |
printf("entering clientDrawOutline\n"); |
printf ("entering clientDrawOutline\n"); |
1017 |
#endif |
#endif |
1018 |
|
|
1019 |
XDrawRectangle(dpy, root, box_gc, frameX(c), frameY(c), |
XDrawRectangle (dpy, root, box_gc, frameX (c), frameY (c), |
1020 |
frameWidth(c) - 1, frameHeight(c) - 1); |
frameWidth (c) - 1, frameHeight (c) - 1); |
1021 |
} |
} |
1022 |
|
|
1023 |
void clientMove(Client * c, XEvent * e) |
void |
1024 |
|
clientMove (Client * c, XEvent * e) |
1025 |
{ |
{ |
1026 |
int mx, my, moving = True, grab = False, use_keys = False, g1, g2; |
int mx, my, moving = True, grab = False, use_keys = False, g1, g2; |
1027 |
Client *closestx, *closesty, *c2; |
Client *closestx, *closesty, *c2; |
1028 |
XWindowChanges wc; |
XWindowChanges wc; |
1029 |
XEvent ev; |
XEvent ev; |
1030 |
int i; |
int i; |
1031 |
int ox, oy; |
int ox, oy; |
1032 |
int cx, cy, dx, dy; |
int cx, cy, dx, dy; |
1033 |
|
|
1034 |
#ifdef DEBUG |
#ifdef DEBUG |
1035 |
printf("entering clientDoMove\n"); |
printf ("entering clientDoMove\n"); |
1036 |
printf("moving client (%#lx)\n", c->window); |
printf ("moving client (%#lx)\n", c->window); |
1037 |
#endif |
#endif |
1038 |
|
|
1039 |
if((c->win_state & WIN_STATE_MAXIMIZED) == WIN_STATE_MAXIMIZED) |
if ((c->win_state & WIN_STATE_MAXIMIZED) == WIN_STATE_MAXIMIZED) |
1040 |
return; |
return; |
1041 |
|
|
1042 |
g1 = XGrabKeyboard(dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
g1 = XGrabKeyboard (dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
1043 |
CurrentTime); |
CurrentTime); |
1044 |
g2 = XGrabPointer(dpy, c->frame, False, |
g2 = XGrabPointer (dpy, c->frame, False, |
1045 |
PointerMotionMask | ButtonReleaseMask, GrabModeAsync, |
PointerMotionMask | ButtonReleaseMask, GrabModeAsync, |
1046 |
GrabModeAsync, None, move_cursor, CurrentTime); |
GrabModeAsync, None, move_cursor, CurrentTime); |
1047 |
|
|
1048 |
if(g1 != GrabSuccess || g2 != GrabSuccess) |
if (g1 != GrabSuccess || g2 != GrabSuccess) |
1049 |
{ |
{ |
1050 |
#ifdef DEBUG |
#ifdef DEBUG |
1051 |
printf("grab failed in clientMove\n"); |
printf ("grab failed in clientMove\n"); |
1052 |
#endif |
#endif |
1053 |
if(g1 == GrabSuccess) |
if (g1 == GrabSuccess) |
1054 |
XUngrabKeyboard(dpy, CurrentTime); |
XUngrabKeyboard (dpy, CurrentTime); |
1055 |
if(g2 == GrabSuccess) |
if (g2 == GrabSuccess) |
1056 |
XUngrabPointer(dpy, CurrentTime); |
XUngrabPointer (dpy, CurrentTime); |
1057 |
return; |
return; |
1058 |
} |
} |
1059 |
|
|
1060 |
if(e->type == KeyPress) |
if (e->type == KeyPress) |
1061 |
{ |
{ |
1062 |
use_keys = True; |
use_keys = True; |
1063 |
XPutBackEvent(dpy, e); |
XPutBackEvent (dpy, e); |
1064 |
} |
} |
1065 |
|
|
1066 |
getMouseXY(dpy, root, &mx, &my); |
getMouseXY (dpy, root, &mx, &my); |
1067 |
ox = c->x; |
ox = c->x; |
1068 |
oy = c->y; |
oy = c->y; |
1069 |
|
|
1070 |
#ifdef DEBUG |
#ifdef DEBUG |
1071 |
printf("entering move loop\n"); |
printf ("entering move loop\n"); |
1072 |
#endif |
#endif |
1073 |
|
|
1074 |
while(moving) |
while (moving) |
1075 |
{ |
{ |
1076 |
XNextEvent(dpy, &ev); |
XNextEvent (dpy, &ev); |
|
|
|
|
if(ev.type == KeyPress) |
|
|
{ |
|
|
if(!grab && box_move) |
|
|
{ |
|
|
XGrabServer(dpy); |
|
|
grab = True; |
|
|
clientDrawOutline(c); |
|
|
} |
|
|
if(box_move) |
|
|
clientDrawOutline(c); |
|
|
if(!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
|
|
{ |
|
|
if(ev.xkey.keycode == keys[KEY_MOVE_LEFT].keycode) |
|
|
c->x = c->x - 16; |
|
|
if(ev.xkey.keycode == keys[KEY_MOVE_RIGHT].keycode) |
|
|
c->x = c->x + 16; |
|
|
} |
|
|
if(!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
|
|
{ |
|
|
if(ev.xkey.keycode == keys[KEY_MOVE_UP].keycode) |
|
|
c->y = c->y - 16; |
|
|
if(ev.xkey.keycode == keys[KEY_MOVE_DOWN].keycode) |
|
|
c->y = c->y + 16; |
|
|
} |
|
|
if(box_move) |
|
|
clientDrawOutline(c); |
|
|
else |
|
|
{ |
|
|
wc.x = c->x; |
|
|
wc.y = c->y; |
|
|
clientConfigure(c, &wc, CWX | CWY); |
|
|
} |
|
|
} |
|
|
else if(use_keys && ev.type == KeyRelease) |
|
|
{ |
|
|
if(IsModifierKey(XKeycodeToKeysym(dpy, ev.xkey.keycode, 0))) |
|
|
moving = False; |
|
|
} |
|
|
else if(ev.type == MotionNotify) |
|
|
{ |
|
|
while(XCheckTypedEvent(dpy, MotionNotify, &ev)); |
|
1077 |
|
|
1078 |
if(!grab && box_move) |
if (ev.type == KeyPress) |
1079 |
{ |
{ |
1080 |
XGrabServer(dpy); |
if (!grab && box_move) |
1081 |
grab = True; |
{ |
1082 |
clientDrawOutline(c); |
XGrabServer (dpy); |
1083 |
} |
grab = True; |
1084 |
if(box_move) |
clientDrawOutline (c); |
1085 |
clientDrawOutline(c); |
} |
1086 |
|
if (box_move) |
1087 |
if(workspace_count > 1) |
clientDrawOutline (c); |
1088 |
{ |
if (!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
1089 |
int msx, msy; |
{ |
1090 |
|
if (ev.xkey.keycode == keys[KEY_MOVE_LEFT].keycode) |
1091 |
|
c->x = c->x - 16; |
1092 |
|
if (ev.xkey.keycode == keys[KEY_MOVE_RIGHT].keycode) |
1093 |
|
c->x = c->x + 16; |
1094 |
|
} |
1095 |
|
if (!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
1096 |
|
{ |
1097 |
|
if (ev.xkey.keycode == keys[KEY_MOVE_UP].keycode) |
1098 |
|
c->y = c->y - 16; |
1099 |
|
if (ev.xkey.keycode == keys[KEY_MOVE_DOWN].keycode) |
1100 |
|
c->y = c->y + 16; |
1101 |
|
} |
1102 |
|
if (box_move) |
1103 |
|
clientDrawOutline (c); |
1104 |
|
else |
1105 |
|
{ |
1106 |
|
wc.x = c->x; |
1107 |
|
wc.y = c->y; |
1108 |
|
clientConfigure (c, &wc, CWX | CWY); |
1109 |
|
} |
1110 |
|
} |
1111 |
|
else if (use_keys && ev.type == KeyRelease) |
1112 |
|
{ |
1113 |
|
if (IsModifierKey (XKeycodeToKeysym (dpy, ev.xkey.keycode, 0))) |
1114 |
|
moving = False; |
1115 |
|
} |
1116 |
|
else if (ev.type == MotionNotify) |
1117 |
|
{ |
1118 |
|
while (XCheckTypedEvent (dpy, MotionNotify, &ev)); |
1119 |
|
|
1120 |
|
if (!grab && box_move) |
1121 |
|
{ |
1122 |
|
XGrabServer (dpy); |
1123 |
|
grab = True; |
1124 |
|
clientDrawOutline (c); |
1125 |
|
} |
1126 |
|
if (box_move) |
1127 |
|
clientDrawOutline (c); |
1128 |
|
|
1129 |
|
if (workspace_count > 1) |
1130 |
|
{ |
1131 |
|
int msx, msy; |
1132 |
|
|
1133 |
getMouseXY(dpy, root, &msx, &msy); |
getMouseXY (dpy, root, &msx, &msy); |
1134 |
if(msx == 0 && !(workspace == 0 && !wrap_workspaces)) |
if (msx == 0 && !(workspace == 0 && !wrap_workspaces)) |
1135 |
{ |
{ |
1136 |
workspaceSwitch(workspace - 1, c); |
workspaceSwitch (workspace - 1, c); |
1137 |
if(!click_to_focus) |
if (!click_to_focus) |
1138 |
XWarpPointer(dpy, None, root, 0, 0, 0, 0, |
XWarpPointer (dpy, None, root, 0, 0, 0, 0, |
1139 |
XDisplayWidth(dpy, screen) - 11, msy); |
XDisplayWidth (dpy, screen) - 11, msy); |
1140 |
ev.xmotion.x_root = XDisplayWidth(dpy, screen) - 11; |
ev.xmotion.x_root = XDisplayWidth (dpy, screen) - 11; |
1141 |
} |
} |
1142 |
else if(msx == XDisplayWidth(dpy, screen) - 1 && |
else if (msx == XDisplayWidth (dpy, screen) - 1 && |
1143 |
!(workspace == workspace_count - 1 && !wrap_workspaces)) |
!(workspace == workspace_count - 1 |
1144 |
{ |
&& !wrap_workspaces)) |
1145 |
workspaceSwitch(workspace + 1, c); |
{ |
1146 |
if(!click_to_focus) |
workspaceSwitch (workspace + 1, c); |
1147 |
XWarpPointer(dpy, None, root, 0, 0, 0, 0, 10, msy); |
if (!click_to_focus) |
1148 |
ev.xmotion.x_root = 10; |
XWarpPointer (dpy, None, root, 0, 0, 0, 0, 10, msy); |
1149 |
} |
ev.xmotion.x_root = 10; |
1150 |
} |
} |
1151 |
|
} |
1152 |
|
|
1153 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
if (!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
1154 |
{ |
{ |
1155 |
c->x = ox + (ev.xmotion.x_root - mx); |
c->x = ox + (ev.xmotion.x_root - mx); |
1156 |
if(snap_to_border) |
if (snap_to_border) |
1157 |
{ |
{ |
1158 |
if(abs(frameX(c) - margins[MARGIN_LEFT]) < snap_width) |
if (abs (frameX (c) - margins[MARGIN_LEFT]) < snap_width) |
1159 |
c->x = frameLeft(c) + margins[MARGIN_LEFT]; |
c->x = frameLeft (c) + margins[MARGIN_LEFT]; |
1160 |
if(abs(frameX(c) - XDisplayWidth(dpy, screen) + |
if (abs (frameX (c) - XDisplayWidth (dpy, screen) + |
1161 |
frameWidth(c) + margins[MARGIN_RIGHT]) < snap_width) |
frameWidth (c) + margins[MARGIN_RIGHT]) < |
1162 |
c->x = (XDisplayWidth(dpy, screen) - frameRight(c) - |
snap_width) |
1163 |
c->width - margins[MARGIN_RIGHT]); |
c->x = |
1164 |
} |
(XDisplayWidth (dpy, screen) - frameRight (c) - |
1165 |
} |
c->width - margins[MARGIN_RIGHT]); |
1166 |
|
} |
1167 |
|
} |
1168 |
|
|
1169 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
if (!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
1170 |
{ |
{ |
1171 |
c->y = oy + (ev.xmotion.y_root - my); |
c->y = oy + (ev.xmotion.y_root - my); |
1172 |
if(snap_to_border) |
if (snap_to_border) |
1173 |
{ |
{ |
1174 |
if(abs(frameY(c) - margins[MARGIN_TOP]) < snap_width) |
if (abs (frameY (c) - margins[MARGIN_TOP]) < snap_width) |
1175 |
c->y = frameTop(c) + margins[MARGIN_TOP]; |
c->y = frameTop (c) + margins[MARGIN_TOP]; |
1176 |
if(abs(frameY(c) - XDisplayHeight(dpy, screen) + |
if (abs (frameY (c) - XDisplayHeight (dpy, screen) + |
1177 |
frameHeight(c) + margins[MARGIN_BOTTOM]) < |
frameHeight (c) + margins[MARGIN_BOTTOM]) < |
1178 |
snap_width) |
snap_width) |
1179 |
c->y = |
c->y = |
1180 |
(XDisplayHeight(dpy, screen) - |
(XDisplayHeight (dpy, screen) - |
1181 |
margins[MARGIN_BOTTOM] - frameHeight(c) + |
margins[MARGIN_BOTTOM] - frameHeight (c) + |
1182 |
frameTop(c)); |
frameTop (c)); |
1183 |
} |
} |
1184 |
|
|
1185 |
if(snap_to_windows) |
if (snap_to_windows) |
1186 |
{ |
{ |
1187 |
cx = cy = snap_width + 1; |
cx = cy = snap_width + 1; |
1188 |
closestx = closesty = NULL; |
closestx = closesty = NULL; |
1189 |
|
|
1190 |
for (c2 = clients, i = 0; i < client_count; c2 = c2->next, i++) |
for (c2 = clients, i = 0; i < client_count; |
1191 |
|
c2 = c2->next, i++) |
1192 |
{ |
{ |
1193 |
if (c2->win_workspace != c->win_workspace) |
if (c2->win_workspace != c->win_workspace) |
1194 |
continue; |
continue; |
1195 |
|
|
1196 |
if (typeDesktop(dpy, c2->window)) |
if (typeDesktop (dpy, c2->window)) |
1197 |
continue; |
continue; |
1198 |
|
|
1199 |
/* Are we touching the bottom of a window? */ |
/* Are we touching the bottom of a window? */ |
1200 |
dy = abs(frameY(c) - (frameY(c2) + frameHeight(c2))); |
dy = |
1201 |
if(dy < snap_width && dy < cy) |
abs (frameY (c) - (frameY (c2) + frameHeight (c2))); |
1202 |
|
if (dy < snap_width && dy < cy) |
1203 |
{ |
{ |
1204 |
cy = dy; |
cy = dy; |
1205 |
closesty = c2; |
closesty = c2; |
1206 |
} |
} |
1207 |
|
|
1208 |
/* Top? */ |
/* Top? */ |
1209 |
dy = abs(frameY(c2) - (frameY(c) + frameHeight(c))); |
dy = abs (frameY (c2) - (frameY (c) + frameHeight (c))); |
1210 |
if(dy < snap_width && dy < cy) |
if (dy < snap_width && dy < cy) |
1211 |
{ |
{ |
1212 |
cy = dy; |
cy = dy; |
1213 |
closesty = c2; |
closesty = c2; |
1214 |
} |
} |
1215 |
|
|
1216 |
/* Left? */ |
/* Left? */ |
1217 |
dx = abs(frameX(c2) - (frameX(c) + frameWidth(c))); |
dx = abs (frameX (c2) - (frameX (c) + frameWidth (c))); |
1218 |
if (dx < snap_width && dx < cx) |
if (dx < snap_width && dx < cx) |
1219 |
{ |
{ |
1220 |
cx = dx; |
cx = dx; |
1221 |
closestx = c2; |
closestx = c2; |
1222 |
} |
} |
1223 |
|
|
1224 |
/* Right */ |
/* Right */ |
1225 |
dx = abs(frameX(c) - (frameX(c2) + frameWidth(c2))); |
dx = abs (frameX (c) - (frameX (c2) + frameWidth (c2))); |
1226 |
if (dx < snap_width && dx < cx) |
if (dx < snap_width && dx < cx) |
1227 |
{ |
{ |
1228 |
cx = dx; |
cx = dx; |
1229 |
closestx = c2; |
closestx = c2; |
1230 |
} |
} |
1231 |
} |
} |
1232 |
|
|
1233 |
if (closesty) |
if (closesty) |
1234 |
{ |
{ |
1235 |
if (cy == abs(frameY(c) - (frameY(closesty) + frameHeight(closesty)))) |
if (cy == |
1236 |
|
abs (frameY (c) - |
1237 |
|
(frameY (closesty) + frameHeight (closesty)))) |
1238 |
{ |
{ |
1239 |
c->y = frameY(closesty) + frameHeight(closesty) + frameTop(c); |
c->y = |
1240 |
|
frameY (closesty) + frameHeight (closesty) + |
1241 |
|
frameTop (c); |
1242 |
} |
} |
1243 |
else |
else |
1244 |
{ |
{ |
1245 |
c->y = frameY(closesty) - (frameHeight(c) - frameTop(c)); |
c->y = |
1246 |
|
frameY (closesty) - (frameHeight (c) - |
1247 |
|
frameTop (c)); |
1248 |
} |
} |
1249 |
} |
} |
1250 |
|
|
1251 |
if (closestx) |
if (closestx) |
1252 |
{ |
{ |
1253 |
if (cx == abs(frameX(c) - (frameX(closestx) + frameWidth(closestx)))) |
if (cx == |
1254 |
|
abs (frameX (c) - |
1255 |
|
(frameX (closestx) + frameWidth (closestx)))) |
1256 |
{ |
{ |
1257 |
c->x = frameX(closestx) + frameWidth(closestx) + frameLeft(c); |
c->x = |
1258 |
|
frameX (closestx) + frameWidth (closestx) + |
1259 |
|
frameLeft (c); |
1260 |
} |
} |
1261 |
else |
else |
1262 |
{ |
{ |
1263 |
c->x = (frameX(closestx) - frameWidth(c)) + frameRight(c); |
c->x = |
1264 |
|
(frameX (closestx) - frameWidth (c)) + |
1265 |
|
frameRight (c); |
1266 |
} |
} |
1267 |
} |
} |
1268 |
} |
} |
1269 |
} |
} |
1270 |
|
|
1271 |
if(box_move) |
if (box_move) |
1272 |
clientDrawOutline(c); |
clientDrawOutline (c); |
1273 |
else |
else |
1274 |
{ |
{ |
1275 |
wc.x = c->x; |
wc.x = c->x; |
1276 |
wc.y = c->y; |
wc.y = c->y; |
1277 |
clientConfigure(c, &wc, CWX | CWY); |
clientConfigure (c, &wc, CWX | CWY); |
1278 |
} |
} |
1279 |
} |
} |
1280 |
else if(!use_keys && ev.type == ButtonRelease) |
else if (!use_keys && ev.type == ButtonRelease) |
1281 |
moving = False; |
moving = False; |
1282 |
else if(ev.type == UnmapNotify && ev.xunmap.window == c->window) |
else if (ev.type == UnmapNotify && ev.xunmap.window == c->window) |
1283 |
moving = False; |
moving = False; |
1284 |
else |
else |
1285 |
handleEvent(&ev); |
handleEvent (&ev); |
1286 |
} |
} |
1287 |
#ifdef DEBUG |
#ifdef DEBUG |
1288 |
printf("leaving move loop\n"); |
printf ("leaving move loop\n"); |
1289 |
#endif |
#endif |
1290 |
|
|
1291 |
XUngrabKeyboard(dpy, CurrentTime); |
XUngrabKeyboard (dpy, CurrentTime); |
1292 |
XUngrabPointer(dpy, CurrentTime); |
XUngrabPointer (dpy, CurrentTime); |
1293 |
|
|
1294 |
if(grab && box_move) |
if (grab && box_move) |
1295 |
clientDrawOutline(c); |
clientDrawOutline (c); |
1296 |
|
|
1297 |
wc.x = c->x; |
wc.x = c->x; |
1298 |
wc.y = c->y; |
wc.y = c->y; |
1299 |
clientConfigure(c, &wc, CWX | CWY); |
clientConfigure (c, &wc, CWX | CWY); |
1300 |
|
|
1301 |
XUngrabServer(dpy); |
XUngrabServer (dpy); |
1302 |
} |
} |
1303 |
|
|
1304 |
void clientResize(Client * c, XEvent * e) |
void |
1305 |
{ |
clientResize (Client * c, XEvent * e) |
1306 |
int mx, my, oldw, oldh, resizing = True, grab = False, corner = |
{ |
1307 |
CORNER_BOTTOM_RIGHT, use_keys = False, g1, g2; |
int mx, my, oldw, oldh, resizing = True, grab = False, corner = |
1308 |
XEvent ev; |
CORNER_BOTTOM_RIGHT, use_keys = False, g1, g2; |
1309 |
XWindowChanges wc; |
XEvent ev; |
1310 |
|
XWindowChanges wc; |
1311 |
#ifdef DEBUG |
|
1312 |
printf("entering clientResize\n"); |
#ifdef DEBUG |
1313 |
printf("resizing client (%#lx)\n", c->window); |
printf ("entering clientResize\n"); |
1314 |
#endif |
printf ("resizing client (%#lx)\n", c->window); |
1315 |
|
#endif |
1316 |
if((c->win_state & WIN_STATE_SHADED) || |
|
1317 |
(c->win_state & WIN_STATE_MAXIMIZED == WIN_STATE_MAXIMIZED)) |
if ((c->win_state & WIN_STATE_SHADED) || |
1318 |
return; |
(c->win_state & WIN_STATE_MAXIMIZED == WIN_STATE_MAXIMIZED)) |
1319 |
|
return; |
1320 |
getMouseXY(dpy, c->frame, &mx, &my); |
|
1321 |
if(e->type == KeyPress) |
getMouseXY (dpy, c->frame, &mx, &my); |
1322 |
{ |
if (e->type == KeyPress) |
1323 |
corner = CORNER_BOTTOM_RIGHT; |
{ |
1324 |
use_keys = True; |
corner = CORNER_BOTTOM_RIGHT; |
1325 |
} |
use_keys = True; |
1326 |
else |
} |
1327 |
{ |
else |
1328 |
if(mx < frameWidth(c) / 2 && my < frameHeight(c) / 2) |
{ |
1329 |
corner = CORNER_TOP_LEFT; |
if (mx < frameWidth (c) / 2 && my < frameHeight (c) / 2) |
1330 |
else if(mx < frameWidth(c) / 2) |
corner = CORNER_TOP_LEFT; |
1331 |
corner = CORNER_BOTTOM_LEFT; |
else if (mx < frameWidth (c) / 2) |
1332 |
else if(my < frameHeight(c) / 2) |
corner = CORNER_BOTTOM_LEFT; |
1333 |
corner = CORNER_TOP_RIGHT; |
else if (my < frameHeight (c) / 2) |
1334 |
} |
corner = CORNER_TOP_RIGHT; |
1335 |
|
} |
1336 |
g1 = XGrabKeyboard(dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
|
1337 |
CurrentTime); |
g1 = XGrabKeyboard (dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
1338 |
g2 = XGrabPointer(dpy, c->frame, False, |
CurrentTime); |
1339 |
PointerMotionMask | ButtonReleaseMask, GrabModeAsync, |
g2 = XGrabPointer (dpy, c->frame, False, |
1340 |
GrabModeAsync, None, resize_cursor[corner], CurrentTime); |
PointerMotionMask | ButtonReleaseMask, GrabModeAsync, |
1341 |
|
GrabModeAsync, None, resize_cursor[corner], CurrentTime); |
1342 |
if(g1 != GrabSuccess || g2 != GrabSuccess) |
|
1343 |
{ |
if (g1 != GrabSuccess || g2 != GrabSuccess) |
1344 |
#ifdef DEBUG |
{ |
1345 |
printf("grab failed in clientResize\n"); |
#ifdef DEBUG |
1346 |
#endif |
printf ("grab failed in clientResize\n"); |
1347 |
if(g1 == GrabSuccess) |
#endif |
1348 |
XUngrabKeyboard(dpy, CurrentTime); |
if (g1 == GrabSuccess) |
1349 |
if(g2 == GrabSuccess) |
XUngrabKeyboard (dpy, CurrentTime); |
1350 |
XUngrabPointer(dpy, CurrentTime); |
if (g2 == GrabSuccess) |
1351 |
return; |
XUngrabPointer (dpy, CurrentTime); |
1352 |
} |
return; |
1353 |
|
} |
1354 |
if(use_keys) |
|
1355 |
XPutBackEvent(dpy, e); |
if (use_keys) |
1356 |
|
XPutBackEvent (dpy, e); |
1357 |
if(corner == CORNER_TOP_RIGHT || corner == CORNER_BOTTOM_RIGHT) |
|
1358 |
mx = frameWidth(c) - mx; |
if (corner == CORNER_TOP_RIGHT || corner == CORNER_BOTTOM_RIGHT) |
1359 |
if(corner == CORNER_BOTTOM_LEFT || corner == CORNER_BOTTOM_RIGHT) |
mx = frameWidth (c) - mx; |
1360 |
my = frameHeight(c) - my; |
if (corner == CORNER_BOTTOM_LEFT || corner == CORNER_BOTTOM_RIGHT) |
1361 |
|
my = frameHeight (c) - my; |
1362 |
#ifdef DEBUG |
|
1363 |
printf("entering resize loop\n"); |
#ifdef DEBUG |
1364 |
#endif |
printf ("entering resize loop\n"); |
1365 |
|
#endif |
1366 |
while(resizing) |
|
1367 |
{ |
while (resizing) |
1368 |
XNextEvent(dpy, &ev); |
{ |
1369 |
|
XNextEvent (dpy, &ev); |
1370 |
if(ev.type == KeyPress) |
|
1371 |
{ |
if (ev.type == KeyPress) |
1372 |
if(!grab && box_resize) |
{ |
1373 |
{ |
if (!grab && box_resize) |
1374 |
XGrabServer(dpy); |
{ |
1375 |
grab = True; |
XGrabServer (dpy); |
1376 |
clientDrawOutline(c); |
grab = True; |
1377 |
} |
clientDrawOutline (c); |
1378 |
if(box_resize) |
} |
1379 |
clientDrawOutline(c); |
if (box_resize) |
1380 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
clientDrawOutline (c); |
1381 |
{ |
if (!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
1382 |
if(ev.xkey.keycode == keys[KEY_MOVE_UP].keycode) |
{ |
1383 |
c->height = |
if (ev.xkey.keycode == keys[KEY_MOVE_UP].keycode) |
1384 |
c->height - (clientGetHeightInc(c) < |
c->height = |
1385 |
10 ? 10 : clientGetHeightInc(c)); |
c->height - (clientGetHeightInc (c) < |
1386 |
if(ev.xkey.keycode == keys[KEY_MOVE_DOWN].keycode) |
10 ? 10 : clientGetHeightInc (c)); |
1387 |
c->height = |
if (ev.xkey.keycode == keys[KEY_MOVE_DOWN].keycode) |
1388 |
c->height + (clientGetHeightInc(c) < |
c->height = |
1389 |
10 ? 10 : clientGetHeightInc(c)); |
c->height + (clientGetHeightInc (c) < |
1390 |
} |
10 ? 10 : clientGetHeightInc (c)); |
1391 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
} |
1392 |
{ |
if (!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
1393 |
if(ev.xkey.keycode == keys[KEY_MOVE_LEFT].keycode) |
{ |
1394 |
c->width = |
if (ev.xkey.keycode == keys[KEY_MOVE_LEFT].keycode) |
1395 |
c->width - (clientGetWidthInc(c) < |
c->width = |
1396 |
10 ? 10 : clientGetWidthInc(c)); |
c->width - (clientGetWidthInc (c) < |
1397 |
if(ev.xkey.keycode == keys[KEY_MOVE_RIGHT].keycode) |
10 ? 10 : clientGetWidthInc (c)); |
1398 |
c->width = |
if (ev.xkey.keycode == keys[KEY_MOVE_RIGHT].keycode) |
1399 |
c->width + (clientGetWidthInc(c) < |
c->width = |
1400 |
10 ? 10 : clientGetWidthInc(c)); |
c->width + (clientGetWidthInc (c) < |
1401 |
} |
10 ? 10 : clientGetWidthInc (c)); |
1402 |
if(box_resize) |
} |
1403 |
clientDrawOutline(c); |
if (box_resize) |
1404 |
else |
clientDrawOutline (c); |
1405 |
{ |
else |
1406 |
wc.x = c->x; |
{ |
1407 |
wc.y = c->y; |
wc.x = c->x; |
1408 |
wc.width = c->width; |
wc.y = c->y; |
1409 |
wc.height = c->height; |
wc.width = c->width; |
1410 |
clientConfigure(c, &wc, CWX | CWY | CWWidth | CWHeight); |
wc.height = c->height; |
1411 |
} |
clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight); |
1412 |
} |
} |
1413 |
else if(use_keys && ev.type == KeyRelease) |
} |
1414 |
{ |
else if (use_keys && ev.type == KeyRelease) |
1415 |
if(IsModifierKey(XKeycodeToKeysym(dpy, ev.xkey.keycode, 0))) |
{ |
1416 |
resizing = False; |
if (IsModifierKey (XKeycodeToKeysym (dpy, ev.xkey.keycode, 0))) |
1417 |
} |
resizing = False; |
1418 |
else if(ev.type == MotionNotify) |
} |
1419 |
{ |
else if (ev.type == MotionNotify) |
1420 |
while(XCheckTypedEvent(dpy, MotionNotify, &ev)); |
{ |
1421 |
|
while (XCheckTypedEvent (dpy, MotionNotify, &ev)); |
1422 |
if(!grab && box_resize) |
|
1423 |
{ |
if (!grab && box_resize) |
1424 |
XGrabServer(dpy); |
{ |
1425 |
grab = True; |
XGrabServer (dpy); |
1426 |
clientDrawOutline(c); |
grab = True; |
1427 |
} |
clientDrawOutline (c); |
1428 |
if(box_resize) |
} |
1429 |
clientDrawOutline(c); |
if (box_resize) |
1430 |
oldw = c->width; |
clientDrawOutline (c); |
1431 |
oldh = c->height; |
oldw = c->width; |
1432 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
oldh = c->height; |
1433 |
{ |
if (!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ)) |
1434 |
if(corner == CORNER_TOP_LEFT || corner == CORNER_BOTTOM_LEFT) |
{ |
1435 |
c->width = |
if (corner == CORNER_TOP_LEFT || corner == CORNER_BOTTOM_LEFT) |
1436 |
(c->x + c->width) - ev.xmotion.x_root + mx - |
c->width = |
1437 |
frameLeft(c); |
(c->x + c->width) - ev.xmotion.x_root + mx - frameLeft (c); |
1438 |
if(corner == CORNER_BOTTOM_RIGHT || corner == CORNER_TOP_RIGHT) |
if (corner == CORNER_BOTTOM_RIGHT || corner == CORNER_TOP_RIGHT) |
1439 |
c->width = (ev.xmotion.x_root - c->x) + mx - frameRight(c); |
c->width = (ev.xmotion.x_root - c->x) + mx - frameRight (c); |
1440 |
} |
} |
1441 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
if (!(c->win_state & WIN_STATE_MAXIMIZED_VERT)) |
1442 |
{ |
{ |
1443 |
if(corner == CORNER_TOP_LEFT || corner == CORNER_TOP_RIGHT) |
if (corner == CORNER_TOP_LEFT || corner == CORNER_TOP_RIGHT) |
1444 |
c->height = |
c->height = |
1445 |
(c->y + c->height) - ev.xmotion.y_root + my - |
(c->y + c->height) - ev.xmotion.y_root + my - frameTop (c); |
1446 |
frameTop(c); |
if (corner == CORNER_BOTTOM_RIGHT || |
1447 |
if(corner == CORNER_BOTTOM_RIGHT || |
corner == CORNER_BOTTOM_LEFT) |
1448 |
corner == CORNER_BOTTOM_LEFT) |
c->height = (ev.xmotion.y_root - c->y) + my - frameBottom (c); |
1449 |
c->height = |
} |
1450 |
(ev.xmotion.y_root - c->y) + my - frameBottom(c); |
clientSetWidth (c, c->width); |
1451 |
} |
clientSetHeight (c, c->height); |
1452 |
clientSetWidth(c, c->width); |
if (!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ) && |
1453 |
clientSetHeight(c, c->height); |
(corner == CORNER_TOP_LEFT || corner == CORNER_BOTTOM_LEFT)) |
1454 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_HORIZ) && |
c->x = c->x - (c->width - oldw); |
1455 |
(corner == CORNER_TOP_LEFT || corner == CORNER_BOTTOM_LEFT)) |
if (!(c->win_state & WIN_STATE_MAXIMIZED_VERT) && |
1456 |
c->x = c->x - (c->width - oldw); |
(corner == CORNER_TOP_LEFT || corner == CORNER_TOP_RIGHT)) |
1457 |
if(!(c->win_state & WIN_STATE_MAXIMIZED_VERT) && |
c->y = c->y - (c->height - oldh); |
1458 |
(corner == CORNER_TOP_LEFT || corner == CORNER_TOP_RIGHT)) |
if (box_resize) |
1459 |
c->y = c->y - (c->height - oldh); |
clientDrawOutline (c); |
1460 |
if(box_resize) |
else |
1461 |
clientDrawOutline(c); |
{ |
1462 |
else |
wc.x = c->x; |
1463 |
{ |
wc.y = c->y; |
1464 |
wc.x = c->x; |
wc.width = c->width; |
1465 |
wc.y = c->y; |
wc.height = c->height; |
1466 |
wc.width = c->width; |
clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight); |
1467 |
wc.height = c->height; |
} |
1468 |
clientConfigure(c, &wc, CWX | CWY | CWWidth | CWHeight); |
} |
1469 |
} |
else if (ev.type == ButtonRelease) |
1470 |
} |
resizing = False; |
1471 |
else if(ev.type == ButtonRelease) |
else if (ev.type == UnmapNotify && ev.xunmap.window == c->window) |
1472 |
resizing = False; |
resizing = False; |
1473 |
else if(ev.type == UnmapNotify && ev.xunmap.window == c->window) |
else |
1474 |
resizing = False; |
handleEvent (&ev); |
1475 |
else |
} |
1476 |
handleEvent(&ev); |
#ifdef DEBUG |
1477 |
} |
printf ("leaving resize loop\n"); |
1478 |
#ifdef DEBUG |
#endif |
1479 |
printf("leaving resize loop\n"); |
|
1480 |
#endif |
XUngrabKeyboard (dpy, CurrentTime); |
1481 |
|
XUngrabPointer (dpy, CurrentTime); |
1482 |
XUngrabKeyboard(dpy, CurrentTime); |
|
1483 |
XUngrabPointer(dpy, CurrentTime); |
if (grab && box_resize) |
1484 |
|
clientDrawOutline (c); |
1485 |
if(grab && box_resize) |
|
1486 |
clientDrawOutline(c); |
wc.x = c->x; |
1487 |
|
wc.y = c->y; |
1488 |
wc.x = c->x; |
wc.width = c->width; |
1489 |
wc.y = c->y; |
wc.height = c->height; |
1490 |
wc.width = c->width; |
clientConfigure (c, &wc, (CWX | CWY | CWHeight | CWWidth)); |
1491 |
wc.height = c->height; |
|
1492 |
clientConfigure(c, &wc, (CWX | CWY | CWHeight | CWWidth)); |
XUngrabServer (dpy); |
1493 |
|
} |
1494 |
XUngrabServer(dpy); |
|
1495 |
} |
Client * |
1496 |
|
clientGetNext (Client * c, int mask) |
1497 |
Client *clientGetNext(Client * c, int mask) |
{ |
1498 |
{ |
Client *c2; |
1499 |
Client *c2; |
unsigned int i, okay; |
1500 |
unsigned int i, okay; |
|
1501 |
|
#ifdef DEBUG |
1502 |
#ifdef DEBUG |
printf ("entering clientGetNext\n"); |
1503 |
printf("entering clientGetNext\n"); |
#endif |
1504 |
#endif |
|
1505 |
|
if (c) |
1506 |
if(c) |
{ |
1507 |
{ |
for (c2 = c->next, i = 0; i < client_count; c2 = c2->next, i++) |
1508 |
for(c2 = c->next, i = 0; i < client_count; c2 = c2->next, i++) |
{ |
1509 |
{ |
okay = True; |
1510 |
okay = True; |
if (typeDesktop (dpy, c->window)) |
1511 |
if(typeDesktop(dpy, c->window)) |
okay = False; |
1512 |
okay = False; |
if (c2->win_hints & WIN_HINTS_SKIP_FOCUS && |
1513 |
if(c2->win_hints & WIN_HINTS_SKIP_FOCUS && |
!(mask & INCLUDE_SKIP_FOCUS)) |
1514 |
!(mask & INCLUDE_SKIP_FOCUS)) |
okay = False; |
1515 |
okay = False; |
if (getWMState (dpy, c2->window) == IconicState && |
1516 |
if(getWMState(dpy, c2->window) == IconicState && |
!(mask & INCLUDE_HIDDEN)) |
1517 |
!(mask & INCLUDE_HIDDEN)) |
okay = False; |
1518 |
okay = False; |
if (c2->win_workspace != workspace && |
1519 |
if(c2->win_workspace != workspace && |
!(mask & INCLUDE_ALL_WORKSPACES)) |
1520 |
!(mask & INCLUDE_ALL_WORKSPACES)) |
okay = False; |
1521 |
okay = False; |
if (okay) |
1522 |
if(okay) |
return c2; |
1523 |
return c2; |
} |
1524 |
} |
} |
1525 |
} |
return NULL; |
1526 |
return NULL; |
} |
1527 |
} |
|
1528 |
|
void |
1529 |
void clientCycle(Client * c) |
clientCycle (Client * c) |
1530 |
{ |
{ |
1531 |
Client *c2 = c; |
Client *c2 = c; |
1532 |
int cycling = True, g1, g2; |
int cycling = True, g1, g2; |
1533 |
XEvent ev; |
XEvent ev; |
1534 |
|
|
1535 |
#ifdef DEBUG |
#ifdef DEBUG |
1536 |
printf("entering clientCycle\n"); |
printf ("entering clientCycle\n"); |
1537 |
#endif |
#endif |
1538 |
|
|
1539 |
if(!c) |
if (!c) |
1540 |
return; |
return; |
1541 |
|
|
1542 |
g1 = XGrabKeyboard(dpy, gnome_win, False, GrabModeAsync, GrabModeAsync, |
g1 = XGrabKeyboard (dpy, gnome_win, False, GrabModeAsync, GrabModeAsync, |
1543 |
CurrentTime); |
CurrentTime); |
1544 |
g2 = XGrabPointer(dpy, gnome_win, False, NoEventMask, GrabModeAsync, |
g2 = XGrabPointer (dpy, gnome_win, False, NoEventMask, GrabModeAsync, |
1545 |
GrabModeAsync, None, None, CurrentTime); |
GrabModeAsync, None, None, CurrentTime); |
1546 |
if(g1 != GrabSuccess || g2 != GrabSuccess) |
if (g1 != GrabSuccess || g2 != GrabSuccess) |
1547 |
{ |
{ |
1548 |
#ifdef DEBUG |
#ifdef DEBUG |
1549 |
printf("grab failed in clientCycle\n"); |
printf ("grab failed in clientCycle\n"); |
1550 |
#endif |
#endif |
1551 |
if(g1 == GrabSuccess) |
if (g1 == GrabSuccess) |
1552 |
XUngrabKeyboard(dpy, CurrentTime); |
XUngrabKeyboard (dpy, CurrentTime); |
1553 |
if(g2 == GrabSuccess) |
if (g2 == GrabSuccess) |
1554 |
XUngrabPointer(dpy, CurrentTime); |
XUngrabPointer (dpy, CurrentTime); |
1555 |
return; |
return; |
1556 |
} |
} |
1557 |
|
|
1558 |
c2 = clientGetNext(c2, INCLUDE_HIDDEN); |
c2 = clientGetNext (c2, INCLUDE_HIDDEN); |
1559 |
if(!c2) |
if (!c2) |
1560 |
cycling = False; |
cycling = False; |
1561 |
|
|
1562 |
#ifdef DEBUG |
#ifdef DEBUG |
1563 |
printf("entering cycle loop\n"); |
printf ("entering cycle loop\n"); |
1564 |
#endif |
#endif |
1565 |
|
|
1566 |
while(cycling) |
while (cycling) |
1567 |
{ |
{ |
1568 |
clientShow(c2, False); |
clientShow (c2, False); |
1569 |
clientRaise(c2); |
clientRaise (c2); |
1570 |
clientSetFocus(c2, False); |
clientSetFocus (c2, False); |
1571 |
|
|
1572 |
XNextEvent(dpy, &ev); |
XNextEvent (dpy, &ev); |
1573 |
if(ev.type == KeyPress) |
if (ev.type == KeyPress) |
1574 |
{ |
{ |
1575 |
if(ev.xkey.keycode == keys[KEY_CYCLE_WINDOWS].keycode) |
if (ev.xkey.keycode == keys[KEY_CYCLE_WINDOWS].keycode) |
1576 |
{ |
{ |
1577 |
if(getWMState(dpy, c2->window) == IconicState) |
if (getWMState (dpy, c2->window) == IconicState) |
1578 |
clientHide(c2, False); |
clientHide (c2, False); |
1579 |
c2 = clientGetNext(c2, INCLUDE_HIDDEN); |
c2 = clientGetNext (c2, INCLUDE_HIDDEN); |
1580 |
if(!c2) |
if (!c2) |
1581 |
cycling = False; |
cycling = False; |
1582 |
} |
} |
1583 |
else |
else |
1584 |
{ |
{ |
1585 |
XPutBackEvent(dpy, &ev); |
XPutBackEvent (dpy, &ev); |
1586 |
cycling = False; |
cycling = False; |
1587 |
} |
} |
1588 |
} |
} |
1589 |
else if(ev.type == KeyRelease) |
else if (ev.type == KeyRelease) |
1590 |
{ |
{ |
1591 |
if(IsModifierKey(XKeycodeToKeysym(dpy, ev.xkey.keycode, 0))) |
if (IsModifierKey (XKeycodeToKeysym (dpy, ev.xkey.keycode, 0))) |
1592 |
cycling = False; |
cycling = False; |
1593 |
} |
} |
1594 |
else |
else |
1595 |
handleEvent(&ev); |
handleEvent (&ev); |
1596 |
} |
} |
1597 |
#ifdef DEBUG |
#ifdef DEBUG |
1598 |
printf("leaving cycle loop\n"); |
printf ("leaving cycle loop\n"); |
1599 |
#endif |
#endif |
1600 |
|
|
1601 |
XUngrabKeyboard(dpy, CurrentTime); |
XUngrabKeyboard (dpy, CurrentTime); |
1602 |
XUngrabPointer(dpy, CurrentTime); |
XUngrabPointer (dpy, CurrentTime); |
1603 |
|
|
1604 |
if(c2) |
if (c2) |
1605 |
{ |
{ |
1606 |
clientShow(c2, True); |
clientShow (c2, True); |
1607 |
clientSetFocus(c2, True); |
clientSetFocus (c2, True); |
1608 |
if(!click_to_focus) |
if (!click_to_focus) |
1609 |
XWarpPointer (dpy, None, c2->window, 0, 0, 0, 0, frameWidth(c2) / 2, frameHeight(c2) / 2); |
XWarpPointer (dpy, None, c2->window, 0, 0, 0, 0, frameWidth (c2) / 2, |
1610 |
} |
frameHeight (c2) / 2); |
1611 |
} |
} |
1612 |
|
} |
1613 |
void clientButtonPress(Client * c, Window w, XButtonEvent * bev) |
|
1614 |
{ |
void |
1615 |
int pressed = True, b, g1, g2; |
clientButtonPress (Client * c, Window w, XButtonEvent * bev) |
1616 |
XEvent ev; |
{ |
1617 |
|
int pressed = True, b, g1, g2; |
1618 |
#ifdef DEBUG |
XEvent ev; |
1619 |
printf("entering clientButtonPress\n"); |
|
1620 |
#endif |
#ifdef DEBUG |
1621 |
|
printf ("entering clientButtonPress\n"); |
1622 |
for(b = 0; b < BUTTON_COUNT; b++) |
#endif |
1623 |
if(c->buttons[b] == w) |
|
1624 |
break; |
for (b = 0; b < BUTTON_COUNT; b++) |
1625 |
|
if (c->buttons[b] == w) |
1626 |
g1 = XGrabKeyboard(dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
break; |
1627 |
CurrentTime); |
|
1628 |
g2 = XGrabPointer(dpy, w, False, |
g1 = XGrabKeyboard (dpy, c->window, False, GrabModeAsync, GrabModeAsync, |
1629 |
ButtonReleaseMask | EnterWindowMask | LeaveWindowMask, |
CurrentTime); |
1630 |
GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
g2 = XGrabPointer (dpy, w, False, |
1631 |
|
ButtonReleaseMask | EnterWindowMask | LeaveWindowMask, |
1632 |
if(g1 != GrabSuccess || g2 != GrabSuccess) |
GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
1633 |
{ |
|
1634 |
#ifdef DEBUG |
if (g1 != GrabSuccess || g2 != GrabSuccess) |
1635 |
printf("grab failed in clientButtonPress\n"); |
{ |
1636 |
#endif |
#ifdef DEBUG |
1637 |
if(g1 == GrabSuccess) |
printf ("grab failed in clientButtonPress\n"); |
1638 |
XUngrabKeyboard(dpy, CurrentTime); |
#endif |
1639 |
if(g2 == GrabSuccess) |
if (g1 == GrabSuccess) |
1640 |
XUngrabPointer(dpy, CurrentTime); |
XUngrabKeyboard (dpy, CurrentTime); |
1641 |
return; |
if (g2 == GrabSuccess) |
1642 |
} |
XUngrabPointer (dpy, CurrentTime); |
1643 |
|
return; |
1644 |
#ifdef DEBUG |
} |
1645 |
printf("entering button press loop\n"); |
|
1646 |
#endif |
#ifdef DEBUG |
1647 |
|
printf ("entering button press loop\n"); |
1648 |
c->button_pressed[b] = True; |
#endif |
1649 |
frameDraw(c); |
|
1650 |
|
c->button_pressed[b] = True; |
1651 |
while(pressed) |
frameDraw (c); |
1652 |
{ |
|
1653 |
XNextEvent(dpy, &ev); |
while (pressed) |
1654 |
|
{ |
1655 |
if(ev.type == EnterNotify) |
XNextEvent (dpy, &ev); |
1656 |
{ |
|
1657 |
c->button_pressed[b] = True; |
if (ev.type == EnterNotify) |
1658 |
frameDraw(c); |
{ |
1659 |
} |
c->button_pressed[b] = True; |
1660 |
else if(ev.type == LeaveNotify) |
frameDraw (c); |
1661 |
{ |
} |
1662 |
c->button_pressed[b] = False; |
else if (ev.type == LeaveNotify) |
1663 |
frameDraw(c); |
{ |
1664 |
} |
c->button_pressed[b] = False; |
1665 |
else if(ev.type == ButtonRelease) |
frameDraw (c); |
1666 |
pressed = False; |
} |
1667 |
else if(ev.type == UnmapNotify && ev.xunmap.window == c->window) |
else if (ev.type == ButtonRelease) |
1668 |
{ |
pressed = False; |
1669 |
pressed = False; |
else if (ev.type == UnmapNotify && ev.xunmap.window == c->window) |
1670 |
c->button_pressed[b] = False; |
{ |
1671 |
} |
pressed = False; |
1672 |
else if(ev.type == KeyPress || ev.type == KeyRelease) |
c->button_pressed[b] = False; |
1673 |
{ |
} |
1674 |
} |
else if (ev.type == KeyPress || ev.type == KeyRelease) |
1675 |
else |
{ |
1676 |
handleEvent(&ev); |
} |
1677 |
} |
else |
1678 |
#ifdef DEBUG |
handleEvent (&ev); |
1679 |
printf("leaving button press loop\n"); |
} |
1680 |
#endif |
#ifdef DEBUG |
1681 |
|
printf ("leaving button press loop\n"); |
1682 |
XUngrabPointer(dpy, CurrentTime); |
#endif |
1683 |
XUngrabKeyboard(dpy, CurrentTime); |
|
1684 |
|
XUngrabPointer (dpy, CurrentTime); |
1685 |
if(c->button_pressed[b]) |
XUngrabKeyboard (dpy, CurrentTime); |
1686 |
{ |
|
1687 |
c->button_pressed[b] = False; |
if (c->button_pressed[b]) |
1688 |
frameDraw(c); |
{ |
1689 |
|
c->button_pressed[b] = False; |
1690 |
switch (b) |
frameDraw (c); |
1691 |
{ |
|
1692 |
case HIDE_BUTTON: |
switch (b) |
1693 |
clientHide(c, True); |
{ |
1694 |
break; |
case HIDE_BUTTON: |
1695 |
case CLOSE_BUTTON: |
clientHide (c, True); |
1696 |
if(bev->button == Button3) |
break; |
1697 |
clientKill(c); |
case CLOSE_BUTTON: |
1698 |
else |
if (bev->button == Button3) |
1699 |
clientClose(c); |
clientKill (c); |
1700 |
break; |
else |
1701 |
case MAXIMIZE_BUTTON: |
clientClose (c); |
1702 |
if(bev->button == Button1) |
break; |
1703 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED); |
case MAXIMIZE_BUTTON: |
1704 |
else if(bev->button == Button2) |
if (bev->button == Button1) |
1705 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED_VERT); |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED); |
1706 |
else if(bev->button == Button3) |
else if (bev->button == Button2) |
1707 |
clientToggleMaximized(c, WIN_STATE_MAXIMIZED_HORIZ); |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_VERT); |
1708 |
break; |
else if (bev->button == Button3) |
1709 |
case SHADE_BUTTON: |
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_HORIZ); |
1710 |
clientToggleShaded(c); |
break; |
1711 |
break; |
case SHADE_BUTTON: |
1712 |
} |
clientToggleShaded (c); |
1713 |
|
break; |
1714 |
|
} |
1715 |
} |
} |
1716 |
} |
} |