source: variable.c @ ea68035

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