source: variable.c @ 366badc

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