/[oroborus]/oroborus/src/client.c
ViewVC logotype

Diff of /oroborus/src/client.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.3 by dreamind, Mon May 27 02:03:30 2002 UTC revision 1.4 by dreamind, Thu May 30 13:57:51 2002 UTC
# Line 21  Line 21 
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  }  }

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26