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

Diff of /oroborus/src/events.c

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

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

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

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