source: variable.c @ 3756803

Last change on this file since 3756803 was 3756803, checked in by Anders Kaseorg <andersk@mit.edu>, 10 years ago
variables_to_init: Move into new function owl_variable_add_defaults Signed-off-by: Anders Kaseorg <andersk@mit.edu>
  • Property mode set to 100644
File size: 42.2 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4#include <unistd.h>
5#include <ctype.h>
6#include "owl.h"
7
8#define OWLVAR_BOOL(name,default,summary,description) \
9        { name, OWL_VARIABLE_BOOL, NULL, default, "on,off", summary,description, NULL, \
10        NULL, NULL, NULL, NULL, NULL, NULL }
11
12#define OWLVAR_BOOL_FULL(name,default,summary,description,validate,set,get) \
13        { name, OWL_VARIABLE_BOOL, NULL, default, "on,off", summary,description, NULL, \
14        validate, set, NULL, get, NULL, NULL }
15
16#define OWLVAR_INT(name,default,summary,description) \
17        { name, OWL_VARIABLE_INT, NULL, default, "<int>", summary,description, NULL, \
18        NULL, NULL, NULL, NULL, NULL, NULL }
19
20#define OWLVAR_INT_FULL(name,default,summary,description,validset,validate,set,get) \
21        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
22        validate, set, NULL, get, NULL, NULL }
23
24#define OWLVAR_PATH(name,default,summary,description) \
25        { name, OWL_VARIABLE_STRING, default, 0, "<path>", summary,description,  NULL, \
26        NULL, NULL, NULL, NULL, NULL, NULL }
27
28#define OWLVAR_STRING(name,default,summary,description) \
29        { name, OWL_VARIABLE_STRING, default, 0, "<string>", summary,description, NULL, \
30        NULL, NULL, NULL, NULL, NULL, NULL }
31
32#define OWLVAR_STRING_FULL(name,default,validset,summary,description,validate,set,get) \
33        { name, OWL_VARIABLE_STRING, default, 0, validset, summary,description, NULL, \
34        validate, set, NULL, get, NULL, NULL }
35
36/* enums are really integers, but where validset is a comma-separated
37 * list of strings which can be specified.  The tokens, starting at 0,
38 * correspond to the values that may be specified. */
39#define OWLVAR_ENUM(name,default,summary,description,validset) \
40        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
41        owl_variable_enum_validate, \
42        NULL, owl_variable_enum_set_fromstring, \
43        NULL, owl_variable_enum_get_tostring, \
44        NULL }
45
46#define OWLVAR_ENUM_FULL(name,default,summary,description,validset,validate, set, get) \
47        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
48        validate, \
49        set, owl_variable_enum_set_fromstring, \
50        get, owl_variable_enum_get_tostring, \
51        NULL }
52
53int owl_variable_add_defaults(owl_vardict *vd)
54{
55  owl_variable variables_to_init[] = {
56
57  OWLVAR_STRING( "personalbell" /* %OwlVarStub */, "off",
58                 "ring the terminal bell when personal messages are received",
59                 "Can be set to 'on', 'off', or the name of a filter which\n"
60                 "messages need to match in order to ring the bell"),
61
62  OWLVAR_BOOL( "bell" /* %OwlVarStub */, 1,
63               "enable / disable the terminal bell", "" ),
64
65  OWLVAR_BOOL_FULL( "debug" /* %OwlVarStub */, OWL_DEBUG,
66                    "whether debugging is enabled",
67                    "If set to 'on', debugging messages are logged to the\n"
68                    "file specified by the debugfile variable.\n",
69                    NULL, owl_variable_debug_set, NULL),
70
71  OWLVAR_BOOL( "startuplogin" /* %OwlVarStub */, 1,
72               "send a login message when owl starts", "" ),
73
74  OWLVAR_BOOL( "shutdownlogout" /* %OwlVarStub */, 1,
75               "send a logout message when owl exits", "" ),
76
77  OWLVAR_BOOL( "rxping" /* %OwlVarStub */, 0,
78               "display received pings", "" ),
79
80  OWLVAR_BOOL( "txping" /* %OwlVarStub */, 1,
81               "send pings", "" ),
82
83  OWLVAR_BOOL( "sepbar_disable" /* %OwlVarStub */, 0,
84               "disable printing information in the separator bar", "" ),
85
86  OWLVAR_BOOL( "smartstrip" /* %OwlVarStub */, 1,
87               "strip kerberos instance for reply", ""),
88
89  OWLVAR_BOOL( "newlinestrip" /* %OwlVarStub */, 1,
90               "strip leading and trailing newlines", ""),
91
92  OWLVAR_BOOL( "displayoutgoing" /* %OwlVarStub */, 1,
93               "display outgoing messages", "" ),
94
95  OWLVAR_BOOL( "loginsubs" /* %OwlVarStub */, 1,
96               "load logins from .anyone on startup", "" ),
97
98  OWLVAR_BOOL( "logging" /* %OwlVarStub */, 0,
99               "turn personal logging on or off", 
100               "If this is set to on, personal messages are\n"
101               "logged in the directory specified\n"
102               "by the 'logpath' variable.  The filename in that\n"
103               "directory is derived from the sender of the message.\n" ),
104
105  OWLVAR_BOOL( "classlogging" /* %OwlVarStub */, 0,
106               "turn class logging on or off",
107               "If this is set to on, class messages are\n"
108               "logged in the directory specified\n"
109               "by the 'classlogpath' variable.\n" 
110               "The filename in that directory is derived from\n"
111               "the name of the class to which the message was sent.\n" ),
112
113  OWLVAR_ENUM( "loggingdirection" /* %OwlVarStub */, OWL_LOGGING_DIRECTION_BOTH,
114               "specifies which kind of messages should be logged",
115               "Can be one of 'both', 'in', or 'out'.  If 'in' is\n"
116               "selected, only incoming messages are logged, if 'out'\n"
117               "is selected only outgoing messages are logged.  If 'both'\n"
118               "is selected both incoming and outgoing messages are\n"
119               "logged.",
120               "both,in,out"),
121
122  OWLVAR_BOOL( "colorztext" /* %OwlVarStub */, 1,
123               "allow @color() in zephyrs to change color",
124               "Note that only messages received after this variable\n"
125               "is set will be affected." ),
126
127  OWLVAR_BOOL( "fancylines" /* %OwlVarStub */, 1,
128               "Use 'nice' line drawing on the terminal.",
129               "If turned off, dashes, pipes and pluses will be used\n"
130               "to draw lines on the screen.  Useful when the terminal\n"
131               "is causing problems" ),
132
133  OWLVAR_BOOL( "zcrypt" /* %OwlVarStub */, 1,
134               "Do automatic zcrypt processing",
135               "" ),
136
137  OWLVAR_BOOL_FULL( "pseudologins" /* %OwlVarStub */, 0,
138                    "Enable zephyr pseudo logins",
139                    "When this is enabled, Owl will periodically check the zephyr\n"
140                    "location of users in your .anyone file.  If a user is present\n"
141                    "but sent no login message, or a user is not present that sent no\n"
142                    "logout message, a pseudo login or logout message will be created\n",
143                    NULL, owl_variable_pseudologins_set, NULL),
144
145  OWLVAR_BOOL( "ignorelogins" /* %OwlVarStub */, 0,
146               "Enable printing of login notifications",
147               "When this is enabled, Owl will print login and logout notifications\n"
148               "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
149               "login or logout notifications.\n"),
150
151  OWLVAR_STRING( "logfilter" /* %OwlVarStub */, "",
152                 "name of a filter controlling which messages to log",
153
154                 "If non empty, any messages matching the given filter will be logged.\n"
155                 "This is a completely separate mechanism from the other logging\n"
156                 "variables like logging, classlogging, loglogins, loggingdirection,\n"
157                 "etc.  If you want this variable to control all logging, make sure\n"
158                 "all other logging variables are in their default state.\n"),
159
160  OWLVAR_BOOL( "loglogins" /* %OwlVarStub */, 0,
161               "Enable logging of login notifications",
162               "When this is enabled, Owl will login login and logout notifications\n"
163               "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
164               "login or logout notifications.\n"),
165
166  OWLVAR_ENUM_FULL( "disable-ctrl-d" /* %OwlVarStub:lockout_ctrld */, 1,
167                    "don't send zephyrs on C-d",
168                    "If set to 'off', C-d won't send a zephyr from the edit\n"
169                    "window.  If set to 'on', C-d will always send a zephyr\n"
170                    "being composed in the edit window.  If set to 'middle',\n"
171                    "C-d will only ever send a zephyr if the cursor is at\n"
172                    "the end of the message being composed.\n\n"
173                    "Note that this works by changing the C-d keybinding\n"
174                    "in the editmulti keymap.\n",
175                    "off,middle,on",
176                    NULL, owl_variable_disable_ctrl_d_set, NULL),
177
178  OWLVAR_PATH( "logpath" /* %OwlVarStub */, "~/zlog/people",
179               "path for logging personal zephyrs", 
180               "Specifies a directory which must exist.\n"
181               "Files will be created in the directory for each sender.\n"),
182
183  OWLVAR_PATH( "classlogpath" /* %OwlVarStub:classlogpath */, "~/zlog/class",
184               "path for logging class zephyrs",
185               "Specifies a directory which must exist.\n"
186               "Files will be created in the directory for each class.\n"),
187
188  OWLVAR_PATH( "debug_file" /* %OwlVarStub */, OWL_DEBUG_FILE,
189               "path for logging debug messages when debugging is enabled",
190               "This file will be logged to if 'debug' is set to 'on'.\n"
191               "BarnOwl will append a dot and the current process's pid to the filename."),
192 
193  OWLVAR_PATH( "zsigproc" /* %OwlVarStub:zsigproc */, NULL,
194               "name of a program to run that will generate zsigs",
195               "This program should produce a zsig on stdout when run.\n"
196               "Note that it is important that this program not block.\n\n"
197               "See the documentation for 'zsig' for more information about\n"
198               "how the outgoing zsig is chosen."
199               ),
200
201  OWLVAR_PATH( "newmsgproc" /* %OwlVarStub:newmsgproc */, NULL,
202               "name of a program to run when new messages are present",
203               "The named program will be run when owl receives new\n"
204               "messages.  It will not be run again until the first\n"
205               "instance exits"),
206
207  OWLVAR_STRING( "zsender" /* %OwlVarStub */, "",
208             "zephyr sender name",
209         "Allows you to customize the outgoing username in\n"
210         "zephyrs.  If this is unset, it will use your Kerberos\n"
211         "principal. Note that customizing the sender name will\n"
212         "cause your zephyrs to be sent unauthenticated."),
213
214  OWLVAR_STRING( "zsigfunc" /* %OwlVarStub */, "BarnOwl::default_zephyr_signature()",
215                 "zsig perl function",
216                 "Called every time you start a zephyrgram without an\n"
217                 "explicit zsig.  The default setting implements the policy\n"
218                 "described in the documentation for the 'zsig' variable.\n"
219                 "See also BarnOwl::random_zephyr_signature().\n"),
220
221  OWLVAR_STRING( "zsig" /* %OwlVarStub */, "",
222                 "zephyr signature",
223                 "The zsig to get on outgoing messages. If this variable is\n"
224                 "unset, 'zsigproc' will be run to generate a zsig. If that is\n"
225                 "also unset, the 'zwrite-signature' zephyr variable will be\n"
226                 "used instead.\n"),
227
228  OWLVAR_STRING( "appendtosepbar" /* %OwlVarStub */, "",
229                 "string to append to the end of the sepbar",
230                 "The sepbar is the bar separating the top and bottom\n"
231                 "of the owl screen.  Any string specified here will\n"
232                 "be displayed on the right of the sepbar\n"),
233
234  OWLVAR_BOOL( "zaway" /* %OwlVarStub */, 0,
235               "turn zaway on or off", "" ),
236
237  OWLVAR_STRING( "zaway_msg" /* %OwlVarStub */, 
238                 OWL_DEFAULT_ZAWAYMSG,
239                 "zaway msg for responding to zephyrs when away", "" ),
240
241  OWLVAR_STRING( "zaway_msg_default" /* %OwlVarStub */, 
242                 OWL_DEFAULT_ZAWAYMSG,
243                 "default zaway message", "" ),
244
245  OWLVAR_BOOL_FULL( "aaway" /* %OwlVarStub */, 0,
246                    "Set AIM away status",
247                    "",
248                    NULL, owl_variable_aaway_set, NULL),
249
250  OWLVAR_STRING( "aaway_msg" /* %OwlVarStub */, 
251                 OWL_DEFAULT_AAWAYMSG,
252                 "AIM away msg for responding when away", "" ),
253
254  OWLVAR_STRING( "aaway_msg_default" /* %OwlVarStub */, 
255                 OWL_DEFAULT_AAWAYMSG,
256                 "default AIM away message", "" ),
257
258  OWLVAR_STRING( "view_home" /* %OwlVarStub */, "all",
259                 "home view to switch to after 'X' and 'V'", 
260                 "SEE ALSO: view, filter\n" ),
261
262  OWLVAR_STRING( "alert_filter" /* %OwlVarStub */, "none",
263                 "filter on which to trigger alert actions",
264                 "" ),
265
266  OWLVAR_STRING( "alert_action" /* %OwlVarStub */, "nop",
267                 "owl command to execute for alert actions",
268                 "" ),
269
270  OWLVAR_STRING_FULL( "tty" /* %OwlVarStub */, "", "<string>", "tty name for zephyr location", "",
271                      NULL, owl_variable_tty_set, NULL),
272
273  OWLVAR_STRING( "default_style" /* %OwlVarStub */, "default",
274                 "name of the default formatting style",
275                 "This sets the default message formatting style.\n"
276                 "Styles may be created with the 'style' command.\n"
277                 "Some built-in styles include:\n"
278                 "   default  - the default owl formatting\n"
279                 "   oneline  - one line per-message\n"
280                 "   perl     - legacy perl interface\n"
281                 "\nSEE ALSO: style, show styles, view -s <style>\n"
282                 ),
283
284
285  OWLVAR_INT(    "edit:maxfillcols" /* %OwlVarStub:edit_maxfillcols */, 70,
286                 "maximum number of columns for M-q (edit:fill-paragraph) to fill text to",
287                 "This specifies the maximum number of columns for M-q to fill text\n"
288                 "to.  If set to 0, M-q will wrap to the width of the window, and\n"
289                 "values less than 0 disable M-q entirely.\n"),
290
291  OWLVAR_INT(    "edit:maxwrapcols" /* %OwlVarStub:edit_maxwrapcols */, 70,
292                 "maximum number of columns for line-wrapping",
293                 "This specifies the maximum number of columns for\n"
294                 "auto-line-wrapping.  If set to 0, text will be wrapped at the\n"
295                 "window width. Values less than 0 disable automatic wrapping.\n"
296                 "\n"
297                 "As a courtesy to recipients, it is recommended that outgoing\n"
298                 "Zephyr messages be no wider than 70 columns.\n"),
299
300  OWLVAR_INT( "aim_ignorelogin_timer" /* %OwlVarStub */, 15,
301              "number of seconds after AIM login to ignore login messages",
302              "This specifies the number of seconds to wait after an\n"
303              "AIM login before allowing the receipt of AIM login notifications.\n"
304              "By default this is set to 15.  If you would like to view login\n"
305              "notifications of buddies as soon as you login, set it to 0 instead."),
306
307             
308  OWLVAR_INT_FULL( "typewinsize" /* %OwlVarStub:typwin_lines */, 
309                   OWL_TYPWIN_SIZE,
310                  "number of lines in the typing window", 
311                   "This specifies the height of the window at the\n"
312                   "bottom of the screen where commands are entered\n"
313                   "and where messages are composed.\n",
314                   "int > 0",
315                   owl_variable_int_validate_gt0,
316                   owl_variable_typewinsize_set,
317                   NULL /* use default for get */
318                   ),
319
320  OWLVAR_INT( "typewindelta" /* %OwlVarStub */, 0,
321                  "number of lines to add to the typing window when in use",
322                   "On small screens you may want the typing window to\n"
323                   "auto-hide when not entering a command or message.\n"
324                   "This variable is the number of lines to add to the\n"
325           "typing window when it is in use; you can then set\n"
326           "typewinsize to 1.\n\n"
327           "This works a lot better with a non-default scrollmode;\n"
328           "try :set scrollmode pagedcenter.\n"),
329
330  OWLVAR_ENUM( "scrollmode" /* %OwlVarStub */, OWL_SCROLLMODE_NORMAL,
331               "how to scroll up and down",
332               "This controls how the screen is scrolled as the\n"
333               "cursor moves between messages being displayed.\n"
334               "The following modes are supported:\n\n"
335               "   normal      - This is the owl default.  Scrolling happens\n"
336               "                 when it needs to, and an attempt is made to\n"
337               "                 keep the current message roughly near\n"
338               "                 the middle of the screen.\n"
339               "   top         - The current message will always be the\n"
340               "                 the top message displayed.\n"
341               "   neartop     - The current message will be one down\n"
342               "                 from the top message displayed,\n"
343               "                 where possible.\n"
344               "   center      - An attempt is made to keep the current\n"
345               "                 message near the center of the screen.\n"
346               "   paged       - The top message displayed only changes\n"
347               "                 when user moves the cursor to the top\n"
348               "                 or bottom of the screen.  When it moves,\n"
349               "                 the screen will be paged up or down and\n"
350               "                 the cursor will be near the top or\n"
351               "                 the bottom.\n"
352               "   pagedcenter - The top message displayed only changes\n"
353               "                 when user moves the cursor to the top\n"
354               "                 or bottom of the screen.  When it moves,\n"
355               "                 the screen will be paged up or down and\n"
356               "                 the cursor will be near the center.\n",
357               "normal,top,neartop,center,paged,pagedcenter" ),
358
359  OWLVAR_BOOL( "narrow-related" /* %OwlVarStub:narrow_related */, 1,
360               "Make smartnarrow use broader filters",
361               "Causes smartfiler to narrow to messages \"related\" to \n"
362               "the current message, as well as ones to the same place.\n\n"
363               "for Zephyr, this controls whether to narrow to e.g. class-help or\n"
364               "class-help.d alone, or to related-class-help, which includes\n"
365               "help, unhelp, help.d, etc.\n\nDefault is true (include unclasses, etc.).\n" ),
366
367  OWLVAR_BOOL( "_followlast" /* %OwlVarStub */, 0,
368               "enable automatic following of the last zephyr",
369               "If the cursor is at the last message, it will\n"
370               "continue to follow the last message if this is set.\n"
371               "Note that this is currently risky as you might accidentally\n"
372               "delete a message right as it came in.\n" ),
373
374  OWLVAR_STRING_FULL( "default_exposure" /* %OwlVarStub */, "",
375                      "none,opstaff,realm-visible,realm-announced,net-visible,net-announced",
376                      "controls the persistent value for exposure",
377                      "The default exposure level corresponds to the Zephyr exposure value\n"
378                      "in ~/.zephyr.vars.  Defaults to realm-visible if there is no value in\n"
379                      "~/.zephyr.vars.\n"
380                      "See the description of exposure for the values this can be.",
381                      NULL, owl_variable_default_exposure_set, owl_variable_default_exposure_get ),
382
383  OWLVAR_STRING_FULL( "exposure" /* %OwlVarStub */, "",
384                      "none,opstaff,realm-visible,realm-announced,net-visible,net-announced",
385                      "controls who can zlocate you",
386                      "The exposure level, defaulting to the value of default_exposure,\n"
387                      "can be one of the following (from least exposure to widest exposure,\n"
388                      "as listed in zctl(1)):\n"
389                      "\n"
390                      "   none            - This completely disables Zephyr for the user. \n"
391                      "                     The user is not registered with Zephyr.  No user\n"
392                      "                     location information is retained by Zephyr.  No\n"
393                      "                     login or logout announcements will be sent.  No\n"
394                      "                     subscriptions will be entered for the user, and\n"
395                      "                     no notices will be displayed by zwgc(1).\n"
396                      "   opstaff         - The user is registered with Zephyr.  No login or\n"
397                      "                     logout announcements will be sent, and location\n"
398                      "                     information will only be visible to Operations\n"
399                      "                     staff.  Default subscriptions and any additional\n"
400                      "                     personal subscriptions will be entered for the\n"
401                      "                     user.\n"
402                      "   realm-visible   - The user is registered with Zephyr.  User\n"
403                      "                     location information is retained by Zephyr and\n"
404                      "                     made available only to users within the user’s\n"
405                      "                     Kerberos realm.  No login or logout\n"
406                      "                     announcements will be sent.  This is the system\n"
407                      "                     default.  Default subscriptions and any\n"
408                      "                     additional personal subscriptions will be\n"
409                      "                     entered for the user.\n"
410                      "   realm-announced - The user is registered with Zephyr.  User\n"
411                      "                     location information is retained by Zephyr and\n"
412                      "                     made available only to users authenticated\n"
413                      "                     within the user’s Kerberos realm.  Login and\n"
414                      "                     logout announcements will be sent, but only to\n"
415                      "                     users within the user’s Kerberos realm who have\n"
416                      "                     explicitly requested such via subscriptions. \n"
417                      "                     Default subscriptions and any additional\n"
418                      "                     personal subscriptions will be entered for the\n"
419                      "                     user.\n"
420                      "   net-visible     - The user is registered with Zephyr.  User\n"
421                      "                     location information is retained by Zephyr and\n"
422                      "                     made available to any authenticated user who\n"
423                      "                     requests such.  Login and logout announcements\n"
424                      "                     will be sent only to users within the user’s\n"
425                      "                     Kerberos realm who have explicitly requested\n"
426                      "                     such via subscriptions.  Default subscriptions\n"
427                      "                     and any additional personal subscriptions will\n"
428                      "                     be entered for the user.\n"
429                      "   net-announced   - The user is registered with Zephyr.  User\n"
430                      "                     location information is retained by Zephyr and\n"
431                      "                     made available to any authenticated user who\n"
432                      "                     requests such.  Login and logout announcements\n"
433                      "                     will be sent to any user has requested such. \n"
434                      "                     Default subscriptions and any additional\n"
435                      "                     personal subscriptions will be entered for the\n"
436                      "                     user.\n",
437                      NULL, owl_variable_exposure_set, NULL /* use default for get */ ),
438
439  /* This MUST be last... */
440  { NULL, 0, NULL, 0, NULL, NULL, NULL, NULL,
441    NULL, NULL, NULL, NULL, NULL, NULL }
442
443  };
444
445  return owl_variable_dict_add_from_list(vd, variables_to_init);
446}
447
448/**************************************************************************/
449/*********************** SPECIFIC TO VARIABLES ****************************/
450/**************************************************************************/
451
452
453/* commonly useful */
454
455int owl_variable_int_validate_gt0(const owl_variable *v, const void *newval)
456{
457  if (newval == NULL) return(0);
458  else if (*(const int*)newval < 1) return(0);
459  else return (1);
460}
461
462int owl_variable_int_validate_positive(const owl_variable *v, const void *newval)
463{
464  if (newval == NULL) return(0);
465  else if (*(const int*)newval < 0) return(0);
466  else return (1);
467}
468
469/* typewinsize */
470int owl_variable_typewinsize_set(owl_variable *v, const void *newval)
471{
472  int rv;
473  rv = owl_variable_int_set_default(v, newval);
474  if (0 == rv) owl_mainpanel_layout_contents(&g.mainpanel);
475  return(rv);
476}
477
478/* debug (cache value in g->debug) */
479int owl_variable_debug_set(owl_variable *v, const void *newval)
480{
481  if (newval && (*(const int*)newval == 1 || *(const int*)newval == 0)) {
482    g.debug = *(const int*)newval;
483  }
484  return owl_variable_bool_set_default(v, newval);
485}
486
487/* When 'aaway' is changed, need to notify the AIM server */
488int owl_variable_aaway_set(owl_variable *v, const void *newval)
489{
490  if (newval) {
491    if (*(const int*)newval == 1) {
492      owl_aim_set_awaymsg(owl_global_get_aaway_msg(&g));
493    } else if (*(const int*)newval == 0) {
494      owl_aim_set_awaymsg("");
495    }
496  }
497  return owl_variable_bool_set_default(v, newval);
498}
499
500int owl_variable_pseudologins_set(owl_variable *v, const void *newval)
501{
502  static owl_timer *timer = NULL;
503  if (newval) {
504    if (*(const int*)newval == 1) {
505      owl_function_zephyr_buddy_check(0);
506      if (timer == NULL) {
507        timer = owl_select_add_timer("owl_zephyr_buddycheck_timer",
508                                     180, 180, owl_zephyr_buddycheck_timer, NULL, NULL);
509      }
510    } else {
511      if (timer != NULL) {
512        owl_select_remove_timer(timer);
513        timer = NULL;
514      }
515    }
516  }
517  return owl_variable_bool_set_default(v, newval);
518}
519
520/* note that changing the value of this will clobber
521 * any user setting of this */
522int owl_variable_disable_ctrl_d_set(owl_variable *v, const void *newval)
523{
524  if (newval && !owl_context_is_startup(owl_global_get_context(&g))) {
525    if (*(const int*)newval == 2) {
526      owl_function_command_norv("bindkey editmulti C-d command edit:delete-next-char");
527    } else if (*(const int*)newval == 1) {
528      owl_function_command_norv("bindkey editmulti C-d command edit:done-or-delete");
529    } else {
530      owl_function_command_norv("bindkey editmulti C-d command edit:done");
531    }
532  } 
533  return owl_variable_int_set_default(v, newval); 
534}
535
536int owl_variable_tty_set(owl_variable *v, const void *newval)
537{
538  owl_zephyr_set_locationinfo(g_get_host_name(), newval);
539  return(owl_variable_string_set_default(v, newval));
540}
541
542int owl_variable_default_exposure_set(owl_variable *v, const void *newval)
543{
544  return owl_zephyr_set_default_exposure(newval);
545}
546
547const void *owl_variable_default_exposure_get(const owl_variable *v)
548{
549  return owl_zephyr_get_default_exposure();
550}
551
552int owl_variable_exposure_set(owl_variable *v, const void *newval)
553{
554  int ret = owl_zephyr_set_exposure(newval);
555  if (ret != 0)
556    return ret;
557  return owl_variable_string_set_default(v, owl_zephyr_normalize_exposure(newval));
558}
559
560/**************************************************************************/
561/****************************** GENERAL ***********************************/
562/**************************************************************************/
563
564int owl_variable_dict_setup(owl_vardict *vd) {
565  owl_dict_create(vd);
566  return owl_variable_add_defaults(vd);
567}
568
569int owl_variable_dict_add_from_list(owl_vardict *vd, owl_variable *variables_to_init)
570{
571  owl_variable *var, *cur;
572  for (var = variables_to_init; var->name != NULL; var++) {
573    cur = g_new(owl_variable, 1);
574    *cur = *var;
575    /* strdup all the strings so we can delete them consistently. */
576    cur->name = g_strdup(var->name);
577    cur->summary = g_strdup(var->summary);
578    cur->description = g_strdup(var->description);
579    switch (cur->type) {
580    case OWL_VARIABLE_OTHER:
581      cur->set_fn(cur, cur->pval_default);
582      break;
583    case OWL_VARIABLE_STRING:
584      if (!cur->validate_fn) 
585        cur->validate_fn = owl_variable_string_validate_default;
586      if (!cur->set_fn) 
587        cur->set_fn = owl_variable_string_set_default;
588      if (!cur->set_fromstring_fn) 
589        cur->set_fromstring_fn = owl_variable_string_set_fromstring_default;
590      if (!cur->get_fn) 
591        cur->get_fn = owl_variable_get_default;
592      if (!cur->get_tostring_fn) 
593        cur->get_tostring_fn = owl_variable_string_get_tostring_default;     
594      if (!cur->delete_fn)
595        cur->delete_fn = owl_variable_delete_default;
596      cur->pval_default = g_strdup(var->pval_default);
597      cur->set_fn(cur, cur->pval_default);
598      break;
599    case OWL_VARIABLE_BOOL:
600      if (!cur->validate_fn) 
601        cur->validate_fn = owl_variable_bool_validate_default;
602      if (!cur->set_fn) 
603        cur->set_fn = owl_variable_bool_set_default;
604      if (!cur->set_fromstring_fn) 
605        cur->set_fromstring_fn = owl_variable_bool_set_fromstring_default;
606      if (!cur->get_fn) 
607        cur->get_fn = owl_variable_get_default;
608      if (!cur->get_tostring_fn) 
609        cur->get_tostring_fn = owl_variable_bool_get_tostring_default;     
610      if (!cur->delete_fn)
611        cur->delete_fn = owl_variable_delete_default;
612      cur->val = g_new(int, 1);
613      cur->set_fn(cur, &cur->ival_default);
614      break;
615    case OWL_VARIABLE_INT:
616      if (!cur->validate_fn) 
617        cur->validate_fn = owl_variable_int_validate_default;
618      if (!cur->set_fn) 
619        cur->set_fn = owl_variable_int_set_default;
620      if (!cur->set_fromstring_fn) 
621        cur->set_fromstring_fn = owl_variable_int_set_fromstring_default;
622      if (!cur->get_fn) 
623        cur->get_fn = owl_variable_get_default;
624      if (!cur->get_tostring_fn) 
625        cur->get_tostring_fn = owl_variable_int_get_tostring_default;     
626      if (!cur->delete_fn)
627        cur->delete_fn = owl_variable_delete_default;
628      cur->val = g_new(int, 1);
629      cur->set_fn(cur, &cur->ival_default);
630      break;
631    default:
632      fprintf(stderr, "owl_variable_setup: invalid variable type\n");
633      return(-2);
634    }
635    owl_dict_insert_element(vd, cur->name, cur, NULL);
636  }
637  return 0;
638}
639
640void owl_variable_dict_add_variable(owl_vardict * vardict,
641                                    owl_variable * var) {
642  owl_dict_insert_element(vardict, var->name, var, (void (*)(void *))owl_variable_delete);
643}
644
645owl_variable * owl_variable_newvar(const char *name, const char *summary, const char * description) {
646  owl_variable * var = g_new0(owl_variable, 1);
647  var->name = g_strdup(name);
648  var->summary = g_strdup(summary);
649  var->description = g_strdup(description);
650  return var;
651}
652
653void owl_variable_update(owl_variable *var, const char *summary, const char *desc) {
654  g_free(var->summary);
655  var->summary = g_strdup(summary);
656  g_free(var->description);
657  var->description = g_strdup(desc);
658}
659
660void owl_variable_dict_newvar_string(owl_vardict * vd, const char *name, const char *summ, const char * desc, const char * initval) {
661  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_STRING);
662  if(old) {
663    owl_variable_update(old, summ, desc);
664    g_free(old->pval_default);
665    old->pval_default = g_strdup(initval);
666  } else {
667    owl_variable * var = owl_variable_newvar(name, summ, desc);
668    var->type = OWL_VARIABLE_STRING;
669    var->pval_default = g_strdup(initval);
670    var->set_fn = owl_variable_string_set_default;
671    var->set_fromstring_fn = owl_variable_string_set_fromstring_default;
672    var->get_fn = owl_variable_get_default;
673    var->get_tostring_fn = owl_variable_string_get_tostring_default;
674    var->delete_fn = owl_variable_delete_default;
675    var->set_fn(var, initval);
676    owl_variable_dict_add_variable(vd, var);
677  }
678}
679
680void owl_variable_dict_newvar_int(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
681  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_INT);
682  if(old) {
683    owl_variable_update(old, summ, desc);
684    old->ival_default = initval;
685  } else {
686    owl_variable * var = owl_variable_newvar(name, summ, desc);
687    var->type = OWL_VARIABLE_INT;
688    var->ival_default = initval;
689    var->validate_fn = owl_variable_int_validate_default;
690    var->set_fn = owl_variable_int_set_default;
691    var->set_fromstring_fn = owl_variable_int_set_fromstring_default;
692    var->get_fn = owl_variable_get_default;
693    var->get_tostring_fn = owl_variable_int_get_tostring_default;
694    var->delete_fn = owl_variable_delete_default;
695    var->val = g_new(int, 1);
696    var->set_fn(var, &initval);
697    owl_variable_dict_add_variable(vd, var);
698  }
699}
700
701void owl_variable_dict_newvar_bool(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
702  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_BOOL);
703  if(old) {
704    owl_variable_update(old, summ, desc);
705    old->ival_default = initval;
706  } else {
707    owl_variable * var = owl_variable_newvar(name, summ, desc);
708    var->type = OWL_VARIABLE_BOOL;
709    var->ival_default = initval;
710    var->validate_fn = owl_variable_bool_validate_default;
711    var->set_fn = owl_variable_bool_set_default;
712    var->set_fromstring_fn = owl_variable_bool_set_fromstring_default;
713    var->get_fn = owl_variable_get_default;
714    var->get_tostring_fn = owl_variable_bool_get_tostring_default;
715    var->delete_fn = owl_variable_delete_default;
716    var->val = g_new(int, 1);
717    var->set_fn(var, &initval);
718    owl_variable_dict_add_variable(vd, var);
719  }
720}
721
722void owl_variable_dict_cleanup(owl_vardict *d)
723{
724  owl_dict_cleanup(d, (void (*)(void *))owl_variable_delete);
725}
726
727void owl_variable_dict_get_names(const owl_vardict *d, owl_list *l) {
728  owl_dict_get_keys(d, l);
729}
730
731void owl_variable_delete(owl_variable *v)
732{
733  if (v->delete_fn) v->delete_fn(v);
734  g_free(v->name);
735  g_free(v->summary);
736  g_free(v->description);
737  if (v->type == OWL_VARIABLE_STRING)
738    g_free(v->pval_default);
739  g_free(v);
740}
741
742
743const char *owl_variable_get_description(const owl_variable *v) {
744  return v->description;
745}
746
747const char *owl_variable_get_summary(const owl_variable *v) {
748  return v->summary;
749}
750
751const char *owl_variable_get_validsettings(const owl_variable *v) {
752  if (v->validsettings) {
753    return v->validsettings;
754  } else {
755    return "";
756  }
757}
758
759/* functions for getting and setting variable values */
760
761/* returns 0 on success, prints a status msg if msg is true */
762int owl_variable_set_fromstring(owl_vardict *d, const char *name, const char *value, int msg, int requirebool) {
763  owl_variable *v;
764  char *tostring;
765  if (!name) return(-1);
766  v = owl_dict_find_element(d, name);
767  if (v == NULL) {
768    if (msg) owl_function_error("Unknown variable %s", name);
769    return -1;
770  }
771  if (!v->set_fromstring_fn) {
772    if (msg) owl_function_error("Variable %s is read-only", name);
773    return -1;   
774  }
775  if (requirebool && v->type!=OWL_VARIABLE_BOOL) {
776    if (msg) owl_function_error("Variable %s is not a boolean", name);
777    return -1;   
778  }
779  if (0 != v->set_fromstring_fn(v, value)) {
780    if (msg) owl_function_error("Unable to set %s (must be %s)", name, 
781                                  owl_variable_get_validsettings(v));
782    return -1;
783  }
784  if (msg && v->get_tostring_fn) {
785    tostring = v->get_tostring_fn(v, v->get_fn(v));
786    owl_function_makemsg("%s = '%s'", name, tostring);
787    g_free(tostring);
788  }   
789  return 0;
790}
791 
792int owl_variable_set_string(owl_vardict *d, const char *name, const char *newval) {
793  owl_variable *v;
794  if (!name) return(-1);
795  v = owl_dict_find_element(d, name);
796  if (v == NULL || !v->set_fn) return(-1);
797  if (v->type!=OWL_VARIABLE_STRING) return(-1);
798  return v->set_fn(v, newval);
799}
800 
801int owl_variable_set_int(owl_vardict *d, const char *name, int newval) {
802  owl_variable *v;
803  if (!name) return(-1);
804  v = owl_dict_find_element(d, name);
805  if (v == NULL || !v->set_fn) return(-1);
806  if (v->type!=OWL_VARIABLE_INT && v->type!=OWL_VARIABLE_BOOL) return(-1);
807  return v->set_fn(v, &newval);
808}
809 
810int owl_variable_set_bool_on(owl_vardict *d, const char *name) {
811  return owl_variable_set_int(d,name,1);
812}
813
814int owl_variable_set_bool_off(owl_vardict *d, const char *name) {
815  return owl_variable_set_int(d,name,0);
816}
817
818char *owl_variable_get_tostring(const owl_vardict *d, const char *name) {
819  owl_variable *v;
820  if (!name) return NULL;
821  v = owl_dict_find_element(d, name);
822  if (v == NULL || !v->get_tostring_fn) return NULL;
823  return v->get_tostring_fn(v, v->get_fn(v));
824}
825
826char *owl_variable_get_default_tostring(const owl_vardict *d, const char *name) {
827  owl_variable *v;
828  if (!name) return NULL;
829  v = owl_dict_find_element(d, name);
830  if (v == NULL || !v->get_tostring_fn) return NULL;
831  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
832    return v->get_tostring_fn(v, &(v->ival_default));
833  } else {
834    return v->get_tostring_fn(v, v->pval_default);
835  }
836}
837
838owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name, int require_type) {
839  owl_variable *v;
840  if (!name) return(NULL);
841  v = owl_dict_find_element(d, name);
842  if (v == NULL || !v->get_fn || v->type != require_type) return(NULL);
843  return v;
844}
845
846/* returns a reference */
847const void *owl_variable_get(const owl_vardict *d, const char *name, int require_type) {
848  owl_variable *v = owl_variable_get_var(d, name, require_type);
849  if(v == NULL) return NULL;
850  return v->get_fn(v);
851}
852
853/* returns a reference */
854const char *owl_variable_get_string(const owl_vardict *d, const char *name) {
855  return owl_variable_get(d,name, OWL_VARIABLE_STRING);
856}
857
858/* returns a reference */
859const void *owl_variable_get_other(const owl_vardict *d, const char *name) {
860  return owl_variable_get(d,name, OWL_VARIABLE_OTHER);
861}
862
863int owl_variable_get_int(const owl_vardict *d, const char *name) {
864  const int *pi;
865  pi = owl_variable_get(d,name,OWL_VARIABLE_INT);
866  if (!pi) return(-1);
867  return(*pi);
868}
869
870int owl_variable_get_bool(const owl_vardict *d, const char *name) {
871  const int *pi;
872  pi = owl_variable_get(d,name,OWL_VARIABLE_BOOL);
873  if (!pi) return(-1);
874  return(*pi);
875}
876
877void owl_variable_describe(const owl_vardict *d, const char *name, owl_fmtext *fm) {
878  char *default_buf;
879  owl_variable *v;
880
881  if (!name
882      || (v = owl_dict_find_element(d, name)) == NULL 
883      || !v->get_fn) {
884    owl_fmtext_appendf_normal(fm, "     No such variable '%s'\n", name);
885    return;
886  }
887  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
888    default_buf = v->get_tostring_fn(v, &(v->ival_default));
889  } else {
890    default_buf = v->get_tostring_fn(v, v->pval_default);
891  }
892  owl_fmtext_appendf_normal(fm, OWL_TABSTR "%-20s - %s (default: '%s')\n",
893                            v->name,
894                            owl_variable_get_summary(v), default_buf);
895  g_free(default_buf);
896}
897
898void owl_variable_get_help(const owl_vardict *d, const char *name, owl_fmtext *fm) {
899  char *tostring;
900  owl_variable *v;
901
902  if (!name
903      || (v = owl_dict_find_element(d, name)) == NULL 
904      || !v->get_fn) {
905    owl_fmtext_append_normal(fm, "No such variable...\n");
906    return;
907  }
908
909  owl_fmtext_append_bold(fm, "OWL VARIABLE\n\n");
910  owl_fmtext_append_normal(fm, OWL_TABSTR);
911  owl_fmtext_append_normal(fm, name);
912  owl_fmtext_append_normal(fm, " - ");
913  owl_fmtext_append_normal(fm, v->summary);
914  owl_fmtext_append_normal(fm, "\n\n");
915
916  owl_fmtext_append_normal(fm, "Current:        ");
917  tostring = owl_variable_get_tostring(d, name);
918  owl_fmtext_append_normal(fm, tostring);
919  g_free(tostring);
920  owl_fmtext_append_normal(fm, "\n\n");
921
922
923  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
924    tostring = v->get_tostring_fn(v, &(v->ival_default));
925  } else {
926    tostring = v->get_tostring_fn(v, v->pval_default);
927  }
928  owl_fmtext_append_normal(fm, "Default:        ");
929  owl_fmtext_append_normal(fm, tostring);
930  owl_fmtext_append_normal(fm, "\n\n");
931
932  owl_fmtext_append_normal(fm, "Valid Settings: ");
933  owl_fmtext_append_normal(fm, owl_variable_get_validsettings(v));
934  owl_fmtext_append_normal(fm, "\n\n");
935
936  if (v->description && *v->description) {
937    owl_fmtext_append_normal(fm, "Description:\n");
938    owl_fmtext_append_normal(fm, owl_variable_get_description(v));
939    owl_fmtext_append_normal(fm, "\n\n");
940  }
941  g_free(tostring);
942}
943
944
945
946
947/**************************************************************************/
948/*********************** GENERAL TYPE-SPECIFIC ****************************/
949/**************************************************************************/
950
951/* default common functions */
952
953const void *owl_variable_get_default(const owl_variable *v) {
954  return v->val;
955}
956
957void owl_variable_delete_default(owl_variable *v)
958{
959  g_free(v->val);
960}
961
962/* default functions for booleans */
963
964int owl_variable_bool_validate_default(const owl_variable *v, const void *newval) {
965  if (newval == NULL) return(0);
966  else if (*(const int*)newval==1 || *(const int*)newval==0) return(1);
967  else return (0);
968}
969
970int owl_variable_bool_set_default(owl_variable *v, const void *newval) {
971  if (v->validate_fn) {
972    if (!v->validate_fn(v, newval)) return(-1);
973  }
974  *(int*)v->val = *(const int*)newval;
975  return(0);
976}
977
978int owl_variable_bool_set_fromstring_default(owl_variable *v, const char *newval) {
979  int i;
980  if (!strcmp(newval, "on")) i=1;
981  else if (!strcmp(newval, "off")) i=0;
982  else return(-1);
983  return (v->set_fn(v, &i));
984}
985
986char *owl_variable_bool_get_tostring_default(const owl_variable *v, const void *val) {
987  if (val == NULL) {
988    return g_strdup("<null>");
989  } else if (*(const int*)val == 0) {
990    return g_strdup("off");
991  } else if (*(const int*)val == 1) {
992    return g_strdup("on");
993  } else {
994    return g_strdup("<invalid>");
995  }
996}
997
998/* default functions for integers */
999
1000int owl_variable_int_validate_default(const owl_variable *v, const void *newval) {
1001  if (newval == NULL) return(0);
1002  else return (1);
1003}
1004
1005int owl_variable_int_set_default(owl_variable *v, const void *newval) {
1006  if (v->validate_fn) {
1007    if (!v->validate_fn(v, newval)) return(-1);
1008  }
1009  *(int*)v->val = *(const int*)newval;
1010  return(0);
1011}
1012
1013int owl_variable_int_set_fromstring_default(owl_variable *v, const char *newval) {
1014  int i;
1015  char *ep;
1016  i = strtol(newval, &ep, 10);
1017  if (*ep || ep==newval) return(-1);
1018  return (v->set_fn(v, &i));
1019}
1020
1021char *owl_variable_int_get_tostring_default(const owl_variable *v, const void *val) {
1022  if (val == NULL) {
1023    return g_strdup("<null>");
1024  } else {
1025    return g_strdup_printf("%d", *(const int*)val);
1026  } 
1027}
1028
1029/* default functions for enums (a variant of integers) */
1030
1031int owl_variable_enum_validate(const owl_variable *v, const void *newval) { 
1032  char **enums;
1033  int nenums, val;
1034  if (newval == NULL) return(0);
1035  enums = g_strsplit_set(v->validsettings, ",", 0);
1036  nenums = g_strv_length(enums);
1037  g_strfreev(enums);
1038  val = *(const int*)newval;
1039  if (val < 0 || val >= nenums) {
1040    return(0);
1041  }
1042  return(1);
1043}
1044
1045int owl_variable_enum_set_fromstring(owl_variable *v, const char *newval) {
1046  char **enums;
1047  int i, val=-1;
1048  if (newval == NULL) return(-1);
1049  enums = g_strsplit_set(v->validsettings, ",", 0);
1050  for (i = 0; enums[i] != NULL; i++) {
1051    if (0==strcmp(newval, enums[i])) {
1052      val = i;
1053    }
1054  }
1055  g_strfreev(enums);
1056  if (val == -1) return(-1);
1057  return (v->set_fn(v, &val));
1058}
1059
1060char *owl_variable_enum_get_tostring(const owl_variable *v, const void *val) {
1061  char **enums;
1062  int nenums, i;
1063  char *tostring;
1064
1065  if (val == NULL) {
1066    return g_strdup("<null>");
1067  }
1068  enums = g_strsplit_set(v->validsettings, ",", 0);
1069  nenums = g_strv_length(enums);
1070  i = *(const int*)val;
1071  if (i<0 || i>=nenums) {
1072    g_strfreev(enums);
1073    return g_strdup_printf("<invalid:%d>", i);
1074  }
1075  tostring = g_strdup(enums[i]);
1076  g_strfreev(enums);
1077  return tostring;
1078}
1079
1080/* default functions for stringeans */
1081
1082int owl_variable_string_validate_default(const struct _owl_variable *v, const void *newval) {
1083  if (newval == NULL) return(0);
1084  else return (1);
1085}
1086
1087int owl_variable_string_set_default(owl_variable *v, const void *newval) {
1088  if (v->validate_fn) {
1089    if (!v->validate_fn(v, newval)) return(-1);
1090  }
1091  g_free(v->val);
1092  v->val = g_strdup(newval);
1093  return(0);
1094}
1095
1096int owl_variable_string_set_fromstring_default(owl_variable *v, const char *newval) {
1097  return (v->set_fn(v, newval));
1098}
1099
1100char *owl_variable_string_get_tostring_default(const owl_variable *v, const void *val) {
1101  if (val == NULL) {
1102    return g_strdup("<null>");
1103  } else {
1104    return g_strdup((const char*)val);
1105  }
1106}
1107
Note: See TracBrowser for help on using the repository browser.