config.c

   1 /*
   2  * config.c - configuration management
   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
  23 /**
  24  * \defgroup ui_callback
  25  */
  26
  27 #include <libconfig.h>
  28 #include <X11/keysym.h>
  29
  30 #include "awesome.h"
  31 #include "layout.h"
  32 #include "tag.h"
  33 #include "draw.h"
  34 #include "util.h"
  35 #include "statusbar.h"
  36 #include "screen.h"
  37 #include "layouts/tile.h"
  38 #include "layouts/max.h"
  39 #include "layouts/floating.h"
  40
  41 static void initfont(Display *, DC *, const char *);
  42 static unsigned long initcolor(Display *, int, const char *);
  43 static unsigned int get_numlockmask(Display *);
  44
  45 /** Link a name to a function */
  46 typedef struct
  47 {
  48     const char *name;
  49     void *func;
  50 } NameFuncLink;
  51
  52 /** Link a name to a key symbol */
  53 typedef struct
  54 {
  55     const char *name;
  56     KeySym keysym;
  57 } KeyMod;
  58
  59 /** List of keyname and corresponding X11 mask codes */
  60 static const KeyMod KeyModList[] =
  61 {
  62     {"Shift", ShiftMask},
  63     {"Lock", LockMask},
  64     {"Control", ControlMask},
  65     {"Mod1", Mod1Mask},
  66     {"Mod2", Mod2Mask},
  67     {"Mod3", Mod3Mask},
  68     {"Mod4", Mod4Mask},
  69     {"Mod5", Mod5Mask},
  70     {"None", 0}
  71 };
  72
  73 /** List of available layouts and link between name and functions */
  74 static const NameFuncLink LayoutsList[] =
  75 {
  76     {"tile", layout_tile},
  77     {"tileleft", layout_tileleft},
  78     {"max", layout_max},
  79     {"floating", layout_floating},
  80     {NULL, NULL}
  81 };
  82
  83 /** List of available UI bindable callbacks and functions */
  84 static const NameFuncLink KeyfuncList[] = {
  85     /* util.c */
  86     {"spawn", uicb_spawn},
  87     {"exec", uicb_exec},
  88     /* client.c */
  89     {"killclient", uicb_killclient},
  90     {"moveresize", uicb_moveresize},
  91     {"settrans", uicb_settrans},
  92     {"setborder", uicb_setborder},
  93     {"swapnext", uicb_swapnext},
  94     {"swapprev", uicb_swapprev},
  95     /* tag.c */
  96     {"tag", uicb_tag},
  97     {"togglefloating", uicb_togglefloating},
  98     {"toggleview", uicb_toggleview},
  99     {"toggletag", uicb_toggletag},
 100     {"view", uicb_view},
 101     {"view_tag_prev_selected", uicb_tag_prev_selected},
 102     {"view_tag_previous", uicb_tag_viewprev},
 103     {"view_tag_next", uicb_tag_viewnext},
 104     /* layout.c */
 105     {"setlayout", uicb_setlayout},
 106     {"focusnext", uicb_focusnext},
 107     {"focusprev", uicb_focusprev},
 108     {"togglemax", uicb_togglemax},
 109     {"toggleverticalmax", uicb_toggleverticalmax},
 110     {"togglehorizontalmax", uicb_togglehorizontalmax},
 111     {"zoom", uicb_zoom},
 112     /* layouts/tile.c */
 113     {"setmwfact", uicb_setmwfact},
 114     {"setnmaster", uicb_setnmaster},
 115     {"setncols", uicb_setncols},
 116     /* screen.c */
 117     {"focusnextscreen", uicb_focusnextscreen},
 118     {"focusprevscreen", uicb_focusprevscreen},
 119     {"movetoscreen", uicb_movetoscreen},
 120     /* awesome.c */
 121     {"quit", uicb_quit},
 122     /* statusbar.c */
 123     {"togglebar", uicb_togglebar},
 124     {NULL, NULL}
 125 };
 126
 127 /** Lookup for a key mask from its name
 128  * \param keyname Key name
 129  * \return Key mask or 0 if not found
 130  */
 131 static KeySym
 132 key_mask_lookup(const char *keyname)
 133 {
 134     int i;
 135
 136     if(keyname)
 137         for(i = 0; KeyModList[i].name; i++)
 138             if(!a_strcmp(keyname, KeyModList[i].name))
 139                 return KeyModList[i].keysym;
 140
 141     return 0;
 142 }
 143
 144 /** Lookup for a function pointer from its name
 145  * in the given NameFuncLink list
 146  * \param funcname Function name
 147  * \param list Function and name link list
 148  * \return function pointer
 149  */
 150 static void *
 151 name_func_lookup(const char *funcname, const NameFuncLink * list)
 152 {
 153     int i;
 154
 155     if(funcname && list)
 156         for(i = 0; list[i].name; i++)
 157             if(!a_strcmp(funcname, list[i].name))
 158                 return list[i].func;
 159
 160     return NULL;
 161 }
 162
 163 /** Parse configuration file and initialize some stuff
 164  * \param disp Display ref
 165  * \param scr Screen number
 166  * \param drawcontext Draw context
 167  */
 168 void
 169 parse_config(Display * disp, int scr, DC * drawcontext, const char *confpatharg, awesome_config *awesomeconf)
 170 {
 171     /* Main configuration object for parsing*/
 172     config_t awesomelibconf;
 173     config_setting_t *conftags;
 174     config_setting_t *conflayouts, *confsublayouts;
 175     config_setting_t *confrules, *confsubrules;
 176     config_setting_t *confkeys, *confsubkeys, *confkeysmasks, *confkeymaskelem;
 177     int i = 0, j = 0;
 178     double f = 0.0;
 179     const char *tmp, *homedir;
 180     char *confpath;
 181     KeySym tmp_key;
 182     ssize_t confpath_len;
 183
 184     if(confpatharg)
 185         confpath = a_strdup(confpatharg);
 186     else
 187     {
 188         homedir = getenv("HOME");
 189         confpath_len = a_strlen(homedir) + a_strlen(AWESOME_CONFIG_FILE) + 2;
 190         confpath = p_new(char, confpath_len);
 191         a_strcpy(confpath, confpath_len, homedir);
 192         a_strcat(confpath, confpath_len, "/");
 193         a_strcat(confpath, confpath_len, AWESOME_CONFIG_FILE);
 194     }
 195
 196     config_init(&awesomelibconf);
 197
 198     a_strcpy(awesomeconf->statustext, sizeof(awesomeconf->statustext), "awesome-" VERSION);
 199
 200     /* set screen */
 201     awesomeconf->screen = scr;
 202     awesomeconf->phys_screen = get_phys_screen(disp, scr);
 203
 204     if(config_read_file(&awesomelibconf, confpath) == CONFIG_FALSE)
 205         fprintf(stderr, "awesome: error parsing configuration file at line %d: %s\n",
 206                config_error_line(&awesomelibconf), config_error_text(&awesomelibconf));
 207
 208
 209     /* font */
 210     tmp = config_lookup_string(&awesomelibconf, "awesome.font");
 211     initfont(disp, drawcontext, tmp ? tmp : "-*-fixed-medium-r-normal-*-13-*-*-*-*-*-*-*");
 212
 213     /* layouts */
 214     conflayouts = config_lookup(&awesomelibconf, "awesome.layouts");
 215
 216     if(!conflayouts)
 217     {
 218         fprintf(stderr, "awesome: layouts not found in configuration file, setting default\n");
 219         awesomeconf->nlayouts = 2;
 220         awesomeconf->layouts = p_new(Layout, awesomeconf->nlayouts + 1);
 221         awesomeconf->layouts[0].symbol = a_strdup("[]=");
 222         awesomeconf->layouts[0].arrange = layout_tile;
 223         awesomeconf->layouts[1].symbol = a_strdup("<><");
 224         awesomeconf->layouts[1].arrange = layout_floating;
 225         awesomeconf->layouts[2].symbol = NULL;
 226         awesomeconf->layouts[2].arrange = NULL;
 227     }
 228     else
 229     {
 230         awesomeconf->nlayouts = config_setting_length(conflayouts);
 231         awesomeconf->layouts = p_new(Layout, awesomeconf->nlayouts + 1);
 232         for(i = 0; (confsublayouts = config_setting_get_elem(conflayouts, i)); i++)
 233         {
 234             awesomeconf->layouts[i].arrange =
 235                 name_func_lookup(config_setting_get_string_elem(confsublayouts, 1), LayoutsList);
 236             if(!awesomeconf->layouts[i].arrange)
 237             {
 238                 fprintf(stderr, "awesome: unknown layout #%d in configuration file\n", i);
 239                 awesomeconf->layouts[i].symbol = NULL;
 240                 continue;
 241             }
 242             awesomeconf->layouts[i].symbol = a_strdup(config_setting_get_string_elem(confsublayouts, 0));
 243         }
 244         awesomeconf->layouts[i].symbol = NULL;
 245         awesomeconf->layouts[i].arrange = NULL;
 246     }
 247
 248     if(!awesomeconf->nlayouts)
 249         eprint("awesome: fatal: no default layout available\n");
 250
 251     for(i = 0; i < awesomeconf->nlayouts; i++)
 252     {
 253         j = textw(drawcontext->font.set, drawcontext->font.xfont, awesomeconf->layouts[i].symbol, drawcontext->font.height);
 254         if(j > awesomeconf->statusbar.width)
 255             awesomeconf->statusbar.width = j;
 256     }
 257
 258     awesomeconf->current_layout = awesomeconf->layouts;
 259
 260     /* tags */
 261     conftags = config_lookup(&awesomelibconf, "awesome.tags");
 262
 263     if(!conftags)
 264     {
 265         fprintf(stderr, "awesome: tags not found in configuration file, setting default\n");
 266         awesomeconf->ntags = 3;
 267         awesomeconf->tags = p_new(Tag, awesomeconf->ntags);
 268         awesomeconf->tags[0].name = a_strdup("this");
 269         awesomeconf->tags[1].name = a_strdup("is");
 270         awesomeconf->tags[2].name = a_strdup("awesome");
 271         awesomeconf->tags[0].selected = True;
 272         awesomeconf->tags[1].selected = False;
 273         awesomeconf->tags[2].selected = False;
 274         awesomeconf->tags[0].was_selected = False;
 275         awesomeconf->tags[1].was_selected = False;
 276         awesomeconf->tags[2].was_selected = False;
 277         awesomeconf->tags[0].layout = awesomeconf->layouts;
 278         awesomeconf->tags[1].layout = awesomeconf->layouts;
 279         awesomeconf->tags[2].layout = awesomeconf->layouts;
 280     }
 281     else
 282     {
 283         awesomeconf->ntags = config_setting_length(conftags);
 284         awesomeconf->tags = p_new(Tag, awesomeconf->ntags);
 285
 286         for(i = 0; (tmp = config_setting_get_string_elem(conftags, i)); i++)
 287         {
 288             awesomeconf->tags[i].name = a_strdup(tmp);
 289             awesomeconf->tags[i].selected = False;
 290             awesomeconf->tags[i].was_selected = False;
 291             /** \todo add support for default tag/layout in configuration file */
 292             awesomeconf->tags[i].layout = awesomeconf->layouts;
 293         }
 294     }
 295
 296     if(!awesomeconf->ntags)
 297         eprint("awesome: fatal: no tags found in configuration file\n");
 298
 299     /* select first tag by default */
 300     awesomeconf->tags[0].selected = True;
 301     awesomeconf->tags[0].was_selected = True;
 302
 303     /* rules */
 304     confrules = config_lookup(&awesomelibconf, "awesome.rules");
 305
 306     if(!confrules)
 307     {
 308         awesomeconf->nrules = 0;
 309         fprintf(stderr, "awesome: no rules found in configuration file\n");
 310     }
 311     else
 312     {
 313         awesomeconf->nrules = config_setting_length(confrules);
 314         awesomeconf->rules = p_new(Rule, awesomeconf->nrules);
 315         for(i = 0; (confsubrules = config_setting_get_elem(confrules, i)); i++)
 316         {
 317             awesomeconf->rules[i].prop = a_strdup(config_setting_get_string(config_setting_get_member(confsubrules, "name")));
 318             awesomeconf->rules[i].tags = a_strdup(config_setting_get_string(config_setting_get_member(confsubrules, "tags")));
 319             if(awesomeconf->rules[i].tags && !a_strlen(awesomeconf->rules[i].tags))
 320                 awesomeconf->rules[i].tags = NULL;
 321             awesomeconf->rules[i].isfloating =
 322                 config_setting_get_bool(config_setting_get_member(confsubrules, "float"));
 323         }
 324     }
 325
 326     /* modkey */
 327     tmp_key = key_mask_lookup(config_lookup_string(&awesomelibconf, "awesome.modkey"));
 328     awesomeconf->modkey = tmp_key ? tmp_key : Mod1Mask;
 329
 330     /* find numlock mask */
 331     awesomeconf->numlockmask = get_numlockmask(disp);
 332
 333     /* keys */
 334     confkeys = config_lookup(&awesomelibconf, "awesome.keys");
 335
 336     if(!confkeys)
 337     {
 338         awesomeconf->nkeys = 0;
 339         fprintf(stderr, "awesome: no keys found in configuration file\n");
 340     }
 341     else
 342     {
 343         awesomeconf->nkeys = config_setting_length(confkeys);
 344         awesomeconf->keys = p_new(Key, awesomeconf->nkeys);
 345
 346         for(i = 0; (confsubkeys = config_setting_get_elem(confkeys, i)); i++)
 347         {
 348             confkeysmasks = config_setting_get_elem(confsubkeys, 0);
 349             for(j = 0; (confkeymaskelem = config_setting_get_elem(confkeysmasks, j)); j++)
 350                 awesomeconf->keys[i].mod |= key_mask_lookup(config_setting_get_string(confkeymaskelem));
 351             awesomeconf->keys[i].keysym = XStringToKeysym(config_setting_get_string_elem(confsubkeys, 1));
 352             awesomeconf->keys[i].func =
 353                 name_func_lookup(config_setting_get_string_elem(confsubkeys, 2), KeyfuncList);
 354             awesomeconf->keys[i].arg = a_strdup(config_setting_get_string_elem(confsubkeys, 3));
 355         }
 356     }
 357
 358     /* barpos */
 359     tmp = config_lookup_string(&awesomelibconf, "awesome.barpos");
 360
 361     if(tmp && !a_strncmp(tmp, "off", 6))
 362         awesomeconf->statusbar_default_position = BarOff;
 363     else if(tmp && !a_strncmp(tmp, "bottom", 6))
 364         awesomeconf->statusbar_default_position = BarBot;
 365     else
 366         awesomeconf->statusbar_default_position = BarTop;
 367
 368     awesomeconf->statusbar.position = awesomeconf->statusbar_default_position;
 369
 370     /* borderpx */
 371     awesomeconf->borderpx = config_lookup_int(&awesomelibconf, "awesome.borderpx");
 372
 373     /* opacity */
 374     awesomeconf->opacity_unfocused = config_lookup_int(&awesomelibconf, "awesome.opacity_unfocused");
 375     if(awesomeconf->opacity_unfocused >= 100 || awesomeconf->opacity_unfocused == 0)
 376         awesomeconf->opacity_unfocused = -1;
 377
 378     /* snap */
 379     i = config_lookup_int(&awesomelibconf, "awesome.snap");
 380     awesomeconf->snap = i ? i : 8;
 381
 382     /* nmaster */
 383     i = config_lookup_int(&awesomelibconf, "awesome.nmaster");
 384     awesomeconf->nmaster = i ? i : 1;
 385
 386     /* ncols */
 387     i = config_lookup_int(&awesomelibconf, "awesome.ncols");
 388     awesomeconf->ncols = i ? i : 1;
 389
 390     /* mwfact */
 391     f = config_lookup_float(&awesomelibconf, "awesome.mwfact");
 392     awesomeconf->mwfact = f ? f : 0.6;
 393
 394     /* resize_hints */
 395     awesomeconf->resize_hints = config_lookup_float(&awesomelibconf, "awesome.resize_hints");
 396
 397     /* colors */
 398     tmp = config_lookup_string(&awesomelibconf, "awesome.normal_border_color");
 399     drawcontext->norm[ColBorder] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#dddddd");
 400
 401     tmp = config_lookup_string(&awesomelibconf, "awesome.normal_bg_color");
 402     drawcontext->norm[ColBG] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#000000");
 403
 404     tmp = config_lookup_string(&awesomelibconf, "awesome.normal_fg_color");
 405     drawcontext->norm[ColFG] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#ffffff");
 406
 407     tmp = config_lookup_string(&awesomelibconf, "awesome.focus_border_color");
 408     drawcontext->sel[ColBorder] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#008b8b");
 409
 410     tmp = config_lookup_string(&awesomelibconf, "awesome.focus_bg_color");
 411     drawcontext->sel[ColBG] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#008b8b");
 412
 413     tmp = config_lookup_string(&awesomelibconf, "awesome.focus_fg_color");
 414     drawcontext->sel[ColFG] = initcolor(disp, awesomeconf->phys_screen, tmp ? tmp : "#ffffff");
 415
 416     config_destroy(&awesomelibconf);
 417     p_delete(&confpath);
 418 }
 419
 420 /** Initialize font from X side and store in draw context
 421  * \param fontstr Font name
 422  * \param disp Display ref
 423  * \param drawcontext Draw context
 424  */
 425 static void
 426 initfont(Display *disp, DC *drawcontext, const char *fontstr)
 427 {
 428     char *def, **missing;
 429     int i, n;
 430
 431     missing = NULL;
 432     if(drawcontext->font.set)
 433         XFreeFontSet(disp, drawcontext->font.set);
 434     drawcontext->font.set = XCreateFontSet(disp, fontstr, &missing, &n, &def);
 435     if(missing)
 436     {
 437         while(n--)
 438             fprintf(stderr, "awesome: missing fontset: %s\n", missing[n]);
 439         XFreeStringList(missing);
 440     }
 441     if(drawcontext->font.set)
 442     {
 443         XFontSetExtents *font_extents;
 444         XFontStruct **xfonts;
 445         char **font_names;
 446         drawcontext->font.ascent = drawcontext->font.descent = 0;
 447         font_extents = XExtentsOfFontSet(drawcontext->font.set);
 448         n = XFontsOfFontSet(drawcontext->font.set, &xfonts, &font_names);
 449         for(i = 0, drawcontext->font.ascent = 0, drawcontext->font.descent = 0; i < n; i++)
 450         {
 451             if(drawcontext->font.ascent < (*xfonts)->ascent)
 452                 drawcontext->font.ascent = (*xfonts)->ascent;
 453             if(drawcontext->font.descent < (*xfonts)->descent)
 454                 drawcontext->font.descent = (*xfonts)->descent;
 455             xfonts++;
 456         }
 457     }
 458     else
 459     {
 460         if(drawcontext->font.xfont)
 461             XFreeFont(disp, drawcontext->font.xfont);
 462         drawcontext->font.xfont = NULL;
 463         if(!(drawcontext->font.xfont = XLoadQueryFont(disp, fontstr))
 464            && !(drawcontext->font.xfont = XLoadQueryFont(disp, "fixed")))
 465             die("awesome: error, cannot load font: '%s'\n", fontstr);
 466         drawcontext->font.ascent = drawcontext->font.xfont->ascent;
 467         drawcontext->font.descent = drawcontext->font.xfont->descent;
 468     }
 469     drawcontext->font.height = drawcontext->font.ascent + drawcontext->font.descent;
 470 }
 471
 472 static unsigned int
 473 get_numlockmask(Display *disp)
 474 {
 475     XModifierKeymap *modmap;
 476     unsigned int mask = 0;
 477     int i, j;
 478
 479     modmap = XGetModifierMapping(disp);
 480     for(i = 0; i < 8; i++)
 481         for(j = 0; j < modmap->max_keypermod; j++)
 482         {
 483             if(modmap->modifiermap[i * modmap->max_keypermod + j]
 484                == XKeysymToKeycode(disp, XK_Num_Lock))
 485                 mask = (1 << i);
 486         }
 487
 488     XFreeModifiermap(modmap);
 489
 490     return mask;
 491 }
 492
 493 /** Initialize color from X side
 494  * \param colorstr Color code
 495  * \param disp Display ref
 496  * \param scr Screen number
 497  * \return XColor pixel
 498  */
 499 static unsigned long
 500 initcolor(Display *disp, int scr, const char *colstr)
 501 {
 502     Colormap cmap = DefaultColormap(disp, scr);
 503     XColor color;
 504     if(!XAllocNamedColor(disp, cmap, colstr, &color, &color))
 505         die("awesome: error, cannot allocate color '%s'\n", colstr);
 506     return color.pixel;
 507 }