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 void
 141 handle_event_buttonpress(XEvent * e, awesome_config *awesomeconf)
 142 {
 143     int i, screen, x = 0, y = 0;
 144     unsigned int udummy;
 145     Client *c;
 146     Window wdummy;
 147     XButtonPressedEvent *ev = &e->xbutton;
 148
 149     for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 150         if(awesomeconf[screen].statusbar.window == ev->window)
 151         {
 152             for(i = 0; i < awesomeconf[screen].ntags; i++)
 153             {
 154                 x += textwidth(e->xany.display, awesomeconf[screen].font, awesomeconf[screen].tags[i].name);
 155                 if(ev->x < x)
 156                 {
 157                     if(ev->button == Button1)
 158                     {
 159                         if(ev->state & awesomeconf[screen].modkey)
 160                             uicb_tag(&awesomeconf[screen], awesomeconf[screen].tags[i].name);
 161                         else
 162                             uicb_view(&awesomeconf[screen], awesomeconf[screen].tags[i].name);
 163                     }
 164                     else if(ev->button == Button3)
 165                     {
 166                         if(ev->state & awesomeconf[screen].modkey)
 167                             uicb_toggletag(&awesomeconf[screen], awesomeconf[screen].tags[i].name);
 168                         else
 169                             uicb_toggleview(&awesomeconf[screen], awesomeconf[screen].tags[i].name);
 170                     }
 171                     else if(ev->button == Button4)
 172                         uicb_tag_viewnext(&awesomeconf[screen], NULL);
 173                     else if(ev->button == Button5)
 174                         uicb_tag_viewprev(&awesomeconf[screen], NULL);
 175                     return;
 176                 }
 177             }
 178             x += awesomeconf[screen].statusbar.txtlayoutwidth;
 179             if(ev->x < x && (ev->button == Button1 || ev->button == Button4))
 180                 uicb_setlayout(&awesomeconf[screen], "+1");
 181             else if(ev->x < x && (ev->button == Button3 || ev->button == Button5))
 182                 uicb_setlayout(&awesomeconf[screen], "-1");
 183             else if(ev->button == Button4)
 184                 uicb_focusnext(&awesomeconf[screen], NULL);
 185             else if(ev->button == Button5)
 186                 uicb_focusprev(&awesomeconf[screen], NULL);
 187             return;
 188         }
 189
 190     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 191     {
 192         XAllowEvents(c->display, ReplayPointer, CurrentTime);
 193         focus(c, ev->same_screen, &awesomeconf[c->screen]);
 194         if(CLEANMASK(ev->state, c->screen) != awesomeconf[c->screen].modkey)
 195         {
 196            if (ev->button == Button1)
 197            {
 198                restack(&awesomeconf[c->screen]);
 199                window_grabbuttons(c->display, c->phys_screen, c->win,
 200                                   True, True, awesomeconf->modkey, awesomeconf->numlockmask);
 201            }
 202         }
 203         else if(ev->button == Button1)
 204         {
 205             if((get_current_layout(awesomeconf[c->screen].tags,
 206                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 207                && !c->isfloating)
 208                 uicb_togglefloating(&awesomeconf[c->screen], "DUMMY");
 209             else
 210                 restack(&awesomeconf[c->screen]);
 211             movemouse(c, awesomeconf);
 212         }
 213         else if(ev->button == Button2)
 214         {
 215             if((get_current_layout(awesomeconf[c->screen].tags,
 216                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 217                 && !c->isfixed && c->isfloating)
 218                 uicb_togglefloating(&awesomeconf[c->screen], NULL);
 219             else
 220                 uicb_zoom(&awesomeconf[c->screen], NULL);
 221         }
 222         else if(ev->button == Button3)
 223         {
 224             if((get_current_layout(awesomeconf[c->screen].tags,
 225                                    awesomeconf[c->screen].ntags)->arrange != layout_floating)
 226                && !c->isfloating)
 227                 uicb_togglefloating(&awesomeconf[c->screen], NULL);
 228             else
 229                 restack(&awesomeconf[c->screen]);
 230             resizemouse(c, awesomeconf);
 231         }
 232         else if(ev->button == Button4)
 233             uicb_settrans(&awesomeconf[c->screen], "+5");
 234         else if(ev->button == Button5)
 235             uicb_settrans(&awesomeconf[c->screen], "-5");
 236     }
 237     else
 238         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 239             if(RootWindow(e->xany.display, screen) == ev->window
 240                && XQueryPointer(e->xany.display, ev->window, &wdummy, &wdummy, &x, &y, &i, &i, &udummy))
 241             {
 242                 screen = get_screen_bycoord(e->xany.display, x, y);
 243                 if(ev->button == Button4)
 244                     uicb_tag_viewnext(&awesomeconf[screen], NULL);
 245                 else if(ev->button == Button5)
 246                     uicb_tag_viewprev(&awesomeconf[screen], NULL);
 247                 break;
 248             }
 249 }
 250
 251 void
 252 handle_event_configurerequest(XEvent * e, awesome_config *awesomeconf)
 253 {
 254     Client *c;
 255     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 256     XWindowChanges wc;
 257
 258     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 259     {
 260         c->ismax = False;
 261         if(ev->value_mask & CWBorderWidth)
 262             c->border = ev->border_width;
 263         if(c->isfixed || c->isfloating
 264            || get_current_layout(awesomeconf[c->screen].tags,
 265                                  awesomeconf[c->screen].ntags)->arrange == layout_floating)
 266         {
 267             if(ev->value_mask & CWX)
 268                 c->x = ev->x;
 269             if(ev->value_mask & CWY)
 270                 c->y = ev->y;
 271             if(ev->value_mask & CWWidth)
 272                 c->w = ev->width;
 273             if(ev->value_mask & CWHeight)
 274                 c->h = ev->height;
 275             if((c->x + c->w) > DisplayWidth(c->display, c->phys_screen) && c->isfloating)
 276                 c->x = DisplayWidth(c->display, c->phys_screen) / 2 - c->w / 2;       /* center in x direction */
 277             if((c->y + c->h) > DisplayHeight(c->display, c->phys_screen) && c->isfloating)
 278                 c->y = DisplayHeight(c->display, c->phys_screen) / 2 - c->h / 2;       /* center in y direction */
 279             if((ev->value_mask & (CWX | CWY)) && !(ev->value_mask & (CWWidth | CWHeight)))
 280                 window_configure(c->display, c->win, c->x, c->y, c->w, c->h, c->border);
 281             if(isvisible(c, c->screen, awesomeconf[c->screen].tags, awesomeconf[c->screen].ntags))
 282                 XMoveResizeWindow(e->xany.display, c->win, c->x, c->y, c->w, c->h);
 283         }
 284         else
 285             window_configure(c->display, c->win, c->x, c->y, c->w, c->h, c->border);
 286     }
 287     else
 288     {
 289         wc.x = ev->x;
 290         wc.y = ev->y;
 291         wc.width = ev->width;
 292         wc.height = ev->height;
 293         wc.border_width = ev->border_width;
 294         wc.sibling = ev->above;
 295         wc.stack_mode = ev->detail;
 296         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 297     }
 298     XSync(e->xany.display, False);
 299 }
 300
 301 void
 302 handle_event_configurenotify(XEvent * e, awesome_config *awesomeconf)
 303 {
 304     XConfigureEvent *ev = &e->xconfigure;
 305     int screen;
 306     ScreenInfo *si;
 307
 308     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 309         if(ev->window == RootWindow(e->xany.display, screen)
 310            && (ev->width != DisplayWidth(e->xany.display, screen)
 311                || ev->height != DisplayHeight(e->xany.display, screen)))
 312         {
 313             DisplayWidth(e->xany.display, screen) = ev->width;
 314             DisplayHeight(e->xany.display, screen) = ev->height;
 315
 316             /* update statusbar */
 317             XFreePixmap(e->xany.display, awesomeconf[screen].statusbar.drawable);
 318
 319             si = get_screen_info(e->xany.display, screen, NULL);
 320             awesomeconf[screen].statusbar.width = si[screen].width;
 321             p_delete(&si);
 322
 323             awesomeconf[screen].statusbar.drawable = XCreatePixmap(e->xany.display, RootWindow(e->xany.display, screen),
 324                                                                    awesomeconf[screen].statusbar.width,
 325                                                                    awesomeconf[screen].statusbar.height,
 326                                                                    DefaultDepth(e->xany.display, screen));
 327             XResizeWindow(e->xany.display,
 328                           awesomeconf[screen].statusbar.window,
 329                           awesomeconf[screen].statusbar.width,
 330                           awesomeconf[screen].statusbar.height);
 331
 332             updatebarpos(e->xany.display, awesomeconf[screen].statusbar);
 333             arrange(&awesomeconf[screen]);
 334         }
 335 }
 336
 337 void
 338 handle_event_destroynotify(XEvent * e, awesome_config *awesomeconf)
 339 {
 340     Client *c;
 341     XDestroyWindowEvent *ev = &e->xdestroywindow;
 342
 343     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 344         client_unmanage(c, WithdrawnState, &awesomeconf[c->screen]);
 345 }
 346
 347 void
 348 handle_event_enternotify(XEvent * e, awesome_config *awesomeconf)
 349 {
 350     Client *c;
 351     XCrossingEvent *ev = &e->xcrossing;
 352     int screen;
 353
 354     if(ev->mode != NotifyNormal || ev->detail == NotifyInferior)
 355         return;
 356     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 357     {
 358         focus(c, ev->same_screen, &awesomeconf[c->screen]);
 359         if (c->isfloating
 360                 || get_current_layout(awesomeconf[c->screen].tags,
 361                                     awesomeconf[c->screen].ntags)->arrange == layout_floating)
 362             window_grabbuttons(c->display, c->phys_screen, c->win,
 363                                True, False, awesomeconf->modkey, awesomeconf->numlockmask);
 364     }
 365     else
 366         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 367             if(ev->window == RootWindow(e->xany.display, screen))
 368                 focus(NULL, True, &awesomeconf[screen]);
 369 }
 370
 371 void
 372 handle_event_expose(XEvent * e, awesome_config *awesomeconf)
 373 {
 374     XExposeEvent *ev = &e->xexpose;
 375     int screen;
 376
 377     if(!ev->count)
 378         for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 379             if(awesomeconf[screen].statusbar.window == ev->window)
 380                 drawstatusbar(&awesomeconf[screen]);
 381 }
 382
 383 void
 384 handle_event_keypress(XEvent * e, awesome_config *awesomeconf)
 385 {
 386     int i, screen, x, y, d;
 387     unsigned int m;
 388     KeySym keysym;
 389     XKeyEvent *ev = &e->xkey;
 390     Window dummy;
 391
 392     keysym = XKeycodeToKeysym(e->xany.display, (KeyCode) ev->keycode, 0);
 393
 394     /* find the right screen for this event */
 395     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 396         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 397         {
 398             /* if screen is 0, we are on first Zaphod screen or on the
 399              * only screen in Xinerama, so we can ask for a better screen
 400              * number with get_screen_bycoord: we'll get 0 in Zaphod mode
 401              * so it's the same, or maybe the real Xinerama screen */
 402             if(screen == 0)
 403                 screen = get_screen_bycoord(e->xany.display, x, y);
 404             break;
 405         }
 406
 407     for(i = 0; i < awesomeconf[screen].nkeys; i++)
 408         if(keysym == awesomeconf[screen].keys[i].keysym
 409            && CLEANMASK(awesomeconf[screen].keys[i].mod, screen) == CLEANMASK(ev->state, screen) && awesomeconf[screen].keys[i].func)
 410             awesomeconf[screen].keys[i].func(&awesomeconf[screen], awesomeconf[screen].keys[i].arg);
 411 }
 412
 413 void
 414 handle_event_leavenotify(XEvent * e, awesome_config *awesomeconf)
 415 {
 416     XCrossingEvent *ev = &e->xcrossing;
 417     int screen;
 418
 419     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 420         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 421             focus(NULL, ev->same_screen, &awesomeconf[screen]);
 422 }
 423
 424 void
 425 handle_event_mappingnotify(XEvent * e, awesome_config *awesomeconf)
 426 {
 427     XMappingEvent *ev = &e->xmapping;
 428     int screen;
 429
 430     XRefreshKeyboardMapping(ev);
 431     if(ev->request == MappingKeyboard)
 432         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 433             grabkeys(&awesomeconf[screen]);
 434 }
 435
 436 void
 437 handle_event_maprequest(XEvent * e, awesome_config *awesomeconf)
 438 {
 439     static XWindowAttributes wa;
 440     XMapRequestEvent *ev = &e->xmaprequest;
 441     int screen, x, y, d;
 442     unsigned int m;
 443     Window dummy;
 444
 445     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 446         return;
 447     if(wa.override_redirect)
 448         return;
 449     if(!get_client_bywin(*awesomeconf->clients, ev->window))
 450     {
 451         for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 452         if(screen == 0)
 453         {
 454             if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 455                              &dummy, &dummy, &x, &y, &d, &d, &m))
 456                 screen = get_screen_bycoord(e->xany.display, x, y);
 457
 458         }
 459         client_manage(ev->window, &wa, &awesomeconf[screen]);
 460     }
 461 }
 462
 463 void
 464 handle_event_propertynotify(XEvent * e, awesome_config *awesomeconf)
 465 {
 466     Client *c;
 467     Window trans;
 468     XPropertyEvent *ev = &e->xproperty;
 469
 470     if(ev->state == PropertyDelete)
 471         return;                 /* ignore */
 472     if((c = get_client_bywin(*awesomeconf->clients, ev->window)))
 473     {
 474         switch (ev->atom)
 475         {
 476         case XA_WM_TRANSIENT_FOR:
 477             XGetTransientForHint(e->xany.display, c->win, &trans);
 478             if(!c->isfloating && (c->isfloating = (get_client_bywin(*awesomeconf->clients, trans) != NULL)))
 479                 arrange(&awesomeconf[c->screen]);
 480             break;
 481         case XA_WM_NORMAL_HINTS:
 482             updatesizehints(c);
 483             break;
 484         }
 485         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(c->display, "_NET_WM_NAME", False))
 486         {
 487             updatetitle(c);
 488             if(c == get_current_tag(awesomeconf->tags, awesomeconf->ntags)->client_sel)
 489                 drawstatusbar(&awesomeconf[c->screen]);
 490         }
 491     }
 492 }
 493
 494 void
 495 handle_event_unmapnotify(XEvent * e, awesome_config *awesomeconf)
 496 {
 497     Client *c;
 498     XUnmapEvent *ev = &e->xunmap;
 499
 500     if((c = get_client_bywin(*awesomeconf->clients, ev->window))
 501        && ev->event == RootWindow(e->xany.display, c->phys_screen)
 502        && ev->send_event && window_getstate(c->display, c->win) == NormalState)
 503         client_unmanage(c, WithdrawnState, &awesomeconf[c->screen]);
 504 }
 505
 506 void
 507 handle_event_shape(XEvent * e,
 508                    awesome_config *awesomeconf __attribute__ ((unused)))
 509 {
 510     XShapeEvent *ev = (XShapeEvent *) e;
 511     Client *c = get_client_bywin(*awesomeconf->clients, ev->window);
 512
 513     if(c)
 514         window_setshape(c->display, c->phys_screen, c->win);
 515 }
 516
 517 void
 518 handle_event_randr_screen_change_notify(XEvent *e,
 519                                         awesome_config *awesomeconf __attribute__ ((unused)))
 520 {
 521     XRRUpdateConfiguration(e);
 522 }
 523
 524 void
 525 grabkeys(awesome_config *awesomeconf)
 526 {
 527     int i;
 528     KeyCode code;
 529
 530     XUngrabKey(awesomeconf->display, AnyKey, AnyModifier, RootWindow(awesomeconf->display, awesomeconf->phys_screen));
 531     for(i = 0; i < awesomeconf->nkeys; i++)
 532     {
 533         if((code = XKeysymToKeycode(awesomeconf->display, awesomeconf->keys[i].keysym)) == NoSymbol)
 534             continue;
 535         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 536         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | LockMask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 537         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True, GrabModeAsync, GrabModeAsync);
 538         XGrabKey(awesomeconf->display, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask | LockMask, RootWindow(awesomeconf->display, awesomeconf->phys_screen), True,
 539                  GrabModeAsync, GrabModeAsync);
 540     }
 541 }
 542 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99