Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • variable.c

    rce68f23 ra16d7e5  
    7070
    7171  OWLVAR_BOOL( "startuplogin" /* %OwlVarStub */, 1,
    72                "send a login message when owl starts", "" ),
     72               "send a login message when BarnOwl starts", "" ),
    7373
    7474  OWLVAR_BOOL( "shutdownlogout" /* %OwlVarStub */, 1,
    75                "send a logout message when owl exits", "" ),
     75               "send a logout message when BarnOwl exits", "" ),
    7676
    7777  OWLVAR_BOOL( "rxping" /* %OwlVarStub */, 0,
    … …  
    137137  OWLVAR_BOOL_FULL( "pseudologins" /* %OwlVarStub */, 0,
    138138                    "Enable zephyr pseudo logins",
    139                     "When this is enabled, Owl will periodically check the zephyr\n"
     139                    "When this is enabled, BarnOwl will periodically check the zephyr\n"
    140140                    "location of users in your .anyone file.  If a user is present\n"
    141141                    "but sent no login message, or a user is not present that sent no\n"
    … …  
    145145  OWLVAR_BOOL( "ignorelogins" /* %OwlVarStub */, 0,
    146146               "Enable printing of login notifications",
    147                "When this is enabled, Owl will print login and logout notifications\n"
    148                "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
     147               "When this is enabled, BarnOwl will print login and logout notifications\n"
     148               "for AIM, zephyr, or other protocols.  If disabled BarnOwl will not print\n"
    149149               "login or logout notifications.\n"),
    150150
    … …  
    160160  OWLVAR_BOOL( "loglogins" /* %OwlVarStub */, 0,
    161161               "Enable logging of login notifications",
    162                "When this is enabled, Owl will login login and logout notifications\n"
     162               "When this is enabled, BarnOwl will log login and logout notifications\n"
    163163               "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
    164164               "login or logout notifications.\n"),
    … …  
    201201  OWLVAR_PATH( "newmsgproc" /* %OwlVarStub:newmsgproc */, NULL,
    202202               "name of a program to run when new messages are present",
    203                "The named program will be run when owl receives new\n"
     203               "The named program will be run when BarnOwl receives new\n"
    204204               "messages.  It will not be run again until the first\n"
    205205               "instance exits"),
    … …  
    229229                 "string to append to the end of the sepbar",
    230230                 "The sepbar is the bar separating the top and bottom\n"
    231                  "of the owl screen.  Any string specified here will\n"
     231                 "of the BarnOwl screen.  Any string specified here will\n"
    232232                 "be displayed on the right of the sepbar\n"),
    233233
    … …  
    265265
    266266  OWLVAR_STRING( "alert_action" /* %OwlVarStub */, "nop",
    267                  "owl command to execute for alert actions",
     267                 "BarnOwl command to execute for alert actions",
    268268                 "" ),
    269269
    … …  
    276276                 "Styles may be created with the 'style' command.\n"
    277277                 "Some built-in styles include:\n"
    278                  "   default  - the default owl formatting\n"
     278                 "   default  - the default BarnOwl formatting\n"
    279279                 "   oneline  - one line per-message\n"
    280280                 "   perl     - legacy perl interface\n"
    … …  
    333333               "cursor moves between messages being displayed.\n"
    334334               "The following modes are supported:\n\n"
    335                "   normal      - This is the owl default.  Scrolling happens\n"
     335               "   normal      - This is the BarnOwl default.  Scrolling happens\n"
    336336               "                 when it needs to, and an attempt is made to\n"
    337337               "                 keep the current message roughly near\n"
    … …  
    662662}
    663663
    664 void owl_variable_dict_newvar_string(owl_vardict * vd, const char *name, const char *summ, const char * desc, const char * initval) {
    665   owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_STRING);
    666   if(old) {
     664void owl_variable_dict_newvar_string(owl_vardict *vd, const char *name, const char *summ, const char *desc, const char *initval)
     665{
     666  owl_variable *old = owl_variable_get_var(vd, name);
     667  if (old && owl_variable_get_type(old) == OWL_VARIABLE_STRING) {
    667668    owl_variable_update(old, summ, desc);
    668669    g_free(old->pval_default);
    … …  
    671672    owl_variable * var = owl_variable_newvar(name, summ, desc);
    672673    var->type = OWL_VARIABLE_STRING;
     674    var->validsettings = "<string>";
    673675    var->pval_default = g_strdup(initval);
    674676    var->set_fn = owl_variable_string_set_default;
    … …  
    682684}
    683685
    684 void owl_variable_dict_newvar_int(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
    685   owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_INT);
    686   if(old) {
     686void owl_variable_dict_newvar_int(owl_vardict *vd, const char *name, const char *summ, const char *desc, int initval)
     687{
     688  owl_variable *old = owl_variable_get_var(vd, name);
     689  if (old && owl_variable_get_type(old) == OWL_VARIABLE_INT) {
    687690    owl_variable_update(old, summ, desc);
    688691    old->ival_default = initval;
    … …  
    690693    owl_variable * var = owl_variable_newvar(name, summ, desc);
    691694    var->type = OWL_VARIABLE_INT;
     695    var->validsettings = "<int>";
    692696    var->ival_default = initval;
    693697    var->validate_fn = owl_variable_int_validate_default;
    … …  
    703707}
    704708
    705 void owl_variable_dict_newvar_bool(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
    706   owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_BOOL);
    707   if(old) {
     709void owl_variable_dict_newvar_bool(owl_vardict *vd, const char *name, const char *summ, const char *desc, bool initval)
     710{
     711  owl_variable *old = owl_variable_get_var(vd, name);
     712  if (old && owl_variable_get_type(old) == OWL_VARIABLE_BOOL) {
    708713    owl_variable_update(old, summ, desc);
    709714    old->ival_default = initval;
    … …  
    711716    owl_variable * var = owl_variable_newvar(name, summ, desc);
    712717    var->type = OWL_VARIABLE_BOOL;
     718    var->validsettings = "on,off";
    713719    var->ival_default = initval;
    714720    var->validate_fn = owl_variable_bool_validate_default;
    … …  
    750756
    751757
     758const char *owl_variable_get_name(const owl_variable *v)
     759{
     760  return v->name;
     761}
     762
    752763const char *owl_variable_get_description(const owl_variable *v) {
    753764  return v->description;
    … …  
    759770
    760771const char *owl_variable_get_validsettings(const owl_variable *v) {
    761   if (v->validsettings) {
    762     return v->validsettings;
    763   } else {
    764     return "";
    765   }
     772  return v->validsettings;
     773}
     774
     775int owl_variable_get_type(const owl_variable *v)
     776{
     777  return v->type;
    766778}
    767779
    … …  
    769781
    770782/* returns 0 on success, prints a status msg if msg is true */
    771 int owl_variable_set_fromstring(owl_vardict *d, const char *name, const char *value, int msg, int requirebool) {
    772   owl_variable *v;
     783int owl_variable_set_fromstring(owl_variable *v, const char *value, int msg) {
    773784  char *tostring;
    774   if (!name) return(-1);
    775   v = owl_dict_find_element(d, name);
    776   if (v == NULL) {
    777     if (msg) owl_function_error("Unknown variable %s", name);
     785  if (!v->set_fromstring_fn) {
     786    if (msg) owl_function_error("Variable %s is read-only", owl_variable_get_name(v));
     787    return -1;   
     788  }
     789  if (0 != v->set_fromstring_fn(v, value)) {
     790    if (msg) owl_function_error("Unable to set %s (must be %s)", owl_variable_get_name(v),
     791                                owl_variable_get_validsettings(v));
    778792    return -1;
    779793  }
    780   if (!v->set_fromstring_fn) {
    781     if (msg) owl_function_error("Variable %s is read-only", name);
    782     return -1;   
    783   }
    784   if (requirebool && v->type!=OWL_VARIABLE_BOOL) {
    785     if (msg) owl_function_error("Variable %s is not a boolean", name);
    786     return -1;   
    787   }
    788   if (0 != v->set_fromstring_fn(v, value)) {
    789     if (msg) owl_function_error("Unable to set %s (must be %s)", name,
    790                                   owl_variable_get_validsettings(v));
    791     return -1;
    792   }
    793   if (msg && v->get_tostring_fn) {
     794  if (msg) {
    794795    tostring = v->get_tostring_fn(v, v->get_fn(v));
    795     owl_function_makemsg("%s = '%s'", name, tostring);
     796    if (tostring)
     797      owl_function_makemsg("%s = '%s'", owl_variable_get_name(v), tostring);
     798    else
     799      owl_function_makemsg("%s = <null>", owl_variable_get_name(v));
    796800    g_free(tostring);
    797801  }   
    … …  
    799803}
    800804 
    801 int owl_variable_set_string(owl_vardict *d, const char *name, const char *newval) {
    802   owl_variable *v;
    803   if (!name) return(-1);
    804   v = owl_dict_find_element(d, name);
    805   if (v == NULL || !v->set_fn) return(-1);
    806   if (v->type!=OWL_VARIABLE_STRING) return(-1);
     805int owl_variable_set_string(owl_variable *v, const char *newval)
     806{
     807  if (v->type != OWL_VARIABLE_STRING) return -1;
    807808  return v->set_fn(v, newval);
    808809}
    809810 
    810 int owl_variable_set_int(owl_vardict *d, const char *name, int newval) {
    811   owl_variable *v;
    812   if (!name) return(-1);
    813   v = owl_dict_find_element(d, name);
    814   if (v == NULL || !v->set_fn) return(-1);
    815   if (v->type!=OWL_VARIABLE_INT && v->type!=OWL_VARIABLE_BOOL) return(-1);
     811int owl_variable_set_int(owl_variable *v, int newval)
     812{
     813  if (v->type != OWL_VARIABLE_INT && v->type != OWL_VARIABLE_BOOL) return -1;
    816814  return v->set_fn(v, &newval);
    817815}
    818816 
    819 int owl_variable_set_bool_on(owl_vardict *d, const char *name) {
    820   return owl_variable_set_int(d,name,1);
    821 }
    822 
    823 int owl_variable_set_bool_off(owl_vardict *d, const char *name) {
    824   return owl_variable_set_int(d,name,0);
    825 }
    826 
    827 CALLER_OWN char *owl_variable_get_tostring(const owl_vardict *d, const char *name)
    828 {
    829   owl_variable *v;
    830   if (!name) return NULL;
    831   v = owl_dict_find_element(d, name);
    832   if (v == NULL || !v->get_tostring_fn) return NULL;
     817int owl_variable_set_bool_on(owl_variable *v)
     818{
     819  if (v->type != OWL_VARIABLE_BOOL) return -1;
     820  return owl_variable_set_int(v, true);
     821}
     822
     823int owl_variable_set_bool_off(owl_variable *v)
     824{
     825  if (v->type != OWL_VARIABLE_BOOL) return -1;
     826  return owl_variable_set_int(v, false);
     827}
     828
     829CALLER_OWN char *owl_variable_get_tostring(const owl_variable *v)
     830{
    833831  return v->get_tostring_fn(v, v->get_fn(v));
    834832}
    835833
    836 CALLER_OWN char *owl_variable_get_default_tostring(const owl_vardict *d, const char *name)
    837 {
    838   owl_variable *v;
    839   if (!name) return NULL;
    840   v = owl_dict_find_element(d, name);
    841   if (v == NULL || !v->get_tostring_fn) return NULL;
     834CALLER_OWN char *owl_variable_get_default_tostring(const owl_variable *v)
     835{
    842836  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
    843837    return v->get_tostring_fn(v, &(v->ival_default));
    … …  
    847841}
    848842
    849 owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name, int require_type) {
    850   owl_variable *v;
    851   if (!name) return(NULL);
    852   v = owl_dict_find_element(d, name);
    853   if (v == NULL || !v->get_fn || v->type != require_type) return(NULL);
    854   return v;
     843owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name)
     844{
     845  return owl_dict_find_element(d, name);
    855846}
    856847
    857848/* returns a reference */
    858 const void *owl_variable_get(const owl_vardict *d, const char *name, int require_type) {
    859   owl_variable *v = owl_variable_get_var(d, name, require_type);
    860   if(v == NULL) return NULL;
     849const void *owl_variable_get(const owl_variable *v)
     850{
    861851  return v->get_fn(v);
    862852}
    863853
     854const char *owl_variable_get_string(const owl_variable *v)
     855{
     856  if (owl_variable_get_type(v) != OWL_VARIABLE_STRING) {
     857    owl_function_error("Variable '%s' is not a string.", owl_variable_get_name(v));
     858    return NULL;
     859  }
     860  return owl_variable_get(v);
     861}
     862
    864863/* returns a reference */
    865 const char *owl_variable_get_string(const owl_vardict *d, const char *name) {
    866   return owl_variable_get(d,name, OWL_VARIABLE_STRING);
    867 }
    868 
    869 /* returns a reference */
    870 const void *owl_variable_get_other(const owl_vardict *d, const char *name) {
    871   return owl_variable_get(d,name, OWL_VARIABLE_OTHER);
    872 }
    873 
    874 int owl_variable_get_int(const owl_vardict *d, const char *name) {
    875   const int *pi;
    876   pi = owl_variable_get(d,name,OWL_VARIABLE_INT);
    877   if (!pi) return(-1);
    878   return(*pi);
    879 }
    880 
    881 int owl_variable_get_bool(const owl_vardict *d, const char *name) {
    882   const int *pi;
    883   pi = owl_variable_get(d,name,OWL_VARIABLE_BOOL);
    884   if (!pi) return(-1);
    885   return(*pi);
    886 }
    887 
    888 void owl_variable_describe(const owl_vardict *d, const char *name, owl_fmtext *fm) {
     864const void *owl_variable_get_other(const owl_variable *v)
     865{
     866  if (owl_variable_get_type(v) != OWL_VARIABLE_OTHER) {
     867    owl_function_error("Variable '%s' is not type other.", owl_variable_get_name(v));
     868    return NULL;
     869  }
     870  return owl_variable_get(v);
     871}
     872
     873int owl_variable_get_int(const owl_variable *v)
     874{
     875  if (owl_variable_get_type(v) != OWL_VARIABLE_INT) {
     876    owl_function_error("Variable '%s' is an int.", owl_variable_get_name(v));
     877    return -1;
     878  }
     879  const int *pi = owl_variable_get(v);
     880  if (!pi) return -1;
     881  return *pi;
     882}
     883
     884int owl_variable_get_bool(const owl_variable *v)
     885{
     886  if (owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
     887    owl_function_error("Variable '%s' is a boolean.", owl_variable_get_name(v));
     888    return -1;
     889  }
     890  const int *pi = owl_variable_get(v);
     891  if (!pi) return -1;
     892  return *pi;
     893}
     894
     895void owl_variable_describe(const owl_variable *v, owl_fmtext *fm)
     896{
     897  char *tostring = owl_variable_get_default_tostring(v);
    889898  char *default_buf;
    890   owl_variable *v;
    891 
    892   if (!name
    893       || (v = owl_dict_find_element(d, name)) == NULL
    894       || !v->get_fn) {
    895     owl_fmtext_appendf_normal(fm, "     No such variable '%s'\n", name);
    896     return;
    897   }
    898   if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
    899     default_buf = v->get_tostring_fn(v, &(v->ival_default));
    900   } else {
    901     default_buf = v->get_tostring_fn(v, v->pval_default);
    902   }
    903   owl_fmtext_appendf_normal(fm, OWL_TABSTR "%-20s - %s (default: '%s')\n",
    904                             v->name,
    905                             owl_variable_get_summary(v), default_buf);
     899
     900  if (tostring)
     901    default_buf = g_strdup_printf("'%s'", tostring);
     902  else
     903    default_buf = g_strdup("<null>");
     904  owl_fmtext_appendf_normal(fm, OWL_TABSTR "%-20s - %s (default: %s)\n",
     905                            owl_variable_get_name(v),
     906                            owl_variable_get_summary(v), default_buf);
    906907  g_free(default_buf);
    907 }
    908 
    909 void owl_variable_get_help(const owl_vardict *d, const char *name, owl_fmtext *fm) {
     908  g_free(tostring);
     909}
     910
     911void owl_variable_get_help(const owl_variable *v, owl_fmtext *fm) {
    910912  char *tostring;
    911   owl_variable *v;
    912 
    913   if (!name
    914       || (v = owl_dict_find_element(d, name)) == NULL
    915       || !v->get_fn) {
    916     owl_fmtext_append_normal(fm, "No such variable...\n");
    917     return;
    918   }
    919913
    920914  owl_fmtext_append_bold(fm, "OWL VARIABLE\n\n");
    921915  owl_fmtext_append_normal(fm, OWL_TABSTR);
    922   owl_fmtext_append_normal(fm, name);
     916  owl_fmtext_append_normal(fm, owl_variable_get_name(v));
    923917  owl_fmtext_append_normal(fm, " - ");
    924   owl_fmtext_append_normal(fm, v->summary);
     918  owl_fmtext_append_normal(fm, owl_variable_get_summary(v));
    925919  owl_fmtext_append_normal(fm, "\n\n");
    926920
    927921  owl_fmtext_append_normal(fm, "Current:        ");
    928   tostring = owl_variable_get_tostring(d, name);
    929   owl_fmtext_append_normal(fm, tostring);
     922  tostring = owl_variable_get_tostring(v);
     923  owl_fmtext_append_normal(fm, (tostring ? tostring : "<null>"));
    930924  g_free(tostring);
    931925  owl_fmtext_append_normal(fm, "\n\n");
    932926
    933927
    934   if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
    935     tostring = v->get_tostring_fn(v, &(v->ival_default));
    936   } else {
    937     tostring = v->get_tostring_fn(v, v->pval_default);
    938   }
     928  tostring = owl_variable_get_default_tostring(v);
    939929  owl_fmtext_append_normal(fm, "Default:        ");
    940   owl_fmtext_append_normal(fm, tostring);
     930  owl_fmtext_append_normal(fm, (tostring ? tostring : "<null>"));
    941931  owl_fmtext_append_normal(fm, "\n\n");
    942932
    … …  
    998988{
    999989  if (val == NULL) {
    1000     return g_strdup("<null>");
     990    return NULL;
    1001991  } else if (*(const int*)val == 0) {
    1002992    return g_strdup("off");
    … …  
    10341024{
    10351025  if (val == NULL) {
    1036     return g_strdup("<null>");
     1026    return NULL;
    10371027  } else {
    10381028    return g_strdup_printf("%d", *(const int*)val);
    … …  
    10781068
    10791069  if (val == NULL) {
    1080     return g_strdup("<null>");
     1070    return NULL;
    10811071  }
    10821072  enums = g_strsplit_set(v->validsettings, ",", 0);
    … …  
    11141104CALLER_OWN char *owl_variable_string_get_tostring_default(const owl_variable *v, const void *val)
    11151105{
    1116   if (val == NULL) {
    1117     return g_strdup("<null>");
    1118   } else {
    1119     return g_strdup((const char*)val);
    1120   }
    1121 }
    1122 
     1106  return g_strdup((const char*)val);
     1107}
     1108
Note: See TracChangeset for help on using the changeset viewer.