source: functions.c @ 751ae8c

release-1.10release-1.6release-1.7release-1.8release-1.9
Last change on this file since 751ae8c was 1cfcab7, checked in by Nelson Elhage <nelhage@mit.edu>, 15 years ago
Update copyright notices for 2010.
  • Property mode set to 100644
File size: 96.0 KB
RevLine 
[7d4fbcd]1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <signal.h>
[789462a]5#include <netinet/in.h>
[7d4fbcd]6#include <string.h>
7#include <time.h>
[2adaf1d]8#include <sys/types.h>
9#include <sys/stat.h>
[8f44c6b]10#include <sys/wait.h>
11#include <errno.h>
[d09e5a1]12#include <signal.h>
[7d4fbcd]13#include "owl.h"
[d564c3d]14#include "filterproc.h"
[7d4fbcd]15
[e19eb97]16char *owl_function_command(const char *cmdbuff)
[d54838d]17{
[7d4fbcd]18  owl_function_debugmsg("executing command: %s", cmdbuff);
19  return owl_cmddict_execute(owl_global_get_cmddict(&g), 
20                             owl_global_get_context(&g), cmdbuff);
21}
22
[e19eb97]23char *owl_function_command_argv(const char *const *argv, int argc)
[c4ba74d]24{
25  return owl_cmddict_execute_argv(owl_global_get_cmddict(&g),
26                                  owl_global_get_context(&g),
27                                  argv, argc);
28}
29
[e19eb97]30void owl_function_command_norv(const char *cmdbuff)
[d54838d]31{
[7d4fbcd]32  char *rv;
[4b464a4]33  rv=owl_function_command(cmdbuff);
[7d4fbcd]34  if (rv) owl_free(rv);
35}
36
[e19eb97]37void owl_function_command_alias(const char *alias_from, const char *alias_to)
[d54838d]38{
[7d4fbcd]39  owl_cmddict_add_alias(owl_global_get_cmddict(&g), alias_from, alias_to);
40}
41
[0a0fb74]42const owl_cmd *owl_function_get_cmd(const char *name)
[d54838d]43{
[7d4fbcd]44  return owl_cmddict_find(owl_global_get_cmddict(&g), name);
45}
46
[c79a047]47void owl_function_show_commands(void)
[d54838d]48{
[7d4fbcd]49  owl_list l;
50  owl_fmtext fm;
51
52  owl_fmtext_init_null(&fm);
53  owl_fmtext_append_bold(&fm, "Commands:  ");
54  owl_fmtext_append_normal(&fm, "(use 'show command <name>' for details)\n");
55  owl_cmddict_get_names(owl_global_get_cmddict(&g), &l);
56  owl_fmtext_append_list(&fm, &l, "\n", owl_function_cmd_describe);
57  owl_fmtext_append_normal(&fm, "\n");
58  owl_function_popless_fmtext(&fm);
[8d4b521]59  owl_cmddict_namelist_cleanup(&l);
[7ab0020]60  owl_fmtext_cleanup(&fm);
[7d4fbcd]61}
62
[e19eb97]63void owl_function_show_view(const char *viewname)
[ef56a67]64{
[9e5c9f3]65  const owl_view *v;
[ef56a67]66  owl_fmtext fm;
67
68  /* we only have the one view right now */
69  v=owl_global_get_current_view(&g);
70  if (viewname && strcmp(viewname, owl_view_get_name(v))) {
[ec6ff52]71    owl_function_error("No view named '%s'", viewname);
[ef56a67]72    return;
73  }
74
75  owl_fmtext_init_null(&fm);
76  owl_view_to_fmtext(v, &fm);
77  owl_function_popless_fmtext(&fm);
[7ab0020]78  owl_fmtext_cleanup(&fm);
[ef56a67]79}
80
[c79a047]81void owl_function_show_styles(void) {
[f1e629d]82  owl_list l;
83  owl_fmtext fm;
84
85  owl_fmtext_init_null(&fm);
86  owl_fmtext_append_bold(&fm, "Styles:\n");
87  owl_global_get_style_names(&g, &l);
88  owl_fmtext_append_list(&fm, &l, "\n", owl_function_style_describe);
89  owl_fmtext_append_normal(&fm, "\n");
90  owl_function_popless_fmtext(&fm);
[8c59178]91  owl_list_cleanup(&l, owl_free);
[7ab0020]92  owl_fmtext_cleanup(&fm);
[f1e629d]93}
94
[e19eb97]95char *owl_function_style_describe(const char *name) {
96  const char *desc;
[65b2173]97  char *s;
[1fdab04]98  const owl_style *style;
[f1e629d]99  style = owl_global_get_style_by_name(&g, name);
100  if (style) {
101    desc = owl_style_get_description(style);
102  } else {
103    desc = "???";
104  }
105  s = owl_sprintf("%-20s - %s%s", name, 
106                  0==owl_style_validate(style)?"":"[INVALID] ",
107                  desc);
108  return s;
109}
[ef56a67]110
[e19eb97]111char *owl_function_cmd_describe(const char *name)
[d54838d]112{
[0a0fb74]113  const owl_cmd *cmd = owl_cmddict_find(owl_global_get_cmddict(&g), name);
[7d4fbcd]114  if (cmd) return owl_cmd_describe(cmd);
115  else return(NULL);
116}
117
[e19eb97]118void owl_function_show_command(const char *name)
[d54838d]119{
[7d4fbcd]120  owl_function_help_for_command(name);
121}
122
[c79a047]123void owl_function_show_license(void)
[debb15d]124{
[e19eb97]125  const char *text;
[debb15d]126
127  text=""
[4228f8b]128    "barnowl version " OWL_VERSION_STRING "\n"
[1cfcab7]129    "Copyright (c) 2006-2010 The BarnOwl Developers. All rights reserved.\n"
[debb15d]130    "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
131    "\n"
132    "Redistribution and use in source and binary forms, with or without\n"
133    "modification, are permitted provided that the following conditions are\n"
134    "met:\n"
135    "\n"
136    "   * Redistributions of source code must retain the above copyright\n"
137    "     notice, this list of conditions and the following disclaimer.\n"
138    "\n"
139    "   * Redistributions in binary form must reproduce the above copyright\n"
140    "     notice, this list of conditions and the following disclaimer in\n"
141    "     the documentation and/or other materials provided with the\n"
142    "     distribution.\n"
143    "\n"
144    "   * Redistributions in any form must be accompanied by information on\n"
145    "     how to obtain complete source code for the Owl software and any\n"
146    "     accompanying software that uses the Owl software. The source code\n"
147    "     must either be included in the distribution or be available for no\n"
148    "     more than the cost of distribution plus a nominal fee, and must be\n"
149    "     freely redistributable under reasonable conditions. For an\n"
150    "     executable file, complete source code means the source code for\n"
151    "     all modules it contains. It does not include source code for\n"
152    "     modules or files that typically accompany the major components of\n"
153    "     the operating system on which the executable file runs.\n"
154    "\n"
155    "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n"
156    "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n"
157    "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR\n"
158    "NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE\n"
159    "LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
160    "CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
161    "SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\n"
162    "BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n"
163    "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\n"
164    "OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN\n"
165    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n";
166  owl_function_popless_text(text);
167}
168
[c79a047]169void owl_function_show_quickstart(void)
[799b60e]170{
[e19eb97]171    const char *message =
[799b60e]172    "Move between messages with the arrow keys, and press 'r' to reply.\n"
173    "For more info, press 'h' or visit http://barnowl.mit.edu/\n\n"
174#ifdef HAVE_LIBZEPHYR
175    "@b(Zephyr:)\n"
176    "To send a message to a user, type ':zwrite @b(username)'. You can also\n"
177    "press 'z' and then type the username. To subscribe to a class, type\n"
178    "':sub @b(class)', and then type ':zwrite -c @b(class)' to send.\n\n"
179#endif
180    "@b(AIM:)\n"
181    "Log in to AIM with ':aimlogin @b(screenname)'. Use ':aimwrite @b(screenname)',\n"
182    "or 'a' and then the screen name, to send someone a message.\n\n"
183    ;
184
185    if (owl_perlconfig_is_function("BarnOwl::Hooks::_get_quickstart")) {
186        char *perlquickstart = owl_perlconfig_execute("BarnOwl::Hooks::_get_quickstart()");
187        if (perlquickstart) {
188            char *result = owl_sprintf("%s%s", message, perlquickstart);
189            owl_function_adminmsg("BarnOwl Quickstart", result);
190            owl_free(result);
191            owl_free(perlquickstart);
192            return;
193        }
194    }
195    owl_function_adminmsg("BarnOwl Quickstart", message);
196}
197
198
[15b34fd]199/* Create an admin message, append it to the global list of messages
200 * and redisplay if necessary.
201 */
[e19eb97]202void owl_function_adminmsg(const char *header, const char *body)
[d54838d]203{
[7d4fbcd]204  owl_message *m;
[4b464a4]205
[7d4fbcd]206  m=owl_malloc(sizeof(owl_message));
[15b34fd]207  owl_message_create_admin(m, header, body);
208 
[8fec514]209  /* add it to the global list and current view */
[7d4fbcd]210  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
211  owl_view_consider_message(owl_global_get_current_view(&g), m);
212
[15b34fd]213  /* do followlast if necessary */
214  if (owl_global_should_followlast(&g)) owl_function_lastmsg_noredisplay();
[7d4fbcd]215
[15b34fd]216  /* redisplay etc. */
[7d4fbcd]217  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
218  owl_global_set_needrefresh(&g);
219}
220
[15b34fd]221/* Create an outgoing zephyr message and return a pointer to it.  Does
[13fe062]222 * not put it on the global queue, use owl_global_messagequeue_addmsg() for
[15b34fd]223 * that.
224 */
[e19eb97]225owl_message *owl_function_make_outgoing_zephyr(const char *body, const char *zwriteline, const char *zsig)
[d09e5a1]226{
227  owl_message *m;
[24ccc01]228  owl_zwrite zw;
229
230  owl_zwrite_create_from_line(&zw, zwriteline);
231  owl_zwrite_set_zsig(&zw, zsig);
[d09e5a1]232
233  /* create the message */
234  m=owl_malloc(sizeof(owl_message));
[24ccc01]235 
236  owl_message_create_from_zwrite(m, &zw, body);
[c230bc1]237  owl_zwrite_cleanup(&zw);
[15b34fd]238
239  return(m);
240}
241
242/* Create an outgoing AIM message, returns a pointer to the created
243 * message or NULL if we're not logged into AIM (and thus unable to
244 * create the message).  Does not put it on the global queue.  Use
[13fe062]245 * owl_global_messagequeue_addmsg() for that .
[15b34fd]246 */
[e19eb97]247owl_message *owl_function_make_outgoing_aim(const char *body, const char *to)
[15b34fd]248{
249  owl_message *m;
250
251  /* error if we're not logged into aim */
252  if (!owl_global_is_aimloggedin(&g)) return(NULL);
253 
254  m=owl_malloc(sizeof(owl_message));
[d559df9]255  owl_message_create_aim(m,
256                         owl_global_get_aim_screenname(&g),
257                         to,
258                         body,
259                         OWL_MESSAGE_DIRECTION_OUT,
260                         0);
[15b34fd]261  return(m);
[d09e5a1]262}
263
[15b34fd]264/* Create an outgoing loopback message and return a pointer to it.
265 * Does not append it to the global queue, use
[13fe062]266 * owl_global_messagequeue_addmsg() for that.
[15b34fd]267 */
[e19eb97]268owl_message *owl_function_make_outgoing_loopback(const char *body)
[37eab7f]269{
270  owl_message *m;
271
272  /* create the message */
273  m=owl_malloc(sizeof(owl_message));
274  owl_message_create_loopback(m, body);
275  owl_message_set_direction_out(m);
276
[15b34fd]277  return(m);
[37eab7f]278}
279
[1b1cd2c]280void owl_function_start_edit_win(const char *line, void (*callback)(owl_editwin *), void *data, void (*cleanup)(void *))
[d54838d]281{
[7d4fbcd]282  owl_editwin *e;
[bdbec0a]283  char *s;
284
285  /* create and setup the editwin */
[58d47ca]286  e = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_MULTILINE,
287                                   owl_global_get_msg_history(&g));
[bdbec0a]288  owl_editwin_set_dotsend(e);
289  s = owl_sprintf("----> %s\n", line);
290  owl_editwin_set_locktext(e, s);
291  owl_free(s);
292
[38cc669]293  owl_editwin_set_cbdata(e, data, cleanup);
294  owl_editwin_set_callback(e, callback);
[2a17b63]295  owl_global_push_context(&g, OWL_CTX_EDITMULTI, e, "editmulti");
[bdbec0a]296}
297
298static void owl_function_write_setup(const char *line, const char *noun, void (*callback)(owl_editwin *))
299{
300
301  if (!owl_global_get_lockout_ctrld(&g))
302    owl_function_makemsg("Type your %s below.  "
303                         "End with ^D or a dot on a line by itself."
304                         "  ^C will quit.", noun);
305  else
306    owl_function_makemsg("Type your %s below.  "
307                         "End with a dot on a line by itself.  ^C will quit.",
308                         noun);
309
[8dfb59c]310  owl_function_start_edit_win(line, callback,
311                              owl_strdup(line),
312                              owl_free);
[bdbec0a]313}
314
315void owl_function_zwrite_setup(const char *line)
316{
[7d4fbcd]317  owl_zwrite z;
318  int ret;
319
320  /* check the arguments */
321  ret=owl_zwrite_create_from_line(&z, line);
322  if (ret) {
[d768834]323    owl_function_error("Error in zwrite arguments");
[c230bc1]324    owl_zwrite_cleanup(&z);
[7d4fbcd]325    return;
326  }
327
328  /* send a ping if necessary */
329  if (owl_global_is_txping(&g)) {
330    owl_zwrite_send_ping(&z);
331  }
[c230bc1]332  owl_zwrite_cleanup(&z);
[7d4fbcd]333
[bdbec0a]334  owl_function_write_setup(line, "zephyr", &owl_callback_zwrite);
[7d4fbcd]335}
336
[e19eb97]337void owl_function_aimwrite_setup(const char *line)
[d09e5a1]338{
[bdbec0a]339  owl_function_write_setup(line, "message", &owl_callback_aimwrite);
[d09e5a1]340}
341
[c79a047]342void owl_function_loopwrite_setup(void)
[37eab7f]343{
[8a2815b]344  owl_function_write_setup("loopwrite", "message", owl_callback_loopwrite);
[1b6b2f3]345}
346
347void owl_callback_zwrite(owl_editwin *e) {
[8dfb59c]348  char *command = owl_editwin_get_cbdata(e);
349  owl_function_zwrite(command,
[1b6b2f3]350                      owl_editwin_get_text(e));
[37eab7f]351}
352
[9ceee9d]353/* send, log and display an outgoing zephyr.  If 'msg' is NULL
354 * the message is expected to be set from the zwrite line itself
355 */
[e19eb97]356void owl_function_zwrite(const char *line, const char *msg)
[d54838d]357{
[d309eb3]358  owl_zwrite z;
[e19eb97]359  const char *mymsg;
[15b34fd]360  owl_message *m;
[d309eb3]361
[a5fc448]362  if(!strncmp(line, "zcrypt", strlen("zcrypt"))) {
363    owl_function_zcrypt(line, msg);
364    return;
365  }
366
[9ceee9d]367  /* create the zwrite and send the message */
368  owl_zwrite_create_from_line(&z, line);
[3f3ee61]369  owl_zwrite_populate_zsig(&z);
[9ceee9d]370  if (msg) {
371    owl_zwrite_set_message(&z, msg);
[d309eb3]372  }
[9ceee9d]373  owl_zwrite_send_message(&z);
374  owl_function_makemsg("Waiting for ack...");
[d309eb3]375
[15b34fd]376  /* If it's personal */
377  if (owl_zwrite_is_personal(&z)) {
378    /* create the outgoing message */
379    mymsg=owl_zwrite_get_message(&z);
380    m=owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
[d309eb3]381
[3c7d086a]382    if (m) {
[13a3c1db]383      owl_global_messagequeue_addmsg(&g, m);
[15b34fd]384    } else {
[3c7d086a]385      owl_function_error("Could not create outgoing zephyr message");
[9ceee9d]386    }
387  }
[453bd70]388
[9ceee9d]389  /* free the zwrite */
[c230bc1]390  owl_zwrite_cleanup(&z);
[d309eb3]391}
392
[9ceee9d]393/* send, log and display an outgoing zcrypt zephyr.  If 'msg' is NULL
[ce7db4d]394 * the message is expected to be set from the zwrite line itself
395 */
[e19eb97]396void owl_function_zcrypt(const char *line, const char *msg)
[d54838d]397{
[7d4fbcd]398  owl_zwrite z;
[e19eb97]399  const char *mymsg;
[9ceee9d]400  char *cryptmsg;
[15b34fd]401  owl_message *m;
[d564c3d]402  const char *argv[7];
[9a7b4f2]403  char *zcrypt;
[d564c3d]404  int rv, status;
[7d4fbcd]405
406  /* create the zwrite and send the message */
407  owl_zwrite_create_from_line(&z, line);
[3f3ee61]408  owl_zwrite_populate_zsig(&z);
[ce7db4d]409  if (msg) {
410    owl_zwrite_set_message(&z, msg);
411  }
412
[9ceee9d]413  mymsg=owl_zwrite_get_message(&z);
[d564c3d]414
[9a7b4f2]415  zcrypt = owl_sprintf("%s/zcrypt", owl_get_bindir());
[d564c3d]416  argv[0] = "zcrypt";
417  argv[1] = "-E";
418  argv[2] = "-c"; argv[3] = owl_zwrite_get_class(&z);
419  argv[4] = "-i"; argv[5] = owl_zwrite_get_instance(&z);
420  argv[6] = NULL;
421
[9a7b4f2]422  rv = call_filter(zcrypt, argv, mymsg, &cryptmsg, &status);
423
424  owl_free(zcrypt);
[d564c3d]425
426  if (rv || status) {
427    if(cryptmsg) owl_free(cryptmsg);
[ec6ff52]428    owl_function_error("Error in zcrypt, possibly no key found.  Message not sent.");
[9ceee9d]429    owl_function_beep();
[c230bc1]430    owl_zwrite_cleanup(&z);
[9ceee9d]431    return;
432  }
433
434  owl_zwrite_set_message(&z, cryptmsg);
435  owl_zwrite_set_opcode(&z, "crypt");
436   
[ce7db4d]437  owl_zwrite_send_message(&z);
[7d4fbcd]438  owl_function_makemsg("Waiting for ack...");
439
[15b34fd]440  /* If it's personal */
441  if (owl_zwrite_is_personal(&z)) {
442    /* create the outgoing message */
443    mymsg=owl_zwrite_get_message(&z);
444    m=owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
[3c7d086a]445    if (m) {
[13a3c1db]446      owl_global_messagequeue_addmsg(&g, m);
[15b34fd]447    } else {
[3c7d086a]448      owl_function_error("Could not create outgoing zephyr message");
[7d4fbcd]449    }
450  }
451
452  /* free the zwrite */
[9ceee9d]453  owl_free(cryptmsg);
[c230bc1]454  owl_zwrite_cleanup(&z);
[7d4fbcd]455}
456
[1b6b2f3]457void owl_callback_aimwrite(owl_editwin *e) {
[8dfb59c]458  char *command = owl_editwin_get_cbdata(e);
459  owl_function_aimwrite(command,
[1b6b2f3]460                        owl_editwin_get_text(e));
461}
462
[e19eb97]463void owl_function_aimwrite(const char *line, const char *msg)
[d09e5a1]464{
[ec6ff52]465  int ret;
[e19eb97]466  const char *to;
[65b2173]467  char *format_msg;
[15b34fd]468  owl_message *m;
[f82e233]469
[4211f50b]470  to = line + 9;
471
[f82e233]472  /* make a formatted copy of the message */
473  format_msg=owl_strdup(msg);
474  owl_text_wordunwrap(format_msg);
[ec6ff52]475 
[f82e233]476  /* send the message */
477  ret=owl_aim_send_im(to, format_msg);
[ec6ff52]478  if (!ret) {
479    owl_function_makemsg("AIM message sent.");
480  } else {
481    owl_function_error("Could not send AIM message.");
482  }
[d09e5a1]483
[15b34fd]484  /* create the outgoing message */
485  m=owl_function_make_outgoing_aim(msg, to);
486
[3c7d086a]487  if (m) {
[13a3c1db]488    owl_global_messagequeue_addmsg(&g, m);
[15b34fd]489  } else {
[3c7d086a]490    owl_function_error("Could not create outgoing AIM message");
[d09e5a1]491  }
[f82e233]492
493  owl_free(format_msg);
[d09e5a1]494}
495
[e19eb97]496void owl_function_send_aimawymsg(const char *to, const char *msg)
[9854278]497{
498  int ret;
499  char *format_msg;
[15b34fd]500  owl_message *m;
[9854278]501
502  /* make a formatted copy of the message */
503  format_msg=owl_strdup(msg);
504  owl_text_wordunwrap(format_msg);
505 
506  /* send the message */
507  ret=owl_aim_send_awaymsg(to, format_msg);
508  if (!ret) {
509    /* owl_function_makemsg("AIM message sent."); */
510  } else {
511    owl_function_error("Could not send AIM message.");
512  }
513
[15b34fd]514  /* create the message */
515  m=owl_function_make_outgoing_aim(msg, to);
516  if (m) {
[13a3c1db]517    owl_global_messagequeue_addmsg(&g, m);
[15b34fd]518  } else {
519    owl_function_error("Could not create AIM message");
[9854278]520  }
521  owl_free(format_msg);
522}
523
[1b6b2f3]524void owl_callback_loopwrite(owl_editwin *e) {
525  owl_function_loopwrite(owl_editwin_get_text(e));
526}
527
[e19eb97]528void owl_function_loopwrite(const char *msg)
[37eab7f]529{
[15b34fd]530  owl_message *min, *mout;
[37eab7f]531
532  /* create a message and put it on the message queue.  This simulates
533   * an incoming message */
[15b34fd]534  min=owl_malloc(sizeof(owl_message));
[4211f50b]535  mout=owl_function_make_outgoing_loopback(msg);
[13a3c1db]536
[37eab7f]537  if (owl_global_is_displayoutgoing(&g)) {
[13a3c1db]538    owl_global_messagequeue_addmsg(&g, mout);
[15b34fd]539  } else {
[91634ec]540    owl_message_delete(mout);
[37eab7f]541  }
542
[13a3c1db]543  owl_message_create_loopback(min, msg);
544  owl_message_set_direction_in(min);
545  owl_global_messagequeue_addmsg(&g, min);
546
[37eab7f]547  /* fake a makemsg */
548  owl_function_makemsg("loopback message sent");
549}
550
[b950088]551/* If filter is non-null, looks for the next message matching
552 * that filter.  If skip_deleted, skips any deleted messages.
553 * If last_if_none, will stop at the last message in the view
554 * if no matching messages are found.  */
[e19eb97]555void owl_function_nextmsg_full(const char *filter, int skip_deleted, int last_if_none)
[d54838d]556{
[b950088]557  int curmsg, i, viewsize, found;
[9e5c9f3]558  const owl_view *v;
[4542047]559  const owl_filter *f = NULL;
[c08c70a]560  const owl_message *m;
[7d4fbcd]561
562  v=owl_global_get_current_view(&g);
[b950088]563
564  if (filter) {
565    f=owl_global_get_filter(&g, filter);
566    if (!f) {
[ec6ff52]567      owl_function_error("No %s filter defined", filter);
[b950088]568      return;
569    }
[7d4fbcd]570  }
571
[b950088]572  curmsg=owl_global_get_curmsg(&g);
573  viewsize=owl_view_get_size(v);
574  found=0;
[7d4fbcd]575
[b950088]576  /* just check to make sure we're in bounds... */
577  if (curmsg>viewsize-1) curmsg=viewsize-1;
578  if (curmsg<0) curmsg=0;
[7d4fbcd]579
[b950088]580  for (i=curmsg+1; i<viewsize; i++) {
581    m=owl_view_get_element(v, i);
582    if (skip_deleted && owl_message_is_delete(m)) continue;
583    if (f && !owl_filter_message_match(f, m)) continue;
584    found = 1;
585    break;
586  }
587
588  if (i>owl_view_get_size(v)-1) i=owl_view_get_size(v)-1;
[5763474]589  if (i<0) i=0;
[b950088]590
591  if (!found) {
[799b60e]592    owl_function_makemsg("already at last%s message%s%s%s",
[b950088]593                         skip_deleted?" non-deleted":"",
[799b60e]594                         filter?" in ":"", filter?filter:"",
595                         owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g)) ?
596                         ", press Enter to scroll" : "");
[5a6e6b9]597    /* if (!skip_deleted) owl_function_beep(); */
[7d4fbcd]598  }
599
[b950088]600  if (last_if_none || found) {
601    owl_global_set_curmsg(&g, i);
602    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
603    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
604    owl_global_set_direction_downwards(&g);
605  }
606}
[7d4fbcd]607
[e19eb97]608void owl_function_prevmsg_full(const char *filter, int skip_deleted, int first_if_none)
[d54838d]609{
[402eb16f]610  int curmsg, i, found;
[9e5c9f3]611  const owl_view *v;
[4542047]612  const owl_filter *f = NULL;
[c08c70a]613  const owl_message *m;
[7d4fbcd]614
615  v=owl_global_get_current_view(&g);
616
[b950088]617  if (filter) {
618    f=owl_global_get_filter(&g, filter);
619    if (!f) {
[ec6ff52]620      owl_function_error("No %s filter defined", filter);
[b950088]621      return;
[7d4fbcd]622    }
[b950088]623  }
[7d4fbcd]624
[b950088]625  curmsg=owl_global_get_curmsg(&g);
626  found=0;
627
628  /* just check to make sure we're in bounds... */
629  if (curmsg<0) curmsg=0;
630
631  for (i=curmsg-1; i>=0; i--) {
632    m=owl_view_get_element(v, i);
633    if (skip_deleted && owl_message_is_delete(m)) continue;
634    if (f && !owl_filter_message_match(f, m)) continue;
635    found = 1;
636    break;
637  }
638
639  if (i<0) i=0;
640
641  if (!found) {
[f51bc78]642    owl_function_makemsg("already at first%s message%s%s",
[b950088]643                         skip_deleted?" non-deleted":"",
644                         filter?" in ":"", filter?filter:"");
[5a6e6b9]645    /* if (!skip_deleted) owl_function_beep(); */
[b950088]646  }
647
648  if (first_if_none || found) {
649    owl_global_set_curmsg(&g, i);
650    owl_function_calculate_topmsg(OWL_DIRECTION_UPWARDS);
651    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
652    owl_global_set_direction_upwards(&g);
[7d4fbcd]653  }
654}
655
[c79a047]656void owl_function_nextmsg(void)
[d54838d]657{
[b950088]658  owl_function_nextmsg_full(NULL, 0, 1);
659}
[7d4fbcd]660
[c79a047]661void owl_function_prevmsg(void)
[d54838d]662{
[b950088]663  owl_function_prevmsg_full(NULL, 0, 1);
664}
[7d4fbcd]665
[c79a047]666void owl_function_nextmsg_notdeleted(void)
[d54838d]667{
[b950088]668  owl_function_nextmsg_full(NULL, 1, 1);
669}
[7d4fbcd]670
[c79a047]671void owl_function_prevmsg_notdeleted(void)
[d54838d]672{
[b950088]673  owl_function_prevmsg_full(NULL, 1, 1);
[7d4fbcd]674}
675
[b950088]676/* if move_after is 1, moves after the delete */
[d54838d]677void owl_function_deletecur(int move_after)
678{
[7d4fbcd]679  int curmsg;
680  owl_view *v;
681
682  v=owl_global_get_current_view(&g);
683
684  /* bail if there's no current message */
685  if (owl_view_get_size(v) < 1) {
[ec6ff52]686    owl_function_error("No current message to delete");
[7d4fbcd]687    return;
688  }
689
690  /* mark the message for deletion */
691  curmsg=owl_global_get_curmsg(&g);
692  owl_view_delete_element(v, curmsg);
693
[b950088]694  if (move_after) {
695    /* move the poiner in the appropriate direction
696     * to the next undeleted msg */
697    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
698      owl_function_prevmsg_notdeleted();
699    } else {
700      owl_function_nextmsg_notdeleted();
701    }
[7d4fbcd]702  }
703}
704
[d54838d]705void owl_function_undeletecur(int move_after)
706{
[7d4fbcd]707  int curmsg;
708  owl_view *v;
709
710  v=owl_global_get_current_view(&g);
711 
712  if (owl_view_get_size(v) < 1) {
[ec6ff52]713    owl_function_error("No current message to undelete");
[7d4fbcd]714    return;
715  }
716  curmsg=owl_global_get_curmsg(&g);
717
718  owl_view_undelete_element(v, curmsg);
719
[b950088]720  if (move_after) {
721    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
722      if (curmsg>0) {
723        owl_function_prevmsg();
724      } else {
725        owl_function_nextmsg();
726      }
[7d4fbcd]727    } else {
[b950088]728      owl_function_nextmsg();
[7d4fbcd]729    }
730  }
731
732  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
733}
734
[c79a047]735void owl_function_expunge(void)
[d54838d]736{
[7d4fbcd]737  int curmsg;
[c08c70a]738  const owl_message *m;
[7d4fbcd]739  owl_messagelist *ml;
740  owl_view *v;
[486688f]741  int lastmsgid=0;
[7d4fbcd]742
743  curmsg=owl_global_get_curmsg(&g);
744  v=owl_global_get_current_view(&g);
745  ml=owl_global_get_msglist(&g);
746
747  m=owl_view_get_element(v, curmsg);
[486688f]748  if (m) lastmsgid = owl_message_get_id(m);
[7d4fbcd]749
750  /* expunge the message list */
751  owl_messagelist_expunge(ml);
752
753  /* update all views (we only have one right now) */
754  owl_view_recalculate(v);
755
[486688f]756  /* find where the new position should be
757     (as close as possible to where we last where) */
758  curmsg = owl_view_get_nearest_to_msgid(v, lastmsgid);
759  if (curmsg>owl_view_get_size(v)-1) curmsg = owl_view_get_size(v)-1;
760  if (curmsg<0) curmsg = 0;
761  owl_global_set_curmsg(&g, curmsg);
762  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
[7d4fbcd]763  /* if there are no messages set the direction to down in case we
764     delete everything upwards */
765  owl_global_set_direction_downwards(&g);
766 
767  owl_function_makemsg("Messages expunged");
768  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
769}
770
[c79a047]771void owl_function_firstmsg(void)
[d54838d]772{
[7d4fbcd]773  owl_global_set_curmsg(&g, 0);
774  owl_global_set_topmsg(&g, 0);
775  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
776  owl_global_set_direction_downwards(&g);
777}
778
[c79a047]779void owl_function_lastmsg_noredisplay(void)
[d54838d]780{
[5eeea3b]781  int oldcurmsg, curmsg;
[9e5c9f3]782  const owl_view *v;
[7d4fbcd]783
784  v=owl_global_get_current_view(&g);
[5eeea3b]785  oldcurmsg=owl_global_get_curmsg(&g);
786  curmsg=owl_view_get_size(v)-1; 
[7d4fbcd]787  if (curmsg<0) curmsg=0;
788  owl_global_set_curmsg(&g, curmsg);
[5eeea3b]789  if (oldcurmsg < curmsg) {
790    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
791  } else if (curmsg<owl_view_get_size(v)) {
792    /* If already at the end, blank the screen and move curmsg
793     * past the end of the messages. */
794    owl_global_set_topmsg(&g, curmsg+1);
795    owl_global_set_curmsg(&g, curmsg+1);
796  } 
[6b580b0]797  /* owl_mainwin_redisplay(owl_global_get_mainwin(&g)); */
[7d4fbcd]798  owl_global_set_direction_downwards(&g);
799}
800
[c79a047]801void owl_function_lastmsg(void)
[d54838d]802{
[7d4fbcd]803  owl_function_lastmsg_noredisplay();
804  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
805}
806
[c79a047]807void owl_function_shift_right(void)
[d54838d]808{
[7d4fbcd]809  owl_global_set_rightshift(&g, owl_global_get_rightshift(&g)+10);
810  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
811  owl_global_set_needrefresh(&g);
812}
813
[c79a047]814void owl_function_shift_left(void)
[d54838d]815{
[7d4fbcd]816  int shift;
817
818  shift=owl_global_get_rightshift(&g);
[8c97fa1]819  if (shift > 0) {
820    owl_global_set_rightshift(&g, MAX(shift - 10, 0));
[7d4fbcd]821    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
822    owl_global_set_needrefresh(&g);
823  } else {
824    owl_function_beep();
[f51bc78]825    owl_function_makemsg("Already full left");
[7d4fbcd]826  }
827}
828
[c79a047]829void owl_function_unsuball(void)
[d54838d]830{
[7d4fbcd]831  unsuball();
832  owl_function_makemsg("Unsubscribed from all messages.");
833}
834
[95474d7]835
836/* Load zephyr subscriptions from the named 'file' and load zephyr's
837 * default subscriptions as well.  An error message is printed if
838 * 'file' can't be opened or if zephyr reports an error in
839 * subscribing.
840 *
841 * If 'file' is NULL, this look for the default filename
842 * $HOME/.zephyr.subs.  If the file can not be opened in this case
843 * only, no error message is printed.
844 */
[e19eb97]845void owl_function_loadsubs(const char *file)
[d54838d]846{
[4357be8]847  int ret, ret2;
[e19eb97]848  const char *foo;
[65b2173]849  char *path;
[ecd5dc5]850
[95474d7]851  if (file==NULL) {
852    ret=owl_zephyr_loadsubs(NULL, 0);
853  } else {
[27d8d83]854    path = owl_util_makepath(file);
855    ret=owl_zephyr_loadsubs(path, 1);
[27f6487]856    owl_free(path);
[95474d7]857  }
[ecd5dc5]858
[4357be8]859  /* for backwards compatibility for now */
860  ret2=owl_zephyr_loaddefaultsubs();
861
[ecd5dc5]862  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
[95474d7]863
864  foo=file?file:"file";
865  if (ret==0 && ret2==0) {
866    if (!file) {
867      owl_function_makemsg("Subscribed to messages.");
868    } else {
869      owl_function_makemsg("Subscribed to messages from %s", file);
870    }
[7d4fbcd]871  } else if (ret==-1) {
[95474d7]872    owl_function_error("Could not read %s", foo);
[7d4fbcd]873  } else {
[95474d7]874    owl_function_error("Error subscribing to messages");
[7d4fbcd]875  }
876}
877
[e19eb97]878void owl_function_loadloginsubs(const char *file)
[d54838d]879{
[7933748]880  int ret;
[ecd5dc5]881
[7933748]882  ret=owl_zephyr_loadloginsubs(file);
[ecd5dc5]883
884  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
[7933748]885  if (ret==0) {
886  } else if (ret==-1) {
[ec6ff52]887    owl_function_error("Could not open file for login subscriptions.");
[7933748]888  } else {
[ec6ff52]889    owl_function_error("Error subscribing to login messages from file.");
[7933748]890  }
891}
892
[1b6b2f3]893void owl_callback_aimlogin(owl_editwin *e) {
[8dfb59c]894  char *user = owl_editwin_get_cbdata(e);
895  owl_function_aimlogin(user,
[db8b00b]896                        owl_editwin_get_text(e));
[1b6b2f3]897}
898
[e19eb97]899void owl_function_aimlogin(const char *user, const char *passwd) {
[4211f50b]900  int ret;
901
902  /* clear the buddylist */
903  owl_buddylist_clear(owl_global_get_buddylist(&g));
904
905  /* try to login */
906  ret=owl_aim_login(user, passwd);
907  if (ret) owl_function_makemsg("Warning: login for %s failed.\n", user);
908}
909
[c79a047]910void owl_function_suspend(void)
[d54838d]911{
[7d4fbcd]912  endwin();
913  printf("\n");
914  kill(getpid(), SIGSTOP);
915
916  /* resize to reinitialize all the windows when we come back */
917  owl_command_resize();
918}
919
[c79a047]920void owl_function_zaway_toggle(void)
[d54838d]921{
[7d4fbcd]922  if (!owl_global_is_zaway(&g)) {
923    owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
924    owl_function_zaway_on();
925  } else {
926    owl_function_zaway_off();
927  }
928}
929
[c79a047]930void owl_function_zaway_on(void)
[d54838d]931{
[7d4fbcd]932  owl_global_set_zaway_on(&g);
[4b660cc]933  owl_function_makemsg("zaway set (%s)", owl_global_get_zaway_msg(&g));
[7d4fbcd]934}
935
[c79a047]936void owl_function_zaway_off(void)
[d54838d]937{
[7d4fbcd]938  owl_global_set_zaway_off(&g);
[4b660cc]939  owl_function_makemsg("zaway off");
940}
941
[c79a047]942void owl_function_aaway_toggle(void)
[4b660cc]943{
944  if (!owl_global_is_aaway(&g)) {
945    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
946    owl_function_aaway_on();
947  } else {
948    owl_function_aaway_off();
949  }
950}
951
[c79a047]952void owl_function_aaway_on(void)
[4b660cc]953{
954  owl_global_set_aaway_on(&g);
955  /* owl_aim_set_awaymsg(owl_global_get_zaway_msg(&g)); */
956  owl_function_makemsg("AIM away set (%s)", owl_global_get_aaway_msg(&g));
957}
958
[c79a047]959void owl_function_aaway_off(void)
[4b660cc]960{
961  owl_global_set_aaway_off(&g);
962  /* owl_aim_set_awaymsg(""); */
963  owl_function_makemsg("AIM away off");
[7d4fbcd]964}
965
[c79a047]966void owl_function_quit(void)
[d54838d]967{
[7d4fbcd]968  char *ret;
969 
970  /* zlog out if we need to */
[7433402]971  if (owl_global_is_havezephyr(&g) &&
972      owl_global_is_shutdownlogout(&g)) {
[31e48a3]973    owl_zephyr_zlog_out();
[7d4fbcd]974  }
975
976  /* execute the commands in shutdown */
[0337203]977  ret = owl_perlconfig_execute("BarnOwl::Hooks::_shutdown();");
[7d4fbcd]978  if (ret) owl_free(ret);
979
[d09e5a1]980  /* signal our child process, if any */
981  if (owl_global_get_newmsgproc_pid(&g)) {
982    kill(owl_global_get_newmsgproc_pid(&g), SIGHUP);
983  }
984
[8c46404]985  /* Quit zephyr */
[09489b89]986  owl_zephyr_shutdown();
[8c46404]987 
988  /* Quit AIM */
989  if (owl_global_is_aimloggedin(&g)) {
990    owl_aim_logout();
991  }
992
[8232149]993  /* done with curses */
[7d4fbcd]994  endwin();
[8232149]995
996  /* restore terminal settings */
997  tcsetattr(0, TCSAFLUSH, owl_global_get_startup_tio(&g));
998
[7d4fbcd]999  owl_function_debugmsg("Quitting Owl");
1000  exit(0);
1001}
1002
[d54838d]1003void owl_function_calculate_topmsg(int direction)
1004{
[aa2f33b3]1005  int recwinlines, topmsg, curmsg;
[9e5c9f3]1006  const owl_view *v;
[7d4fbcd]1007
1008  v=owl_global_get_current_view(&g);
[aa2f33b3]1009  curmsg=owl_global_get_curmsg(&g);
1010  topmsg=owl_global_get_topmsg(&g);
[7d4fbcd]1011  recwinlines=owl_global_get_recwin_lines(&g);
1012
[f9c43ae]1013  /*
[7d4fbcd]1014  if (owl_view_get_size(v) < 1) {
1015    return;
1016  }
[f9c43ae]1017  */
[aa2f33b3]1018
1019  switch (owl_global_get_scrollmode(&g)) {
1020  case OWL_SCROLLMODE_TOP:
[f9c43ae]1021    topmsg = owl_function_calculate_topmsg_top(direction, v, curmsg, topmsg, recwinlines);
[aa2f33b3]1022    break;
1023  case OWL_SCROLLMODE_NEARTOP:
[f9c43ae]1024    topmsg = owl_function_calculate_topmsg_neartop(direction, v, curmsg, topmsg, recwinlines);
[aa2f33b3]1025    break;
1026  case OWL_SCROLLMODE_CENTER:
[f9c43ae]1027    topmsg = owl_function_calculate_topmsg_center(direction, v, curmsg, topmsg, recwinlines);
[aa2f33b3]1028    break;
1029  case OWL_SCROLLMODE_PAGED:
[f9c43ae]1030    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 0);
[aa2f33b3]1031    break;
1032  case OWL_SCROLLMODE_PAGEDCENTER:
[f9c43ae]1033    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 1);
[aa2f33b3]1034    break;
1035  case OWL_SCROLLMODE_NORMAL:
1036  default:
[f9c43ae]1037    topmsg = owl_function_calculate_topmsg_normal(direction, v, curmsg, topmsg, recwinlines);
[aa2f33b3]1038  }
[3a2daac]1039  owl_function_debugmsg("Calculated a topmsg of %i", topmsg);
[aa2f33b3]1040  owl_global_set_topmsg(&g, topmsg);
1041}
1042
1043/* Returns what the new topmsg should be. 
1044 * Passed the last direction of movement,
1045 * the current view,
1046 * the current message number in the view,
1047 * the top message currently being displayed,
1048 * and the number of lines in the recwin.
1049 */
[9e5c9f3]1050int owl_function_calculate_topmsg_top(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
[d54838d]1051{
[f9c43ae]1052  return(curmsg);
[aa2f33b3]1053}
1054
[9e5c9f3]1055int owl_function_calculate_topmsg_neartop(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
[d54838d]1056{
[aa2f33b3]1057  if (curmsg>0 
1058      && (owl_message_get_numlines(owl_view_get_element(v, curmsg-1))
1059          <  recwinlines/2)) {
[f9c43ae]1060    return(curmsg-1);
[aa2f33b3]1061  } else {
[f9c43ae]1062    return(curmsg);
[aa2f33b3]1063  }
1064}
1065 
[9e5c9f3]1066int owl_function_calculate_topmsg_center(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
[d54838d]1067{
[aa2f33b3]1068  int i, last, lines;
1069
1070  last = curmsg;
1071  lines = 0;
1072  for (i=curmsg-1; i>=0; i--) {
1073    lines += owl_message_get_numlines(owl_view_get_element(v, i));
1074    if (lines > recwinlines/2) break;
1075    last = i;
1076  }
[f9c43ae]1077  return(last);
[aa2f33b3]1078}
1079 
[9e5c9f3]1080int owl_function_calculate_topmsg_paged(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines, int center_on_page)
[d54838d]1081{
[aa2f33b3]1082  int i, last, lines, savey;
1083 
1084  /* If we're off the top of the screen, scroll up such that the
1085   * curmsg is near the botton of the screen. */
1086  if (curmsg < topmsg) {
1087    last = curmsg;
1088    lines = 0;
1089    for (i=curmsg; i>=0; i--) {
1090      lines += owl_message_get_numlines(owl_view_get_element(v, i));
1091      if (lines > recwinlines) break;
1092    last = i;
1093    }
1094    if (center_on_page) {
[f9c43ae]1095      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
[aa2f33b3]1096    } else {
[f9c43ae]1097      return(last);
[aa2f33b3]1098    }
1099  }
1100
1101  /* Find number of lines from top to bottom of curmsg (store in savey) */
1102  savey=0;
1103  for (i=topmsg; i<=curmsg; i++) {
1104    savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1105  }
1106
1107  /* if we're off the bottom of the screen, scroll down */
1108  if (savey > recwinlines) {
1109    if (center_on_page) {
[f9c43ae]1110      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
[aa2f33b3]1111    } else {
[f9c43ae]1112      return(curmsg);
[aa2f33b3]1113    }
1114  }
1115
1116  /* else just stay as we are... */
[f9c43ae]1117  return(topmsg);
[aa2f33b3]1118}
1119
[9e5c9f3]1120int owl_function_calculate_topmsg_normal(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
[d54838d]1121{
[801b7ac]1122  int savey, i, foo, y;
[f9c43ae]1123
[88736cb]1124  if (curmsg<0) return(topmsg);
1125   
[f9c43ae]1126  /* If we're off the top of the screen then center */
1127  if (curmsg<topmsg) {
1128    topmsg=owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines);
1129  }
1130
[801b7ac]1131  /* If curmsg is so far past topmsg that there are more messages than
1132     lines, skip the line counting that follows because we're
1133     certainly off screen.  */
1134  savey=curmsg-topmsg;
1135  if (savey <= recwinlines) {
1136    /* Find number of lines from top to bottom of curmsg (store in savey) */
1137    savey = 0;
1138    for (i=topmsg; i<=curmsg; i++) {
1139      savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1140    }
[7d4fbcd]1141  }
1142
[f9c43ae]1143  /* If we're off the bottom of the screen, set the topmsg to curmsg
1144   * and scroll upwards */
1145  if (savey > recwinlines) {
1146    topmsg=curmsg;
[801b7ac]1147    savey=owl_message_get_numlines(owl_view_get_element(v, curmsg));
[f9c43ae]1148    direction=OWL_DIRECTION_UPWARDS;
[7d4fbcd]1149  }
[f9c43ae]1150 
[7d4fbcd]1151  /* If our bottom line is less than 1/4 down the screen then scroll up */
1152  if (direction == OWL_DIRECTION_UPWARDS || direction == OWL_DIRECTION_NONE) {
1153    if (savey < (recwinlines / 4)) {
1154      y=0;
[801b7ac]1155      for (i=curmsg; i>=0; i--) {
1156        foo=owl_message_get_numlines(owl_view_get_element(v, i));
[7d4fbcd]1157        /* will we run the curmsg off the screen? */
1158        if ((foo+y) >= recwinlines) {
[801b7ac]1159          i++;
1160          if (i>curmsg) i=curmsg;
[7d4fbcd]1161          break;
1162        }
1163        /* have saved 1/2 the screen space? */
1164        y+=foo;
1165        if (y > (recwinlines / 2)) break;
1166      }
[801b7ac]1167      if (i<0) i=0;
1168      return(i);
[7d4fbcd]1169    }
1170  }
1171
1172  if (direction == OWL_DIRECTION_DOWNWARDS || direction == OWL_DIRECTION_NONE) {
1173    /* If curmsg bottom line is more than 3/4 down the screen then scroll down */
1174    if (savey > ((recwinlines * 3)/4)) {
1175      y=0;
1176      /* count lines from the top until we can save 1/2 the screen size */
[801b7ac]1177      for (i=topmsg; i<curmsg; i++) {
1178        y+=owl_message_get_numlines(owl_view_get_element(v, i));
[7d4fbcd]1179        if (y > (recwinlines / 2)) break;
1180      }
[801b7ac]1181      if (i==curmsg) {
1182        i--;
[7d4fbcd]1183      }
[801b7ac]1184      return(i+1);
[7d4fbcd]1185    }
1186  }
[aa2f33b3]1187
[f9c43ae]1188  return(topmsg);
[7d4fbcd]1189}
1190
[c79a047]1191void owl_function_resize(void)
[d54838d]1192{
[7d4fbcd]1193  owl_global_set_resize_pending(&g);
1194}
1195
[e19eb97]1196void owl_function_debugmsg(const char *fmt, ...)
[d54838d]1197{
[7d4fbcd]1198  FILE *file;
1199  time_t now;
1200  va_list ap;
1201  va_start(ap, fmt);
1202
[52761cc]1203  if (!owl_global_is_debug_fast(&g))
1204    return;
[7d4fbcd]1205
[52761cc]1206  file = fopen(owl_global_get_debug_file(&g), "a");
1207  if (!file) /* XXX should report this */
1208    return;
[7d4fbcd]1209
[52761cc]1210  now = time(NULL);
[7d4fbcd]1211
[52761cc]1212  fprintf(file, "[%d -  %.24s - %lds]: ",
1213          (int) getpid(), ctime(&now), now - owl_global_get_starttime(&g));
[7d4fbcd]1214  vfprintf(file, fmt, ap);
[52761cc]1215  putc('\n', file);
[7d4fbcd]1216  fclose(file);
1217
1218  va_end(ap);
1219}
1220
[c79a047]1221void owl_function_beep(void)
[d54838d]1222{
[7d4fbcd]1223  if (owl_global_is_bell(&g)) {
1224    beep();
[b45293f]1225    owl_global_set_needrefresh(&g); /* do we really need this? */
[7d4fbcd]1226  }
1227}
1228
[e19eb97]1229int owl_function_subscribe(const char *class, const char *inst, const char *recip)
[d54838d]1230{
[7d4fbcd]1231  int ret;
1232
1233  ret=owl_zephyr_sub(class, inst, recip);
1234  if (ret) {
[ec6ff52]1235    owl_function_error("Error subscribing.");
[7d4fbcd]1236  } else {
1237    owl_function_makemsg("Subscribed.");
1238  }
[3617286]1239  return(ret);
[7d4fbcd]1240}
1241
[e19eb97]1242void owl_function_unsubscribe(const char *class, const char *inst, const char *recip)
[d54838d]1243{
[7d4fbcd]1244  int ret;
1245
1246  ret=owl_zephyr_unsub(class, inst, recip);
1247  if (ret) {
[ec6ff52]1248    owl_function_error("Error subscribing.");
[7d4fbcd]1249  } else {
1250    owl_function_makemsg("Unsubscribed.");
1251  }
1252}
1253
[d54838d]1254void owl_function_set_cursor(WINDOW *win)
1255{
[8ae2de9]1256  /* Be careful that this window is actually empty, otherwise panels get confused */
[dfe94f9]1257  if (is_wintouched(win)) {
1258    owl_function_debugmsg("Warning: owl_function_set_cursor called on dirty window");
1259    update_panels();
1260  }
[7d4fbcd]1261  wnoutrefresh(win);
1262}
1263
[c79a047]1264void owl_function_full_redisplay(void)
[d54838d]1265{
[7d4fbcd]1266  redrawwin(owl_global_get_curs_recwin(&g));
1267  redrawwin(owl_global_get_curs_sepwin(&g));
[af1920fd]1268  /* Work around curses segfualts with windows off the screen */
[451becb]1269  if (g.lines >= owl_global_get_typwin_lines(&g)+2)
1270      redrawwin(owl_global_get_curs_typwin(&g));
1271  if (g.lines >= 2)
1272      redrawwin(owl_global_get_curs_msgwin(&g));
[7d4fbcd]1273
1274  sepbar("");
1275  owl_function_makemsg("");
1276
1277  owl_global_set_needrefresh(&g);
1278}
1279
[e19eb97]1280void owl_function_popless_text(const char *text)
[d54838d]1281{
[7d4fbcd]1282  owl_popwin *pw;
1283  owl_viewwin *v;
1284
1285  pw=owl_global_get_popwin(&g);
1286  v=owl_global_get_viewwin(&g);
1287
1288  owl_popwin_up(pw);
[2a17b63]1289  owl_global_push_context(&g, OWL_CTX_POPLESS, v, "popless");
[7d4fbcd]1290  owl_viewwin_init_text(v, owl_popwin_get_curswin(pw),
1291                        owl_popwin_get_lines(pw), owl_popwin_get_cols(pw),
1292                        text);
[4cca591]1293  owl_viewwin_redisplay(v);
[7d4fbcd]1294  owl_global_set_needrefresh(&g);
1295}
1296
[075ba92]1297void owl_function_popless_fmtext(const owl_fmtext *fm)
[d54838d]1298{
[7d4fbcd]1299  owl_popwin *pw;
1300  owl_viewwin *v;
1301
1302  pw=owl_global_get_popwin(&g);
1303  v=owl_global_get_viewwin(&g);
1304
1305  owl_popwin_up(pw);
[2a17b63]1306  owl_global_push_context(&g, OWL_CTX_POPLESS, v, "popless");
[7d4fbcd]1307  owl_viewwin_init_fmtext(v, owl_popwin_get_curswin(pw),
1308                   owl_popwin_get_lines(pw), owl_popwin_get_cols(pw),
1309                   fm);
[4cca591]1310  owl_viewwin_redisplay(v);
[7d4fbcd]1311  owl_global_set_needrefresh(&g);
[f17bff98]1312}
1313
[e19eb97]1314void owl_function_popless_file(const char *filename)
[f17bff98]1315{
1316  owl_fmtext fm;
1317  FILE *file;
[b7ee89b]1318  char *s = NULL;
[f17bff98]1319
1320  file=fopen(filename, "r");
1321  if (!file) {
1322    owl_function_error("Could not open file: %s", filename);
1323    return;
1324  }
1325
1326  owl_fmtext_init_null(&fm);
[b7ee89b]1327  while (owl_getline(&s, file))
1328    owl_fmtext_append_normal(&fm, s);
1329  owl_free(s);
[f17bff98]1330
1331  owl_function_popless_fmtext(&fm);
[7ab0020]1332  owl_fmtext_cleanup(&fm);
[f17bff98]1333  fclose(file);
[7d4fbcd]1334}
1335
[c79a047]1336void owl_function_about(void)
[d54838d]1337{
[2101a50]1338  owl_function_popless_text(
1339    "This is barnowl version " OWL_VERSION_STRING ".\n\n"
1340    "barnowl is a fork of the Owl zephyr client, written and\n"
1341    "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
1342    "Massachusetts Institute of Technology. \n"
1343    "\n"
1344    "Owl was written by James Kretchmar. The first version, 0.5, was\n"
1345    "released in March 2002.\n"
1346    "\n"
1347    "The name 'owl' was chosen in reference to the owls in the\n"
1348    "Harry Potter novels, who are tasked with carrying messages\n"
1349    "between Witches and Wizards. The name 'barnowl' was chosen\n"
1350    "because we feel our owls should live closer to our ponies.\n"
1351    "\n"
[1cfcab7]1352    "Copyright (c) 2006-2010 The BarnOwl Developers. All rights reserved.\n"
[2101a50]1353    "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
1354    "Copyright 2002 Massachusetts Institute of Technology\n"
1355    "\n"
1356    "This program is free software. You can redistribute it and/or\n"
1357    "modify under the terms of the Sleepycat License. Use the \n"
1358    "':show license' command to display the full license\n"
1359  );
[7d4fbcd]1360}
1361
[c79a047]1362void owl_function_info(void)
[d54838d]1363{
[c08c70a]1364  const owl_message *m;
[5789230]1365  owl_fmtext fm, attrfm;
[9e5c9f3]1366  const owl_view *v;
[09489b89]1367#ifdef HAVE_LIBZEPHYR
[1077891a]1368  const ZNotice_t *n;
[09489b89]1369#endif
[7d4fbcd]1370
[d0d65df]1371  owl_fmtext_init_null(&fm);
1372 
[7d4fbcd]1373  v=owl_global_get_current_view(&g);
[5eeea3b]1374  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1375  if (!m || owl_view_get_size(v)==0) {
[ec6ff52]1376    owl_function_error("No message selected\n");
[7d4fbcd]1377    return;
1378  }
1379
[5789230]1380  owl_fmtext_append_bold(&fm, "General Information:\n");
[57609b3]1381  owl_fmtext_appendf_normal(&fm, "  Msg Id    : %i\n", owl_message_get_id(m));
[df0d93a]1382
[5789230]1383  owl_fmtext_append_normal(&fm, "  Type      : ");
[37eab7f]1384  owl_fmtext_append_bold(&fm, owl_message_get_type(m));
[df0d93a]1385  owl_fmtext_append_normal(&fm, "\n");
1386
[4b464a4]1387  if (owl_message_is_direction_in(m)) {
[5789230]1388    owl_fmtext_append_normal(&fm, "  Direction : in\n");
[4b464a4]1389  } else if (owl_message_is_direction_out(m)) {
[5789230]1390    owl_fmtext_append_normal(&fm, "  Direction : out\n");
[4b464a4]1391  } else if (owl_message_is_direction_none(m)) {
[5789230]1392    owl_fmtext_append_normal(&fm, "  Direction : none\n");
[4b464a4]1393  } else {
[5789230]1394    owl_fmtext_append_normal(&fm, "  Direction : unknown\n");
[4b464a4]1395  }
[df0d93a]1396
[57609b3]1397  owl_fmtext_appendf_normal(&fm, "  Time      : %s\n", owl_message_get_timestr(m));
[4b464a4]1398
[df0d93a]1399  if (!owl_message_is_type_admin(m)) {
[57609b3]1400    owl_fmtext_appendf_normal(&fm, "  Sender    : %s\n", owl_message_get_sender(m));
1401    owl_fmtext_appendf_normal(&fm, "  Recipient : %s\n", owl_message_get_recipient(m));
[df0d93a]1402  }
[57609b3]1403
[0ff8fb57]1404  if (owl_message_is_type_zephyr(m)) {
[5789230]1405    owl_fmtext_append_bold(&fm, "\nZephyr Specific Information:\n");
[0ff8fb57]1406   
[57609b3]1407    owl_fmtext_appendf_normal(&fm, "  Class     : %s\n", owl_message_get_class(m));
1408    owl_fmtext_appendf_normal(&fm, "  Instance  : %s\n", owl_message_get_instance(m));
1409    owl_fmtext_appendf_normal(&fm, "  Opcode    : %s\n", owl_message_get_opcode(m));
[09489b89]1410#ifdef HAVE_LIBZEPHYR
[d0d65df]1411    if (owl_message_is_direction_in(m)) {
[09489b89]1412      char *ptr, tmpbuff[1024];
1413      int i, j, fields, len;
1414
[d0d65df]1415      n=owl_message_get_notice(m);
[df0d93a]1416
[5a95b69]1417      if (!owl_message_is_pseudo(m)) {
1418        owl_fmtext_append_normal(&fm, "  Kind      : ");
1419        if (n->z_kind==UNSAFE) {
1420          owl_fmtext_append_normal(&fm, "UNSAFE\n");
1421        } else if (n->z_kind==UNACKED) {
1422          owl_fmtext_append_normal(&fm, "UNACKED\n");
1423        } else if (n->z_kind==ACKED) {
1424          owl_fmtext_append_normal(&fm, "ACKED\n");
1425        } else if (n->z_kind==HMACK) {
1426          owl_fmtext_append_normal(&fm, "HMACK\n");
1427        } else if (n->z_kind==HMCTL) {
1428          owl_fmtext_append_normal(&fm, "HMCTL\n");
1429        } else if (n->z_kind==SERVACK) {
1430          owl_fmtext_append_normal(&fm, "SERVACK\n");
1431        } else if (n->z_kind==SERVNAK) {
1432          owl_fmtext_append_normal(&fm, "SERVNACK\n");
1433        } else if (n->z_kind==CLIENTACK) {
1434          owl_fmtext_append_normal(&fm, "CLIENTACK\n");
1435        } else if (n->z_kind==STAT) {
1436          owl_fmtext_append_normal(&fm, "STAT\n");
1437        } else {
1438          owl_fmtext_append_normal(&fm, "ILLEGAL VALUE\n");
1439        }
[d0d65df]1440      }
[57609b3]1441      owl_fmtext_appendf_normal(&fm, "  Host      : %s\n", owl_message_get_hostname(m));
[5a95b69]1442
1443      if (!owl_message_is_pseudo(m)) {
1444        owl_fmtext_append_normal(&fm, "\n");
[57609b3]1445        owl_fmtext_appendf_normal(&fm, "  Port      : %i\n", ntohs(n->z_port));
[f12d199]1446        owl_fmtext_appendf_normal(&fm, "  Auth      : %s\n", owl_zephyr_get_authstr(n));
[57609b3]1447
1448        /* FIXME make these more descriptive */
[f12d199]1449        owl_fmtext_appendf_normal(&fm, "  Checkd Ath: %i\n", n->z_checked_auth);
[57609b3]1450        owl_fmtext_appendf_normal(&fm, "  Multi notc: %s\n", n->z_multinotice);
1451        owl_fmtext_appendf_normal(&fm, "  Num other : %i\n", n->z_num_other_fields);
1452        owl_fmtext_appendf_normal(&fm, "  Msg Len   : %i\n", n->z_message_len);
[5a95b69]1453
1454        fields=owl_zephyr_get_num_fields(n);
[57609b3]1455        owl_fmtext_appendf_normal(&fm, "  Fields    : %i\n", fields);
1456
[5a95b69]1457        for (i=0; i<fields; i++) {
[5376a95]1458          ptr=owl_zephyr_get_field_as_utf8(n, i+1);
[b0430a6]1459          len=strlen(ptr);
[5a95b69]1460          if (len<30) {
1461            strncpy(tmpbuff, ptr, len);
1462            tmpbuff[len]='\0';
1463          } else {
1464            strncpy(tmpbuff, ptr, 30);
1465            tmpbuff[30]='\0';
1466            strcat(tmpbuff, "...");
1467          }
[b0430a6]1468          owl_free(ptr);
[57609b3]1469
[5a95b69]1470          for (j=0; j<strlen(tmpbuff); j++) {
1471            if (tmpbuff[j]=='\n') tmpbuff[j]='~';
1472            if (tmpbuff[j]=='\r') tmpbuff[j]='!';
1473          }
[57609b3]1474
1475          owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i+1, tmpbuff);
[5a95b69]1476        }
[57609b3]1477        owl_fmtext_appendf_normal(&fm, "  Default Fm: %s\n", n->z_default_format);
[d0d65df]1478      }
[57609b3]1479
[7d4fbcd]1480    }
[57609b3]1481#endif
[7d4fbcd]1482  }
[0ff8fb57]1483
[5789230]1484  owl_fmtext_append_bold(&fm, "\nOwl Message Attributes:\n");
1485  owl_message_attributes_tofmtext(m, &attrfm);
1486  owl_fmtext_append_fmtext(&fm, &attrfm);
[d0d65df]1487 
1488  owl_function_popless_fmtext(&fm);
[7ab0020]1489  owl_fmtext_cleanup(&fm);
1490  owl_fmtext_cleanup(&attrfm);
[7d4fbcd]1491}
1492
[5639bf2]1493/* print the current message in a popup window.
1494 * Use the 'default' style regardless of whatever
1495 * style the user may be using
1496 */
[c79a047]1497void owl_function_curmsg_to_popwin(void)
[d54838d]1498{
[9e5c9f3]1499  const owl_view *v;
[c08c70a]1500  const owl_message *m;
[1fdab04]1501  const owl_style *s;
[5639bf2]1502  owl_fmtext fm;
[7d4fbcd]1503
[5639bf2]1504  v=owl_global_get_current_view(&g);
1505  s=owl_global_get_style_by_name(&g, "default");
[7d4fbcd]1506
[5eeea3b]1507  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1508
1509  if (!m || owl_view_get_size(v)==0) {
[ec6ff52]1510    owl_function_error("No current message");
[7d4fbcd]1511    return;
1512  }
1513
[5639bf2]1514  owl_fmtext_init_null(&fm);
1515  owl_style_get_formattext(s, &fm, m);
1516
1517  owl_function_popless_fmtext(&fm);
[7ab0020]1518  owl_fmtext_cleanup(&fm);
[7d4fbcd]1519}
1520
[d54838d]1521void owl_function_page_curmsg(int step)
1522{
[7d4fbcd]1523  /* scroll down or up within the current message IF the message is truncated */
1524
1525  int offset, curmsg, lines;
[9e5c9f3]1526  const owl_view *v;
[7d4fbcd]1527  owl_message *m;
1528
1529  offset=owl_global_get_curmsg_vert_offset(&g);
1530  v=owl_global_get_current_view(&g);
1531  curmsg=owl_global_get_curmsg(&g);
1532  m=owl_view_get_element(v, curmsg);
[5eeea3b]1533  if (!m || owl_view_get_size(v)==0) return;
[7d4fbcd]1534  lines=owl_message_get_numlines(m);
1535
1536  if (offset==0) {
1537    /* Bail if the curmsg isn't the last one displayed */
1538    if (curmsg != owl_mainwin_get_last_msg(owl_global_get_mainwin(&g))) {
[f51bc78]1539      owl_function_makemsg("The entire message is already displayed");
[7d4fbcd]1540      return;
1541    }
1542   
1543    /* Bail if we're not truncated */
1544    if (!owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g))) {
[f51bc78]1545      owl_function_makemsg("The entire message is already displayed");
[7d4fbcd]1546      return;
1547    }
1548  }
1549 
1550 
1551  /* don't scroll past the last line */
1552  if (step>0) {
1553    if (offset+step > lines-1) {
1554      owl_global_set_curmsg_vert_offset(&g, lines-1);
1555    } else {
1556      owl_global_set_curmsg_vert_offset(&g, offset+step);
1557    }
1558  }
1559
1560  /* would we be before the beginning of the message? */
1561  if (step<0) {
1562    if (offset+step<0) {
1563      owl_global_set_curmsg_vert_offset(&g, 0);
1564    } else {
1565      owl_global_set_curmsg_vert_offset(&g, offset+step);
1566    }
1567  }
1568 
1569  /* redisplay */
1570  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1571  owl_global_set_needrefresh(&g);
1572}
1573
[d54838d]1574void owl_function_resize_typwin(int newsize)
1575{
[7d4fbcd]1576  owl_global_set_typwin_lines(&g, newsize);
1577  owl_function_resize();
1578}
1579
[c79a047]1580void owl_function_mainwin_pagedown(void)
[d54838d]1581{
[7d4fbcd]1582  int i;
1583
1584  i=owl_mainwin_get_last_msg(owl_global_get_mainwin(&g));
1585  if (i<0) return;
[f2e36b5]1586  if (owl_mainwin_is_last_msg_truncated(owl_global_get_mainwin(&g))
1587      && (owl_global_get_curmsg(&g) < i)
1588      && (i>0)) {
1589    i--;
1590  }
[7d4fbcd]1591  owl_global_set_curmsg(&g, i);
1592  owl_function_nextmsg();
1593}
1594
[c79a047]1595void owl_function_mainwin_pageup(void)
[d54838d]1596{
[7d4fbcd]1597  owl_global_set_curmsg(&g, owl_global_get_topmsg(&g));
1598  owl_function_prevmsg();
1599}
1600
[c79a047]1601void owl_function_getsubs(void)
[d54838d]1602{
[09489b89]1603  char *buff;
[7d4fbcd]1604
[09489b89]1605  buff=owl_zephyr_getsubs();
[7d4fbcd]1606
[09489b89]1607  if (buff) {
1608    owl_function_popless_text(buff);
1609  } else {
1610    owl_function_popless_text("Error getting subscriptions");
[7d4fbcd]1611  }
[09489b89]1612           
[1c6c4d3]1613  owl_free(buff);
[7d4fbcd]1614}
1615
[c79a047]1616void owl_function_printallvars(void)
[d54838d]1617{
[e19eb97]1618  const char *name;
[b4c270c]1619  char var[LINE];
[7d4fbcd]1620  owl_list varnames;
[b4c270c]1621  int i, numvarnames;
1622  GString *str   = g_string_new("");
[7d4fbcd]1623
[b4c270c]1624  g_string_append_printf(str, "%-20s = %s\n", "VARIABLE", "VALUE");
1625  g_string_append_printf(str, "%-20s   %s\n",  "--------", "-----");
[7d4fbcd]1626  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1627  numvarnames = owl_list_get_size(&varnames);
1628  for (i=0; i<numvarnames; i++) {
1629    name = owl_list_get_element(&varnames, i);
1630    if (name && name[0]!='_') {
[b4c270c]1631      g_string_append_printf(str, "\n%-20s = ", name);
1632      owl_variable_get_tostring(owl_global_get_vardict(&g), name, var, LINE);
1633      g_string_append(str, var);
[7d4fbcd]1634    }
1635  }
[b4c270c]1636  g_string_append(str, "\n");
[0e57335]1637  owl_variable_dict_namelist_cleanup(&varnames);
[b4c270c]1638
1639  owl_function_popless_text(str->str);
1640  g_string_free(str, TRUE);
[7d4fbcd]1641}
1642
[c79a047]1643void owl_function_show_variables(void)
[d54838d]1644{
[7d4fbcd]1645  owl_list varnames;
1646  owl_fmtext fm; 
1647  int i, numvarnames;
[e19eb97]1648  const char *varname;
[7d4fbcd]1649
1650  owl_fmtext_init_null(&fm);
1651  owl_fmtext_append_bold(&fm, 
1652      "Variables: (use 'show variable <name>' for details)\n");
1653  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1654  numvarnames = owl_list_get_size(&varnames);
1655  for (i=0; i<numvarnames; i++) {
1656    varname = owl_list_get_element(&varnames, i);
1657    if (varname && varname[0]!='_') {
[aa2f33b3]1658      owl_variable_describe(owl_global_get_vardict(&g), varname, &fm);
[7d4fbcd]1659    }
1660  }
[0e57335]1661  owl_variable_dict_namelist_cleanup(&varnames);
[7d4fbcd]1662  owl_function_popless_fmtext(&fm);
[7ab0020]1663  owl_fmtext_cleanup(&fm);
[7d4fbcd]1664}
1665
[e19eb97]1666void owl_function_show_variable(const char *name)
[d54838d]1667{
[7d4fbcd]1668  owl_fmtext fm; 
1669
1670  owl_fmtext_init_null(&fm);
1671  owl_variable_get_help(owl_global_get_vardict(&g), name, &fm);
1672  owl_function_popless_fmtext(&fm);
[7ab0020]1673  owl_fmtext_cleanup(&fm);
[7d4fbcd]1674}
1675
1676/* note: this applies to global message list, not to view.
1677 * If flag is 1, deletes.  If flag is 0, undeletes. */
[d54838d]1678void owl_function_delete_by_id(int id, int flag)
1679{
[3eb599d]1680  const owl_messagelist *ml;
[7d4fbcd]1681  owl_message *m;
1682  ml = owl_global_get_msglist(&g);
1683  m = owl_messagelist_get_by_id(ml, id);
1684  if (m) {
1685    if (flag == 1) {
1686      owl_message_mark_delete(m);
1687    } else if (flag == 0) {
1688      owl_message_unmark_delete(m);
1689    }
1690    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1691    owl_global_set_needrefresh(&g);
1692  } else {
[ec6ff52]1693    owl_function_error("No message with id %d: unable to mark for (un)delete",id);
[7d4fbcd]1694  }
1695}
1696
[c79a047]1697void owl_function_delete_automsgs(void)
[d54838d]1698{
[7d4fbcd]1699  /* mark for deletion all messages in the current view that match the
1700   * 'trash' filter */
1701
1702  int i, j, count;
1703  owl_message *m;
[9e5c9f3]1704  const owl_view *v;
[4542047]1705  const owl_filter *f;
[7d4fbcd]1706
1707  /* get the trash filter */
1708  f=owl_global_get_filter(&g, "trash");
1709  if (!f) {
[ec6ff52]1710    owl_function_error("No trash filter defined");
[7d4fbcd]1711    return;
1712  }
1713
1714  v=owl_global_get_current_view(&g);
1715
1716  count=0;
1717  j=owl_view_get_size(v);
1718  for (i=0; i<j; i++) {
1719    m=owl_view_get_element(v, i);
1720    if (owl_filter_message_match(f, m)) {
1721      count++;
1722      owl_message_mark_delete(m);
1723    }
1724  }
1725  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
[1c6c4d3]1726  owl_function_makemsg("%i messages marked for deletion", count);
[7d4fbcd]1727  owl_global_set_needrefresh(&g);
1728}
1729
[c79a047]1730void owl_function_status(void)
[d54838d]1731{
[49a8434]1732  char buff[MAXPATHLEN+1];
[7d4fbcd]1733  time_t start;
1734  int up, days, hours, minutes;
[a352335c]1735  owl_fmtext fm;
1736
1737  owl_fmtext_init_null(&fm);
[7d4fbcd]1738
1739  start=owl_global_get_starttime(&g);
1740
[d9b0b972]1741  owl_fmtext_append_normal(&fm, "General Information:\n");
1742
1743  owl_fmtext_append_normal(&fm, "  Version: ");
[a352335c]1744  owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
1745  owl_fmtext_append_normal(&fm, "\n");
1746
[cdd3959]1747  owl_fmtext_append_normal(&fm, "  Startup Arguments: ");
[a352335c]1748  owl_fmtext_append_normal(&fm, owl_global_get_startupargs(&g));
1749  owl_fmtext_append_normal(&fm, "\n");
[b6a7367]1750
1751  owl_fmtext_append_normal(&fm, "  Current Directory: ");
[49a8434]1752  if(getcwd(buff, MAXPATHLEN) == NULL) {
1753    owl_fmtext_append_normal(&fm, "<Error in getcwd>");
1754  } else {
1755    owl_fmtext_append_normal(&fm, buff);
1756  }
[b6a7367]1757  owl_fmtext_append_normal(&fm, "\n");
1758
[c1d166b]1759  owl_fmtext_appendf_normal(&fm, "  Startup Time: %s", ctime(&start));
[7d4fbcd]1760
1761  up=owl_global_get_runtime(&g);
1762  days=up/86400;
1763  up-=days*86400;
1764  hours=up/3600;
1765  up-=hours*3600;
1766  minutes=up/60;
1767  up-=minutes*60;
[c1d166b]1768  owl_fmtext_appendf_normal(&fm, "  Run Time: %i days %2.2i:%2.2i:%2.2i\n", days, hours, minutes, up);
[7d4fbcd]1769
[d9b0b972]1770  owl_fmtext_append_normal(&fm, "\nProtocol Options:\n");
1771  owl_fmtext_append_normal(&fm, "  Zephyr included    : ");
1772  if (owl_global_is_havezephyr(&g)) {
1773    owl_fmtext_append_normal(&fm, "yes\n");
[7d4fbcd]1774  } else {
[d9b0b972]1775    owl_fmtext_append_normal(&fm, "no\n");
[7d4fbcd]1776  }
[d9b0b972]1777  owl_fmtext_append_normal(&fm, "  AIM included       : yes\n");
1778  owl_fmtext_append_normal(&fm, "  Loopback included  : yes\n");
1779
[8262340]1780
[d9b0b972]1781  owl_fmtext_append_normal(&fm, "\nBuild Options:\n");
1782  owl_fmtext_append_normal(&fm, "  Stderr redirection : ");
1783#if OWL_STDERR_REDIR
1784  owl_fmtext_append_normal(&fm, "yes\n");
1785#else
1786  owl_fmtext_append_normal(&fm, "no\n");
1787#endif
1788 
1789
1790  owl_fmtext_append_normal(&fm, "\nAIM Status:\n");
1791  owl_fmtext_append_normal(&fm, "  Logged in: ");
[a352335c]1792  if (owl_global_is_aimloggedin(&g)) {
1793    owl_fmtext_append_normal(&fm, owl_global_get_aim_screenname(&g));
1794    owl_fmtext_append_normal(&fm, "\n");
1795  } else {
[d9b0b972]1796    owl_fmtext_append_normal(&fm, "(not logged in)\n");
[a352335c]1797  }
[d9b0b972]1798
1799  owl_fmtext_append_normal(&fm, "  Processing events: ");
[a352335c]1800  if (owl_global_is_doaimevents(&g)) {
[d9b0b972]1801    owl_fmtext_append_normal(&fm, "yes\n");
[a352335c]1802  } else {
[d9b0b972]1803    owl_fmtext_append_normal(&fm, "no\n");
[a352335c]1804  }
1805
1806  owl_function_popless_fmtext(&fm);
[7ab0020]1807  owl_fmtext_cleanup(&fm);
[7d4fbcd]1808}
1809
[c79a047]1810void owl_function_show_term(void)
[d54838d]1811{
[7d4fbcd]1812  owl_fmtext fm;
1813
1814  owl_fmtext_init_null(&fm);
[c1d166b]1815  owl_fmtext_appendf_normal(&fm, "Terminal Lines: %i\nTerminal Columns: %i\n",
[7d4fbcd]1816          owl_global_get_lines(&g),
1817          owl_global_get_cols(&g));
1818
1819  if (owl_global_get_hascolors(&g)) {
1820    owl_fmtext_append_normal(&fm, "Color: Yes\n");
[c1d166b]1821    owl_fmtext_appendf_normal(&fm, "Number of color pairs: %i\n", owl_global_get_colorpairs(&g));
1822    owl_fmtext_appendf_normal(&fm, "Can change colors: %s\n", can_change_color() ? "yes" : "no");
[7d4fbcd]1823  } else {
1824    owl_fmtext_append_normal(&fm, "Color: No\n");
1825  }
1826
1827  owl_function_popless_fmtext(&fm);
[7ab0020]1828  owl_fmtext_cleanup(&fm);
[7d4fbcd]1829}
1830
[e7cc1c3]1831/* if type = 0 then normal reply.
1832 * if type = 1 then it's a reply to sender
1833 * if enter = 0 then allow the command to be edited
1834 * if enter = 1 then don't wait for editing
1835 */
[d54838d]1836void owl_function_reply(int type, int enter)
1837{
[740d5f7]1838  char *buff=NULL;
[c08c70a]1839  const owl_message *m;
[4542047]1840  const owl_filter *f;
[7d4fbcd]1841 
1842  if (owl_view_get_size(owl_global_get_current_view(&g))==0) {
[ec6ff52]1843    owl_function_error("No message selected");
[7d4fbcd]1844  } else {
[5ebc202]1845    char *cmd;
[7d4fbcd]1846   
1847    m=owl_view_get_element(owl_global_get_current_view(&g), owl_global_get_curmsg(&g));
[5eeea3b]1848    if (!m) {
[ec6ff52]1849      owl_function_error("No message selected");
[5eeea3b]1850      return;
1851    }
1852
[7d4fbcd]1853    /* first check if we catch the reply-lockout filter */
1854    f=owl_global_get_filter(&g, "reply-lockout");
1855    if (f) {
1856      if (owl_filter_message_match(f, m)) {
[ec6ff52]1857        owl_function_error("Sorry, replies to this message have been disabled by the reply-lockout filter");
[7d4fbcd]1858        return;
1859      }
1860    }
[4b464a4]1861
[2c09826]1862    /* then check if it's a question and just bring up the command prompt */
1863    if (owl_message_is_question(m)) {
1864      owl_function_start_command("");
1865      return;
1866    }
1867
[740d5f7]1868    if((type == 0 &&
1869        (cmd=owl_perlconfig_message_call_method(m, "replycmd", 0, NULL))) ||
1870       (type == 1 &&
1871        (cmd=owl_perlconfig_message_call_method(m, "replysendercmd", 0, NULL)))) {
1872      buff = cmd;
[d09e5a1]1873    }
[1b6b2f3]1874
[e0540e4]1875    if(!buff) {
1876        owl_function_error("I don't know how to reply to that message.");
1877        return;
1878    }
[740d5f7]1879
[d09e5a1]1880    if (enter) {
1881      owl_history *hist = owl_global_get_cmd_history(&g);
1882      owl_history_store(hist, buff);
1883      owl_history_reset(hist);
1884      owl_function_command_norv(buff);
1885    } else {
1886      owl_function_start_command(buff);
[7d4fbcd]1887    }
[d09e5a1]1888    owl_free(buff);
[7d4fbcd]1889  }
1890}
1891
[e19eb97]1892void owl_function_zlocate(int argc, const char *const *argv, int auth)
[d54838d]1893{
[2527615]1894  owl_fmtext fm;
[dca3b27]1895  char *ptr;
1896  char *result;
[2527615]1897  int i;
1898
1899  owl_fmtext_init_null(&fm);
[7d4fbcd]1900
[2527615]1901  for (i=0; i<argc; i++) {
[dca3b27]1902    ptr = long_zuser(argv[i]);
1903    result = owl_zephyr_zlocate(ptr, auth);
1904    owl_fmtext_append_normal(&fm, result);
1905    owl_free(result);
[2527615]1906    owl_free(ptr);
[7d4fbcd]1907  }
1908
[2527615]1909  owl_function_popless_fmtext(&fm);
[7ab0020]1910  owl_fmtext_cleanup(&fm);
[7d4fbcd]1911}
1912
[5934b87]1913void owl_callback_command(owl_editwin *e)
1914{
1915  char *rv;
1916  const char *line = owl_editwin_get_text(e);
1917
1918  rv = owl_function_command(line);
1919   if (rv) {
1920    owl_function_makemsg("%s", rv);
1921    owl_free(rv);
1922  }
1923}
1924
[e19eb97]1925void owl_function_start_command(const char *line)
[d54838d]1926{
[7d4fbcd]1927  owl_editwin *tw;
1928
[58d47ca]1929  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
[10b866d]1930
[7d4fbcd]1931  owl_editwin_set_locktext(tw, "command: ");
1932  owl_global_set_needrefresh(&g);
1933
[47519e1b]1934  owl_editwin_insert_string(tw, line);
[2ee9e8d]1935  owl_editwin_redisplay(tw);
[cf83b7a]1936
[2a17b63]1937  owl_global_push_context(&g, OWL_CTX_EDITLINE, tw, "editline");
[5934b87]1938  owl_editwin_set_callback(tw, owl_callback_command);
[cf83b7a]1939}
1940
[9186c75]1941owl_editwin *owl_function_start_question(const char *line)
[cf83b7a]1942{
1943  owl_editwin *tw;
1944
[58d47ca]1945  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
[cf83b7a]1946
1947  owl_editwin_set_locktext(tw, line);
1948  owl_global_set_needrefresh(&g);
1949
[2ee9e8d]1950  owl_editwin_redisplay(tw);
[cf83b7a]1951
[6b78afb]1952  owl_global_push_context(&g, OWL_CTX_EDITRESPONSE, tw, "editresponse");
[9186c75]1953  return tw;
[7d4fbcd]1954}
1955
[9186c75]1956owl_editwin *owl_function_start_password(const char *line)
[453bd70]1957{
1958  owl_editwin *tw;
1959
[58d47ca]1960  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, NULL);
1961
[453bd70]1962  owl_editwin_set_echochar(tw, '*');
1963
1964  owl_editwin_set_locktext(tw, line);
1965  owl_global_set_needrefresh(&g);
1966
[2ee9e8d]1967  owl_editwin_redisplay(tw);
[453bd70]1968
[2a17b63]1969  owl_global_push_context(&g, OWL_CTX_EDITRESPONSE, tw, "editresponse");
[9186c75]1970  return tw;
[453bd70]1971}
1972
[e19eb97]1973char *owl_function_exec(int argc, const char *const *argv, const char *buff, int type)
[d54838d]1974{
[7d4fbcd]1975  /* if type == 1 display in a popup
1976   * if type == 2 display an admin messages
1977   * if type == 0 return output
1978   * else display in a popup
1979   */
[e19eb97]1980  const char *redirect = " 2>&1 < /dev/null";
[65b2173]1981  char *newbuff;
[b7ee89b]1982  char *out;
[7d4fbcd]1983  FILE *p;
1984
[2a2bb60]1985#if OWL_STDERR_REDIR
1986  redirect = " < /dev/null";
1987#endif
1988
[7d4fbcd]1989  if (argc<2) {
[ec6ff52]1990    owl_function_error("Wrong number of arguments to the exec command");
[7d4fbcd]1991    return NULL;
1992  }
1993
1994  buff = skiptokens(buff, 1);
[36486be]1995  newbuff = owl_sprintf("%s%s", buff, redirect);
[7d4fbcd]1996
[afbf668]1997  if (type == 1) {
1998    owl_popexec_new(newbuff);
[7d4fbcd]1999  } else {
[b7ee89b]2000    p = popen(newbuff, "r");
2001    out = owl_slurp(p);
[afbf668]2002    pclose(p);
2003   
2004    if (type==1) {
2005      owl_function_popless_text(out);
2006    } else if (type==0) {
[b85c1c4]2007      owl_free(newbuff);
[afbf668]2008      return out;
2009    } else if (type==2) {
2010      owl_function_adminmsg(buff, out);
2011    } else {
2012      owl_function_popless_text(out);
2013    }
2014    owl_free(out);
[7d4fbcd]2015  }
[b85c1c4]2016  owl_free(newbuff);
[7d4fbcd]2017  return NULL;
2018}
2019
[e19eb97]2020char *owl_function_perl(int argc, const char *const *argv, const char *buff, int type)
[d54838d]2021{
[7d4fbcd]2022  /* if type == 1 display in a popup
2023   * if type == 2 display an admin messages
2024   * if type == 0 return output
2025   * else display in a popup
2026   */
2027  char *perlout;
2028
2029  if (argc<2) {
[ec6ff52]2030    owl_function_error("Wrong number of arguments to perl command");
[7d4fbcd]2031    return NULL;
2032  }
2033
2034  /* consume first token (argv[0]) */
2035  buff = skiptokens(buff, 1);
2036
[f1e629d]2037  perlout = owl_perlconfig_execute(buff);
[7d4fbcd]2038  if (perlout) { 
2039    if (type==1) {
2040      owl_function_popless_text(perlout);
2041    } else if (type==2) {
2042      owl_function_adminmsg(buff, perlout);
2043    } else if (type==0) {
2044      return perlout;
2045    } else {
2046      owl_function_popless_text(perlout);
2047    }
2048    owl_free(perlout);
2049  }
2050  return NULL;
2051}
2052
[5e0b690]2053/* Change the filter associated with the current view.
2054 * This also figures out which message in the new filter
2055 * should have the pointer.
2056 */
[e19eb97]2057void owl_function_change_currentview_filter(const char *filtname)
[c3ab155]2058{
2059  owl_view *v;
2060  owl_filter *f;
2061  int curid=-1, newpos, curmsg;
[c08c70a]2062  const owl_message *curm=NULL;
[c3ab155]2063
2064  v=owl_global_get_current_view(&g);
2065
2066  curmsg=owl_global_get_curmsg(&g);
2067  if (curmsg==-1) {
2068    owl_function_debugmsg("Hit the curmsg==-1 case in change_view");
2069  } else {
2070    curm=owl_view_get_element(v, curmsg);
2071    if (curm) {
2072      curid=owl_message_get_id(curm);
2073      owl_view_save_curmsgid(v, curid);
2074    }
2075  }
2076
2077  f=owl_global_get_filter(&g, filtname);
2078  if (!f) {
[ec6ff52]2079    owl_function_error("Unknown filter %s", filtname);
[c3ab155]2080    return;
2081  }
2082
2083  owl_view_new_filter(v, f);
2084
2085  /* Figure out what to set the current message to.
2086   * - If the view we're leaving has messages in it, go to the closest message
2087   *   to the last message pointed to in that view.
2088   * - If the view we're leaving is empty, try to restore the position
2089   *   from the last time we were in the new view.  */
2090  if (curm) {
2091    newpos = owl_view_get_nearest_to_msgid(v, curid);
2092  } else {
2093    newpos = owl_view_get_nearest_to_saved(v);
2094  }
2095
2096  owl_global_set_curmsg(&g, newpos);
2097  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
2098  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2099  owl_global_set_direction_downwards(&g);
2100}
[7d4fbcd]2101
[5e0b690]2102/* Create a new filter, or replace an existing one
2103 * with a new definition.
2104 */
[e19eb97]2105void owl_function_create_filter(int argc, const char *const *argv)
[d54838d]2106{
[7d4fbcd]2107  owl_filter *f;
[9e5c9f3]2108  const owl_view *v;
[23fddad]2109  int inuse = 0;
[7d4fbcd]2110
2111  if (argc < 2) {
[ec6ff52]2112    owl_function_error("Wrong number of arguments to filter command");
[7d4fbcd]2113    return;
2114  }
2115
[3895e23]2116  owl_function_debugmsg("owl_function_create_filter: starting to create filter named %s", argv[1]);
2117
[7d4fbcd]2118  v=owl_global_get_current_view(&g);
2119
2120  /* don't touch the all filter */
2121  if (!strcmp(argv[1], "all")) {
[ec6ff52]2122    owl_function_error("You may not change the 'all' filter.");
[7d4fbcd]2123    return;
2124  }
2125
2126  /* deal with the case of trying change the filter color */
2127  if (argc==4 && !strcmp(argv[2], "-c")) {
2128    f=owl_global_get_filter(&g, argv[1]);
2129    if (!f) {
[ec6ff52]2130      owl_function_error("The filter '%s' does not exist.", argv[1]);
[7d4fbcd]2131      return;
2132    }
[601733d]2133    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
[12c35df]2134      owl_function_error("The color '%s' is not available.", argv[3]);
2135      return;
2136    }
[8fa9562]2137    owl_filter_set_fgcolor(f, owl_util_string_to_color(argv[3]));
2138    owl_global_set_needrefresh(&g);
2139    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2140    return;
2141  }
2142  if (argc==4 && !strcmp(argv[2], "-b")) {
2143    f=owl_global_get_filter(&g, argv[1]);
2144    if (!f) {
2145      owl_function_error("The filter '%s' does not exist.", argv[1]);
2146      return;
2147    }
[601733d]2148    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
[8fa9562]2149      owl_function_error("The color '%s' is not available.", argv[3]);
2150      return;
2151    }
2152    owl_filter_set_bgcolor(f, owl_util_string_to_color(argv[3]));
[7d4fbcd]2153    owl_global_set_needrefresh(&g);
2154    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2155    return;
2156  }
2157
2158  /* create the filter and check for errors */
[23fddad]2159  f = owl_filter_new(argv[1], argc-2, argv+2);
2160  if (f == NULL) {
[40458b9]2161    owl_function_error("Invalid filter");
[7d4fbcd]2162    return;
2163  }
2164
2165  /* if the named filter is in use by the current view, remember it */
2166  if (!strcmp(owl_view_get_filtname(v), argv[1])) {
2167    inuse=1;
2168  }
2169
2170  /* if the named filter already exists, nuke it */
2171  if (owl_global_get_filter(&g, argv[1])) {
2172    owl_global_remove_filter(&g, argv[1]);
2173  }
2174
2175  /* add the filter */
2176  owl_global_add_filter(&g, f);
2177
2178  /* if it was in use by the current view then update */
2179  if (inuse) {
[3895e23]2180    owl_function_change_currentview_filter(argv[1]);
[7d4fbcd]2181  }
2182  owl_global_set_needrefresh(&g);
2183  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2184}
2185
[3895e23]2186/* If 'filtername' does not start with 'not-' create a filter named
2187 * 'not-<filtername>' defined as "not filter <filtername>".  If the
2188 * filter 'not-<filtername>' already exists, do not overwrite it.  If
2189 * 'filtername' begins with 'not-' and a filter 'filtername' already
2190 * exists, then do nothing.  If the filter 'filtername' does not
2191 * exist, create it and define it as 'not filter <filtername>'
2192 *
2193 * Returns the name of the negated filter, which the caller must free.
2194 */
[e19eb97]2195char *owl_function_create_negative_filter(const char *filtername)
[3895e23]2196{
2197  char *newname;
[4542047]2198  const owl_filter *tmpfilt;
[e19eb97]2199  const char *argv[5];
[3895e23]2200
2201  owl_function_debugmsg("owl_function_create_negative_filter");
2202 
2203  if (!strncmp(filtername, "not-", 4)) {
2204    newname=owl_strdup(filtername+4);
2205  } else {
2206    newname=owl_sprintf("not-%s", filtername);
2207  }
2208
2209  tmpfilt=owl_global_get_filter(&g, newname);
2210  if (!tmpfilt) {
2211    argv[0]="filter"; /* anything is fine here */
2212    argv[1]=newname;
2213    argv[2]="not";
2214    argv[3]="filter";
2215    argv[4]=filtername;
2216    owl_function_create_filter(5, argv);
2217  }
2218
2219  owl_function_debugmsg("owl_function_create_negative_filter: returning with %s", newname);
2220  return(newname);
2221}
2222
[c79a047]2223void owl_function_show_filters(void)
[d54838d]2224{
[4542047]2225  const owl_filter *f;
[129e609]2226  GList *fl;
[7d4fbcd]2227  owl_fmtext fm;
2228
2229  owl_fmtext_init_null(&fm);
2230
2231  owl_fmtext_append_bold(&fm, "Filters:\n");
2232
[129e609]2233  for (fl = g.filterlist; fl; fl = g_list_next(fl)) {
2234    f = fl->data;
[7d4fbcd]2235    owl_fmtext_append_normal(&fm, "   ");
2236    if (owl_global_get_hascolors(&g)) {
[8fa9562]2237      owl_fmtext_append_normal_color(&fm, owl_filter_get_name(f), owl_filter_get_fgcolor(f), owl_filter_get_bgcolor(f));
[7d4fbcd]2238    } else {
2239      owl_fmtext_append_normal(&fm, owl_filter_get_name(f));
2240    }
2241    owl_fmtext_append_normal(&fm, "\n");
2242  }
2243  owl_function_popless_fmtext(&fm);
[7ab0020]2244  owl_fmtext_cleanup(&fm);
[7d4fbcd]2245}
2246
[e19eb97]2247void owl_function_show_filter(const char *name)
[d54838d]2248{
[4542047]2249  const owl_filter *f;
[cdc6ff1]2250  char *buff, *tmp;
[7d4fbcd]2251
2252  f=owl_global_get_filter(&g, name);
2253  if (!f) {
[ec6ff52]2254    owl_function_error("There is no filter named %s", name);
[7d4fbcd]2255    return;
2256  }
[cdc6ff1]2257  tmp = owl_filter_print(f);
2258  buff = owl_sprintf("%s: %s", owl_filter_get_name(f), tmp);
[7d4fbcd]2259  owl_function_popless_text(buff);
[0504f63]2260  owl_free(buff);
[cdc6ff1]2261  owl_free(tmp);
[7d4fbcd]2262}
2263
[c79a047]2264void owl_function_show_zpunts(void)
[d54838d]2265{
[4542047]2266  const owl_filter *f;
[77bced3]2267  const owl_list *fl;
[7d4fbcd]2268  char buff[5000];
[0504f63]2269  char *tmp;
[7d4fbcd]2270  owl_fmtext fm;
2271  int i, j;
2272
2273  owl_fmtext_init_null(&fm);
2274
2275  fl=owl_global_get_puntlist(&g);
2276  j=owl_list_get_size(fl);
2277  owl_fmtext_append_bold(&fm, "Active zpunt filters:\n");
2278
2279  for (i=0; i<j; i++) {
2280    f=owl_list_get_element(fl, i);
[ce7b824]2281    snprintf(buff, sizeof(buff), "[% 2d] ", i+1);
2282    owl_fmtext_append_normal(&fm, buff);
[0504f63]2283    tmp = owl_filter_print(f);
2284    owl_fmtext_append_normal(&fm, tmp);
2285    owl_free(tmp);
[7d4fbcd]2286  }
2287  owl_function_popless_fmtext(&fm);
[7ab0020]2288  owl_fmtext_cleanup(&fm);
[7d4fbcd]2289}
2290
[3abf28b]2291/* Create a filter for a class, instance if one doesn't exist.  If
2292 * instance is NULL then catch all messgaes in the class.  Returns the
2293 * name of the filter, which the caller must free.
[66e409c]2294 * If 'related' is nonzero, encompass unclasses and .d classes as well.
[3abf28b]2295 */
[66e409c]2296char *owl_function_classinstfilt(const char *c, const char *i, int related) 
[d54838d]2297{
[7d4fbcd]2298  owl_filter *f;
2299  char *argbuff, *filtname;
[d54838d]2300  char *tmpclass, *tmpinstance = NULL;
[7a20e4c]2301  char *class, *instance = NULL;
[7d4fbcd]2302
[66e409c]2303  if (related) {
2304    class = owl_util_baseclass(c);
2305    if (i) {
2306      instance = owl_util_baseclass(i);
2307    }
2308  } else {
2309    class = owl_strdup(c);
2310    if (i) {
2311      instance = owl_strdup(i);
2312    }
[7a20e4c]2313  }
2314
[7d4fbcd]2315  /* name for the filter */
2316  if (!instance) {
[66e409c]2317    filtname = owl_sprintf("%sclass-%s", related ? "related-" : "", class);
[7d4fbcd]2318  } else {
[66e409c]2319    filtname = owl_sprintf("%sclass-%s-instance-%s", related ? "related-" : "", class, instance);
[7d4fbcd]2320  }
[ed2412d]2321  /* downcase it */
[28ee32b]2322  {
2323    char *temp = g_utf8_strdown(filtname, -1);
2324    if (temp) {
2325      owl_free(filtname);
2326      filtname = temp;
2327    }
2328  }
[4099cf8]2329  /* turn spaces, single quotes, and double quotes into dots */
[e3d9c77]2330  owl_text_tr(filtname, ' ', '.');
[4099cf8]2331  owl_text_tr(filtname, '\'', '.');
2332  owl_text_tr(filtname, '"', '.');
[ed2412d]2333 
[7d4fbcd]2334  /* if it already exists then go with it.  This lets users override */
2335  if (owl_global_get_filter(&g, filtname)) {
[ed2412d]2336    return(filtname);
[7d4fbcd]2337  }
2338
2339  /* create the new filter */
[995eb4b]2340  tmpclass=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
[12c35df]2341  owl_text_tr(tmpclass, ' ', '.');
[4099cf8]2342  owl_text_tr(tmpclass, '\'', '.');
2343  owl_text_tr(tmpclass, '"', '.');
[ed2412d]2344  if (instance) {
[995eb4b]2345    tmpinstance=owl_text_quote(instance, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
[12c35df]2346    owl_text_tr(tmpinstance, ' ', '.');
[4099cf8]2347    owl_text_tr(tmpinstance, '\'', '.');
2348    owl_text_tr(tmpinstance, '"', '.');
[ed2412d]2349  }
[a0e6082]2350
[66e409c]2351  argbuff = owl_sprintf(related ? "class ^(un)*%s(\\.d)*$" : "class ^%s$", tmpclass);
[d54838d]2352  if (tmpinstance) {
[a0e6082]2353    char *tmp = argbuff;
[66e409c]2354    argbuff = owl_sprintf(related ? "%s and ( instance ^(un)*%s(\\.d)*$ )" : "%s and instance ^%s$", tmp, tmpinstance);
[a0e6082]2355    owl_free(tmp);
[7d4fbcd]2356  }
[ed2412d]2357  owl_free(tmpclass);
[d54838d]2358  if (tmpinstance) owl_free(tmpinstance);
[7d4fbcd]2359
[23fddad]2360  f = owl_filter_new_fromstring(filtname, argbuff);
[7d4fbcd]2361
2362  /* add it to the global list */
2363  owl_global_add_filter(&g, f);
2364
2365  owl_free(argbuff);
[be5aa09]2366  owl_free(class);
2367  if (instance) {
2368    owl_free(instance);
2369  }
[ed2412d]2370  return(filtname);
[7d4fbcd]2371}
2372
[3abf28b]2373/* Create a filter for personal zephyrs to or from the specified
2374 * zephyr user.  Includes login/logout notifications for the user.
2375 * The name of the filter will be 'user-<user>'.  If a filter already
2376 * exists with this name, no new filter will be created.  This allows
2377 * the configuration to override this function.  Returns the name of
2378 * the filter, which the caller must free.
2379 */
[e19eb97]2380char *owl_function_zuserfilt(const char *user)
[d54838d]2381{
[7d4fbcd]2382  owl_filter *f;
[1d12db24]2383  char *argbuff, *longuser, *esclonguser, *shortuser, *filtname;
[7d4fbcd]2384
2385  /* stick the local realm on if it's not there */
[4b464a4]2386  longuser=long_zuser(user);
2387  shortuser=short_zuser(user);
[7d4fbcd]2388
2389  /* name for the filter */
[9a2ae6c]2390  filtname=owl_sprintf("user-%s", shortuser);
[7d4fbcd]2391
2392  /* if it already exists then go with it.  This lets users override */
2393  if (owl_global_get_filter(&g, filtname)) {
[3abf28b]2394    return(owl_strdup(filtname));
[7d4fbcd]2395  }
2396
2397  /* create the new-internal filter */
[1d12db24]2398  esclonguser = owl_text_quote(longuser, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2399
[9a2ae6c]2400  argbuff=owl_sprintf("( type ^zephyr$ and filter personal and "
2401      "( ( direction ^in$ and sender ^%1$s$ ) or ( direction ^out$ and "
2402      "recipient ^%1$s$ ) ) ) or ( ( class ^login$ ) and ( sender ^%1$s$ ) )",
[1d12db24]2403      esclonguser);
[7d4fbcd]2404
[23fddad]2405  f = owl_filter_new_fromstring(filtname, argbuff);
[7d4fbcd]2406
2407  /* add it to the global list */
2408  owl_global_add_filter(&g, f);
2409
2410  /* free stuff */
2411  owl_free(argbuff);
2412  owl_free(longuser);
[1d12db24]2413  owl_free(esclonguser);
[7d4fbcd]2414  owl_free(shortuser);
[7360fab]2415
[ed2412d]2416  return(filtname);
[7d4fbcd]2417}
2418
[3abf28b]2419/* Create a filter for AIM IM messages to or from the specified
2420 * screenname.  The name of the filter will be 'aimuser-<user>'.  If a
2421 * filter already exists with this name, no new filter will be
2422 * created.  This allows the configuration to override this function.
2423 * Returns the name of the filter, which the caller must free.
2424 */
[e19eb97]2425char *owl_function_aimuserfilt(const char *user)
[3abf28b]2426{
2427  owl_filter *f;
2428  char *argbuff, *filtname;
[af9b92e]2429  char *escuser;
[3abf28b]2430
2431  /* name for the filter */
[9a2ae6c]2432  filtname=owl_sprintf("aimuser-%s", user);
[3abf28b]2433
2434  /* if it already exists then go with it.  This lets users override */
2435  if (owl_global_get_filter(&g, filtname)) {
2436    return(owl_strdup(filtname));
2437  }
2438
2439  /* create the new-internal filter */
[af9b92e]2440  escuser = owl_text_quote(user, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2441
[9a2ae6c]2442  argbuff = owl_sprintf(
2443      "( type ^aim$ and ( ( sender ^%1$s$ and recipient ^%2$s$ ) or "
2444      "( sender ^%2$s$ and recipient ^%1$s$ ) ) )",
2445      escuser, owl_global_get_aim_screenname_for_filters(&g));
[3abf28b]2446
[23fddad]2447  f = owl_filter_new_fromstring(filtname, argbuff);
[3abf28b]2448
2449  /* add it to the global list */
2450  owl_global_add_filter(&g, f);
2451
2452  /* free stuff */
2453  owl_free(argbuff);
[af9b92e]2454  owl_free(escuser);
[3abf28b]2455
2456  return(filtname);
2457}
2458
[e19eb97]2459char *owl_function_typefilt(const char *type)
[d54838d]2460{
[f73e519]2461  owl_filter *f;
[1d12db24]2462  char *argbuff, *filtname, *esctype;
[f73e519]2463
2464  /* name for the filter */
2465  filtname=owl_sprintf("type-%s", type);
2466
2467  /* if it already exists then go with it.  This lets users override */
2468  if (owl_global_get_filter(&g, filtname)) {
2469    return filtname;
2470  }
2471
2472  /* create the new-internal filter */
[1d12db24]2473  esctype = owl_text_quote(type, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2474
2475  argbuff = owl_sprintf("type ^%s$", esctype);
[f73e519]2476
[23fddad]2477  f = owl_filter_new_fromstring(filtname, argbuff);
[f73e519]2478
2479  /* add it to the global list */
2480  owl_global_add_filter(&g, f);
2481
2482  /* free stuff */
2483  owl_free(argbuff);
[1d12db24]2484  owl_free(esctype);
[f73e519]2485
2486  return filtname;
2487}
2488
[7d4fbcd]2489/* If flag is 1, marks for deletion.  If flag is 0,
2490 * unmarks for deletion. */
[d54838d]2491void owl_function_delete_curview_msgs(int flag)
2492{
[9e5c9f3]2493  const owl_view *v;
[7d4fbcd]2494  int i, j;
2495
2496  v=owl_global_get_current_view(&g);
2497  j=owl_view_get_size(v);
2498  for (i=0; i<j; i++) {
2499    if (flag == 1) {
2500      owl_message_mark_delete(owl_view_get_element(v, i));
2501    } else if (flag == 0) {
2502      owl_message_unmark_delete(owl_view_get_element(v, i));
2503    }
2504  }
2505
2506  owl_function_makemsg("%i messages marked for %sdeletion", j, flag?"":"un");
2507
2508  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
2509}
2510
[3abf28b]2511/* Create a filter based on the current message.  Returns the name of
2512 * a filter or null.  The caller must free this name.
2513 *
2514 * if the curmsg is a personal zephyr return a filter name
[e6d989f]2515 *    to the zephyr conversation with that user.
[3abf28b]2516 * If the curmsg is a zephyr class message, instance foo, recip *,
2517 *    return a filter name to the class, inst.
2518 * If the curmsg is a zephyr class message and type==0 then
2519 *    return a filter name for just the class.
2520 * If the curmsg is a zephyr class message and type==1 then
2521 *    return a filter name for the class and instance.
2522 * If the curmsg is a personal AIM message returna  filter
2523 *    name to the AIM conversation with that user
2524 */
[8a5b5a1]2525char *owl_function_smartfilter(int type, int invert_related)
[d54838d]2526{
[9e5c9f3]2527  const owl_view *v;
[c08c70a]2528  const owl_message *m;
[4b464a4]2529  char *zperson, *filtname=NULL;
[66e409c]2530  const char *argv[2];
[8a5b5a1]2531  int related = owl_global_is_narrow_related(&g) ^ invert_related;
2532
[7d4fbcd]2533  v=owl_global_get_current_view(&g);
2534  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2535
[5eeea3b]2536  if (!m || owl_view_get_size(v)==0) {
[ec6ff52]2537    owl_function_error("No message selected\n");
[4b464a4]2538    return(NULL);
[7d4fbcd]2539  }
2540
[f73e519]2541  /* very simple handling of admin messages for now */
[4b464a4]2542  if (owl_message_is_type_admin(m)) {
[3abf28b]2543    return(owl_function_typefilt("admin"));
2544  }
2545
[995eb4b]2546  /* very simple handling of loopback messages for now */
2547  if (owl_message_is_type_loopback(m)) {
2548    return(owl_function_typefilt("loopback"));
2549  }
2550
[3abf28b]2551  /* aim messages */
2552  if (owl_message_is_type_aim(m)) {
2553    if (owl_message_is_direction_in(m)) {
2554      filtname=owl_function_aimuserfilt(owl_message_get_sender(m));
2555    } else if (owl_message_is_direction_out(m)) {
2556      filtname=owl_function_aimuserfilt(owl_message_get_recipient(m));
2557    }
2558    return(filtname);
[7d4fbcd]2559  }
2560
[4b464a4]2561  /* narrow personal and login messages to the sender or recip as appropriate */
[25729b2]2562  if (owl_message_is_type_zephyr(m)) {
[0ef0e8f]2563    if (owl_message_is_personal(m) || owl_message_is_loginout(m)) {
[4b464a4]2564      if (owl_message_is_direction_in(m)) {
[25729b2]2565        zperson=short_zuser(owl_message_get_sender(m));
[4b464a4]2566      } else {
[25729b2]2567        zperson=short_zuser(owl_message_get_recipient(m));
[4b464a4]2568      }
[3abf28b]2569      filtname=owl_function_zuserfilt(zperson);
[4b464a4]2570      owl_free(zperson);
2571      return(filtname);
[7d4fbcd]2572    }
2573
[25729b2]2574    /* narrow class MESSAGE, instance foo, recip * messages to class, inst */
[ce74deb]2575    if (!strcasecmp(owl_message_get_class(m), "message")) {
[66e409c]2576      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
[25729b2]2577      return(filtname);
2578    }
2579
2580    /* otherwise narrow to the class */
2581    if (type==0) {
[66e409c]2582      filtname=owl_function_classinstfilt(owl_message_get_class(m), NULL, related);
[25729b2]2583    } else if (type==1) {
[66e409c]2584      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
[25729b2]2585    }
[4b464a4]2586    return(filtname);
[7d4fbcd]2587  }
2588
[25729b2]2589  /* pass it off to perl */
[66e409c]2590  argv[0] = type ? "1" : "0";
2591  argv[1] = related ? "1" : "0";
2592  return owl_perlconfig_message_call_method(m, "smartfilter", 2, argv);
[7d4fbcd]2593}
2594
[d54838d]2595void owl_function_smartzpunt(int type)
2596{
[d36f2cb]2597  /* Starts a zpunt command based on the current class,instance pair.
2598   * If type=0, uses just class.  If type=1, uses instance as well. */
[9e5c9f3]2599  const owl_view *v;
[c08c70a]2600  const owl_message *m;
[e19eb97]2601  const char *cmdprefix, *mclass, *minst;
[65b2173]2602  char *cmd;
[d36f2cb]2603 
2604  v=owl_global_get_current_view(&g);
2605  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2606
[5eeea3b]2607  if (!m || owl_view_get_size(v)==0) {
[ec6ff52]2608    owl_function_error("No message selected\n");
[d36f2cb]2609    return;
2610  }
2611
2612  /* for now we skip admin messages. */
[4b464a4]2613  if (owl_message_is_type_admin(m)
[5789230]2614      || owl_message_is_loginout(m)
[4b464a4]2615      || !owl_message_is_type_zephyr(m)) {
[ec6ff52]2616    owl_function_error("smartzpunt doesn't support this message type.");
[d36f2cb]2617    return;
2618  }
2619
[cee1f25]2620  mclass = owl_message_get_class(m);
2621  minst = owl_message_get_instance(m);
[d36f2cb]2622  if (!mclass || !*mclass || *mclass==' '
2623      || (!strcasecmp(mclass, "message") && !strcasecmp(minst, "personal"))
2624      || (type && (!minst || !*minst|| *minst==' '))) {
[ec6ff52]2625    owl_function_error("smartzpunt can't safely do this for <%s,%s>",
[d36f2cb]2626                         mclass, minst);
2627  } else {
2628    cmdprefix = "start-command zpunt ";
[cee1f25]2629    cmd = owl_malloc(strlen(cmdprefix)+strlen(mclass)+strlen(minst)+10);
[d36f2cb]2630    strcpy(cmd, cmdprefix);
[cee1f25]2631    strcat(cmd, owl_getquoting(mclass));
[d36f2cb]2632    strcat(cmd, mclass);
[cee1f25]2633    strcat(cmd, owl_getquoting(mclass));
[d36f2cb]2634    if (type) {
2635      strcat(cmd, " ");
[cee1f25]2636      strcat(cmd, owl_getquoting(minst));
[d36f2cb]2637      strcat(cmd, minst);
[cee1f25]2638      strcat(cmd, owl_getquoting(minst));
[d36f2cb]2639    } else {
2640      strcat(cmd, " *");
2641    }
2642    owl_function_command(cmd);
2643    owl_free(cmd);
2644  }
2645}
2646
[5e0b690]2647/* Set the color of the current view's filter to
2648 * be 'color'
2649 */
[e19eb97]2650void owl_function_color_current_filter(const char *fgcolor, const char *bgcolor)
[d54838d]2651{
[e19eb97]2652  const char *name;
[7d4fbcd]2653
2654  name=owl_view_get_filtname(owl_global_get_current_view(&g));
[8fa9562]2655  owl_function_color_filter(name, fgcolor, bgcolor);
[5e0b690]2656}
2657
2658/* Set the color of the filter 'filter' to be 'color'.  If the color
2659 * name does not exist, return -1, if the filter does not exist or is
2660 * the "all" filter, return -2.  Return 0 on success
2661 */
[e19eb97]2662int owl_function_color_filter(const char *filtname, const char *fgcolor, const char *bgcolor)
[5e0b690]2663{
2664  owl_filter *f;
2665
2666  f=owl_global_get_filter(&g, filtname);
[7d4fbcd]2667  if (!f) {
[ec6ff52]2668    owl_function_error("Unknown filter");
[5e0b690]2669    return(-2);
[7d4fbcd]2670  }
2671
2672  /* don't touch the all filter */
[5e0b690]2673  if (!strcmp(filtname, "all")) {
[ec6ff52]2674    owl_function_error("You may not change the 'all' filter.");
[5e0b690]2675    return(-2);
[7d4fbcd]2676  }
2677
[601733d]2678  if (owl_util_string_to_color(fgcolor)==OWL_COLOR_INVALID) {
[8fa9562]2679    owl_function_error("No color named '%s' avilable.", fgcolor);
[5e0b690]2680    return(-1);
[12c35df]2681  }
[8fa9562]2682
2683
2684  if (bgcolor != NULL) {
[601733d]2685    if (owl_util_string_to_color(bgcolor)==OWL_COLOR_INVALID) {
[8fa9562]2686      owl_function_error("No color named '%s' avilable.", bgcolor);
2687      return(-1);
2688    }
2689    owl_filter_set_bgcolor(f, owl_util_string_to_color(bgcolor));
2690  }
2691  owl_filter_set_fgcolor(f, owl_util_string_to_color(fgcolor));
2692 
[7d4fbcd]2693  owl_global_set_needrefresh(&g);
2694  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
[5e0b690]2695  return(0);
[7d4fbcd]2696}
2697
[c79a047]2698void owl_function_show_colors(void)
[d54838d]2699{
[7d4fbcd]2700  owl_fmtext fm;
[c2c5c77]2701  int i; 
2702 
[7d4fbcd]2703  owl_fmtext_init_null(&fm);
[ca9142e]2704  owl_fmtext_append_normal(&fm, "default: ");
[8fa9562]2705  owl_fmtext_append_normal_color(&fm, "default\n", OWL_COLOR_DEFAULT, OWL_COLOR_DEFAULT);
[ca9142e]2706
2707  owl_fmtext_append_normal(&fm,"red:      ");
[8fa9562]2708  owl_fmtext_append_normal_color(&fm, "red\n", OWL_COLOR_RED, OWL_COLOR_DEFAULT);
[ca9142e]2709
2710  owl_fmtext_append_normal(&fm,"green:    ");
[8fa9562]2711  owl_fmtext_append_normal_color(&fm, "green\n", OWL_COLOR_GREEN, OWL_COLOR_DEFAULT);
[ca9142e]2712
2713  owl_fmtext_append_normal(&fm,"yellow:   ");
[8fa9562]2714  owl_fmtext_append_normal_color(&fm, "yellow\n", OWL_COLOR_YELLOW, OWL_COLOR_DEFAULT);
[ca9142e]2715
2716  owl_fmtext_append_normal(&fm,"blue:     ");
[8fa9562]2717  owl_fmtext_append_normal_color(&fm, "blue\n", OWL_COLOR_BLUE, OWL_COLOR_DEFAULT);
[ca9142e]2718
2719  owl_fmtext_append_normal(&fm,"magenta:  ");
[8fa9562]2720  owl_fmtext_append_normal_color(&fm, "magenta\n", OWL_COLOR_MAGENTA, OWL_COLOR_DEFAULT);
[ca9142e]2721
2722  owl_fmtext_append_normal(&fm,"cyan:     ");
[8fa9562]2723  owl_fmtext_append_normal_color(&fm, "cyan\n", OWL_COLOR_CYAN, OWL_COLOR_DEFAULT);
[ca9142e]2724
2725  owl_fmtext_append_normal(&fm,"white:    ");
[8fa9562]2726  owl_fmtext_append_normal_color(&fm, "white\n", OWL_COLOR_WHITE, OWL_COLOR_DEFAULT);
[7d4fbcd]2727
[c2c5c77]2728  for(i = 8; i < COLORS; ++i) {
2729    char* str1 = owl_sprintf("%4i:     ",i);
2730    char* str2 = owl_sprintf("%i\n",i);
2731    owl_fmtext_append_normal(&fm,str1);
2732    owl_fmtext_append_normal_color(&fm, str2, i, OWL_COLOR_DEFAULT);
2733    owl_free(str1);
2734     owl_free(str2);
2735  }
2736 
[7d4fbcd]2737  owl_function_popless_fmtext(&fm);
[7ab0020]2738  owl_fmtext_cleanup(&fm);
[7d4fbcd]2739}
2740
[5bb6c21]2741/* add the given class, inst, recip to the punt list for filtering.
2742 *   if direction==0 then punt
2743 *   if direction==1 then unpunt
2744 */
[e19eb97]2745void owl_function_zpunt(const char *class, const char *inst, const char *recip, int direction)
[d54838d]2746{
[c894c15]2747  char *puntexpr, *classexpr, *instexpr, *recipexpr;
[bc08664]2748  char *quoted;
[7d4fbcd]2749
[5bb6c21]2750  if (!strcmp(class, "*")) {
[c894c15]2751    classexpr = owl_sprintf("class .*");
[5bb6c21]2752  } else {
[bc08664]2753    quoted=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
[cee1f25]2754    owl_text_tr(quoted, ' ', '.');
[4099cf8]2755    owl_text_tr(quoted, '\'', '.');
2756    owl_text_tr(quoted, '"', '.');
[c894c15]2757    classexpr = owl_sprintf("class ^(un)*%s(\\.d)*$", quoted);
[bc08664]2758    owl_free(quoted);
[5bb6c21]2759  }
2760  if (!strcmp(inst, "*")) {
[c894c15]2761    instexpr = owl_sprintf(" and instance .*");
[7d4fbcd]2762  } else {
[bc08664]2763    quoted=owl_text_quote(inst, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
[cee1f25]2764    owl_text_tr(quoted, ' ', '.');
[4099cf8]2765    owl_text_tr(quoted, '\'', '.');
2766    owl_text_tr(quoted, '"', '.');
[c894c15]2767    instexpr = owl_sprintf(" and instance ^(un)*%s(\\.d)*$", quoted);
[bc08664]2768    owl_free(quoted);
[7d4fbcd]2769  }
[c894c15]2770  if (!strcmp(recip, "*")) {
2771    recipexpr = owl_sprintf("");
2772  } else {
[e6c59ba]2773    if(!strcmp(recip, "%me%")) {
2774      recip = owl_zephyr_get_sender();
2775    }
[bc08664]2776    quoted=owl_text_quote(recip, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
[cee1f25]2777    owl_text_tr(quoted, ' ', '.');
[4099cf8]2778    owl_text_tr(quoted, '\'', '.');
2779    owl_text_tr(quoted, '"', '.');
[7980fb2]2780    recipexpr = owl_sprintf(" and recipient ^%s$", quoted);
[bc08664]2781    owl_free(quoted);
[5bb6c21]2782  }
[ce7b824]2783
[c894c15]2784  puntexpr = owl_sprintf("%s %s %s", classexpr, instexpr, recipexpr);
2785  owl_function_punt(puntexpr, direction);
2786  owl_free(puntexpr);
2787  owl_free(classexpr);
2788  owl_free(instexpr);
2789  owl_free(recipexpr);
[ce7b824]2790}
2791
[e19eb97]2792void owl_function_punt(const char *filter, int direction)
[ce7b824]2793{
2794  owl_filter *f;
2795  owl_list *fl;
[23fddad]2796  int i, j;
[ce7b824]2797  fl=owl_global_get_puntlist(&g);
2798
2799  /* first, create the filter */
2800  owl_function_debugmsg("About to filter %s", filter);
[23fddad]2801  f = owl_filter_new_fromstring("punt-filter", filter);
2802  if (f == NULL) {
[ec6ff52]2803    owl_function_error("Error creating filter for zpunt");
[7d4fbcd]2804    return;
2805  }
2806
2807  /* Check for an identical filter */
2808  j=owl_list_get_size(fl);
2809  for (i=0; i<j; i++) {
2810    if (owl_filter_equiv(f, owl_list_get_element(fl, i))) {
[ce7b824]2811      owl_function_debugmsg("found an equivalent punt filter");
[7d4fbcd]2812      /* if we're punting, then just silently bow out on this duplicate */
2813      if (direction==0) {
[23fddad]2814        owl_filter_delete(f);
[7d4fbcd]2815        return;
2816      }
2817
2818      /* if we're unpunting, then remove this filter from the puntlist */
2819      if (direction==1) {
[23fddad]2820        owl_filter_delete(owl_list_get_element(fl, i));
[7d4fbcd]2821        owl_list_remove_element(fl, i);
[23fddad]2822        owl_filter_delete(f);
[7d4fbcd]2823        return;
2824      }
2825    }
2826  }
2827
[ce7b824]2828  owl_function_debugmsg("punting");
[7d4fbcd]2829  /* If we're punting, add the filter to the global punt list */
2830  if (direction==0) {
2831    owl_list_append_element(fl, f);
2832  }
2833}
2834
[c79a047]2835void owl_function_show_keymaps(void)
[d54838d]2836{
[7d4fbcd]2837  owl_list l;
2838  owl_fmtext fm;
[afa200a]2839  const owl_keymap *km;
[12bc46a]2840  const owl_keyhandler *kh;
[1aee7d9]2841  int i, numkm;
[e19eb97]2842  const char *kmname;
[7d4fbcd]2843
[1aee7d9]2844  kh = owl_global_get_keyhandler(&g);
[7d4fbcd]2845  owl_fmtext_init_null(&fm);
2846  owl_fmtext_append_bold(&fm, "Keymaps:   ");
2847  owl_fmtext_append_normal(&fm, "(use 'show keymap <name>' for details)\n");
[1aee7d9]2848  owl_keyhandler_get_keymap_names(kh, &l);
[7d4fbcd]2849  owl_fmtext_append_list(&fm, &l, "\n", owl_function_keymap_summary);
2850  owl_fmtext_append_normal(&fm, "\n");
[1aee7d9]2851
2852  numkm = owl_list_get_size(&l);
2853  for (i=0; i<numkm; i++) {
2854    kmname = owl_list_get_element(&l, i);
2855    km = owl_keyhandler_get_keymap(kh, kmname);
2856    owl_fmtext_append_bold(&fm, "\n\n----------------------------------------------------------------------------------------------------\n\n");
2857    owl_keymap_get_details(km, &fm);   
2858  }
2859  owl_fmtext_append_normal(&fm, "\n");
2860 
[7d4fbcd]2861  owl_function_popless_fmtext(&fm);
[bb0d439]2862  owl_keyhandler_keymap_namelist_cleanup(&l);
[7ab0020]2863  owl_fmtext_cleanup(&fm);
[7d4fbcd]2864}
2865
[e19eb97]2866char *owl_function_keymap_summary(const char *name)
[d54838d]2867{
[afa200a]2868  const owl_keymap *km
[7d4fbcd]2869    = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2870  if (km) return owl_keymap_summary(km);
2871  else return(NULL);
2872}
2873
2874/* TODO: implement for real */
[e19eb97]2875void owl_function_show_keymap(const char *name)
[d54838d]2876{
[1fd0b25]2877  owl_fmtext fm;
[afa200a]2878  const owl_keymap *km;
[7d4fbcd]2879
2880  owl_fmtext_init_null(&fm);
2881  km = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2882  if (km) {
2883    owl_keymap_get_details(km, &fm);
2884  } else {
2885    owl_fmtext_append_normal(&fm, "No such keymap...\n");
2886  } 
2887  owl_function_popless_fmtext(&fm);
[7ab0020]2888  owl_fmtext_cleanup(&fm);
[7d4fbcd]2889}
2890
[e19eb97]2891void owl_function_help_for_command(const char *cmdname)
[d54838d]2892{
[1fd0b25]2893  owl_fmtext fm;
[7d4fbcd]2894
2895  owl_fmtext_init_null(&fm);
2896  owl_cmd_get_help(owl_global_get_cmddict(&g), cmdname, &fm);
2897  owl_function_popless_fmtext(&fm); 
[7ab0020]2898  owl_fmtext_cleanup(&fm);
[7d4fbcd]2899}
[1fd0b25]2900
[e19eb97]2901void owl_function_search_start(const char *string, int direction)
[d54838d]2902{
[ab225e0]2903  /* direction is OWL_DIRECTION_DOWNWARDS or OWL_DIRECTION_UPWARDS or
2904   * OWL_DIRECTION_NONE */
[41c9a96]2905  owl_regex re;
2906
2907  if (string && owl_regex_create_quoted(&re, string) == 0) {
2908    owl_global_set_search_re(&g, &re);
[5cbc929]2909    owl_regex_cleanup(&re);
[41c9a96]2910  } else {
2911    owl_global_set_search_re(&g, NULL);
2912  }
[ab225e0]2913
2914  if (direction == OWL_DIRECTION_NONE)
2915    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2916  else
2917    owl_function_search_helper(0, direction);
[1fd0b25]2918}
2919
[d54838d]2920void owl_function_search_continue(int direction)
2921{
[1fd0b25]2922  /* direction is OWL_DIRECTION_DOWNWARDS or OWL_DIRECTION_UPWARDS */
2923  owl_function_search_helper(1, direction);
2924}
2925
[d54838d]2926void owl_function_search_helper(int mode, int direction)
2927{
[1fd0b25]2928  /* move to a message that contains the string.  If direction is
2929   * OWL_DIRECTION_DOWNWARDS then search fowards, if direction is
2930   * OWL_DIRECTION_UPWARDS then search backwards.
2931   *
2932   * If mode==0 then it will stay on the current message if it
2933   * contains the string.
2934   */
2935