ioncore/conf.c

   1 /*
   2  * ion/ioncore/conf.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2007.
   5  *
   6  * Ion is free software; you can redistribute it and/or modify it under
   7  * the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include <libtu/map.h>
  16 #include <libtu/minmax.h>
  17 #include <libtu/objp.h>
  18 #include <libtu/map.h>
  19 #include <libextl/readconfig.h>
  20
  21 #include "common.h"
  22 #include "global.h"
  23 #include "modules.h"
  24 #include "rootwin.h"
  25 #include "bindmaps.h"
  26 #include "kbresize.h"
  27 #include "reginfo.h"
  28 #include "group-ws.h"
  29 #include "llist.h"
  30
  31
  32 StringIntMap frame_idxs[]={
  33     {"last", LLIST_INDEX_LAST},
  34     {"next",  LLIST_INDEX_AFTER_CURRENT},
  35     {"next-act",  LLIST_INDEX_AFTER_CURRENT_ACT},
  36     END_STRINGINTMAP
  37 };
  38
  39 static bool get_winprop_fn_set=FALSE;
  40 static ExtlFn get_winprop_fn;
  41
  42 static bool get_layout_fn_set=FALSE;
  43 static ExtlFn get_layout_fn;
  44
  45
  46 /*EXTL_DOC
  47  * Set ioncore basic settings. The table \var{tab} may contain the
  48  * following fields.
  49  *
  50  * \begin{tabularx}{\linewidth}{lX}
  51  *  \tabhead{Field & Description}
  52  *  \var{opaque_resize} & (boolean) Controls whether interactive move and
  53  *                        resize operations simply draw a rubberband during
  54  *                        the operation (false) or immediately affect the
  55  *                        object in question at every step (true). \\
  56  *  \var{warp} &          (boolean) Should focusing operations move the
  57  *                        pointer to the object to be focused? \\
  58  *  \var{switchto} &      (boolean) Should a managing \type{WMPlex} switch
  59  *                        to a newly mapped client window? \\
  60  *  \var{screen_notify} & (boolean) Should notification tooltips be displayed
  61  *                        for hidden workspaces with activity? \\
  62  *  \var{frame_default_index} & (string) Specifies where to add new regions
  63  *                        on the mutually exclusive list of a frame. One of
  64  *                        ''last'', ''next'' (for after current), ''next-act''
  65  *                        (for after current and anything with activity right
  66  *                        after it). \\
  67  *  \var{dblclick_delay} & (integer) Delay between clicks of a double click.\\
  68  *  \var{kbresize_delay} & (integer) Delay in milliseconds for ending keyboard
  69  *                         resize mode after inactivity. \\
  70  *  \var{kbresize_t_max} & (integer) Controls keyboard resize acceleration.
  71  *                         See description below for details. \\
  72  *  \var{kbresize_t_min} & (integer) See below. \\
  73  *  \var{kbresize_step} & (floating point) See below. \\
  74  *  \var{kbresize_maxacc} & (floating point) See below. \\
  75  *  \var{framed_transients} & (boolean) Put transients in nested frames. \\
  76  *  \var{float_placement_method} & (string) How to place floating frames.
  77  *                          One of ''udlr'' (up-down, then left-right),
  78  *                          ''lrud'' (left-right, then up-down) or ''random''. \\
  79  *  \var{mousefocus} & String: ''disable'' or ''sloppy''. \\
  80  *  \var{unsqueeze} & (boolean) Auto-unsqueeze transients/menus/queries/etc. \\
  81  *  \var{autoraise} & (boolean) Autoraise regions in groups on goto. \\
  82  * \end{tabularx}
  83  *
  84  * When a keyboard resize function is called, and at most \var{kbresize_t_max}
  85  * milliseconds has passed from a previous call, acceleration factor is reset
  86  * to 1.0. Otherwise, if at least \var{kbresize_t_min} milliseconds have
  87  * passed from the from previous acceleration update or reset the squere root
  88  * of the acceleration factor is incremented by \var{kbresize_step}. The
  89  * maximum acceleration factor (pixels/call modulo size hints) is given by
  90  * \var{kbresize_maxacc}. The default values are (200, 50, 30, 100).
  91  */
  92 EXTL_EXPORT
  93 void ioncore_set(ExtlTab tab)
  94 {
  95     int dd, rd;
  96     char *wst, *tmp;
  97     ExtlTab t;
  98     ExtlFn fn;
  99
 100     extl_table_gets_b(tab, "opaque_resize", &(ioncore_g.opaque_resize));
 101     extl_table_gets_b(tab, "warp", &(ioncore_g.warp_enabled));
 102     extl_table_gets_b(tab, "switchto", &(ioncore_g.switchto_new));
 103     extl_table_gets_b(tab, "screen_notify", &(ioncore_g.screen_notify));
 104     extl_table_gets_b(tab, "framed_transients", &(ioncore_g.framed_transients));
 105     extl_table_gets_b(tab, "unsqueeze", &(ioncore_g.unsqueeze_enabled));
 106     extl_table_gets_b(tab, "autoraise", &(ioncore_g.autoraise));
 107
 108     if(extl_table_gets_s(tab, "frame_default_index", &tmp)){
 109         ioncore_g.frame_default_index=stringintmap_value(frame_idxs,
 110                                                          tmp,
 111                                                          ioncore_g.frame_default_index);
 112         free(tmp);
 113     }
 114
 115     if(extl_table_gets_s(tab, "mousefocus", &tmp)){
 116         if(strcmp(tmp, "disabled")==0)
 117             ioncore_g.no_mousefocus=TRUE;
 118         else if(strcmp(tmp, "sloppy")==0)
 119             ioncore_g.no_mousefocus=FALSE;
 120     }
 121
 122     if(extl_table_gets_i(tab, "dblclick_delay", &dd))
 123         ioncore_g.dblclick_delay=maxof(0, dd);
 124
 125     ioncore_set_moveres_accel(tab);
 126
 127     ioncore_groupws_set(tab);
 128
 129     /* Internal -- therefore undocumented above */
 130     if(extl_table_gets_f(tab, "_get_winprop", &fn)){
 131         if(get_winprop_fn_set)
 132             extl_unref_fn(get_winprop_fn);
 133         get_winprop_fn=fn;
 134         get_winprop_fn_set=TRUE;
 135     }
 136
 137     if(extl_table_gets_f(tab, "_get_layout", &fn)){
 138         if(get_layout_fn_set)
 139             extl_unref_fn(get_layout_fn);
 140         get_layout_fn=fn;
 141         get_layout_fn_set=TRUE;
 142     }
 143
 144 }
 145
 146
 147 /*EXTL_DOC
 148  * Get ioncore basic settings. For details see \fnref{ioncore.set}.
 149  */
 150 EXTL_SAFE
 151 EXTL_EXPORT
 152 ExtlTab ioncore_get()
 153 {
 154     ExtlTab tab=extl_create_table();
 155
 156     extl_table_sets_b(tab, "opaque_resize", ioncore_g.opaque_resize);
 157     extl_table_sets_b(tab, "warp", ioncore_g.warp_enabled);
 158     extl_table_sets_b(tab, "switchto", ioncore_g.switchto_new);
 159     extl_table_sets_i(tab, "dblclick_delay", ioncore_g.dblclick_delay);
 160     extl_table_sets_b(tab, "screen_notify", ioncore_g.screen_notify);
 161     extl_table_sets_b(tab, "framed_transients", ioncore_g.framed_transients);
 162     extl_table_sets_b(tab, "unsqueeze", ioncore_g.unsqueeze_enabled);
 163     extl_table_sets_b(tab, "autoraise", ioncore_g.autoraise);
 164
 165
 166     extl_table_sets_s(tab, "frame_default_index",
 167                       stringintmap_key(frame_idxs,
 168                                        ioncore_g.frame_default_index,
 169                                        NULL));
 170
 171     extl_table_sets_s(tab, "mousefocus", (ioncore_g.no_mousefocus
 172                                           ? "disabled"
 173                                           : "sloppy"));
 174
 175     ioncore_get_moveres_accel(tab);
 176
 177     ioncore_groupws_get(tab);
 178
 179     return tab;
 180 }
 181
 182
 183 ExtlTab ioncore_get_winprop(WClientWin *cwin)
 184 {
 185     ExtlTab tab=extl_table_none();
 186
 187     if(get_winprop_fn_set){
 188         extl_protect(NULL);
 189         extl_call(get_winprop_fn, "o", "t", cwin, &tab);
 190         extl_unprotect(NULL);
 191     }
 192
 193     return tab;
 194 }
 195
 196
 197 ExtlTab ioncore_get_layout(const char *layout)
 198 {
 199     ExtlTab tab=extl_table_none();
 200
 201     if(get_layout_fn_set){
 202         extl_protect(NULL);
 203         extl_call(get_layout_fn, "s", "t", layout, &tab);
 204         extl_unprotect(NULL);
 205     }
 206
 207     return tab;
 208 }
 209
 210
 211 /*EXTL_DOC
 212  * Get important directories (userdir, sessiondir, searchpath).
 213  */
 214 EXTL_SAFE
 215 EXTL_EXPORT
 216 ExtlTab ioncore_get_paths(ExtlTab tab)
 217 {
 218     tab=extl_create_table();
 219     extl_table_sets_s(tab, "userdir", extl_userdir());
 220     extl_table_sets_s(tab, "sessiondir", extl_sessiondir());
 221     extl_table_sets_s(tab, "searchpath", extl_searchpath());
 222     return tab;
 223 }
 224
 225
 226 /*EXTL_DOC
 227  * Set important directories (sessiondir, searchpath).
 228  */
 229 EXTL_EXPORT
 230 bool ioncore_set_paths(ExtlTab tab)
 231 {
 232     char *s;
 233
 234     if(extl_table_gets_s(tab, "userdir", &s)){
 235         warn(TR("User directory can not be set."));
 236         free(s);
 237         return FALSE;
 238     }
 239
 240     if(extl_table_gets_s(tab, "sessiondir", &s)){
 241         extl_set_sessiondir(s);
 242         free(s);
 243         return FALSE;
 244     }
 245
 246     if(extl_table_gets_s(tab, "searchpath", &s)){
 247         extl_set_searchpath(s);
 248         free(s);
 249         return FALSE;
 250     }
 251
 252     return TRUE;
 253 }
 254
 255
 256 /* Exports these in ioncore. */
 257
 258 /*EXTL_DOC
 259  * Lookup script \var{file}. If \var{try_in_dir} is set, it is tried
 260  * before the standard search path.
 261  */
 262 EXTL_SAFE
 263 EXTL_EXPORT_AS(ioncore, lookup_script)
 264 char *extl_lookup_script(const char *file, const char *sp);
 265
 266
 267 /*EXTL_DOC
 268  * Get a file name to save (session) data in. The string \var{basename}
 269  * should contain no path or extension components.
 270  */
 271 EXTL_SAFE
 272 EXTL_EXPORT_AS(ioncore, get_savefile)
 273 char *extl_get_savefile(const char *basename);
 274
 275
 276 /*EXTL_DOC
 277  * Write \var{tab} in file with basename \var{basename} in the
 278  * session directory.
 279  */
 280 EXTL_SAFE
 281 EXTL_EXPORT_AS(ioncore, write_savefile)
 282 bool extl_write_savefile(const char *basename, ExtlTab tab);
 283
 284
 285 /*EXTL_DOC
 286  * Read a savefile.
 287  */
 288 EXTL_SAFE
 289 EXTL_EXPORT_AS(ioncore, read_savefile)
 290 ExtlTab extl_extl_read_savefile(const char *basename);
 291
 292
 293
 294 bool ioncore_read_main_config(const char *cfgfile)
 295 {
 296     bool ret;
 297     int unset=0;
 298
 299     if(cfgfile==NULL)
 300         cfgfile="cfg_ion";
 301
 302     ret=extl_read_config(cfgfile, ".", TRUE);
 303
 304     unset+=(ioncore_screen_bindmap->nbindings==0);
 305     unset+=(ioncore_mplex_bindmap->nbindings==0);
 306     unset+=(ioncore_frame_bindmap->nbindings==0);
 307
 308     if(unset>0){
 309         warn(TR("Some bindmaps were empty, loading ioncore_efbb."));
 310         extl_read_config("ioncore_efbb", NULL, TRUE);
 311     }
 312
 313     return (ret && unset==0);
 314 }