event.c

   1 /*
   2  * event.c - event handlers
   3  *
   4  * Copyright © 2007 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <X11/keysym.h>
  23 #include <X11/Xatom.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/extensions/shape.h>
  26 #include <X11/extensions/Xrandr.h>
  27
  28 #include "screen.h"
  29 #include "event.h"
  30 #include "layout.h"
  31 #include "tag.h"
  32 #include "draw.h"
  33 #include "statusbar.h"
  34 #include "util.h"
  35 #include "window.h"
  36 #include "layouts/tile.h"
  37 #include "layouts/floating.h"
  38
  39 #define CLEANMASK(mask, screen)         (mask & ~(awesomeconf[screen].numlockmask | LockMask))
  40 #define MOUSEMASK                       (BUTTONMASK | PointerMotionMask)
  41
  42 static void
  43 movemouse(Client *c, awesome_config *awesomeconf)
  44 {
  45     int x1, y1, ocx, ocy, di, nx, ny;
  46     unsigned int dui;
  47     Window dummy;
  48     XEvent ev;
  49     ScreenInfo *si;
  50
  51     si = get_screen_info(c->display, c->screen, &awesomeconf[c->screen].statusbar);
  52
  53     ocx = nx = c->x;
  54     ocy = ny = c->y;
  55     if(XGrabPointer(c->display, RootWindow(c->display, c->phys_screen), False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
  56                     None, awesomeconf[c->screen].cursor[CurMove], CurrentTime) != GrabSuccess)
  57         return;
  58     XQueryPointer(c->display, RootWindow(c->display, c->phys_screen), &dummy, &dummy, &x1, &y1, &di, &di, &dui);
  59     for(;;)
  60     {
  61         XMaskEvent(c->display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
  62         switch (ev.type)
  63         {
  64         case ButtonRelease:
  65             XUngrabPointer(c->display, CurrentTime);
  66             p_delete(&si);
  67             return;
  68         case ConfigureRequest:
  69             handle_event_configurerequest(&ev,awesomeconf);
  70             break;
  71         case Expose:
  72             handle_event_expose(&ev, awesomeconf);
  73             break;
  74         case MapRequest:
  75             handle_event_maprequest(&ev, awesomeconf);
  76             break;
  77         case MotionNotify:
  78             XSync(c->display, False);
  79             nx = ocx + (ev.xmotion.x - x1);
  80             ny = ocy + (ev.xmotion.y - y1);
  81             if(abs(nx) < awesomeconf[c->screen].snap + si[c->screen].x_org && nx > si[c->screen].x_org)
  82                 nx = si[c->screen].x_org;
  83             else if(abs((si[c->screen].x_org + si[c->screen].width) - (nx + c->w + 2 * c->border)) < awesomeconf[c->screen].snap)
  84                 nx = si[c->screen].x_org + si[c->screen].width - c->w - 2 * c->border;
  85             if(abs(ny) < awesomeconf[c->screen].snap + si[c->screen].y_org && ny > si[c->screen].y_org)
  86                 ny = si[c->screen].y_org;
  87             else if(abs((si[c->screen].y_org + si[c->screen].height) - (ny + c->h + 2 * c->border)) < awesomeconf[c->screen].snap)
  88                 ny = si[c->screen].y_org + si[c->screen].height - c->h - 2 * c->border;
  89             client_resize(c, nx, ny, c->w, c->h, &awesomeconf[c->screen], False, False);
  90             break;
  91         }
  92     }
  93 }
  94
  95 static void
  96 resizemouse(Client * c, awesome_config *awesomeconf)
  97 {
  98     int ocx, ocy, nw, nh;
  99     XEvent ev;
 100
 101     ocx = c->x;
 102     ocy = c->y;
 103     if(XGrabPointer(c->display, RootWindow(c->display, c->phys_screen),
 104                     False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
 105                     None, awesomeconf[c->screen].cursor[CurResize], CurrentTime) != GrabSuccess)
 106         return;
 107     c->ismax = False;
 108     XWarpPointer(c->display, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);
 109     for(;;)
 110     {
 111         XMaskEvent(c->display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
 112         switch (ev.type)
 113         {
 114         case ButtonRelease:
 115             XWarpPointer(c->display, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);
 116             XUngrabPointer(c->display, CurrentTime);
 117             while(XCheckMaskEvent(c->display, EnterWindowMask, &ev));
 118             return;
 119         case ConfigureRequest:
 120             handle_event_configurerequest(&ev,awesomeconf);
 121             break;
 122         case Expose:
 123             handle_event_expose(&ev, awesomeconf);
 124             break;
 125         case MapRequest:
 126             handle_event_maprequest(&ev, awesomeconf);
 127             break;
 128         case MotionNotify:
 129             XSync(c->display, False);
 130             if((nw = ev.xmotion.x - ocx - 2 * c->border + 1) <= 0)
 131                 nw = 1;
 132             if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0)
 133                 nh = 1;
 134             client_resize(c, c->x, c->y, nw, nh, &awesomeconf[c->screen], True, False);
 135             break;
 136         }
 137     }
 138 }
 139
 140
 141 static void
 142 handle_mouse_button_press(awesome_config *awesomeconf,
 143                           unsigned int button, unsigned int state, unsigned int numlockmask,
 144                           Button *buttons, int nbuttons, char *arg)
 145 {
 146     int i;
 147
 148     for(i = 0; i < nbuttons; i++)
 149         if(button == buttons[i].button
 150            && (state == buttons[i].mod || state == (buttons[i].mod | numlockmask))
 151            && buttons[i].func)
 152         {
 153             if(arg)
 154                 buttons[i].func(awesomeconf, arg);
 155             else
 156                 buttons[i].func(awesomeconf, buttons[i].arg);
 157             return;
 158         }
 159 }
 160 void
 161 handle_event_buttonpress(XEvent * e, awesome_config *awesomeconf)
 162 {
 163     int i, screen, x = 0, y = 0;
 164     unsigned int udummy;
 165     Client *c;
 166     Window wdummy;
 167     char arg[256];
 168     XButtonPressedEvent *ev = &e->xbutton;
 169
 170     for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 171         if(awesomeconf[screen].statusbar.window == ev->window)
 172         {
 173             for(i = 0; i < awesomeconf[screen].ntags; i++)
 174             {
 175                 x += textwidth(e->xany.display, awesomeconf[screen].font, awesomeconf[screen].tags[i].name);
 176                 if(ev->x < x)
 177                 {
 178                     snprintf(arg, sizeof(arg), "%d", i + 1);
 179                     handle_mouse_button_press(&awesomeconf[screen],
 180                                               ev->button, ev->state, awesomeconf->numlockmask,
 181                                               awesomeconf->buttons.tag, awesomeconf->buttons.ntag, arg);
 182                     return;
 183                 }
 184             }
 185             x += awesomeconf[screen].statusbar.txtlayoutwidth;
 186             if(ev->x <x)
 187                 handle_mouse_button_press(&awesomeconf[screen],
 188                                           ev->button, ev->state, awesomeconf->numlockmask,
 189                                           awesomeconf->buttons.layout, awesomeconf->buttons.nlayout, NULL);
 190             else
 191                 handle_mouse_button_press(&awesomeconf[screen],
 192                                           ev->button, ev->state, awesomeconf->numlockmask,
 193                                           awesomeconf->buttons.title, awesomeconf->buttons.ntitle, NULL);
 194             return;
 195         }
 196
 197     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 198     {
 199         XAllowEvents(c->display, ReplayPointer, CurrentTime);
 200         focus(c, ev->same_screen, &awesomeconf[c->screen]);
 201         if(CLEANMASK(ev->state, c->screen) != awesomeconf[c->screen].modkey)
 202         {
 203            if (ev->button == Button1)
 204            {
 205                restack(&awesomeconf[c->screen]);
 206                window_grabbuttons(c->display, c->phys_screen, c->win,
 207                                   True, True, awesomeconf->modkey, awesomeconf->numlockmask);
 208            }
 209         }
 210         else if(ev->button == Button1)
 211         {
 212             if((get_current_layout(awesomeconf[c->screen].tags,
 213                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 214                && !c->isfloating)
 215                 uicb_togglefloating(&awesomeconf[c->screen], "DUMMY");
 216             else
 217                 restack(&awesomeconf[c->screen]);
 218             movemouse(c, awesomeconf);
 219         }
 220         else if(ev->button == Button2)
 221         {
 222             if((get_current_layout(awesomeconf[c->screen].tags,
 223                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 224                 && !c->isfixed && c->isfloating)
 225                 uicb_togglefloating(&awesomeconf[c->screen], NULL);
 226             else
 227                 uicb_zoom(&awesomeconf[c->screen], NULL);
 228         }
 229         else if(ev->button == Button3)
 230         {
 231             if((get_current_layout(awesomeconf[c->screen].tags,
 232                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 233                && !c->isfloating)
 234                 uicb_togglefloating(&awesomeconf[c->screen], "DUMMY");
 235             else
 236                 restack(&awesomeconf[c->screen]);
 237             resizemouse(c, awesomeconf);
 238         }
 239         else if(ev->button == Button4)
 240             uicb_settrans(&awesomeconf[c->screen], "+5");
 241         else if(ev->button == Button5)
 242             uicb_settrans(&awesomeconf[c->screen], "-5");
 243     }
 244     else
 245         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 246             if(RootWindow(e->xany.display, screen) == ev->window
 247                && XQueryPointer(e->xany.display, ev->window, &wdummy, &wdummy, &x, &y, &i, &i, &udummy))
 248             {
 249                 screen = get_screen_bycoord(e->xany.display, x, y);
 250                 if(ev->button == Button4)
 251                     uicb_tag_viewnext(&awesomeconf[screen], NULL);
 252                 else if(ev->button == Button5)
 253                     uicb_tag_viewprev(&awesomeconf[screen], NULL);
 254                 break;
 255             }
 256 }
 257
 258 void
 259 handle_event_configurerequest(XEvent * e, awesome_config *awesomeconf)
 260 {
 261     Client *c;
 262     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 263     XWindowChanges wc;
 264
 265     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 266     {
 267         c->ismax = False;
 268         if(ev->value_mask & CWBorderWidth)
 269             c->border = ev->border_width;
 270         if(c->isfixed || c->isfloating
 271            || get_current_layout(awesomeconf[c->screen].tags,
 272                                  awesomeconf[c->screen].ntags)->arrange == layout_floating)
 273         {
 274             if(ev->value_mask & CWX)
 275                 c->x = ev->x;
 276             if(ev->value_mask & CWY)
 277                 c->y = ev->y;
 278             if(ev->value_mask & CWWidth)
 279                 c->w = ev->width;
 280             if(ev->value_mask & CWHeight)
 281                 c->h = ev->height;
 282             if((c->x + c->w) > DisplayWidth(c->display, c->phys_screen) && c->isfloating)
 283                 c->x = DisplayWidth(c->display, c->phys_screen) / 2 - c->w / 2;       /* center in x direction */
 284             if((c->y + c->h) > DisplayHeight(c->display, c->phys_screen) && c->isfloating)
 285                 c->y = DisplayHeight(c->display, c->phys_screen) / 2 - c->h / 2;       /* center in y direction */
 286             if((ev->value_mask & (CWX | CWY)) && !(ev->value_mask & (CWWidth | CWHeight)))
 287                 window_configure(c->display, c->win, c->x, c->y, c->w, c->h, c->border);
 288             if(isvisible(c, c->screen, awesomeconf[c->screen].tags, awesomeconf[c->screen].ntags))
 289                 XMoveResizeWindow(e->xany.display, c->win, c->x, c->y, c->w, c->h);
 290         }
 291         else
 292             window_configure(c->display, c->win, c->x, c->y, c->w, c->h, c->border);
 293     }
 294     else
 295     {
 296         wc.x = ev->x;
 297         wc.y = ev->y;
 298         wc.width = ev->width;
 299         wc.height = ev->height;
 300         wc.border_width = ev->border_width;
 301         wc.sibling = ev->above;
 302         wc.stack_mode = ev->detail;
 303         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 304     }
 305     XSync(e->xany.display, False);
 306 }
 307
 308 void
 309 handle_event_configurenotify(XEvent * e, awesome_config *awesomeconf)
 310 {
 311     XConfigureEvent *ev = &e->xconfigure;
 312     int screen;
 313     ScreenInfo *si;
 314
 315     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 316         if(ev->window == RootWindow(e->xany.display, screen)
 317            && (ev->width != DisplayWidth(e->xany.display, screen)
 318                || ev->height != DisplayHeight(e->xany.display, screen)))
 319         {
 320             DisplayWidth(e->xany.display, screen) = ev->width;
 321             DisplayHeight(e->xany.display, screen) = ev->height;
 322
 323             /* update statusbar */
 324             XFreePixmap(e->xany.display, awesomeconf[screen].statusbar.drawable);
 325
 326             si = get_screen_info(e->xany.display, screen, NULL);
 327             awesomeconf[screen].statusbar.width = si[screen].width;
 328             p_delete(&si);
 329
 330             awesomeconf[screen].statusbar.drawable = XCreatePixmap(e->xany.display, RootWindow(e->xany.display, screen),
 331                                                                    awesomeconf[screen].statusbar.width,
 332                                                                    awesomeconf[screen].statusbar.height,
 333                                                                    DefaultDepth(e->xany.display, screen));
 334             XResizeWindow(e->xany.display,
 335                           awesomeconf[screen].statusbar.window,
 336                           awesomeconf[screen].statusbar.width,
 337                           awesomeconf[screen].statusbar.height);
 338
 339             updatebarpos(e->xany.display, awesomeconf[screen].statusbar);
 340             arrange(&awesomeconf[screen]);
 341         }
 342 }
 343
 344 void
 345 handle_event_destroynotify(XEvent * e, awesome_config *awesomeconf)
 346 {
 347     Client *c;
 348     XDestroyWindowEvent *ev = &e->xdestroywindow;
 349
 350     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 351         client_unmanage(c, WithdrawnState, &awesomeconf[c->screen]);
 352 }
 353
 354 void
 355 handle_event_enternotify(XEvent * e, awesome_config *awesomeconf)
 356 {
 357     Client *c;
 358     XCrossingEvent *ev = &e->xcrossing;
 359     int screen;
 360
 361     if(ev->mode != NotifyNormal || ev->detail == NotifyInferior)
 362         return;
 363     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 364     {
 365         focus(c, ev->same_screen, &awesomeconf[c->screen]);
 366         if (c->isfloating
 367                 || get_current_layout(awesomeconf[c->screen].tags,
 368                                     awesomeconf[c->screen].ntags)->arrange == layout_floating)
 369             window_grabbuttons(c->display, c->phys_screen, c->win,
 370                                True, False, awesomeconf->modkey, awesomeconf->numlockmask);
 371     }
 372     else
 373         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 374             if(ev->window == RootWindow(e->xany.display, screen))
 375                 focus(NULL, True, &awesomeconf[screen]);
 376 }
 377
 378 void
 379 handle_event_expose(XEvent * e, awesome_config *awesomeconf)
 380 {
 381     XExposeEvent *ev = &e->xexpose;
 382     int screen;
 383
 384     if(!ev->count)
 385         for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 386             if(awesomeconf[screen].statusbar.window == ev->window)
 387                 drawstatusbar(&awesomeconf[screen]);
 388 }
 389
 390 void
 391 handle_event_keypress(XEvent * e, awesome_config *awesomeconf)
 392 {
 393     int i, screen, x, y, d;
 394     unsigned int m;
 395     KeySym keysym;
 396     XKeyEvent *ev = &e->xkey;
 397     Window dummy;
 398
 399     keysym = XKeycodeToKeysym(e->xany.display, (KeyCode) ev->keycode, 0);
 400
 401     /* find the right screen for this event */
 402     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 403         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 404         {
 405             /* if screen is 0, we are on first Zaphod screen or on the
 406              * only screen in Xinerama, so we can ask for a better screen
 407              * number with get_screen_bycoord: we'll get 0 in Zaphod mode
 408              * so it's the same, or maybe the real Xinerama screen */
 409             if(screen == 0)
 410                 screen = get_screen_bycoord(e->xany.display, x, y);
 411             break;
 412         }
 413
 414     for(i = 0; i < awesomeconf[screen].nkeys; i++)
 415         if(keysym == awesomeconf[screen].keys[i].keysym
 416            && CLEANMASK(awesomeconf[screen].keys[i].mod, screen) == CLEANMASK(ev->state, screen) && awesomeconf[screen].keys[i].func)
 417             awesomeconf[screen].keys[i].func(&awesomeconf[screen], awesomeconf[screen].keys[i].arg);
 418 }
 419
 420 void
 421 handle_event_leavenotify(XEvent * e, awesome_config *awesomeconf)
 422 {
 423     XCrossingEvent *ev = &e->xcrossing;
 424     int screen;
 425
 426     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 427         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 428             focus(NULL, ev->same_screen, &awesomeconf[screen]);
 429 }
 430
 431 void
 432 handle_event_mappingnotify(XEvent * e, awesome_config *awesomeconf)
 433 {
 434     XMappingEvent *ev = &e->xmapping;
 435     int screen;
 436
 437     XRefreshKeyboardMapping(ev);
 438     if(ev->request == MappingKeyboard)
 439         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 440             grabkeys(&awesomeconf[screen]);
 441 }
 442
 443 void
 444 handle_event_maprequest(XEvent * e, awesome_config *awesomeconf)
 445 {
 446     static XWindowAttributes wa;
 447     XMapRequestEvent *ev = &e->xmaprequest;
 448     int screen, x, y, d;
 449     unsigned int m;
 450     Window dummy;
 451
 452     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 453         return;
 454     if(wa.override_redirect)
 455         return;
 456     if(!get_client_bywin(*awesomeconf->clients, ev->window))
 457     {
 458         for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 459         if(screen == 0)
 460         {
 461             if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 462                              &dummy, &dummy, &x, &y, &d, &d, &m))
 463                 screen = get_screen_bycoord(e->xany.display, x, y);
 464
 465         }
 466         client_manage(ev->window, &wa, &awesomeconf[screen]);
 467     }
 468 }
 469
 470 void
 471 handle_event_propertynotify(XEvent * e, awesome_config *awesomeconf)
 472 {
 473     Client *c;
 474     Window trans;
 475     XPropertyEvent *ev = &e->xproperty;
 476
 477     if(ev->state == PropertyDelete)
 478         return;                 /* ignore */
 479     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 480     {
 481         switch (ev->atom)
 482         {
 483         case XA_WM_TRANSIENT_FOR:
 484             XGetTransientForHint(e->xany.display, c->win, &trans);
 485             if(!c->isfloating && (c->isfloating = (get_client_bywin(*awesomeconf->clients, trans) != NULL)))
 486                 arrange(&awesomeconf[c->screen]);
 487             break;
 488         case XA_WM_NORMAL_HINTS:
 489             updatesizehints(c);
 490             break;
 491         }
 492         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(c->display, "_NET_WM_NAME", False))
 493         {
 494             updatetitle(c);
 495             if(c == get_current_tag(awesomeconf->tags, awesomeconf->ntags)->client_sel)
 496                 drawstatusbar(&awesomeconf[c->screen]);
 497         }
 498     }
 499 }
 500
 501 void
 502 handle_event_unmapnotify(XEvent * e, awesome_config *awesomeconf)
 503 {
 504     Client *c;
 505     XUnmapEvent *ev = &e->xunmap;
 506
 507     if((c = get_client_bywin(*awesomeconf->clients, ev->window))
 508        && ev->event == RootWindow(e->xany.display, c->phys_screen)
 509        && ev->send_event && window_getstate(c->display, c->win) == NormalState)
 510         client_unmanage(c, WithdrawnState, &awesomeconf[c->screen]);
 511 }
 512
 513 void
 514 handle_event_shape(XEvent * e,
 515                    awesome_config *awesomeconf __attribute__ ((unused)))
 516 {
 517     XShapeEvent *ev = (XShapeEvent *) e;
 518     Client *c = get_client_bywin(*awesomeconf->clients, ev->window);
 519
 520     if(c)
 521         window_setshape(c->display, c->phys_screen, c->win);
 522 }
 523
 524 void
 525 handle_event_randr_screen_change_notify(XEvent *e,
 526                                         awesome_config *awesomeconf __attribute__ ((unused)))
 527 {
 528     XRRUpdateConfiguration(e);
 529 }
 530
 531 void
 532 grabkeys(awesome_config *awesomeconf)
 533 {
 534     int i;
 535     KeyCode code;
 536
 537     XUngrabKey(awesomeconf->display, AnyKey, AnyModifier, RootWindow(awesomeconf->display, awesomeconf->phys_screen));
 538     for(i = 0; i < awesomeconf->nkeys; i++)
 539     {
 540         if((code = XKeysymToKeycode(awesomeconf->display, awesomeconf->keys[i].keysym)) == NoSymbol)
 541             continue;
 542         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 543         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | LockMask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 544         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 545         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask | LockMask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True,
 546                  GrabModeAsync, GrabModeAsync);
 547     }
 548 }
 549 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99