source: functions.c @ 47128d9

release-1.10release-1.8release-1.9
Last change on this file since 47128d9 was 47128d9, checked in by David Benjamin <davidben@mit.edu>, 14 years ago
Allow interrupts to be taken at any point This way we can catch SIGINT in the middle of a search if we care. (Though ideally we wouldn't block the event loop when searching like this.)
  • Property mode set to 100644
File size: 95.5 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <signal.h>
5#include <netinet/in.h>
6#include <string.h>
7#include <time.h>
8#include <sys/types.h>
9#include <sys/stat.h>
10#include <sys/wait.h>
11#include <errno.h>
12#include <signal.h>
13#include "owl.h"
14#include "filterproc.h"
15
16char *owl_function_command(const char *cmdbuff)
17{
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
23char *owl_function_command_argv(const char *const *argv, int argc)
24{
25  return owl_cmddict_execute_argv(owl_global_get_cmddict(&g),
26                                  owl_global_get_context(&g),
27                                  argv, argc);
28}
29
30void owl_function_command_norv(const char *cmdbuff)
31{
32  char *rv;
33  rv=owl_function_command(cmdbuff);
34  if (rv) g_free(rv);
35}
36
37void owl_function_command_alias(const char *alias_from, const char *alias_to)
38{
39  owl_cmddict_add_alias(owl_global_get_cmddict(&g), alias_from, alias_to);
40}
41
42const owl_cmd *owl_function_get_cmd(const char *name)
43{
44  return owl_cmddict_find(owl_global_get_cmddict(&g), name);
45}
46
47void owl_function_show_commands(void)
48{
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_list_create(&l);
56  owl_cmddict_get_names(owl_global_get_cmddict(&g), &l);
57  owl_fmtext_append_list(&fm, &l, "\n", owl_function_cmd_describe);
58  owl_fmtext_append_normal(&fm, "\n");
59  owl_function_popless_fmtext(&fm);
60  owl_list_cleanup(&l, g_free);
61  owl_fmtext_cleanup(&fm);
62}
63
64void owl_function_show_view(const char *viewname)
65{
66  const owl_view *v;
67  owl_fmtext fm;
68
69  /* we only have the one view right now */
70  v=owl_global_get_current_view(&g);
71  if (viewname && strcmp(viewname, owl_view_get_name(v))) {
72    owl_function_error("No view named '%s'", viewname);
73    return;
74  }
75
76  owl_fmtext_init_null(&fm);
77  owl_view_to_fmtext(v, &fm);
78  owl_function_popless_fmtext(&fm);
79  owl_fmtext_cleanup(&fm);
80}
81
82void owl_function_show_styles(void) {
83  owl_list l;
84  owl_fmtext fm;
85
86  owl_fmtext_init_null(&fm);
87  owl_fmtext_append_bold(&fm, "Styles:\n");
88  owl_list_create(&l);
89  owl_global_get_style_names(&g, &l);
90  owl_fmtext_append_list(&fm, &l, "\n", owl_function_style_describe);
91  owl_fmtext_append_normal(&fm, "\n");
92  owl_function_popless_fmtext(&fm);
93  owl_list_cleanup(&l, g_free);
94  owl_fmtext_cleanup(&fm);
95}
96
97static void _owl_function_timer_append_fmtext(gpointer data, gpointer user_data) {
98  owl_fmtext *fm = user_data;
99  owl_timer *timer = data;
100  char *str = g_strdup_printf("- %s: in %d seconds",
101                              timer->name ? timer->name : "(unnamed)",
102                              (int)(timer->time - time(NULL)));
103  owl_fmtext_append_normal(fm, str);
104  g_free(str);
105  if (timer->interval) {
106    str = g_strdup_printf(", repeat every %d seconds", timer->interval);
107    owl_fmtext_append_normal(fm, str);
108    g_free(str);
109  }
110  owl_fmtext_append_normal(fm, "\n");
111}
112
113void owl_function_show_timers(void) {
114  owl_fmtext fm;
115  GList **timers;
116
117  owl_fmtext_init_null(&fm);
118  owl_fmtext_append_bold(&fm, "Active timers:\n");
119
120  timers = owl_global_get_timerlist(&g);
121  g_list_foreach(*timers, _owl_function_timer_append_fmtext, &fm);
122
123  owl_function_popless_fmtext(&fm);
124  owl_fmtext_cleanup(&fm);
125}
126
127char *owl_function_style_describe(const char *name) {
128  const char *desc;
129  char *s;
130  const owl_style *style;
131  style = owl_global_get_style_by_name(&g, name);
132  if (style) {
133    desc = owl_style_get_description(style);
134  } else {
135    desc = "???";
136  }
137  s = g_strdup_printf("%-20s - %s%s", name,
138                      0 == owl_style_validate(style) ? "" : "[INVALID] ",
139                      desc);
140  return s;
141}
142
143char *owl_function_cmd_describe(const char *name)
144{
145  const owl_cmd *cmd = owl_cmddict_find(owl_global_get_cmddict(&g), name);
146  if (cmd) return owl_cmd_describe(cmd);
147  else return(NULL);
148}
149
150void owl_function_show_command(const char *name)
151{
152  owl_function_help_for_command(name);
153}
154
155void owl_function_show_license(void)
156{
157  const char *text;
158
159  text=""
160    "barnowl version " OWL_VERSION_STRING "\n"
161    "Copyright (c) 2006-2011 The BarnOwl Developers. All rights reserved.\n"
162    "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
163    "\n"
164    "Redistribution and use in source and binary forms, with or without\n"
165    "modification, are permitted provided that the following conditions are\n"
166    "met:\n"
167    "\n"
168    "   * Redistributions of source code must retain the above copyright\n"
169    "     notice, this list of conditions and the following disclaimer.\n"
170    "\n"
171    "   * Redistributions in binary form must reproduce the above copyright\n"
172    "     notice, this list of conditions and the following disclaimer in\n"
173    "     the documentation and/or other materials provided with the\n"
174    "     distribution.\n"
175    "\n"
176    "   * Redistributions in any form must be accompanied by information on\n"
177    "     how to obtain complete source code for the Owl software and any\n"
178    "     accompanying software that uses the Owl software. The source code\n"
179    "     must either be included in the distribution or be available for no\n"
180    "     more than the cost of distribution plus a nominal fee, and must be\n"
181    "     freely redistributable under reasonable conditions. For an\n"
182    "     executable file, complete source code means the source code for\n"
183    "     all modules it contains. It does not include source code for\n"
184    "     modules or files that typically accompany the major components of\n"
185    "     the operating system on which the executable file runs.\n"
186    "\n"
187    "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n"
188    "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n"
189    "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR\n"
190    "NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE\n"
191    "LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n"
192    "CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n"
193    "SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\n"
194    "BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n"
195    "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\n"
196    "OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN\n"
197    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n";
198  owl_function_popless_text(text);
199}
200
201void owl_function_show_quickstart(void)
202{
203    const char *message =
204    "Move between messages with the arrow keys, and press 'r' to reply.\n"
205    "For more info, press 'h' or visit http://barnowl.mit.edu/\n\n"
206#ifdef HAVE_LIBZEPHYR
207    "@b(Zephyr:)\n"
208    "To send a message to a user, type ':zwrite @b(username)'. You can also\n"
209    "press 'z' and then type the username. To subscribe to a class, type\n"
210    "':sub @b(class)', and then type ':zwrite -c @b(class)' to send.\n\n"
211#endif
212    "@b(AIM:)\n"
213    "Log in to AIM with ':aimlogin @b(screenname)'. Use ':aimwrite @b(screenname)',\n"
214    "or 'a' and then the screen name, to send someone a message.\n\n"
215    ;
216
217    if (owl_perlconfig_is_function("BarnOwl::Hooks::_get_quickstart")) {
218        char *perlquickstart = owl_perlconfig_execute("BarnOwl::Hooks::_get_quickstart()");
219        if (perlquickstart) {
220            char *result = g_strdup_printf("%s%s", message, perlquickstart);
221            owl_function_adminmsg("BarnOwl Quickstart", result);
222            g_free(result);
223            g_free(perlquickstart);
224            return;
225        }
226    }
227    owl_function_adminmsg("BarnOwl Quickstart", message);
228}
229
230
231/* Create an admin message, append it to the global list of messages
232 * and redisplay if necessary.
233 */
234void owl_function_adminmsg(const char *header, const char *body)
235{
236  owl_message *m;
237
238  m=g_new(owl_message, 1);
239  owl_message_create_admin(m, header, body);
240 
241  /* add it to the global list and current view */
242  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
243  owl_view_consider_message(owl_global_get_current_view(&g), m);
244
245  /* do followlast if necessary */
246  if (owl_global_should_followlast(&g)) owl_function_lastmsg_noredisplay();
247
248  /* redisplay etc. */
249  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
250}
251
252/* Queues outgoing zephyrs; if z sends to n people, queue n messages
253 * (except in case of cc). If there are no recipients queues 1
254 * message.
255 */
256void owl_function_add_outgoing_zephyrs(const owl_zwrite *z)
257{
258  if (z->cc || owl_zwrite_get_numrecips(z) == 0) {
259    /* create the message */
260    owl_message *m = g_new(owl_message, 1);
261    owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), 0);
262
263    owl_global_messagequeue_addmsg(&g, m);
264  } else {
265    int i;
266    for (i = 0; i < owl_zwrite_get_numrecips(z); i++) {
267      /* create the message */
268      owl_message *m = g_new(owl_message, 1);
269      owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), i);
270
271      owl_global_messagequeue_addmsg(&g, m);
272    }
273  }
274}
275
276/* Create an outgoing AIM message, returns a pointer to the created
277 * message or NULL if we're not logged into AIM (and thus unable to
278 * create the message).  Does not put it on the global queue.  Use
279 * owl_global_messagequeue_addmsg() for that.
280 */
281owl_message *owl_function_make_outgoing_aim(const char *body, const char *to)
282{
283  owl_message *m;
284
285  /* error if we're not logged into aim */
286  if (!owl_global_is_aimloggedin(&g)) return(NULL);
287 
288  m=g_new(owl_message, 1);
289  owl_message_create_aim(m,
290                         owl_global_get_aim_screenname(&g),
291                         to,
292                         body,
293                         OWL_MESSAGE_DIRECTION_OUT,
294                         0);
295  return(m);
296}
297
298/* Create an outgoing loopback message and return a pointer to it.
299 * Does not append it to the global queue, use
300 * owl_global_messagequeue_addmsg() for that.
301 */
302owl_message *owl_function_make_outgoing_loopback(const char *body)
303{
304  owl_message *m;
305
306  /* create the message */
307  m=g_new(owl_message, 1);
308  owl_message_create_loopback(m, body);
309  owl_message_set_direction_out(m);
310
311  return(m);
312}
313
314void owl_function_start_edit_win(const char *line, void (*callback)(owl_editwin *), void *data, void (*cleanup)(void *))
315{
316  owl_editwin *e;
317  owl_context *ctx;
318  char *s;
319
320  /* create and setup the editwin */
321  e = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_MULTILINE,
322                                   owl_global_get_msg_history(&g));
323  owl_editwin_set_dotsend(e);
324  s = g_strdup_printf("----> %s\n", line);
325  owl_editwin_set_locktext(e, s);
326  g_free(s);
327
328  owl_editwin_set_cbdata(e, data, cleanup);
329  owl_editwin_set_callback(e, callback);
330  ctx = owl_editcontext_new(OWL_CTX_EDITMULTI, e, "editmulti",
331                            owl_global_deactivate_editcontext, &g);
332  owl_global_push_context_obj(&g, ctx);
333
334}
335
336static void owl_function_write_setup(const char *noun)
337{
338
339  if (!owl_global_get_lockout_ctrld(&g))
340    owl_function_makemsg("Type your %s below.  "
341                         "End with ^D or a dot on a line by itself."
342                         "  ^C will quit.", noun);
343  else
344    owl_function_makemsg("Type your %s below.  "
345                         "End with a dot on a line by itself.  ^C will quit.",
346                         noun);
347}
348
349void owl_function_zwrite_setup(owl_zwrite *z)
350{
351  /* send a ping if necessary */
352  if (owl_global_is_txping(&g)) {
353    owl_zwrite_send_ping(z);
354  }
355
356
357  owl_function_write_setup("zephyr");
358  owl_function_start_edit_win(z->zwriteline,
359                              &owl_callback_zwrite,
360                              z, (void(*)(void*))owl_zwrite_delete);
361}
362
363void owl_function_aimwrite_setup(const char *to)
364{
365  /* TODO: We probably actually want an owl_aimwrite object like
366   * owl_zwrite. */
367  char *line = g_strdup_printf("aimwrite %s", to);
368  owl_function_write_setup("message");
369  owl_function_start_edit_win(line,
370                              &owl_callback_aimwrite,
371                              g_strdup(to),
372                              g_free);
373  g_free(line);
374}
375
376void owl_function_loopwrite_setup(void)
377{
378  owl_function_write_setup("message");
379  owl_function_start_edit_win("loopwrite",
380                              &owl_callback_loopwrite,
381                              NULL, NULL);
382}
383
384void owl_callback_zwrite(owl_editwin *e) {
385  owl_zwrite *z = owl_editwin_get_cbdata(e);
386  owl_function_zwrite(z, owl_editwin_get_text(e));
387}
388
389/* send, log and display outgoing zephyrs.  If 'msg' is NULL the
390 * message is expected to be set from the zwrite line itself
391 */
392#ifdef HAVE_LIBZEPHYR
393void owl_function_zwrite(owl_zwrite *z, const char *msg)
394{
395  int ret;
396
397  if(strcmp(z->cmd, "zcrypt") == 0) {
398    owl_function_zcrypt(z, msg);
399    return;
400  }
401
402  /* create the zwrite and send the message */
403  owl_zwrite_populate_zsig(z);
404  if (msg) {
405    owl_zwrite_set_message(z, msg);
406  }
407  ret = owl_zwrite_send_message(z);
408  if (ret != 0) {
409    owl_function_makemsg("Error sending zephyr: %s", error_message(ret));
410    return;
411  }
412  owl_function_makemsg("Waiting for ack...");
413
414  /* If it's personal */
415  if (owl_zwrite_is_personal(z)) {
416    /* create the outgoing message */
417    owl_function_add_outgoing_zephyrs(z);
418  }
419}
420#else
421void owl_function_zwrite(owl_zwrite *z, const char *msg) {
422}
423#endif
424
425/* send, log and display outgoing zcrypt zephyrs.  If 'msg' is NULL
426 * the message is expected to be set from the zwrite line itself
427 */
428void owl_function_zcrypt(owl_zwrite *z, const char *msg)
429{
430  char *cryptmsg;
431  const char *argv[7];
432  char *zcrypt;
433  int rv, status;
434  char *old_msg;
435
436  /* create the zwrite and send the message */
437  owl_zwrite_populate_zsig(z);
438  if (msg) {
439    owl_zwrite_set_message(z, msg);
440  }
441  old_msg = g_strdup(owl_zwrite_get_message(z));
442
443  zcrypt = g_strdup_printf("%s/zcrypt", owl_get_bindir());
444  argv[0] = "zcrypt";
445  argv[1] = "-E";
446  argv[2] = "-c"; argv[3] = owl_zwrite_get_class(z);
447  argv[4] = "-i"; argv[5] = owl_zwrite_get_instance(z);
448  argv[6] = NULL;
449
450  rv = call_filter(zcrypt, argv, owl_zwrite_get_message(z), &cryptmsg, &status);
451
452  g_free(zcrypt);
453
454  if (rv || status) {
455    if(cryptmsg) g_free(cryptmsg);
456    g_free(old_msg);
457    owl_function_error("Error in zcrypt, possibly no key found.  Message not sent.");
458    owl_function_beep();
459    return;
460  }
461
462  owl_zwrite_set_message_raw(z, cryptmsg);
463  owl_zwrite_set_opcode(z, "crypt");
464
465  owl_zwrite_send_message(z);
466  owl_function_makemsg("Waiting for ack...");
467
468  /* If it's personal */
469  if (owl_zwrite_is_personal(z)) {
470    /* Create the outgoing message. Restore the un-crypted message for display. */
471    owl_zwrite_set_message_raw(z, old_msg);
472    owl_function_add_outgoing_zephyrs(z);
473  }
474
475  /* free the zwrite */
476  g_free(cryptmsg);
477}
478
479void owl_callback_aimwrite(owl_editwin *e) {
480  char *to = owl_editwin_get_cbdata(e);
481  owl_function_aimwrite(to, owl_editwin_get_text(e), true);
482}
483
484void owl_function_aimwrite(const char *to, const char *msg, bool unwrap)
485{
486  int ret;
487  char *format_msg;
488  owl_message *m;
489
490  /* make a formatted copy of the message */
491  format_msg = g_strdup(msg);
492  if (unwrap)
493    owl_text_wordunwrap(format_msg);
494 
495  /* send the message */
496  ret=owl_aim_send_im(to, format_msg);
497  if (!ret) {
498    owl_function_makemsg("AIM message sent.");
499  } else {
500    owl_function_error("Could not send AIM message.");
501  }
502
503  /* create the outgoing message */
504  m=owl_function_make_outgoing_aim(msg, to);
505
506  if (m) {
507    owl_global_messagequeue_addmsg(&g, m);
508  } else {
509    owl_function_error("Could not create outgoing AIM message");
510  }
511
512  g_free(format_msg);
513}
514
515void owl_function_send_aimawymsg(const char *to, const char *msg)
516{
517  int ret;
518  char *format_msg;
519  owl_message *m;
520
521  /* make a formatted copy of the message */
522  format_msg=g_strdup(msg);
523  owl_text_wordunwrap(format_msg);
524 
525  /* send the message */
526  ret=owl_aim_send_awaymsg(to, format_msg);
527  if (!ret) {
528    /* owl_function_makemsg("AIM message sent."); */
529  } else {
530    owl_function_error("Could not send AIM message.");
531  }
532
533  /* create the message */
534  m=owl_function_make_outgoing_aim(msg, to);
535  if (m) {
536    owl_global_messagequeue_addmsg(&g, m);
537  } else {
538    owl_function_error("Could not create AIM message");
539  }
540  g_free(format_msg);
541}
542
543void owl_callback_loopwrite(owl_editwin *e) {
544  owl_function_loopwrite(owl_editwin_get_text(e));
545}
546
547void owl_function_loopwrite(const char *msg)
548{
549  owl_message *min, *mout;
550
551  /* create a message and put it on the message queue.  This simulates
552   * an incoming message */
553  min=g_new(owl_message, 1);
554  mout=owl_function_make_outgoing_loopback(msg);
555
556  if (owl_global_is_displayoutgoing(&g)) {
557    owl_global_messagequeue_addmsg(&g, mout);
558  } else {
559    owl_message_delete(mout);
560  }
561
562  owl_message_create_loopback(min, msg);
563  owl_message_set_direction_in(min);
564  owl_global_messagequeue_addmsg(&g, min);
565
566  /* fake a makemsg */
567  owl_function_makemsg("loopback message sent");
568}
569
570/* If filter is non-null, looks for the next message matching
571 * that filter.  If skip_deleted, skips any deleted messages.
572 * If last_if_none, will stop at the last message in the view
573 * if no matching messages are found.  */
574void owl_function_nextmsg_full(const char *filter, int skip_deleted, int last_if_none)
575{
576  int curmsg, i, viewsize, found;
577  const owl_view *v;
578  const owl_filter *f = NULL;
579  const owl_message *m;
580
581  v=owl_global_get_current_view(&g);
582
583  if (filter) {
584    f=owl_global_get_filter(&g, filter);
585    if (!f) {
586      owl_function_error("No %s filter defined", filter);
587      return;
588    }
589  }
590
591  curmsg=owl_global_get_curmsg(&g);
592  viewsize=owl_view_get_size(v);
593  found=0;
594
595  /* just check to make sure we're in bounds... */
596  if (curmsg>viewsize-1) curmsg=viewsize-1;
597  if (curmsg<0) curmsg=0;
598
599  for (i=curmsg+1; i<viewsize; i++) {
600    m=owl_view_get_element(v, i);
601    if (skip_deleted && owl_message_is_delete(m)) continue;
602    if (f && !owl_filter_message_match(f, m)) continue;
603    found = 1;
604    break;
605  }
606
607  if (i>owl_view_get_size(v)-1) i=owl_view_get_size(v)-1;
608  if (i<0) i=0;
609
610  if (!found) {
611    owl_function_makemsg("already at last%s message%s%s%s",
612                         skip_deleted?" non-deleted":"",
613                         filter?" in ":"", filter?filter:"",
614                         owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g)) ?
615                         ", press Enter to scroll" : "");
616    /* if (!skip_deleted) owl_function_beep(); */
617  }
618
619  if (last_if_none || found) {
620    owl_global_set_curmsg(&g, i);
621    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
622    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
623    owl_global_set_direction_downwards(&g);
624  }
625}
626
627void owl_function_prevmsg_full(const char *filter, int skip_deleted, int first_if_none)
628{
629  int curmsg, i, found;
630  const owl_view *v;
631  const owl_filter *f = NULL;
632  const owl_message *m;
633
634  v=owl_global_get_current_view(&g);
635
636  if (filter) {
637    f=owl_global_get_filter(&g, filter);
638    if (!f) {
639      owl_function_error("No %s filter defined", filter);
640      return;
641    }
642  }
643
644  curmsg=owl_global_get_curmsg(&g);
645  found=0;
646
647  /* just check to make sure we're in bounds... */
648  if (curmsg<0) curmsg=0;
649
650  for (i=curmsg-1; i>=0; i--) {
651    m=owl_view_get_element(v, i);
652    if (skip_deleted && owl_message_is_delete(m)) continue;
653    if (f && !owl_filter_message_match(f, m)) continue;
654    found = 1;
655    break;
656  }
657
658  if (i<0) i=0;
659
660  if (!found) {
661    owl_function_makemsg("already at first%s message%s%s",
662                         skip_deleted?" non-deleted":"",
663                         filter?" in ":"", filter?filter:"");
664    /* if (!skip_deleted) owl_function_beep(); */
665  }
666
667  if (first_if_none || found) {
668    owl_global_set_curmsg(&g, i);
669    owl_function_calculate_topmsg(OWL_DIRECTION_UPWARDS);
670    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
671    owl_global_set_direction_upwards(&g);
672  }
673}
674
675void owl_function_nextmsg(void)
676{
677  owl_function_nextmsg_full(NULL, 0, 1);
678}
679
680void owl_function_prevmsg(void)
681{
682  owl_function_prevmsg_full(NULL, 0, 1);
683}
684
685void owl_function_nextmsg_notdeleted(void)
686{
687  owl_function_nextmsg_full(NULL, 1, 1);
688}
689
690void owl_function_prevmsg_notdeleted(void)
691{
692  owl_function_prevmsg_full(NULL, 1, 1);
693}
694
695/* if move_after is 1, moves after the delete */
696void owl_function_deletecur(int move_after)
697{
698  int curmsg;
699  owl_view *v;
700
701  v=owl_global_get_current_view(&g);
702
703  /* bail if there's no current message */
704  if (owl_view_get_size(v) < 1) {
705    owl_function_error("No current message to delete");
706    return;
707  }
708
709  /* mark the message for deletion */
710  curmsg=owl_global_get_curmsg(&g);
711  owl_view_delete_element(v, curmsg);
712
713  if (move_after) {
714    /* move the poiner in the appropriate direction
715     * to the next undeleted msg */
716    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
717      owl_function_prevmsg_notdeleted();
718    } else {
719      owl_function_nextmsg_notdeleted();
720    }
721  }
722}
723
724void owl_function_undeletecur(int move_after)
725{
726  int curmsg;
727  owl_view *v;
728
729  v=owl_global_get_current_view(&g);
730 
731  if (owl_view_get_size(v) < 1) {
732    owl_function_error("No current message to undelete");
733    return;
734  }
735  curmsg=owl_global_get_curmsg(&g);
736
737  owl_view_undelete_element(v, curmsg);
738
739  if (move_after) {
740    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
741      if (curmsg>0) {
742        owl_function_prevmsg();
743      } else {
744        owl_function_nextmsg();
745      }
746    } else {
747      owl_function_nextmsg();
748    }
749  }
750
751  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
752}
753
754void owl_function_expunge(void)
755{
756  int curmsg;
757  const owl_message *m;
758  owl_messagelist *ml;
759  owl_view *v;
760  int lastmsgid=0;
761
762  curmsg=owl_global_get_curmsg(&g);
763  v=owl_global_get_current_view(&g);
764  ml=owl_global_get_msglist(&g);
765
766  m=owl_view_get_element(v, curmsg);
767  if (m) lastmsgid = owl_message_get_id(m);
768
769  /* expunge the message list */
770  owl_messagelist_expunge(ml);
771
772  /* update all views (we only have one right now) */
773  owl_view_recalculate(v);
774
775  /* find where the new position should be
776     (as close as possible to where we last where) */
777  curmsg = owl_view_get_nearest_to_msgid(v, lastmsgid);
778  if (curmsg>owl_view_get_size(v)-1) curmsg = owl_view_get_size(v)-1;
779  if (curmsg<0) curmsg = 0;
780  owl_global_set_curmsg(&g, curmsg);
781  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
782  /* if there are no messages set the direction to down in case we
783     delete everything upwards */
784  owl_global_set_direction_downwards(&g);
785 
786  owl_function_makemsg("Messages expunged");
787  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
788}
789
790void owl_function_firstmsg(void)
791{
792  owl_global_set_curmsg(&g, 0);
793  owl_global_set_topmsg(&g, 0);
794  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
795  owl_global_set_direction_downwards(&g);
796}
797
798void owl_function_lastmsg_noredisplay(void)
799{
800  int oldcurmsg, curmsg;
801  const owl_view *v;
802
803  v=owl_global_get_current_view(&g);
804  oldcurmsg=owl_global_get_curmsg(&g);
805  curmsg=owl_view_get_size(v)-1; 
806  if (curmsg<0) curmsg=0;
807  owl_global_set_curmsg(&g, curmsg);
808  if (oldcurmsg < curmsg) {
809    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
810  } else if (curmsg<owl_view_get_size(v)) {
811    /* If already at the end, blank the screen and move curmsg
812     * past the end of the messages. */
813    owl_global_set_topmsg(&g, curmsg+1);
814    owl_global_set_curmsg(&g, curmsg+1);
815  } 
816  /* owl_mainwin_redisplay(owl_global_get_mainwin(&g)); */
817  owl_global_set_direction_downwards(&g);
818}
819
820void owl_function_lastmsg(void)
821{
822  owl_function_lastmsg_noredisplay();
823  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
824}
825
826void owl_function_shift_right(void)
827{
828  owl_global_set_rightshift(&g, owl_global_get_rightshift(&g)+10);
829}
830
831void owl_function_shift_left(void)
832{
833  int shift;
834
835  shift=owl_global_get_rightshift(&g);
836  if (shift > 0) {
837    owl_global_set_rightshift(&g, MAX(shift - 10, 0));
838  } else {
839    owl_function_beep();
840    owl_function_makemsg("Already full left");
841  }
842}
843
844void owl_function_unsuball(void)
845{
846  unsuball();
847  owl_function_makemsg("Unsubscribed from all messages.");
848}
849
850
851/* Load zephyr subscriptions from the named 'file' and load zephyr's
852 * default subscriptions as well.  An error message is printed if
853 * 'file' can't be opened or if zephyr reports an error in
854 * subscribing.
855 *
856 * If 'file' is NULL, this look for the default filename
857 * $HOME/.zephyr.subs.  If the file can not be opened in this case
858 * only, no error message is printed.
859 */
860void owl_function_loadsubs(const char *file)
861{
862  int ret, ret2;
863  const char *foo;
864  char *path;
865
866  if (file==NULL) {
867    ret=owl_zephyr_loadsubs(NULL, 0);
868  } else {
869    path = owl_util_makepath(file);
870    ret=owl_zephyr_loadsubs(path, 1);
871    g_free(path);
872  }
873
874  /* for backwards compatibility for now */
875  ret2=owl_zephyr_loaddefaultsubs();
876
877  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
878
879  foo=file?file:"file";
880  if (ret==0 && ret2==0) {
881    if (!file) {
882      owl_function_makemsg("Subscribed to messages.");
883    } else {
884      owl_function_makemsg("Subscribed to messages from %s", file);
885    }
886  } else if (ret==-1) {
887    owl_function_error("Could not read %s", foo);
888  } else {
889    owl_function_error("Error subscribing to messages");
890  }
891}
892
893void owl_function_loadloginsubs(const char *file)
894{
895  int ret;
896
897  ret=owl_zephyr_loadloginsubs(file);
898
899  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
900  if (ret==0) {
901  } else if (ret==-1) {
902    owl_function_error("Could not open file for login subscriptions.");
903  } else {
904    owl_function_error("Error subscribing to login messages from file.");
905  }
906}
907
908void owl_callback_aimlogin(owl_editwin *e) {
909  char *user = owl_editwin_get_cbdata(e);
910  owl_function_aimlogin(user,
911                        owl_editwin_get_text(e));
912}
913
914void owl_function_aimlogin(const char *user, const char *passwd) {
915  int ret;
916
917  /* clear the buddylist */
918  owl_buddylist_clear(owl_global_get_buddylist(&g));
919
920  /* try to login */
921  ret=owl_aim_login(user, passwd);
922  if (ret) owl_function_makemsg("Warning: login for %s failed.\n", user);
923}
924
925void owl_function_suspend(void)
926{
927  endwin();
928  printf("\n");
929  kill(getpid(), SIGSTOP);
930
931  /* resize to reinitialize all the windows when we come back */
932  owl_command_resize();
933}
934
935void owl_function_zaway_toggle(void)
936{
937  if (!owl_global_is_zaway(&g)) {
938    owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
939    owl_function_zaway_on();
940  } else {
941    owl_function_zaway_off();
942  }
943}
944
945void owl_function_zaway_on(void)
946{
947  owl_global_set_zaway_on(&g);
948  owl_function_makemsg("zaway set (%s)", owl_global_get_zaway_msg(&g));
949}
950
951void owl_function_zaway_off(void)
952{
953  owl_global_set_zaway_off(&g);
954  owl_function_makemsg("zaway off");
955}
956
957void owl_function_aaway_toggle(void)
958{
959  if (!owl_global_is_aaway(&g)) {
960    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
961    owl_function_aaway_on();
962  } else {
963    owl_function_aaway_off();
964  }
965}
966
967void owl_function_aaway_on(void)
968{
969  owl_global_set_aaway_on(&g);
970  /* owl_aim_set_awaymsg(owl_global_get_zaway_msg(&g)); */
971  owl_function_makemsg("AIM away set (%s)", owl_global_get_aaway_msg(&g));
972}
973
974void owl_function_aaway_off(void)
975{
976  owl_global_set_aaway_off(&g);
977  /* owl_aim_set_awaymsg(""); */
978  owl_function_makemsg("AIM away off");
979}
980
981void owl_function_quit(void)
982{
983  char *ret;
984 
985  /* zlog out if we need to */
986  if (owl_global_is_havezephyr(&g) &&
987      owl_global_is_shutdownlogout(&g)) {
988    owl_zephyr_zlog_out();
989  }
990
991  /* execute the commands in shutdown */
992  ret = owl_perlconfig_execute("BarnOwl::Hooks::_shutdown();");
993  if (ret) g_free(ret);
994
995  /* signal our child process, if any */
996  if (owl_global_get_newmsgproc_pid(&g)) {
997    kill(owl_global_get_newmsgproc_pid(&g), SIGHUP);
998  }
999 
1000  /* Quit AIM */
1001  if (owl_global_is_aimloggedin(&g)) {
1002    owl_aim_logout();
1003  }
1004
1005  owl_function_debugmsg("Quitting Owl");
1006  owl_select_quit_loop();
1007}
1008
1009void owl_function_calculate_topmsg(int direction)
1010{
1011  int recwinlines, topmsg, curmsg;
1012  const owl_view *v;
1013
1014  v=owl_global_get_current_view(&g);
1015  curmsg=owl_global_get_curmsg(&g);
1016  topmsg=owl_global_get_topmsg(&g);
1017  recwinlines=owl_global_get_recwin_lines(&g);
1018
1019  /*
1020  if (owl_view_get_size(v) < 1) {
1021    return;
1022  }
1023  */
1024
1025  switch (owl_global_get_scrollmode(&g)) {
1026  case OWL_SCROLLMODE_TOP:
1027    topmsg = owl_function_calculate_topmsg_top(direction, v, curmsg, topmsg, recwinlines);
1028    break;
1029  case OWL_SCROLLMODE_NEARTOP:
1030    topmsg = owl_function_calculate_topmsg_neartop(direction, v, curmsg, topmsg, recwinlines);
1031    break;
1032  case OWL_SCROLLMODE_CENTER:
1033    topmsg = owl_function_calculate_topmsg_center(direction, v, curmsg, topmsg, recwinlines);
1034    break;
1035  case OWL_SCROLLMODE_PAGED:
1036    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 0);
1037    break;
1038  case OWL_SCROLLMODE_PAGEDCENTER:
1039    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 1);
1040    break;
1041  case OWL_SCROLLMODE_NORMAL:
1042  default:
1043    topmsg = owl_function_calculate_topmsg_normal(direction, v, curmsg, topmsg, recwinlines);
1044  }
1045  owl_function_debugmsg("Calculated a topmsg of %i", topmsg);
1046  owl_global_set_topmsg(&g, topmsg);
1047}
1048
1049/* Returns what the new topmsg should be. 
1050 * Passed the last direction of movement,
1051 * the current view,
1052 * the current message number in the view,
1053 * the top message currently being displayed,
1054 * and the number of lines in the recwin.
1055 */
1056int owl_function_calculate_topmsg_top(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
1057{
1058  return(curmsg);
1059}
1060
1061int owl_function_calculate_topmsg_neartop(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
1062{
1063  if (curmsg>0 
1064      && (owl_message_get_numlines(owl_view_get_element(v, curmsg-1))
1065          <  recwinlines/2)) {
1066    return(curmsg-1);
1067  } else {
1068    return(curmsg);
1069  }
1070}
1071 
1072int owl_function_calculate_topmsg_center(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
1073{
1074  int i, last, lines;
1075
1076  last = curmsg;
1077  lines = 0;
1078  for (i=curmsg-1; i>=0; i--) {
1079    lines += owl_message_get_numlines(owl_view_get_element(v, i));
1080    if (lines > recwinlines/2) break;
1081    last = i;
1082  }
1083  return(last);
1084}
1085 
1086int owl_function_calculate_topmsg_paged(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines, int center_on_page)
1087{
1088  int i, last, lines, savey;
1089 
1090  /* If we're off the top of the screen, scroll up such that the
1091   * curmsg is near the botton of the screen. */
1092  if (curmsg < topmsg) {
1093    last = curmsg;
1094    lines = 0;
1095    for (i=curmsg; i>=0; i--) {
1096      lines += owl_message_get_numlines(owl_view_get_element(v, i));
1097      if (lines > recwinlines) break;
1098    last = i;
1099    }
1100    if (center_on_page) {
1101      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
1102    } else {
1103      return(last);
1104    }
1105  }
1106
1107  /* Find number of lines from top to bottom of curmsg (store in savey) */
1108  savey=0;
1109  for (i=topmsg; i<=curmsg; i++) {
1110    savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1111  }
1112
1113  /* if we're off the bottom of the screen, scroll down */
1114  if (savey > recwinlines) {
1115    if (center_on_page) {
1116      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
1117    } else {
1118      return(curmsg);
1119    }
1120  }
1121
1122  /* else just stay as we are... */
1123  return(topmsg);
1124}
1125
1126int owl_function_calculate_topmsg_normal(int direction, const owl_view *v, int curmsg, int topmsg, int recwinlines)
1127{
1128  int savey, i, foo, y;
1129
1130  if (curmsg<0) return(topmsg);
1131   
1132  /* If we're off the top of the screen then center */
1133  if (curmsg<topmsg) {
1134    topmsg=owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines);
1135  }
1136
1137  /* If curmsg is so far past topmsg that there are more messages than
1138     lines, skip the line counting that follows because we're
1139     certainly off screen.  */
1140  savey=curmsg-topmsg;
1141  if (savey <= recwinlines) {
1142    /* Find number of lines from top to bottom of curmsg (store in savey) */
1143    savey = 0;
1144    for (i=topmsg; i<=curmsg; i++) {
1145      savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1146    }
1147  }
1148
1149  /* If we're off the bottom of the screen, set the topmsg to curmsg
1150   * and scroll upwards */
1151  if (savey > recwinlines) {
1152    topmsg=curmsg;
1153    savey=owl_message_get_numlines(owl_view_get_element(v, curmsg));
1154    direction=OWL_DIRECTION_UPWARDS;
1155  }
1156 
1157  /* If our bottom line is less than 1/4 down the screen then scroll up */
1158  if (direction == OWL_DIRECTION_UPWARDS || direction == OWL_DIRECTION_NONE) {
1159    if (savey < (recwinlines / 4)) {
1160      y=0;
1161      for (i=curmsg; i>=0; i--) {
1162        foo=owl_message_get_numlines(owl_view_get_element(v, i));
1163        /* will we run the curmsg off the screen? */
1164        if ((foo+y) >= recwinlines) {
1165          i++;
1166          if (i>curmsg) i=curmsg;
1167          break;
1168        }
1169        /* have saved 1/2 the screen space? */
1170        y+=foo;
1171        if (y > (recwinlines / 2)) break;
1172      }
1173      if (i<0) i=0;
1174      return(i);
1175    }
1176  }
1177
1178  if (direction == OWL_DIRECTION_DOWNWARDS || direction == OWL_DIRECTION_NONE) {
1179    /* If curmsg bottom line is more than 3/4 down the screen then scroll down */
1180    if (savey > ((recwinlines * 3)/4)) {
1181      y=0;
1182      /* count lines from the top until we can save 1/2 the screen size */
1183      for (i=topmsg; i<curmsg; i++) {
1184        y+=owl_message_get_numlines(owl_view_get_element(v, i));
1185        if (y > (recwinlines / 2)) break;
1186      }
1187      if (i==curmsg) {
1188        i--;
1189      }
1190      return(i+1);
1191    }
1192  }
1193
1194  return(topmsg);
1195}
1196
1197void owl_function_resize(void)
1198{
1199  owl_global_set_resize_pending(&g);
1200}
1201
1202void G_GNUC_PRINTF(1, 2) owl_function_debugmsg(const char *fmt, ...)
1203{
1204  FILE *file;
1205  time_t now;
1206  va_list ap;
1207  va_start(ap, fmt);
1208
1209  if (!owl_global_is_debug_fast(&g))
1210    return;
1211
1212  file = owl_global_get_debug_file_handle(&g);
1213  if (!file) /* XXX should report this */
1214    return;
1215
1216  now = time(NULL);
1217
1218  fprintf(file, "[%d -  %.24s - %lds]: ",
1219          (int) getpid(), ctime(&now), now - owl_global_get_starttime(&g));
1220  vfprintf(file, fmt, ap);
1221  putc('\n', file);
1222  fflush(file);
1223
1224  va_end(ap);
1225}
1226
1227void owl_function_beep(void)
1228{
1229  if (owl_global_is_bell(&g)) {
1230    beep();
1231  }
1232}
1233
1234int owl_function_subscribe(const char *class, const char *inst, const char *recip)
1235{
1236  int ret;
1237
1238  ret=owl_zephyr_sub(class, inst, recip);
1239  if (ret) {
1240    owl_function_error("Error subscribing.");
1241  } else {
1242    owl_function_makemsg("Subscribed.");
1243  }
1244  return(ret);
1245}
1246
1247void owl_function_unsubscribe(const char *class, const char *inst, const char *recip)
1248{
1249  int ret;
1250
1251  ret=owl_zephyr_unsub(class, inst, recip);
1252  if (ret) {
1253    owl_function_error("Error subscribing.");
1254  } else {
1255    owl_function_makemsg("Unsubscribed.");
1256  }
1257}
1258
1259static void _dirty_everything(owl_window *w) {
1260  if (!owl_window_is_realized(w))
1261    return;
1262  owl_window_dirty(w);
1263  owl_window_children_foreach(w, (GFunc)_dirty_everything, NULL);
1264}
1265
1266void owl_function_full_redisplay(void)
1267{
1268  /* Ask every widget to redraw itself. */
1269  _dirty_everything(owl_window_get_screen());
1270  /* Force ncurses to redisplay everything. */
1271  clearok(stdscr, TRUE);
1272}
1273
1274void owl_function_popless_text(const char *text)
1275{
1276  owl_popwin *pw;
1277  owl_viewwin *v;
1278
1279  if (owl_global_get_popwin(&g) || owl_global_get_viewwin(&g)) {
1280    owl_function_error("Popwin already in use.");
1281    return;
1282  }
1283  pw = owl_popwin_new();
1284  owl_global_set_popwin(&g, pw);
1285  owl_popwin_up(pw);
1286
1287  v = owl_viewwin_new_text(owl_popwin_get_content(pw), text);
1288  owl_global_set_viewwin(&g, v);
1289
1290  owl_global_push_context(&g, OWL_CTX_POPLESS, v, "popless", NULL);
1291}
1292
1293void owl_function_popless_fmtext(const owl_fmtext *fm)
1294{
1295  owl_popwin *pw;
1296  owl_viewwin *v;
1297
1298  if (owl_global_get_popwin(&g) || owl_global_get_viewwin(&g)) {
1299    owl_function_error("Popwin already in use.");
1300    return;
1301  }
1302  pw = owl_popwin_new();
1303  owl_global_set_popwin(&g, pw);
1304  owl_popwin_up(pw);
1305
1306  v = owl_viewwin_new_fmtext(owl_popwin_get_content(pw), fm);
1307  owl_global_set_viewwin(&g, v);
1308
1309  owl_global_push_context(&g, OWL_CTX_POPLESS, v, "popless", NULL);
1310}
1311
1312void owl_function_popless_file(const char *filename)
1313{
1314  owl_fmtext fm;
1315  FILE *file;
1316  char *s = NULL;
1317
1318  file=fopen(filename, "r");
1319  if (!file) {
1320    owl_function_error("Could not open file: %s", filename);
1321    return;
1322  }
1323
1324  owl_fmtext_init_null(&fm);
1325  while (owl_getline(&s, file))
1326    owl_fmtext_append_normal(&fm, s);
1327  g_free(s);
1328
1329  owl_function_popless_fmtext(&fm);
1330  owl_fmtext_cleanup(&fm);
1331  fclose(file);
1332}
1333
1334void owl_function_about(void)
1335{
1336  owl_function_popless_text(
1337    "This is barnowl version " OWL_VERSION_STRING ".\n\n"
1338    "barnowl is a fork of the Owl zephyr client, written and\n"
1339    "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
1340    "Massachusetts Institute of Technology. \n"
1341    "\n"
1342    "Owl was written by James Kretchmar. The first version, 0.5, was\n"
1343    "released in March 2002.\n"
1344    "\n"
1345    "The name 'owl' was chosen in reference to the owls in the\n"
1346    "Harry Potter novels, who are tasked with carrying messages\n"
1347    "between Witches and Wizards. The name 'barnowl' was chosen\n"
1348    "because we feel our owls should live closer to our ponies.\n"
1349    "\n"
1350    "Copyright (c) 2006-2011 The BarnOwl Developers. All rights reserved.\n"
1351    "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
1352    "Copyright 2002 Massachusetts Institute of Technology\n"
1353    "\n"
1354    "This program is free software. You can redistribute it and/or\n"
1355    "modify under the terms of the Sleepycat License. Use the \n"
1356    "':show license' command to display the full license\n"
1357  );
1358}
1359
1360void owl_function_info(void)
1361{
1362  const owl_message *m;
1363  owl_fmtext fm, attrfm;
1364  const owl_view *v;
1365#ifdef HAVE_LIBZEPHYR
1366  const ZNotice_t *n;
1367#endif
1368
1369  owl_fmtext_init_null(&fm);
1370 
1371  v=owl_global_get_current_view(&g);
1372  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1373  if (!m || owl_view_get_size(v)==0) {
1374    owl_function_error("No message selected\n");
1375    return;
1376  }
1377
1378  owl_fmtext_append_bold(&fm, "General Information:\n");
1379  owl_fmtext_appendf_normal(&fm, "  Msg Id    : %i\n", owl_message_get_id(m));
1380
1381  owl_fmtext_append_normal(&fm, "  Type      : ");
1382  owl_fmtext_append_bold(&fm, owl_message_get_type(m));
1383  owl_fmtext_append_normal(&fm, "\n");
1384
1385  if (owl_message_is_direction_in(m)) {
1386    owl_fmtext_append_normal(&fm, "  Direction : in\n");
1387  } else if (owl_message_is_direction_out(m)) {
1388    owl_fmtext_append_normal(&fm, "  Direction : out\n");
1389  } else if (owl_message_is_direction_none(m)) {
1390    owl_fmtext_append_normal(&fm, "  Direction : none\n");
1391  } else {
1392    owl_fmtext_append_normal(&fm, "  Direction : unknown\n");
1393  }
1394
1395  owl_fmtext_appendf_normal(&fm, "  Time      : %s\n", owl_message_get_timestr(m));
1396
1397  if (!owl_message_is_type_admin(m)) {
1398    owl_fmtext_appendf_normal(&fm, "  Sender    : %s\n", owl_message_get_sender(m));
1399    owl_fmtext_appendf_normal(&fm, "  Recipient : %s\n", owl_message_get_recipient(m));
1400  }
1401
1402  if (owl_message_is_type_zephyr(m)) {
1403    owl_fmtext_append_bold(&fm, "\nZephyr Specific Information:\n");
1404   
1405    owl_fmtext_appendf_normal(&fm, "  Class     : %s\n", owl_message_get_class(m));
1406    owl_fmtext_appendf_normal(&fm, "  Instance  : %s\n", owl_message_get_instance(m));
1407    owl_fmtext_appendf_normal(&fm, "  Opcode    : %s\n", owl_message_get_opcode(m));
1408#ifdef HAVE_LIBZEPHYR
1409    if (owl_message_is_direction_in(m)) {
1410      char *ptr, tmpbuff[1024];
1411      int i, j, fields, len;
1412
1413      n=owl_message_get_notice(m);
1414
1415      if (!owl_message_is_pseudo(m)) {
1416        owl_fmtext_append_normal(&fm, "  Kind      : ");
1417        if (n->z_kind==UNSAFE) {
1418          owl_fmtext_append_normal(&fm, "UNSAFE\n");
1419        } else if (n->z_kind==UNACKED) {
1420          owl_fmtext_append_normal(&fm, "UNACKED\n");
1421        } else if (n->z_kind==ACKED) {
1422          owl_fmtext_append_normal(&fm, "ACKED\n");
1423        } else if (n->z_kind==HMACK) {
1424          owl_fmtext_append_normal(&fm, "HMACK\n");
1425        } else if (n->z_kind==HMCTL) {
1426          owl_fmtext_append_normal(&fm, "HMCTL\n");
1427        } else if (n->z_kind==SERVACK) {
1428          owl_fmtext_append_normal(&fm, "SERVACK\n");
1429        } else if (n->z_kind==SERVNAK) {
1430          owl_fmtext_append_normal(&fm, "SERVNACK\n");
1431        } else if (n->z_kind==CLIENTACK) {
1432          owl_fmtext_append_normal(&fm, "CLIENTACK\n");
1433        } else if (n->z_kind==STAT) {
1434          owl_fmtext_append_normal(&fm, "STAT\n");
1435        } else {
1436          owl_fmtext_append_normal(&fm, "ILLEGAL VALUE\n");
1437        }
1438      }
1439      owl_fmtext_appendf_normal(&fm, "  Host      : %s\n", owl_message_get_hostname(m));
1440
1441      if (!owl_message_is_pseudo(m)) {
1442        owl_fmtext_append_normal(&fm, "\n");
1443        owl_fmtext_appendf_normal(&fm, "  Port      : %i\n", ntohs(n->z_port));
1444        owl_fmtext_appendf_normal(&fm, "  Auth      : %s\n", owl_zephyr_get_authstr(n));
1445
1446        /* FIXME make these more descriptive */
1447        owl_fmtext_appendf_normal(&fm, "  Checkd Ath: %i\n", n->z_checked_auth);
1448        owl_fmtext_appendf_normal(&fm, "  Multi notc: %s\n", n->z_multinotice);
1449        owl_fmtext_appendf_normal(&fm, "  Num other : %i\n", n->z_num_other_fields);
1450        owl_fmtext_appendf_normal(&fm, "  Msg Len   : %i\n", n->z_message_len);
1451
1452        fields=owl_zephyr_get_num_fields(n);
1453        owl_fmtext_appendf_normal(&fm, "  Fields    : %i\n", fields);
1454
1455        for (i=0; i<fields; i++) {
1456          ptr=owl_zephyr_get_field_as_utf8(n, i+1);
1457          len=strlen(ptr);
1458          if (len<30) {
1459            strncpy(tmpbuff, ptr, len);
1460            tmpbuff[len]='\0';
1461          } else {
1462            strncpy(tmpbuff, ptr, 30);
1463            tmpbuff[30]='\0';
1464            strcat(tmpbuff, "...");
1465          }
1466          g_free(ptr);
1467
1468          for (j=0; j<strlen(tmpbuff); j++) {
1469            if (tmpbuff[j]=='\n') tmpbuff[j]='~';
1470            if (tmpbuff[j]=='\r') tmpbuff[j]='!';
1471          }
1472
1473          owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i+1, tmpbuff);
1474        }
1475        owl_fmtext_appendf_normal(&fm, "  Default Fm: %s\n", n->z_default_format);
1476      }
1477
1478    }
1479#endif
1480  }
1481
1482  owl_fmtext_append_bold(&fm, "\nOwl Message Attributes:\n");
1483  owl_message_attributes_tofmtext(m, &attrfm);
1484  owl_fmtext_append_fmtext(&fm, &attrfm);
1485 
1486  owl_function_popless_fmtext(&fm);
1487  owl_fmtext_cleanup(&fm);
1488  owl_fmtext_cleanup(&attrfm);
1489}
1490
1491/* print the current message in a popup window.
1492 * Use the 'default' style regardless of whatever
1493 * style the user may be using
1494 */
1495void owl_function_curmsg_to_popwin(void)
1496{
1497  const owl_view *v;
1498  const owl_message *m;
1499  const owl_style *s;
1500  owl_fmtext fm;
1501
1502  v=owl_global_get_current_view(&g);
1503  s=owl_global_get_style_by_name(&g, "default");
1504
1505  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1506
1507  if (!m || owl_view_get_size(v)==0) {
1508    owl_function_error("No current message");
1509    return;
1510  }
1511
1512  owl_fmtext_init_null(&fm);
1513  owl_style_get_formattext(s, &fm, m);
1514
1515  owl_function_popless_fmtext(&fm);
1516  owl_fmtext_cleanup(&fm);
1517}
1518
1519void owl_function_page_curmsg(int step)
1520{
1521  /* scroll down or up within the current message IF the message is truncated */
1522
1523  int offset, curmsg, lines;
1524  const owl_view *v;
1525  owl_message *m;
1526
1527  offset=owl_global_get_curmsg_vert_offset(&g);
1528  v=owl_global_get_current_view(&g);
1529  curmsg=owl_global_get_curmsg(&g);
1530  m=owl_view_get_element(v, curmsg);
1531  if (!m || owl_view_get_size(v)==0) return;
1532  lines=owl_message_get_numlines(m);
1533
1534  if (offset==0) {
1535    /* Bail if the curmsg isn't the last one displayed */
1536    if (curmsg != owl_mainwin_get_last_msg(owl_global_get_mainwin(&g))) {
1537      owl_function_makemsg("The entire message is already displayed");
1538      return;
1539    }
1540   
1541    /* Bail if we're not truncated */
1542    if (!owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g))) {
1543      owl_function_makemsg("The entire message is already displayed");
1544      return;
1545    }
1546  }
1547 
1548 
1549  /* don't scroll past the last line */
1550  if (step>0) {
1551    if (offset+step > lines-1) {
1552      owl_global_set_curmsg_vert_offset(&g, lines-1);
1553    } else {
1554      owl_global_set_curmsg_vert_offset(&g, offset+step);
1555    }
1556  }
1557
1558  /* would we be before the beginning of the message? */
1559  if (step<0) {
1560    if (offset+step<0) {
1561      owl_global_set_curmsg_vert_offset(&g, 0);
1562    } else {
1563      owl_global_set_curmsg_vert_offset(&g, offset+step);
1564    }
1565  }
1566 
1567  /* redisplay */
1568  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1569}
1570
1571void owl_function_resize_typwin(int newsize)
1572{
1573  owl_global_set_typwin_lines(&g, newsize);
1574  owl_mainpanel_layout_contents(&g.mainpanel);
1575}
1576
1577void owl_function_mainwin_pagedown(void)
1578{
1579  int i;
1580
1581  i=owl_mainwin_get_last_msg(owl_global_get_mainwin(&g));
1582  if (i<0) return;
1583  if (owl_mainwin_is_last_msg_truncated(owl_global_get_mainwin(&g))
1584      && (owl_global_get_curmsg(&g) < i)
1585      && (i>0)) {
1586    i--;
1587  }
1588  owl_global_set_curmsg(&g, i);
1589  owl_function_nextmsg();
1590}
1591
1592void owl_function_mainwin_pageup(void)
1593{
1594  owl_global_set_curmsg(&g, owl_global_get_topmsg(&g));
1595  owl_function_prevmsg();
1596}
1597
1598void owl_function_getsubs(void)
1599{
1600  char *buff;
1601
1602  buff=owl_zephyr_getsubs();
1603
1604  if (buff) {
1605    owl_function_popless_text(buff);
1606  } else {
1607    owl_function_popless_text("Error getting subscriptions");
1608  }
1609           
1610  g_free(buff);
1611}
1612
1613void owl_function_printallvars(void)
1614{
1615  const char *name;
1616  char *var;
1617  owl_list varnames;
1618  int i, numvarnames;
1619  GString *str   = g_string_new("");
1620
1621  g_string_append_printf(str, "%-20s = %s\n", "VARIABLE", "VALUE");
1622  g_string_append_printf(str, "%-20s   %s\n",  "--------", "-----");
1623  owl_list_create(&varnames);
1624  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1625  numvarnames = owl_list_get_size(&varnames);
1626  for (i=0; i<numvarnames; i++) {
1627    name = owl_list_get_element(&varnames, i);
1628    if (name && name[0]!='_') {
1629      g_string_append_printf(str, "\n%-20s = ", name);
1630      var = owl_variable_get_tostring(owl_global_get_vardict(&g), name);
1631      if (var) {
1632        g_string_append(str, var);
1633        g_free(var);
1634      }
1635    }
1636  }
1637  g_string_append(str, "\n");
1638  owl_list_cleanup(&varnames, g_free);
1639
1640  owl_function_popless_text(str->str);
1641  g_string_free(str, true);
1642}
1643
1644void owl_function_show_variables(void)
1645{
1646  owl_list varnames;
1647  owl_fmtext fm; 
1648  int i, numvarnames;
1649  const char *varname;
1650
1651  owl_fmtext_init_null(&fm);
1652  owl_fmtext_append_bold(&fm, 
1653      "Variables: (use 'show variable <name>' for details)\n");
1654  owl_list_create(&varnames);
1655  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1656  numvarnames = owl_list_get_size(&varnames);
1657  for (i=0; i<numvarnames; i++) {
1658    varname = owl_list_get_element(&varnames, i);
1659    if (varname && varname[0]!='_') {
1660      owl_variable_describe(owl_global_get_vardict(&g), varname, &fm);
1661    }
1662  }
1663  owl_list_cleanup(&varnames, g_free);
1664  owl_function_popless_fmtext(&fm);
1665  owl_fmtext_cleanup(&fm);
1666}
1667
1668void owl_function_show_variable(const char *name)
1669{
1670  owl_fmtext fm; 
1671
1672  owl_fmtext_init_null(&fm);
1673  owl_variable_get_help(owl_global_get_vardict(&g), name, &fm);
1674  owl_function_popless_fmtext(&fm);
1675  owl_fmtext_cleanup(&fm);
1676}
1677
1678/* note: this applies to global message list, not to view.
1679 * If flag is 1, deletes.  If flag is 0, undeletes. */
1680void owl_function_delete_by_id(int id, int flag)
1681{
1682  const owl_messagelist *ml;
1683  owl_message *m;
1684  ml = owl_global_get_msglist(&g);
1685  m = owl_messagelist_get_by_id(ml, id);
1686  if (m) {
1687    if (flag == 1) {
1688      owl_message_mark_delete(m);
1689    } else if (flag == 0) {
1690      owl_message_unmark_delete(m);
1691    }
1692    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1693  } else {
1694    owl_function_error("No message with id %d: unable to mark for (un)delete",id);
1695  }
1696}
1697
1698void owl_function_delete_automsgs(void)
1699{
1700  /* mark for deletion all messages in the current view that match the
1701   * 'trash' filter */
1702
1703  int i, j, count;
1704  owl_message *m;
1705  const owl_view *v;
1706  const owl_filter *f;
1707
1708  /* get the trash filter */
1709  f=owl_global_get_filter(&g, "trash");
1710  if (!f) {
1711    owl_function_error("No trash filter defined");
1712    return;
1713  }
1714
1715  v=owl_global_get_current_view(&g);
1716
1717  count=0;
1718  j=owl_view_get_size(v);
1719  for (i=0; i<j; i++) {
1720    m=owl_view_get_element(v, i);
1721    if (owl_filter_message_match(f, m)) {
1722      count++;
1723      owl_message_mark_delete(m);
1724    }
1725  }
1726  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1727  owl_function_makemsg("%i messages marked for deletion", count);
1728}
1729
1730void owl_function_status(void)
1731{
1732  char buff[MAXPATHLEN+1];
1733  time_t start;
1734  int up, days, hours, minutes;
1735  owl_fmtext fm;
1736
1737  owl_fmtext_init_null(&fm);
1738
1739  start=owl_global_get_starttime(&g);
1740
1741  owl_fmtext_append_normal(&fm, "General Information:\n");
1742
1743  owl_fmtext_append_normal(&fm, "  Version: ");
1744  owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
1745  owl_fmtext_append_normal(&fm, "\n");
1746
1747  owl_fmtext_append_normal(&fm, "  Startup Arguments: ");
1748  owl_fmtext_append_normal(&fm, owl_global_get_startupargs(&g));
1749  owl_fmtext_append_normal(&fm, "\n");
1750
1751  owl_fmtext_append_normal(&fm, "  Current Directory: ");
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  }
1757  owl_fmtext_append_normal(&fm, "\n");
1758
1759  owl_fmtext_appendf_normal(&fm, "  Startup Time: %s", ctime(&start));
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;
1768  owl_fmtext_appendf_normal(&fm, "  Run Time: %i days %2.2i:%2.2i:%2.2i\n", days, hours, minutes, up);
1769
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");
1774  } else {
1775    owl_fmtext_append_normal(&fm, "no\n");
1776  }
1777  owl_fmtext_append_normal(&fm, "  AIM included       : yes\n");
1778  owl_fmtext_append_normal(&fm, "  Loopback included  : yes\n");
1779
1780
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: ");
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 {
1796    owl_fmtext_append_normal(&fm, "(not logged in)\n");
1797  }
1798
1799  owl_fmtext_append_normal(&fm, "  Processing events: ");
1800  if (owl_global_is_doaimevents(&g)) {
1801    owl_fmtext_append_normal(&fm, "yes\n");
1802  } else {
1803    owl_fmtext_append_normal(&fm, "no\n");
1804  }
1805
1806  owl_function_popless_fmtext(&fm);
1807  owl_fmtext_cleanup(&fm);
1808}
1809
1810void owl_function_show_term(void)
1811{
1812  owl_fmtext fm;
1813
1814  owl_fmtext_init_null(&fm);
1815  owl_fmtext_appendf_normal(&fm, "Terminal Lines: %i\nTerminal Columns: %i\n",
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");
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");
1823  } else {
1824    owl_fmtext_append_normal(&fm, "Color: No\n");
1825  }
1826
1827  owl_function_popless_fmtext(&fm);
1828  owl_fmtext_cleanup(&fm);
1829}
1830
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 */
1836void owl_function_reply(int type, int enter)
1837{
1838  char *buff=NULL;
1839  const owl_message *m;
1840  const owl_filter *f;
1841 
1842  if (owl_view_get_size(owl_global_get_current_view(&g))==0) {
1843    owl_function_error("No message selected");
1844  } else {
1845    char *cmd;
1846   
1847    m=owl_view_get_element(owl_global_get_current_view(&g), owl_global_get_curmsg(&g));
1848    if (!m) {
1849      owl_function_error("No message selected");
1850      return;
1851    }
1852
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)) {
1857        owl_function_error("Sorry, replies to this message have been disabled by the reply-lockout filter");
1858        return;
1859      }
1860    }
1861
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
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;
1873    }
1874
1875    if(!buff) {
1876        owl_function_error("I don't know how to reply to that message.");
1877        return;
1878    }
1879
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);
1887    }
1888    g_free(buff);
1889  }
1890}
1891
1892void owl_function_zlocate(int argc, const char *const *argv, int auth)
1893{
1894  owl_fmtext fm;
1895  char *ptr;
1896  char *result;
1897  int i;
1898
1899  owl_fmtext_init_null(&fm);
1900
1901  for (i=0; i<argc; i++) {
1902    ptr = long_zuser(argv[i]);
1903    result = owl_zephyr_zlocate(ptr, auth);
1904    owl_fmtext_append_normal(&fm, result);
1905    g_free(result);
1906    g_free(ptr);
1907  }
1908
1909  owl_function_popless_fmtext(&fm);
1910  owl_fmtext_cleanup(&fm);
1911}
1912
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    g_free(rv);
1922  }
1923}
1924
1925void owl_function_start_command(const char *line)
1926{
1927  owl_editwin *tw;
1928  owl_context *ctx;
1929
1930  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
1931
1932  owl_editwin_set_locktext(tw, "command: ");
1933
1934  owl_editwin_insert_string(tw, line);
1935
1936  ctx = owl_editcontext_new(OWL_CTX_EDITLINE, tw, "editline",
1937                            owl_global_deactivate_editcontext, &g);
1938  owl_global_push_context_obj(&g, ctx);
1939  owl_editwin_set_callback(tw, owl_callback_command);
1940}
1941
1942owl_editwin *owl_function_start_question(const char *line)
1943{
1944  owl_editwin *tw;
1945  owl_context *ctx;
1946
1947  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
1948
1949  owl_editwin_set_locktext(tw, line);
1950
1951  ctx = owl_editcontext_new(OWL_CTX_EDITRESPONSE, tw, "editresponse",
1952                            owl_global_deactivate_editcontext, &g);
1953  owl_global_push_context_obj(&g, ctx);
1954  return tw;
1955}
1956
1957owl_editwin *owl_function_start_password(const char *line)
1958{
1959  owl_editwin *tw;
1960  owl_context *ctx;
1961
1962  tw = owl_global_set_typwin_active(&g, OWL_EDITWIN_STYLE_ONELINE, NULL);
1963
1964  owl_editwin_set_echochar(tw, '*');
1965
1966  owl_editwin_set_locktext(tw, line);
1967
1968  ctx = owl_editcontext_new(OWL_CTX_EDITRESPONSE, tw, "editresponse",
1969                            owl_global_deactivate_editcontext, &g);
1970  owl_global_push_context_obj(&g, ctx);
1971  return tw;
1972}
1973
1974char *owl_function_exec(int argc, const char *const *argv, const char *buff, int type)
1975{
1976  /* if type == 1 display in a popup
1977   * if type == 2 display an admin messages
1978   * if type == 0 return output
1979   * else display in a popup
1980   */
1981  const char *redirect = " 2>&1 < /dev/null";
1982  char *newbuff;
1983  char *out;
1984  FILE *p;
1985
1986#if OWL_STDERR_REDIR
1987  redirect = " < /dev/null";
1988#endif
1989
1990  if (argc<2) {
1991    owl_function_error("Wrong number of arguments to the exec command");
1992    return NULL;
1993  }
1994
1995  buff = skiptokens(buff, 1);
1996  newbuff = g_strdup_printf("exec%s; %s", redirect, buff);
1997
1998  if (type == OWL_OUTPUT_POPUP) {
1999    owl_popexec_new(newbuff);
2000  } else {
2001    p = popen(newbuff, "r");
2002    out = owl_slurp(p);
2003    pclose(p);
2004   
2005    if (type == OWL_OUTPUT_RETURN) {
2006      g_free(newbuff);
2007      return out;
2008    } else if (type == OWL_OUTPUT_ADMINMSG) {
2009      owl_function_adminmsg(buff, out);
2010    }
2011    g_free(out);
2012  }
2013  g_free(newbuff);
2014  return NULL;
2015}
2016
2017char *owl_function_perl(int argc, const char *const *argv, const char *buff, int type)
2018{
2019  /* if type == 1 display in a popup
2020   * if type == 2 display an admin messages
2021   * if type == 0 return output
2022   * else display in a popup
2023   */
2024  char *perlout;
2025
2026  if (argc<2) {
2027    owl_function_error("Wrong number of arguments to perl command");
2028    return NULL;
2029  }
2030
2031  /* consume first token (argv[0]) */
2032  buff = skiptokens(buff, 1);
2033
2034  perlout = owl_perlconfig_execute(buff);
2035  if (perlout) { 
2036    if (type == OWL_OUTPUT_POPUP) {
2037      owl_function_popless_text(perlout);
2038    } else if (type == OWL_OUTPUT_ADMINMSG) {
2039      owl_function_adminmsg(buff, perlout);
2040    } else if (type == OWL_OUTPUT_RETURN) {
2041      return perlout;
2042    }
2043    g_free(perlout);
2044  }
2045  return NULL;
2046}
2047
2048/* Change the filter associated with the current view.
2049 * This also figures out which message in the new filter
2050 * should have the pointer.
2051 */
2052void owl_function_change_currentview_filter(const char *filtname)
2053{
2054  owl_view *v;
2055  owl_filter *f;
2056  int curid=-1, newpos, curmsg;
2057  const owl_message *curm=NULL;
2058
2059  v=owl_global_get_current_view(&g);
2060
2061  curmsg=owl_global_get_curmsg(&g);
2062  if (curmsg==-1) {
2063    owl_function_debugmsg("Hit the curmsg==-1 case in change_view");
2064  } else {
2065    curm=owl_view_get_element(v, curmsg);
2066    if (curm) {
2067      curid=owl_message_get_id(curm);
2068      owl_view_save_curmsgid(v, curid);
2069    }
2070  }
2071
2072  f=owl_global_get_filter(&g, filtname);
2073  if (!f) {
2074    owl_function_error("Unknown filter %s", filtname);
2075    return;
2076  }
2077
2078  owl_view_new_filter(v, f);
2079
2080  /* Figure out what to set the current message to.
2081   * - If the view we're leaving has messages in it, go to the closest message
2082   *   to the last message pointed to in that view.
2083   * - If the view we're leaving is empty, try to restore the position
2084   *   from the last time we were in the new view.  */
2085  if (curm) {
2086    newpos = owl_view_get_nearest_to_msgid(v, curid);
2087  } else {
2088    newpos = owl_view_get_nearest_to_saved(v);
2089  }
2090
2091  owl_global_set_curmsg(&g, newpos);
2092  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
2093  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2094  owl_global_set_direction_downwards(&g);
2095}
2096
2097/* Create a new filter, or replace an existing one
2098 * with a new definition.
2099 */
2100void owl_function_create_filter(int argc, const char *const *argv)
2101{
2102  owl_filter *f;
2103  const owl_view *v;
2104  int inuse = 0;
2105
2106  if (argc < 2) {
2107    owl_function_error("Wrong number of arguments to filter command");
2108    return;
2109  }
2110
2111  owl_function_debugmsg("owl_function_create_filter: starting to create filter named %s", argv[1]);
2112
2113  v=owl_global_get_current_view(&g);
2114
2115  /* don't touch the all filter */
2116  if (!strcmp(argv[1], "all")) {
2117    owl_function_error("You may not change the 'all' filter.");
2118    return;
2119  }
2120
2121  /* deal with the case of trying change the filter color */
2122  if (argc==4 && !strcmp(argv[2], "-c")) {
2123    f=owl_global_get_filter(&g, argv[1]);
2124    if (!f) {
2125      owl_function_error("The filter '%s' does not exist.", argv[1]);
2126      return;
2127    }
2128    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
2129      owl_function_error("The color '%s' is not available.", argv[3]);
2130      return;
2131    }
2132    owl_filter_set_fgcolor(f, owl_util_string_to_color(argv[3]));
2133    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2134    return;
2135  }
2136  if (argc==4 && !strcmp(argv[2], "-b")) {
2137    f=owl_global_get_filter(&g, argv[1]);
2138    if (!f) {
2139      owl_function_error("The filter '%s' does not exist.", argv[1]);
2140      return;
2141    }
2142    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
2143      owl_function_error("The color '%s' is not available.", argv[3]);
2144      return;
2145    }
2146    owl_filter_set_bgcolor(f, owl_util_string_to_color(argv[3]));
2147    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2148    return;
2149  }
2150
2151  /* create the filter and check for errors */
2152  f = owl_filter_new(argv[1], argc-2, argv+2);
2153  if (f == NULL) {
2154    owl_function_error("Invalid filter");
2155    return;
2156  }
2157
2158  /* if the named filter is in use by the current view, remember it */
2159  if (!strcmp(owl_view_get_filtname(v), argv[1])) {
2160    inuse=1;
2161  }
2162
2163  /* if the named filter already exists, nuke it */
2164  if (owl_global_get_filter(&g, argv[1])) {
2165    owl_global_remove_filter(&g, argv[1]);
2166  }
2167
2168  /* add the filter */
2169  owl_global_add_filter(&g, f);
2170
2171  /* if it was in use by the current view then update */
2172  if (inuse) {
2173    owl_function_change_currentview_filter(argv[1]);
2174  }
2175  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2176}
2177
2178/* If 'filtername' does not start with 'not-' create a filter named
2179 * 'not-<filtername>' defined as "not filter <filtername>".  If the
2180 * filter 'not-<filtername>' already exists, do not overwrite it.  If
2181 * 'filtername' begins with 'not-' and a filter 'filtername' already
2182 * exists, then do nothing.  If the filter 'filtername' does not
2183 * exist, create it and define it as 'not filter <filtername>'
2184 *
2185 * Returns the name of the negated filter, which the caller must free.
2186 */
2187char *owl_function_create_negative_filter(const char *filtername)
2188{
2189  char *newname;
2190  const owl_filter *tmpfilt;
2191  const char *argv[5];
2192
2193  owl_function_debugmsg("owl_function_create_negative_filter");
2194 
2195  if (!strncmp(filtername, "not-", 4)) {
2196    newname=g_strdup(filtername+4);
2197  } else {
2198    newname=g_strdup_printf("not-%s", filtername);
2199  }
2200
2201  tmpfilt=owl_global_get_filter(&g, newname);
2202  if (!tmpfilt) {
2203    argv[0]="filter"; /* anything is fine here */
2204    argv[1]=newname;
2205    argv[2]="not";
2206    argv[3]="filter";
2207    argv[4]=filtername;
2208    owl_function_create_filter(5, argv);
2209  }
2210
2211  owl_function_debugmsg("owl_function_create_negative_filter: returning with %s", newname);
2212  return(newname);
2213}
2214
2215void owl_function_show_filters(void)
2216{
2217  const owl_filter *f;
2218  GList *fl;
2219  owl_fmtext fm;
2220
2221  owl_fmtext_init_null(&fm);
2222
2223  owl_fmtext_append_bold(&fm, "Filters:\n");
2224
2225  for (fl = g.filterlist; fl; fl = g_list_next(fl)) {
2226    f = fl->data;
2227    owl_fmtext_append_normal(&fm, "   ");
2228    if (owl_global_get_hascolors(&g)) {
2229      owl_fmtext_append_normal_color(&fm, owl_filter_get_name(f), owl_filter_get_fgcolor(f), owl_filter_get_bgcolor(f));
2230    } else {
2231      owl_fmtext_append_normal(&fm, owl_filter_get_name(f));
2232    }
2233    owl_fmtext_append_normal(&fm, "\n");
2234  }
2235  owl_function_popless_fmtext(&fm);
2236  owl_fmtext_cleanup(&fm);
2237}
2238
2239void owl_function_show_filter(const char *name)
2240{
2241  const owl_filter *f;
2242  char *buff, *tmp;
2243
2244  f=owl_global_get_filter(&g, name);
2245  if (!f) {
2246    owl_function_error("There is no filter named %s", name);
2247    return;
2248  }
2249  tmp = owl_filter_print(f);
2250  buff = g_strdup_printf("%s: %s", owl_filter_get_name(f), tmp);
2251  owl_function_popless_text(buff);
2252  g_free(buff);
2253  g_free(tmp);
2254}
2255
2256void owl_function_show_zpunts(void)
2257{
2258  const owl_filter *f;
2259  const owl_list *fl;
2260  char *tmp;
2261  owl_fmtext fm;
2262  int i, j;
2263
2264  owl_fmtext_init_null(&fm);
2265
2266  fl=owl_global_get_puntlist(&g);
2267  j=owl_list_get_size(fl);
2268  owl_fmtext_append_bold(&fm, "Active zpunt filters:\n");
2269
2270  for (i=0; i<j; i++) {
2271    f=owl_list_get_element(fl, i);
2272    owl_fmtext_appendf_normal(&fm, "[% 2d] ", i+1);
2273    tmp = owl_filter_print(f);
2274    owl_fmtext_append_normal(&fm, tmp);
2275    g_free(tmp);
2276  }
2277  owl_function_popless_fmtext(&fm);
2278  owl_fmtext_cleanup(&fm);
2279}
2280
2281/* Create a filter for a class, instance if one doesn't exist.  If
2282 * instance is NULL then catch all messgaes in the class.  Returns the
2283 * name of the filter or null.  The caller must free this name.
2284 * If 'related' is nonzero, encompass unclasses and .d classes as well.
2285 */
2286char *owl_function_classinstfilt(const char *c, const char *i, int related) 
2287{
2288  owl_filter *f;
2289  char *filtname;
2290  char *tmpclass, *tmpinstance = NULL;
2291  char *class, *instance = NULL;
2292  GString *buf;
2293
2294  if (related) {
2295    class = owl_util_baseclass(c);
2296    if (i) {
2297      instance = owl_util_baseclass(i);
2298    }
2299  } else {
2300    class = g_strdup(c);
2301    if (i) {
2302      instance = g_strdup(i);
2303    }
2304  }
2305
2306  /* name for the filter */
2307  if (!instance) {
2308    filtname = g_strdup_printf("%sclass-%s", related ? "related-" : "", class);
2309  } else {
2310    filtname = g_strdup_printf("%sclass-%s-instance-%s", related ? "related-" : "", class, instance);
2311  }
2312  /* downcase it */
2313  {
2314    char *temp = g_utf8_strdown(filtname, -1);
2315    if (temp) {
2316      g_free(filtname);
2317      filtname = temp;
2318    }
2319  }
2320 
2321  /* if it already exists then go with it.  This lets users override */
2322  if (owl_global_get_filter(&g, filtname)) {
2323    goto done;
2324  }
2325
2326  /* create the new filter */
2327  tmpclass=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2328  if (instance) {
2329    tmpinstance=owl_text_quote(instance, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2330  }
2331
2332  buf = g_string_new("");
2333  owl_string_appendf_quoted(buf,
2334                            related ? "class ^(un)*%q(\\.d)*$" : "class ^%q$",
2335                            tmpclass);
2336
2337  if (tmpinstance) {
2338    owl_string_appendf_quoted(buf,
2339                              related ?
2340                              " and ( instance ^(un)*%q(\\.d)*$ )" :
2341                              " and instance ^%q$",
2342                              tmpinstance);
2343  }
2344  g_free(tmpclass);
2345  g_free(tmpinstance);
2346
2347  f = owl_filter_new_fromstring(filtname, buf->str);
2348  g_string_free(buf, true);
2349  if (f == NULL) {
2350    /* Couldn't make a filter for some reason. Return NULL. */
2351    owl_function_error("Error creating filter '%s'", filtname);
2352    g_free(filtname);
2353    filtname = NULL;
2354    goto done;
2355  }
2356
2357  /* add it to the global list */
2358  owl_global_add_filter(&g, f);
2359
2360done:
2361  g_free(class);
2362  if (instance) {
2363    g_free(instance);
2364  }
2365  return(filtname);
2366}
2367
2368/* Create a filter for personal zephyrs to or from the specified
2369 * zephyr user.  Includes login/logout notifications for the user.
2370 * The name of the filter will be 'user-<shortuser>'.  If a filter already
2371 * exists with this name, no new filter will be created.  This allows
2372 * the configuration to override this function.  Returns the name of
2373 * the filter, which the caller must free.
2374 */
2375char *owl_function_zuserfilt(const char *longuser)
2376{
2377  owl_filter *f;
2378  char *argbuff, *esclonguser, *shortuser, *filtname;
2379
2380  /* name for the filter */
2381  shortuser = short_zuser(longuser);
2382  filtname = g_strdup_printf("user-%s", shortuser);
2383  g_free(shortuser);
2384
2385  /* if it already exists then go with it.  This lets users override */
2386  if (owl_global_get_filter(&g, filtname)) {
2387    return filtname;
2388  }
2389
2390  /* create the new-internal filter */
2391  esclonguser = owl_text_quote(longuser, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2392
2393  argbuff=owl_string_build_quoted("( type ^zephyr$ and filter personal and "
2394      "( ( direction ^in$ and sender ^%q$ ) or ( direction ^out$ and "
2395      "recipient ^%q$ ) ) ) or ( ( class ^login$ ) and ( sender ^%q$ ) )",
2396      esclonguser, esclonguser, esclonguser);
2397  g_free(esclonguser);
2398
2399  f = owl_filter_new_fromstring(filtname, argbuff);
2400  g_free(argbuff);
2401
2402  if (f == NULL) {
2403    /* Couldn't make a filter for some reason. Return NULL. */
2404    owl_function_error("Error creating filter '%s'", filtname);
2405    g_free(filtname);
2406    return NULL;
2407  }
2408
2409  /* add it to the global list */
2410  owl_global_add_filter(&g, f);
2411
2412  return(filtname);
2413}
2414
2415/* Create a filter for AIM IM messages to or from the specified
2416 * screenname.  The name of the filter will be 'aimuser-<user>'.  If a
2417 * filter already exists with this name, no new filter will be
2418 * created.  This allows the configuration to override this function.
2419 * Returns the name of the filter, which the caller must free.
2420 */
2421char *owl_function_aimuserfilt(const char *user)
2422{
2423  owl_filter *f;
2424  char *argbuff, *filtname;
2425  char *escuser;
2426
2427  /* name for the filter */
2428  filtname=g_strdup_printf("aimuser-%s", user);
2429
2430  /* if it already exists then go with it.  This lets users override */
2431  if (owl_global_get_filter(&g, filtname)) {
2432    return(g_strdup(filtname));
2433  }
2434
2435  /* create the new-internal filter */
2436  escuser = owl_text_quote(user, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2437
2438  argbuff = g_strdup_printf(
2439      "( type ^aim$ and ( ( sender ^%1$s$ and recipient ^%2$s$ ) or "
2440      "( sender ^%2$s$ and recipient ^%1$s$ ) ) )",
2441      escuser, owl_global_get_aim_screenname_for_filters(&g));
2442  g_free(escuser);
2443
2444  f = owl_filter_new_fromstring(filtname, argbuff);
2445  g_free(argbuff);
2446
2447  if (f == NULL) {
2448    owl_function_error("Error creating filter '%s'", filtname);
2449    g_free(filtname);
2450    return NULL;
2451  }
2452
2453  /* add it to the global list */
2454  owl_global_add_filter(&g, f);
2455
2456  return(filtname);
2457}
2458
2459char *owl_function_typefilt(const char *type)
2460{
2461  owl_filter *f;
2462  char *argbuff, *filtname, *esctype;
2463
2464  /* name for the filter */
2465  filtname=g_strdup_printf("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 */
2473  esctype = owl_text_quote(type, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2474
2475  argbuff = owl_string_build_quoted("type ^%q$", esctype);
2476  g_free(esctype);
2477
2478  f = owl_filter_new_fromstring(filtname, argbuff);
2479  g_free(argbuff);
2480
2481  if (f == NULL) {
2482    owl_function_error("Error creating filter '%s'", filtname);
2483    g_free(filtname);
2484    return NULL;
2485  }
2486
2487  /* add it to the global list */
2488  owl_global_add_filter(&g, f);
2489
2490  return filtname;
2491}
2492
2493/* If flag is 1, marks for deletion.  If flag is 0,
2494 * unmarks for deletion. */
2495void owl_function_delete_curview_msgs(int flag)
2496{
2497  const owl_view *v;
2498  int i, j;
2499
2500  v=owl_global_get_current_view(&g);
2501  j=owl_view_get_size(v);
2502  for (i=0; i<j; i++) {
2503    if (flag == 1) {
2504      owl_message_mark_delete(owl_view_get_element(v, i));
2505    } else if (flag == 0) {
2506      owl_message_unmark_delete(owl_view_get_element(v, i));
2507    }
2508  }
2509
2510  owl_function_makemsg("%i messages marked for %sdeletion", j, flag?"":"un");
2511
2512  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
2513}
2514
2515static char *owl_function_smartfilter_cc(const owl_message *m) {
2516  const char *ccs;
2517  char *ccs_quoted;
2518  char *filtname;
2519  owl_filter *f;
2520  GString *buf;
2521
2522  ccs = owl_message_get_attribute_value(m, "zephyr_ccs");
2523
2524  filtname = g_strdup_printf("conversation-%s", ccs);
2525  owl_text_tr(filtname, ' ', '-');
2526
2527  if (owl_global_get_filter(&g, filtname)) {
2528    return filtname;
2529  }
2530
2531  buf = g_string_new("type ^zephyr$ and filter personal and "
2532                     "zephyr_ccs ^");
2533  ccs_quoted = owl_text_quote(ccs, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2534  owl_string_append_quoted_arg(buf, ccs_quoted);
2535  g_string_append_c(buf, '$');
2536  g_free(ccs_quoted);
2537
2538  f = owl_filter_new_fromstring(filtname, buf->str);
2539  g_string_free(buf, true);
2540
2541  if (f == NULL) {
2542    owl_function_error("Error creating filter '%s'", filtname);
2543    g_free(filtname);
2544    return NULL;
2545  }
2546
2547  owl_global_add_filter(&g, f);
2548
2549  return filtname;
2550}
2551
2552/* Create a filter based on the current message.  Returns the name of
2553 * a filter or null.  The caller must free this name.
2554 *
2555 * if the curmsg is a personal zephyr return a filter name
2556 *    to the zephyr conversation with that user.
2557 * If the curmsg is a zephyr class message, instance foo, recip *,
2558 *    return a filter name to the class, inst.
2559 * If the curmsg is a zephyr class message and type==0 then
2560 *    return a filter name for just the class.
2561 * If the curmsg is a zephyr class message and type==1 then
2562 *    return a filter name for the class and instance.
2563 * If the curmsg is a personal AIM message returna  filter
2564 *    name to the AIM conversation with that user
2565 */
2566char *owl_function_smartfilter(int type, int invert_related)
2567{
2568  const owl_view *v;
2569  const owl_message *m;
2570  char *filtname = NULL;
2571  const char *argv[2], *zperson;
2572  int related = owl_global_is_narrow_related(&g) ^ invert_related;
2573
2574  v=owl_global_get_current_view(&g);
2575  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2576
2577  if (!m || owl_view_get_size(v)==0) {
2578    owl_function_error("No message selected\n");
2579    return(NULL);
2580  }
2581
2582  /* very simple handling of admin messages for now */
2583  if (owl_message_is_type_admin(m)) {
2584    return(owl_function_typefilt("admin"));
2585  }
2586
2587  /* very simple handling of loopback messages for now */
2588  if (owl_message_is_type_loopback(m)) {
2589    return(owl_function_typefilt("loopback"));
2590  }
2591
2592  /* aim messages */
2593  if (owl_message_is_type_aim(m)) {
2594    if (owl_message_is_direction_in(m)) {
2595      filtname=owl_function_aimuserfilt(owl_message_get_sender(m));
2596    } else if (owl_message_is_direction_out(m)) {
2597      filtname=owl_function_aimuserfilt(owl_message_get_recipient(m));
2598    }
2599    return(filtname);
2600  }
2601
2602  /* narrow personal and login messages to the sender or recip as appropriate */
2603  if (owl_message_is_type_zephyr(m)) {
2604    if (owl_message_is_personal(m) || owl_message_is_loginout(m)) {
2605      if (owl_message_get_attribute_value(m, "zephyr_ccs") != NULL) {
2606        return owl_function_smartfilter_cc(m);
2607      }
2608
2609      if (owl_message_is_direction_in(m)) {
2610        zperson = owl_message_get_sender(m);
2611      } else {
2612        zperson = owl_message_get_recipient(m);
2613      }
2614      filtname = owl_function_zuserfilt(zperson);
2615      return filtname;
2616    }
2617
2618    /* narrow class MESSAGE, instance foo, recip * messages to class, inst */
2619    if (!strcasecmp(owl_message_get_class(m), "message")) {
2620      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
2621      return(filtname);
2622    }
2623
2624    /* otherwise narrow to the class */
2625    if (type==0) {
2626      filtname=owl_function_classinstfilt(owl_message_get_class(m), NULL, related);
2627    } else if (type==1) {
2628      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
2629    }
2630    return(filtname);
2631  }
2632
2633  /* pass it off to perl */
2634  argv[0] = type ? "1" : "0";
2635  argv[1] = related ? "1" : "0";
2636  return owl_perlconfig_message_call_method(m, "smartfilter", 2, argv);
2637}
2638
2639void owl_function_smartzpunt(int type)
2640{
2641  /* Starts a zpunt command based on the current class,instance pair.
2642   * If type=0, uses just class.  If type=1, uses instance as well. */
2643  const owl_view *v;
2644  const owl_message *m;
2645  const char *mclass, *minst;
2646  GString *buf;
2647 
2648  v=owl_global_get_current_view(&g);
2649  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2650
2651  if (!m || owl_view_get_size(v)==0) {
2652    owl_function_error("No message selected\n");
2653    return;
2654  }
2655
2656  /* for now we skip admin messages. */
2657  if (owl_message_is_type_admin(m)
2658      || owl_message_is_loginout(m)
2659      || !owl_message_is_type_zephyr(m)) {
2660    owl_function_error("smartzpunt doesn't support this message type.");
2661    return;
2662  }
2663
2664  mclass = owl_message_get_class(m);
2665  minst = owl_message_get_instance(m);
2666  if (!mclass || !*mclass || *mclass==' '
2667      || (!strcasecmp(mclass, "message") && !strcasecmp(minst, "personal"))
2668      || (type && (!minst || !*minst|| *minst==' '))) {
2669    owl_function_error("smartzpunt can't safely do this for <%s,%s>",
2670                         mclass, minst);
2671  } else {
2672    buf = g_string_new("start-command zpunt ");
2673    owl_string_append_quoted_arg(buf, mclass);
2674    if (type) {
2675      g_string_append_c(buf, ' ');
2676      owl_string_append_quoted_arg(buf, minst);
2677    } else {
2678      g_string_append(buf, " *");
2679    }
2680    owl_function_command_norv(buf->str);
2681    g_string_free(buf, true);
2682  }
2683}
2684
2685/* Set the color of the current view's filter to
2686 * be 'color'
2687 */
2688void owl_function_color_current_filter(const char *fgcolor, const char *bgcolor)
2689{
2690  const char *name;
2691
2692  name=owl_view_get_filtname(owl_global_get_current_view(&g));
2693  owl_function_color_filter(name, fgcolor, bgcolor);
2694}
2695
2696/* Set the color of the filter 'filter' to be 'color'.  If the color
2697 * name does not exist, return -1, if the filter does not exist or is
2698 * the "all" filter, return -2.  Return 0 on success
2699 */
2700int owl_function_color_filter(const char *filtname, const char *fgcolor, const char *bgcolor)
2701{
2702  owl_filter *f;
2703
2704  f=owl_global_get_filter(&g, filtname);
2705  if (!f) {
2706    owl_function_error("Unknown filter");
2707    return(-2);
2708  }
2709
2710  /* don't touch the all filter */
2711  if (!strcmp(filtname, "all")) {
2712    owl_function_error("You may not change the 'all' filter.");
2713    return(-2);
2714  }
2715
2716  if (owl_util_string_to_color(fgcolor)==OWL_COLOR_INVALID) {
2717    owl_function_error("No color named '%s' avilable.", fgcolor);
2718    return(-1);
2719  }
2720
2721
2722  if (bgcolor != NULL) {
2723    if (owl_util_string_to_color(bgcolor)==OWL_COLOR_INVALID) {
2724      owl_function_error("No color named '%s' avilable.", bgcolor);
2725      return(-1);
2726    }
2727    owl_filter_set_bgcolor(f, owl_util_string_to_color(bgcolor));
2728  }
2729  owl_filter_set_fgcolor(f, owl_util_string_to_color(fgcolor));
2730 
2731  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2732  return(0);
2733}
2734
2735void owl_function_show_colors(void)
2736{
2737  owl_fmtext fm;
2738  int i; 
2739 
2740  owl_fmtext_init_null(&fm);
2741  owl_fmtext_append_normal(&fm,"default:  ");
2742  owl_fmtext_append_normal_color(&fm, "default\n", OWL_COLOR_DEFAULT, OWL_COLOR_DEFAULT);
2743
2744  owl_fmtext_append_normal(&fm,"black:    ");
2745  owl_fmtext_append_normal_color(&fm, "black\n", OWL_COLOR_BLACK, OWL_COLOR_DEFAULT);
2746
2747  owl_fmtext_append_normal(&fm,"red:      ");
2748  owl_fmtext_append_normal_color(&fm, "red\n", OWL_COLOR_RED, OWL_COLOR_DEFAULT);
2749
2750  owl_fmtext_append_normal(&fm,"green:    ");
2751  owl_fmtext_append_normal_color(&fm, "green\n", OWL_COLOR_GREEN, OWL_COLOR_DEFAULT);
2752
2753  owl_fmtext_append_normal(&fm,"yellow:   ");
2754  owl_fmtext_append_normal_color(&fm, "yellow\n", OWL_COLOR_YELLOW, OWL_COLOR_DEFAULT);
2755
2756  owl_fmtext_append_normal(&fm,"blue:     ");
2757  owl_fmtext_append_normal_color(&fm, "blue\n", OWL_COLOR_BLUE, OWL_COLOR_DEFAULT);
2758
2759  owl_fmtext_append_normal(&fm,"magenta:  ");
2760  owl_fmtext_append_normal_color(&fm, "magenta\n", OWL_COLOR_MAGENTA, OWL_COLOR_DEFAULT);
2761
2762  owl_fmtext_append_normal(&fm,"cyan:     ");
2763  owl_fmtext_append_normal_color(&fm, "cyan\n", OWL_COLOR_CYAN, OWL_COLOR_DEFAULT);
2764
2765  owl_fmtext_append_normal(&fm,"white:    ");
2766  owl_fmtext_append_normal_color(&fm, "white\n", OWL_COLOR_WHITE, OWL_COLOR_DEFAULT);
2767
2768  for(i = 8; i < COLORS; ++i) {
2769    char* str1 = g_strdup_printf("%4i:     ",i);
2770    char* str2 = g_strdup_printf("%i\n",i);
2771    owl_fmtext_append_normal(&fm,str1);
2772    owl_fmtext_append_normal_color(&fm, str2, i, OWL_COLOR_DEFAULT);
2773    g_free(str1);
2774     g_free(str2);
2775  }
2776 
2777  owl_function_popless_fmtext(&fm);
2778  owl_fmtext_cleanup(&fm);
2779}
2780
2781/* add the given class, inst, recip to the punt list for filtering.
2782 *   if direction==0 then punt
2783 *   if direction==1 then unpunt
2784 */
2785void owl_function_zpunt(const char *class, const char *inst, const char *recip, int direction)
2786{
2787  GString *buf;
2788  char *quoted;
2789
2790  buf = g_string_new("");
2791  if (!strcmp(class, "*")) {
2792    g_string_append(buf, "class .*");
2793  } else {
2794    quoted=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2795    owl_string_appendf_quoted(buf, "class ^(un)*%q(\\.d)*$", quoted);
2796    g_free(quoted);
2797  }
2798  if (!strcmp(inst, "*")) {
2799    g_string_append(buf, " and instance .*");
2800  } else {
2801    quoted=owl_text_quote(inst, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2802    owl_string_appendf_quoted(buf, " and instance ^(un)*%q(\\.d)*$", quoted);
2803    g_free(quoted);
2804  }
2805  if (!strcmp(recip, "*")) {
2806    /* g_string_append(buf, ""); */
2807  } else {
2808    if(!strcmp(recip, "%me%")) {
2809      recip = owl_zephyr_get_sender();
2810    }
2811    quoted=owl_text_quote(recip, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2812    owl_string_appendf_quoted(buf, " and recipient ^%q$", quoted);
2813    g_free(quoted);
2814  }
2815
2816  owl_function_punt(buf->str, direction);
2817  g_string_free(buf, true);
2818}
2819
2820void owl_function_punt(const char *filter, int direction)
2821{
2822  owl_filter *f;
2823  owl_list *fl;
2824  int i, j;
2825  fl=owl_global_get_puntlist(&g);
2826
2827  /* first, create the filter */
2828  owl_function_debugmsg("About to filter %s", filter);
2829  f = owl_filter_new_fromstring("punt-filter", filter);
2830  if (f == NULL) {
2831    owl_function_error("Error creating filter for zpunt");
2832    return;
2833  }
2834
2835  /* Check for an identical filter */
2836  j=owl_list_get_size(fl);
2837  for (i=0; i<j; i++) {
2838    if (owl_filter_equiv(f, owl_list_get_element(fl, i))) {
2839      owl_function_debugmsg("found an equivalent punt filter");
2840      /* if we're punting, then just silently bow out on this duplicate */
2841      if (direction==0) {
2842        owl_filter_delete(f);
2843        return;
2844      }
2845
2846      /* if we're unpunting, then remove this filter from the puntlist */
2847      if (direction==1) {
2848        owl_filter_delete(owl_list_get_element(fl, i));
2849        owl_list_remove_element(fl, i);
2850        owl_filter_delete(f);
2851        return;
2852      }
2853    }
2854  }
2855
2856  owl_function_debugmsg("punting");
2857  /* If we're punting, add the filter to the global punt list */
2858  if (direction==0) {
2859    owl_list_append_element(fl, f);
2860  }
2861}
2862
2863void owl_function_show_keymaps(void)
2864{
2865  owl_list l;
2866  owl_fmtext fm;
2867  const owl_keymap *km;
2868  const owl_keyhandler *kh;
2869  int i, numkm;
2870  const char *kmname;
2871
2872  kh = owl_global_get_keyhandler(&g);
2873  owl_fmtext_init_null(&fm);
2874  owl_fmtext_append_bold(&fm, "Keymaps:   ");
2875  owl_fmtext_append_normal(&fm, "(use 'show keymap <name>' for details)\n");
2876  owl_list_create(&l);
2877  owl_keyhandler_get_keymap_names(kh, &l);
2878  owl_fmtext_append_list(&fm, &l, "\n", owl_function_keymap_summary);
2879  owl_fmtext_append_normal(&fm, "\n");
2880
2881  numkm = owl_list_get_size(&l);
2882  for (i=0; i<numkm; i++) {
2883    kmname = owl_list_get_element(&l, i);
2884    km = owl_keyhandler_get_keymap(kh, kmname);
2885    owl_fmtext_append_bold(&fm, "\n\n----------------------------------------------------------------------------------------------------\n\n");
2886    owl_keymap_get_details(km, &fm, 0);
2887  }
2888  owl_fmtext_append_normal(&fm, "\n");
2889 
2890  owl_function_popless_fmtext(&fm);
2891  owl_list_cleanup(&l, g_free);
2892  owl_fmtext_cleanup(&fm);
2893}
2894
2895char *owl_function_keymap_summary(const char *name)
2896{
2897  const owl_keymap *km
2898    = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2899  if (km) return owl_keymap_summary(km);
2900  else return(NULL);
2901}
2902
2903/* TODO: implement for real */
2904void owl_function_show_keymap(const char *name)
2905{
2906  owl_fmtext fm;
2907  const owl_keymap *km;
2908
2909  owl_fmtext_init_null(&fm);
2910  km = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2911  if (km) {
2912    owl_keymap_get_details(km, &fm, 1);
2913  } else {
2914    owl_fmtext_append_normal(&fm, "No such keymap...\n");
2915  } 
2916  owl_function_popless_fmtext(&fm);
2917  owl_fmtext_cleanup(&fm);
2918}
2919
2920void owl_function_help_for_command(const char *cmdname)
2921{
2922  owl_fmtext fm;
2923
2924  owl_fmtext_init_null(&fm);
2925  owl_cmd_get_help(owl_global_get_cmddict(&g), cmdname, &fm);
2926  owl_function_popless_fmtext(&fm); 
2927  owl_fmtext_cleanup(&fm);
2928}
2929
2930void owl_function_set_search(const char *string)
2931{
2932  owl_regex re;
2933
2934  if (string && owl_regex_create_quoted(&re, string) == 0) {
2935    owl_global_set_search_re(&g, &re);
2936    owl_regex_cleanup(&re);
2937  } else {
2938    owl_global_set_search_re(&g, NULL);
2939  }
2940}
2941
2942void owl_function_search_helper(int consider_current, int direction)
2943{
2944  /* move to a message that contains the string.  If direction is
2945   * OWL_DIRECTION_DOWNWARDS then search fowards, if direction is
2946   * OWL_DIRECTION_UPWARDS then search backwards.
2947   *
2948   * If consider_current is true then it will stay on the
2949   * current message if it contains the string.
2950   */
2951
2952  const owl_view *v;
2953  int viewsize, i, curmsg, start;
2954  owl_message *m;
2955
2956  v=owl_global_get_current_view(&g);
2957  viewsize=owl_view_get_size(v);
2958  curmsg=owl_global_get_curmsg(&g);
2959 
2960  if (viewsize==0) {
2961    owl_function_error("No messages present");
2962    return;
2963  }
2964
2965  if (consider_current) {
2966    start=curmsg;
2967  } else if (direction==OWL_DIRECTION_DOWNWARDS) {
2968    start=curmsg+1;
2969  } else {
2970    start=curmsg-1;
2971  }
2972
2973  /* bounds check */
2974  if (start>=viewsize || start<0) {
2975    owl_function_error("No further matches found");
2976    return;
2977  }
2978
2979  for (i=start; i<viewsize && i>=0;) {
2980    m=owl_view_get_element(v, i);
2981    if (owl_message_search(m, owl_global_get_search_re(&g))) {
2982      owl_global_set_curmsg(&g, i);
2983      owl_function_calculate_topmsg(direction);
2984      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2985      if (direction==OWL_DIRECTION_DOWNWARDS) {
2986        owl_global_set_direction_downwards(&g);
2987      } else {
2988        owl_global_set_direction_upwards(&g);
2989      }
2990      return;
2991    }
2992    if (direction==OWL_DIRECTION_DOWNWARDS) {
2993      i++;
2994    } else {
2995      i--;
2996    }
2997    if (owl_global_take_interrupt(&g)) {
2998      owl_function_makemsg("Search interrupted!");
2999      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3000      return;
3001    }
3002  }
3003  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3004  owl_function_error("No matches found");
3005}
3006
3007/* strips formatting from ztext and returns the unformatted text.
3008 * caller is responsible for freeing. */
3009char *owl_function_ztext_stylestrip(const char *zt)
3010{
3011  owl_fmtext fm;
3012  char *plaintext;
3013
3014  owl_fmtext_init_null(&fm);
3015  owl_fmtext_append_ztext(&fm, zt);
3016  plaintext = owl_fmtext_print_plain(&fm);
3017  owl_fmtext_cleanup(&fm);
3018  return(plaintext);
3019}
3020
3021/* Popup a buddylisting.  If filename is NULL use the default .anyone */
3022void owl_function_buddylist(int aim, int zephyr, const char *filename)
3023{
3024  int i, j, idle;
3025  int interrupted = 0;
3026  owl_fmtext fm;
3027  const owl_buddylist *bl;
3028  const owl_buddy *b;
3029  char *timestr;
3030#ifdef HAVE_LIBZEPHYR
3031  int x;
3032  owl_list anyone;
3033  const char *user;
3034  char *tmp;
3035  ZLocations_t location[200];
3036  int numlocs, ret;
3037#endif
3038
3039  owl_fmtext_init_null(&fm);
3040
3041  /* AIM first */
3042  if (aim && owl_global_is_aimloggedin(&g)) {
3043    bl=owl_global_get_buddylist(&g);
3044
3045    owl_fmtext_append_bold(&fm, "AIM users logged in:\n");
3046    /* we're assuming AIM for now */
3047    j=owl_buddylist_get_size(bl);
3048    for (i=0; i<j; i++) {
3049      b=owl_buddylist_get_buddy_n(bl, i);
3050      idle=owl_buddy_get_idle_time(b);
3051      if (idle!=0) {
3052        timestr=owl_util_minutes_to_timestr(idle);
3053      } else {
3054        timestr=g_strdup("");
3055      }
3056      owl_fmtext_appendf_normal(&fm, "  %-20.20s %-12.12s\n", owl_buddy_get_name(b), timestr);
3057      g_free(timestr);
3058    }
3059  }
3060
3061#ifdef HAVE_LIBZEPHYR
3062  if (zephyr) {
3063    if(!owl_global_is_havezephyr(&g)) {
3064      owl_function_error("Zephyr currently not available.");
3065    } else {
3066      owl_fmtext_append_bold(&fm, "Zephyr users logged in:\n");
3067      owl_list_create(&anyone);
3068      ret=owl_zephyr_get_anyone_list(&anyone, filename);
3069      if (ret) {
3070        if (errno == ENOENT) {
3071          owl_fmtext_append_normal(&fm, " You have not added any zephyr buddies.  Use the\n");
3072          owl_fmtext_append_normal(&fm, " command ':addbuddy zephyr ");
3073          owl_fmtext_append_bold(  &fm, "<username>");
3074          owl_fmtext_append_normal(&fm, "'.\n");
3075        } else {
3076          owl_fmtext_append_normal(&fm, " Could not read zephyr buddies from the .anyone file.\n");
3077        }
3078      } else {
3079        j=owl_list_get_size(&anyone);
3080        for (i=0; i<j; i++) {
3081          user=owl_list_get_element(&anyone, i);
3082          ret=ZLocateUser(zstr(user), &numlocs, ZAUTH);
3083
3084          if (owl_global_take_interrupt(&g)) {
3085            interrupted = 1;
3086            owl_function_makemsg("Interrupted!");
3087            break;
3088          }
3089
3090          if (ret!=ZERR_NONE) {
3091            owl_function_error("Error getting location for %s", user);
3092            continue;
3093          }
3094
3095          numlocs=200;
3096          ret=ZGetLocations(location, &numlocs);
3097          if (ret==0) {
3098            for (x=0; x<numlocs; x++) {
3099              tmp=short_zuser(user);
3100              owl_fmtext_appendf_normal(&fm, "  %-10.10s %-24.24s %-12.12s  %20.20s\n",
3101                                        tmp,
3102                                        location[x].host,
3103                                        location[x].tty,
3104                                        location[x].time);
3105              g_free(tmp);
3106            }
3107            if (numlocs>=200) {
3108              owl_fmtext_append_normal(&fm, "  Too many locations found for this user, truncating.\n");
3109            }
3110          }
3111        }
3112      }
3113      owl_list_cleanup(&anyone, g_free);
3114    }
3115  }
3116#endif
3117
3118  if (aim && zephyr) {
3119    if (owl_perlconfig_is_function("BarnOwl::Hooks::_get_blist")) {
3120      char * perlblist = owl_perlconfig_execute("BarnOwl::Hooks::_get_blist()");
3121      if (perlblist) {
3122        owl_fmtext_append_ztext(&fm, perlblist);
3123        g_free(perlblist);
3124      }
3125    }
3126  }
3127
3128  if(!interrupted) {
3129    owl_function_popless_fmtext(&fm);
3130  }
3131  owl_fmtext_cleanup(&fm);
3132}
3133
3134/* Dump messages in the current view to the file 'filename'. */
3135void owl_function_dump(const char *filename) 
3136{
3137  int i, j;
3138  owl_message *m;
3139  const owl_view *v;
3140  FILE *file;
3141  char *plaintext;
3142
3143  v=owl_global_get_current_view(&g);
3144
3145  /* in the future make it ask yes/no */
3146  /*
3147  ret=stat(filename, &sbuf);
3148  if (!ret) {
3149    ret=owl_function_askyesno("File exists, continue? [Y/n]");
3150    if (!ret) return;
3151  }
3152  */
3153
3154  file=fopen(filename, "w");
3155  if (!file) {
3156    owl_function_error("Error opening file");
3157    return;
3158  }
3159
3160  j=owl_view_get_size(v);
3161  for (i=0; i<j; i++) {
3162    m=owl_view_get_element(v, i);
3163    plaintext = owl_strip_format_chars(owl_message_get_text(m));
3164    if (plaintext) {
3165      fputs(plaintext, file);
3166      g_free(plaintext);
3167    }
3168  }
3169  fclose(file);
3170  owl_function_makemsg("Messages dumped to %s", filename);
3171}
3172
3173void owl_function_do_newmsgproc(void)
3174{
3175  if (owl_global_get_newmsgproc(&g) && strcmp(owl_global_get_newmsgproc(&g), "")) {
3176    /* if there's a process out there, we need to check on it */
3177    if (owl_global_get_newmsgproc_pid(&g)) {
3178      owl_function_debugmsg("Checking on newmsgproc pid==%i", owl_global_get_newmsgproc_pid(&g));
3179      owl_function_debugmsg("Waitpid return is %i", waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG));
3180      waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG);
3181      if (waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG)==-1) {
3182        /* it exited */
3183        owl_global_set_newmsgproc_pid(&g, 0);
3184        owl_function_debugmsg("newmsgproc exited");
3185      } else {
3186        owl_function_debugmsg("newmsgproc did not exit");
3187      }
3188    }
3189   
3190    /* if it exited, fork & exec a new one */
3191    if (owl_global_get_newmsgproc_pid(&g)==0) {
3192      pid_t i;
3193      int myargc;
3194      i=fork();
3195      if (i) {
3196        /* parent set the child's pid */
3197        owl_global_set_newmsgproc_pid(&g, i);
3198        owl_function_debugmsg("I'm the parent and I started a new newmsgproc with pid %i", i);
3199      } else {
3200        /* child exec's the program */
3201        char **parsed;
3202        parsed=owl_parseline(owl_global_get_newmsgproc(&g), &myargc);
3203        if (myargc < 0) {
3204          owl_function_debugmsg("Could not parse newmsgproc '%s': unbalanced quotes?", owl_global_get_newmsgproc(&g));
3205        }
3206        if (myargc <= 0) {
3207          _exit(127);
3208        }
3209        owl_function_debugmsg("About to exec \"%s\" with %d arguments", parsed[0], myargc);
3210       
3211        execvp(parsed[0], parsed);
3212       
3213       
3214        /* was there an error exec'ing? */
3215        owl_function_debugmsg("Cannot run newmsgproc '%s': cannot exec '%s': %s", 
3216                              owl_global_get_newmsgproc(&g), parsed[0], strerror(errno));
3217        _exit(127);
3218      }
3219    }
3220  }
3221}
3222
3223/* print the xterm escape sequence to raise the window */
3224void owl_function_xterm_raise(void)
3225{
3226  printf("\033[5t");
3227}
3228
3229/* print the xterm escape sequence to deiconify the window */
3230void owl_function_xterm_deiconify(void)
3231{
3232  printf("\033[1t");
3233}
3234
3235/* Add the specified command to the startup file.  Eventually this
3236 * should be clever, and rewriting settings that will obviosly
3237 * override earlier settings with 'set' 'bindkey' and 'alias'
3238 * commands.  For now though we just remove any line that would
3239 * duplicate this one and then append this line to the end of
3240 * startupfile.
3241 */
3242void owl_function_addstartup(const char *buff)
3243{
3244  FILE *file;
3245  const char *filename;
3246
3247  filename=owl_global_get_startupfile(&g);
3248
3249  /* delete earlier copies */
3250  owl_util_file_deleteline(filename, buff, 1);
3251
3252  file=fopen(filename, "a");
3253  if (!file) {
3254    owl_function_error("Error opening startupfile for new command");
3255    return;
3256  }
3257
3258  /* add this line */
3259  fprintf(file, "%s\n", buff);
3260
3261  fclose(file);
3262}
3263
3264/* Remove the specified command from the startup file. */
3265void owl_function_delstartup(const char *buff)
3266{
3267  const char *filename;
3268  filename=owl_global_get_startupfile(&g);
3269  owl_util_file_deleteline(filename, buff, 1);
3270}
3271
3272/* Execute owl commands from the given filename.  If the filename
3273 * is NULL, use the default owl startup commands file.
3274 */
3275void owl_function_source(const char *filename)
3276{
3277  char *path;
3278  FILE *file;
3279  char *s = NULL;
3280  int fail_silent = 0;
3281
3282  if (!filename) {
3283    fail_silent = 1;
3284    path = g_strdup(owl_global_get_startupfile(&g));
3285  } else {
3286    path = owl_util_makepath(filename);
3287  }
3288  file = fopen(path, "r");
3289  g_free(path);
3290  if (!file) {
3291    if (!fail_silent) {
3292      owl_function_error("Error opening file: %s", filename);
3293    }
3294    return;
3295  }
3296  while (owl_getline_chomp(&s, file)) {
3297    if (s[0] == '\0' || s[0] == '#')
3298      continue;
3299    owl_function_command_norv(s);
3300  }
3301
3302  g_free(s);
3303  fclose(file);
3304}
3305
3306void owl_function_change_style(owl_view *v, const char *stylename)
3307{
3308  const owl_style *s;
3309
3310  s=owl_global_get_style_by_name(&g, stylename);
3311  if (!s) {
3312    owl_function_error("No style named %s", stylename);
3313    return;
3314  }
3315  owl_view_set_style(v, s);
3316  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3317  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3318  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3319}
3320
3321void owl_function_toggleoneline(void)
3322{
3323  owl_view *v;
3324  const owl_style *s;
3325
3326  v=owl_global_get_current_view(&g);
3327  s=owl_view_get_style(v);
3328
3329  if (!owl_style_matches_name(s, "oneline")) {
3330    owl_function_change_style(v, "oneline");
3331  } else {
3332    owl_function_change_style(v, owl_global_get_default_style(&g));
3333  }
3334
3335  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3336  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3337  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3338}
3339
3340void G_GNUC_PRINTF(1, 2) owl_function_error(const char *fmt, ...)
3341{
3342  static int in_error = 0;
3343  va_list ap;
3344  char *buff;
3345  const char *nl;
3346
3347  if (++in_error > 2) {
3348    /* More than two nested errors, bail immediately. */
3349    in_error--;
3350    return;
3351  }
3352
3353  va_start(ap, fmt);
3354  buff = g_strdup_vprintf(fmt, ap);
3355  va_end(ap);
3356
3357  owl_function_debugmsg("ERROR: %s", buff);
3358  owl_function_log_err(buff);
3359
3360  nl = strchr(buff, '\n');
3361
3362  /*
3363    Showing admin messages triggers a lot of code. If we have a
3364    recursive error call, that's the most likely candidate, so
3365    suppress the call in that case, to try to avoid infinite looping.
3366  */
3367
3368  if(nl && *(nl + 1) && in_error == 1) {
3369    /* Multiline error */
3370    owl_function_adminmsg("ERROR", buff);
3371  } else {
3372    owl_function_makemsg("[Error] %s", buff);
3373  }
3374
3375  g_free(buff);
3376
3377  in_error--;
3378}
3379
3380void owl_function_log_err(const char *string)
3381{
3382  char *date;
3383  time_t now;
3384  char *buff;
3385
3386  now=time(NULL);
3387  date=g_strdup(ctime(&now));
3388  date[strlen(date)-1]='\0';
3389
3390  buff = g_strdup_printf("%s %s", date, string);
3391
3392  owl_errqueue_append_err(owl_global_get_errqueue(&g), buff);
3393
3394  g_free(buff);
3395  g_free(date);
3396}
3397
3398void owl_function_showerrs(void)
3399{
3400  owl_fmtext fm;
3401
3402  owl_fmtext_init_null(&fm);
3403  owl_fmtext_append_normal(&fm, "Errors:\n\n");
3404  owl_errqueue_to_fmtext(owl_global_get_errqueue(&g), &fm);
3405  owl_function_popless_fmtext(&fm);
3406}
3407
3408void G_GNUC_PRINTF(1, 2) owl_function_makemsg(const char *fmt, ...)
3409{
3410  va_list ap;
3411  char *str;
3412
3413  va_start(ap, fmt);
3414  str = g_strdup_vprintf(fmt, ap);
3415  va_end(ap);
3416
3417  owl_function_debugmsg("makemsg: %s", str);
3418  owl_msgwin_set_text_nocopy(&g.msgwin, str);
3419}
3420
3421/* get locations for everyone in .anyone.  If 'notify' is '1' then
3422 * send a pseudo login or logout message for everyone not in sync with
3423 * the global zephyr buddy list.  The list is updated regardless of
3424 * the status of 'notify'.
3425 */
3426void owl_function_zephyr_buddy_check(int notify)
3427{
3428#ifdef HAVE_LIBZEPHYR
3429  int i, j;
3430  owl_list anyone;
3431  GList **zaldlist;
3432  GList *zaldptr;
3433  ZAsyncLocateData_t *zald;
3434  const char *user;
3435
3436  if (!owl_global_is_havezephyr(&g)) return;
3437  owl_global_set_pseudologin_notify(&g, notify);
3438  zaldlist = owl_global_get_zaldlist(&g);
3439
3440  /* Clear the existing ZALDs first. */
3441  zaldptr = g_list_first(*zaldlist);
3442  while (zaldptr) {
3443    ZFreeALD(zaldptr->data);
3444    g_free(zaldptr->data);
3445    zaldptr = g_list_next(zaldptr);
3446  }
3447  g_list_free(*zaldlist);
3448  *zaldlist = NULL;
3449
3450  owl_list_create(&anyone);
3451  owl_zephyr_get_anyone_list(&anyone, NULL);
3452  j = owl_list_get_size(&anyone);
3453  for (i = 0; i < j; i++) {
3454    user = owl_list_get_element(&anyone, i);
3455    zald = g_new(ZAsyncLocateData_t, 1);
3456    if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
3457      *zaldlist = g_list_append(*zaldlist, zald);
3458    } else {
3459      g_free(zald);
3460    }
3461  }
3462
3463  owl_list_cleanup(&anyone, g_free);
3464#endif
3465}
3466
3467void owl_function_aimsearch_results(const char *email, owl_list *namelist)
3468{
3469  owl_fmtext fm;
3470  int i, j;
3471
3472  owl_fmtext_init_null(&fm);
3473  owl_fmtext_append_normal(&fm, "AIM screennames associated with ");
3474  owl_fmtext_append_normal(&fm, email);
3475  owl_fmtext_append_normal(&fm, ":\n");
3476
3477  j=owl_list_get_size(namelist);
3478  for (i=0; i<j; i++) {
3479    owl_fmtext_append_normal(&fm, "  ");
3480    owl_fmtext_append_normal(&fm, owl_list_get_element(namelist, i));
3481    owl_fmtext_append_normal(&fm, "\n");
3482  }
3483
3484  owl_function_popless_fmtext(&fm);
3485  owl_fmtext_cleanup(&fm);
3486}
3487
3488int owl_function_get_color_count(void)
3489{
3490     return COLORS;
3491}
3492
3493void _owl_function_mark_message(const owl_message *m)
3494{
3495  if (m) {
3496    owl_global_set_markedmsgid(&g, owl_message_get_id(m));
3497    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3498  }
3499}
3500
3501void owl_function_mark_message(void)
3502{
3503  const owl_message *m;
3504  const owl_view *v;
3505
3506  v=owl_global_get_current_view(&g);
3507
3508  /* bail if there's no current message */
3509  if (owl_view_get_size(v) < 1) {
3510    owl_function_error("No messages to mark");
3511    return;
3512  }
3513
3514  /* mark the message */
3515  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
3516  _owl_function_mark_message(m);
3517  owl_function_makemsg("Mark set");
3518}
3519
3520void owl_function_swap_cur_marked(void)
3521{
3522  int marked_id;
3523  const owl_message *m;
3524  const owl_view *v;
3525
3526  marked_id=owl_global_get_markedmsgid(&g);
3527  if (marked_id == -1) {
3528    owl_function_error("Mark not set.");
3529    return;
3530  }
3531
3532  v=owl_global_get_current_view(&g);
3533  /* bail if there's no current message */
3534  if (owl_view_get_size(v) < 1) {
3535    return;
3536  }
3537
3538  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
3539  _owl_function_mark_message(m);
3540  owl_global_set_curmsg(&g, owl_view_get_nearest_to_msgid(v, marked_id));
3541  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
3542  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3543  owl_global_set_direction_downwards(&g);
3544}
Note: See TracBrowser for help on using the repository browser.