source: functions.c @ 78f6c35

release-1.8release-1.9
Last change on this file since 78f6c35 was 78f6c35, checked in by David Benjamin <davidben@mit.edu>, 10 years ago
Don't use skiptokens in punt/unpunt There was no need for it. This cuts down on one of the more nasty usages of skiptokens in command parsing.
  • Property mode set to 100644
File size: 95.8 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  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    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  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 (has_colors()) {
1820    owl_fmtext_append_normal(&fm, "Color: Yes\n");
1821    owl_fmtext_appendf_normal(&fm, "Number of color pairs: %i\n", owl_util_get_colorpairs());
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    owl_fmtext_append_normal_color(&fm, owl_filter_get_name(f),
2229                                   owl_filter_get_fgcolor(f),
2230                                   owl_filter_get_bgcolor(f));
2231    owl_fmtext_append_normal(&fm, "\n");
2232  }
2233  owl_function_popless_fmtext(&fm);
2234  owl_fmtext_cleanup(&fm);
2235}
2236
2237void owl_function_show_filter(const char *name)
2238{
2239  const owl_filter *f;
2240  char *buff, *tmp;
2241
2242  f=owl_global_get_filter(&g, name);
2243  if (!f) {
2244    owl_function_error("There is no filter named %s", name);
2245    return;
2246  }
2247  tmp = owl_filter_print(f);
2248  buff = g_strdup_printf("%s: %s", owl_filter_get_name(f), tmp);
2249  owl_function_popless_text(buff);
2250  g_free(buff);
2251  g_free(tmp);
2252}
2253
2254void owl_function_show_zpunts(void)
2255{
2256  const owl_filter *f;
2257  const owl_list *fl;
2258  char *tmp;
2259  owl_fmtext fm;
2260  int i, j;
2261
2262  owl_fmtext_init_null(&fm);
2263
2264  fl=owl_global_get_puntlist(&g);
2265  j=owl_list_get_size(fl);
2266  owl_fmtext_append_bold(&fm, "Active zpunt filters:\n");
2267
2268  for (i=0; i<j; i++) {
2269    f=owl_list_get_element(fl, i);
2270    owl_fmtext_appendf_normal(&fm, "[% 2d] ", i+1);
2271    tmp = owl_filter_print(f);
2272    owl_fmtext_append_normal(&fm, tmp);
2273    g_free(tmp);
2274  }
2275  owl_function_popless_fmtext(&fm);
2276  owl_fmtext_cleanup(&fm);
2277}
2278
2279/* Create a filter for a class, instance if one doesn't exist.  If
2280 * instance is NULL then catch all messgaes in the class.  Returns the
2281 * name of the filter or null.  The caller must free this name.
2282 * If 'related' is nonzero, encompass unclasses and .d classes as well.
2283 */
2284char *owl_function_classinstfilt(const char *c, const char *i, int related) 
2285{
2286  owl_filter *f;
2287  char *filtname;
2288  char *tmpclass, *tmpinstance = NULL;
2289  char *class, *instance = NULL;
2290  GString *buf;
2291
2292  if (related) {
2293    class = owl_util_baseclass(c);
2294    if (i) {
2295      instance = owl_util_baseclass(i);
2296    }
2297  } else {
2298    class = g_strdup(c);
2299    if (i) {
2300      instance = g_strdup(i);
2301    }
2302  }
2303
2304  /* name for the filter */
2305  if (!instance) {
2306    filtname = g_strdup_printf("%sclass-%s", related ? "related-" : "", class);
2307  } else {
2308    filtname = g_strdup_printf("%sclass-%s-instance-%s", related ? "related-" : "", class, instance);
2309  }
2310  /* downcase it */
2311  {
2312    char *temp = g_utf8_strdown(filtname, -1);
2313    if (temp) {
2314      g_free(filtname);
2315      filtname = temp;
2316    }
2317  }
2318 
2319  /* if it already exists then go with it.  This lets users override */
2320  if (owl_global_get_filter(&g, filtname)) {
2321    goto done;
2322  }
2323
2324  /* create the new filter */
2325  tmpclass=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2326  if (instance) {
2327    tmpinstance=owl_text_quote(instance, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2328  }
2329
2330  buf = g_string_new("");
2331  owl_string_appendf_quoted(buf,
2332                            related ? "class ^(un)*%q(\\.d)*$" : "class ^%q$",
2333                            tmpclass);
2334
2335  if (tmpinstance) {
2336    owl_string_appendf_quoted(buf,
2337                              related ?
2338                              " and ( instance ^(un)*%q(\\.d)*$ )" :
2339                              " and instance ^%q$",
2340                              tmpinstance);
2341  }
2342  g_free(tmpclass);
2343  g_free(tmpinstance);
2344
2345  f = owl_filter_new_fromstring(filtname, buf->str);
2346  g_string_free(buf, true);
2347  if (f == NULL) {
2348    /* Couldn't make a filter for some reason. Return NULL. */
2349    owl_function_error("Error creating filter '%s'", filtname);
2350    g_free(filtname);
2351    filtname = NULL;
2352    goto done;
2353  }
2354
2355  /* add it to the global list */
2356  owl_global_add_filter(&g, f);
2357
2358done:
2359  g_free(class);
2360  g_free(instance);
2361  return(filtname);
2362}
2363
2364/* Create a filter for personal zephyrs to or from the specified
2365 * zephyr user.  Includes login/logout notifications for the user.
2366 * The name of the filter will be 'user-<shortuser>'.  If a filter already
2367 * exists with this name, no new filter will be created.  This allows
2368 * the configuration to override this function.  Returns the name of
2369 * the filter, which the caller must free.
2370 */
2371char *owl_function_zuserfilt(const char *longuser)
2372{
2373  owl_filter *f;
2374  char *argbuff, *esclonguser, *shortuser, *filtname;
2375
2376  /* name for the filter */
2377  shortuser = short_zuser(longuser);
2378  filtname = g_strdup_printf("user-%s", shortuser);
2379  g_free(shortuser);
2380
2381  /* if it already exists then go with it.  This lets users override */
2382  if (owl_global_get_filter(&g, filtname)) {
2383    return filtname;
2384  }
2385
2386  /* create the new-internal filter */
2387  esclonguser = owl_text_quote(longuser, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2388
2389  argbuff=owl_string_build_quoted("( type ^zephyr$ and filter personal and "
2390      "( ( direction ^in$ and sender ^%q$ ) or ( direction ^out$ and "
2391      "recipient ^%q$ ) ) ) or ( ( class ^login$ ) and ( sender ^%q$ ) )",
2392      esclonguser, esclonguser, esclonguser);
2393  g_free(esclonguser);
2394
2395  f = owl_filter_new_fromstring(filtname, argbuff);
2396  g_free(argbuff);
2397
2398  if (f == NULL) {
2399    /* Couldn't make a filter for some reason. Return NULL. */
2400    owl_function_error("Error creating filter '%s'", filtname);
2401    g_free(filtname);
2402    return NULL;
2403  }
2404
2405  /* add it to the global list */
2406  owl_global_add_filter(&g, f);
2407
2408  return(filtname);
2409}
2410
2411/* Create a filter for AIM IM messages to or from the specified
2412 * screenname.  The name of the filter will be 'aimuser-<user>'.  If a
2413 * filter already exists with this name, no new filter will be
2414 * created.  This allows the configuration to override this function.
2415 * Returns the name of the filter, which the caller must free.
2416 */
2417char *owl_function_aimuserfilt(const char *user)
2418{
2419  owl_filter *f;
2420  char *argbuff, *filtname;
2421  char *escuser;
2422
2423  /* name for the filter */
2424  filtname=g_strdup_printf("aimuser-%s", user);
2425
2426  /* if it already exists then go with it.  This lets users override */
2427  if (owl_global_get_filter(&g, filtname)) {
2428    return(g_strdup(filtname));
2429  }
2430
2431  /* create the new-internal filter */
2432  escuser = owl_text_quote(user, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2433
2434  argbuff = g_strdup_printf(
2435      "( type ^aim$ and ( ( sender ^%1$s$ and recipient ^%2$s$ ) or "
2436      "( sender ^%2$s$ and recipient ^%1$s$ ) ) )",
2437      escuser, owl_global_get_aim_screenname_for_filters(&g));
2438  g_free(escuser);
2439
2440  f = owl_filter_new_fromstring(filtname, argbuff);
2441  g_free(argbuff);
2442
2443  if (f == NULL) {
2444    owl_function_error("Error creating filter '%s'", filtname);
2445    g_free(filtname);
2446    return NULL;
2447  }
2448
2449  /* add it to the global list */
2450  owl_global_add_filter(&g, f);
2451
2452  return(filtname);
2453}
2454
2455char *owl_function_typefilt(const char *type)
2456{
2457  owl_filter *f;
2458  char *argbuff, *filtname, *esctype;
2459
2460  /* name for the filter */
2461  filtname=g_strdup_printf("type-%s", type);
2462
2463  /* if it already exists then go with it.  This lets users override */
2464  if (owl_global_get_filter(&g, filtname)) {
2465    return filtname;
2466  }
2467
2468  /* create the new-internal filter */
2469  esctype = owl_text_quote(type, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2470
2471  argbuff = owl_string_build_quoted("type ^%q$", esctype);
2472  g_free(esctype);
2473
2474  f = owl_filter_new_fromstring(filtname, argbuff);
2475  g_free(argbuff);
2476
2477  if (f == NULL) {
2478    owl_function_error("Error creating filter '%s'", filtname);
2479    g_free(filtname);
2480    return NULL;
2481  }
2482
2483  /* add it to the global list */
2484  owl_global_add_filter(&g, f);
2485
2486  return filtname;
2487}
2488
2489/* If flag is 1, marks for deletion.  If flag is 0,
2490 * unmarks for deletion. */
2491void owl_function_delete_curview_msgs(int flag)
2492{
2493  const owl_view *v;
2494  int i, j;
2495
2496  v=owl_global_get_current_view(&g);
2497  j=owl_view_get_size(v);
2498  for (i=0; i<j; i++) {
2499    if (flag == 1) {
2500      owl_message_mark_delete(owl_view_get_element(v, i));
2501    } else if (flag == 0) {
2502      owl_message_unmark_delete(owl_view_get_element(v, i));
2503    }
2504  }
2505
2506  owl_function_makemsg("%i messages marked for %sdeletion", j, flag?"":"un");
2507
2508  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
2509}
2510
2511static char *owl_function_smartfilter_cc(const owl_message *m) {
2512  const char *ccs;
2513  char *ccs_quoted;
2514  char *filtname;
2515  owl_filter *f;
2516  GString *buf;
2517
2518  ccs = owl_message_get_attribute_value(m, "zephyr_ccs");
2519
2520  filtname = g_strdup_printf("conversation-%s", ccs);
2521  g_strdelimit(filtname, " ", '-');
2522
2523  if (owl_global_get_filter(&g, filtname)) {
2524    return filtname;
2525  }
2526
2527  buf = g_string_new("type ^zephyr$ and filter personal and "
2528                     "zephyr_ccs ^");
2529  ccs_quoted = owl_text_quote(ccs, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2530  owl_string_append_quoted_arg(buf, ccs_quoted);
2531  g_string_append_c(buf, '$');
2532  g_free(ccs_quoted);
2533
2534  f = owl_filter_new_fromstring(filtname, buf->str);
2535  g_string_free(buf, true);
2536
2537  if (f == NULL) {
2538    owl_function_error("Error creating filter '%s'", filtname);
2539    g_free(filtname);
2540    return NULL;
2541  }
2542
2543  owl_global_add_filter(&g, f);
2544
2545  return filtname;
2546}
2547
2548/* Create a filter based on the current message.  Returns the name of
2549 * a filter or null.  The caller must free this name.
2550 *
2551 * if the curmsg is a personal zephyr return a filter name
2552 *    to the zephyr conversation with that user.
2553 * If the curmsg is a zephyr class message, instance foo, recip *,
2554 *    return a filter name to the class, inst.
2555 * If the curmsg is a zephyr class message and type==0 then
2556 *    return a filter name for just the class.
2557 * If the curmsg is a zephyr class message and type==1 then
2558 *    return a filter name for the class and instance.
2559 * If the curmsg is a personal AIM message returna  filter
2560 *    name to the AIM conversation with that user
2561 */
2562char *owl_function_smartfilter(int type, int invert_related)
2563{
2564  const owl_view *v;
2565  const owl_message *m;
2566  char *filtname = NULL;
2567  const char *argv[2], *zperson;
2568  int related = owl_global_is_narrow_related(&g) ^ invert_related;
2569
2570  v=owl_global_get_current_view(&g);
2571  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2572
2573  if (!m || owl_view_get_size(v)==0) {
2574    owl_function_error("No message selected\n");
2575    return(NULL);
2576  }
2577
2578  /* very simple handling of admin messages for now */
2579  if (owl_message_is_type_admin(m)) {
2580    return(owl_function_typefilt("admin"));
2581  }
2582
2583  /* very simple handling of loopback messages for now */
2584  if (owl_message_is_type_loopback(m)) {
2585    return(owl_function_typefilt("loopback"));
2586  }
2587
2588  /* aim messages */
2589  if (owl_message_is_type_aim(m)) {
2590    if (owl_message_is_direction_in(m)) {
2591      filtname=owl_function_aimuserfilt(owl_message_get_sender(m));
2592    } else if (owl_message_is_direction_out(m)) {
2593      filtname=owl_function_aimuserfilt(owl_message_get_recipient(m));
2594    }
2595    return(filtname);
2596  }
2597
2598  /* narrow personal and login messages to the sender or recip as appropriate */
2599  if (owl_message_is_type_zephyr(m)) {
2600    if (owl_message_is_personal(m) || owl_message_is_loginout(m)) {
2601      if (owl_message_get_attribute_value(m, "zephyr_ccs") != NULL) {
2602        return owl_function_smartfilter_cc(m);
2603      }
2604
2605      if (owl_message_is_direction_in(m)) {
2606        zperson = owl_message_get_sender(m);
2607      } else {
2608        zperson = owl_message_get_recipient(m);
2609      }
2610      filtname = owl_function_zuserfilt(zperson);
2611      return filtname;
2612    }
2613
2614    /* narrow class MESSAGE, instance foo, recip * messages to class, inst */
2615    if (!strcasecmp(owl_message_get_class(m), "message")) {
2616      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
2617      return(filtname);
2618    }
2619
2620    /* otherwise narrow to the class */
2621    if (type==0) {
2622      filtname=owl_function_classinstfilt(owl_message_get_class(m), NULL, related);
2623    } else if (type==1) {
2624      filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m), related);
2625    }
2626    return(filtname);
2627  }
2628
2629  /* pass it off to perl */
2630  argv[0] = type ? "1" : "0";
2631  argv[1] = related ? "1" : "0";
2632  return owl_perlconfig_message_call_method(m, "smartfilter", 2, argv);
2633}
2634
2635void owl_function_smartzpunt(int type)
2636{
2637  /* Starts a zpunt command based on the current class,instance pair.
2638   * If type=0, uses just class.  If type=1, uses instance as well. */
2639  const owl_view *v;
2640  const owl_message *m;
2641  const char *mclass, *minst;
2642  GString *buf;
2643 
2644  v=owl_global_get_current_view(&g);
2645  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2646
2647  if (!m || owl_view_get_size(v)==0) {
2648    owl_function_error("No message selected\n");
2649    return;
2650  }
2651
2652  /* for now we skip admin messages. */
2653  if (owl_message_is_type_admin(m)
2654      || owl_message_is_loginout(m)
2655      || !owl_message_is_type_zephyr(m)) {
2656    owl_function_error("smartzpunt doesn't support this message type.");
2657    return;
2658  }
2659
2660  mclass = owl_message_get_class(m);
2661  minst = owl_message_get_instance(m);
2662  if (!mclass || !*mclass || *mclass==' '
2663      || (!strcasecmp(mclass, "message") && !strcasecmp(minst, "personal"))
2664      || (type && (!minst || !*minst|| *minst==' '))) {
2665    owl_function_error("smartzpunt can't safely do this for <%s,%s>",
2666                         mclass, minst);
2667  } else {
2668    buf = g_string_new("start-command zpunt ");
2669    owl_string_append_quoted_arg(buf, mclass);
2670    if (type) {
2671      g_string_append_c(buf, ' ');
2672      owl_string_append_quoted_arg(buf, minst);
2673    } else {
2674      g_string_append(buf, " *");
2675    }
2676    owl_function_command_norv(buf->str);
2677    g_string_free(buf, true);
2678  }
2679}
2680
2681/* Set the color of the current view's filter to
2682 * be 'color'
2683 */
2684void owl_function_color_current_filter(const char *fgcolor, const char *bgcolor)
2685{
2686  const char *name;
2687
2688  name=owl_view_get_filtname(owl_global_get_current_view(&g));
2689  owl_function_color_filter(name, fgcolor, bgcolor);
2690}
2691
2692/* Set the color of the filter 'filter' to be 'color'.  If the color
2693 * name does not exist, return -1, if the filter does not exist or is
2694 * the "all" filter, return -2.  Return 0 on success
2695 */
2696int owl_function_color_filter(const char *filtname, const char *fgcolor, const char *bgcolor)
2697{
2698  owl_filter *f;
2699
2700  f=owl_global_get_filter(&g, filtname);
2701  if (!f) {
2702    owl_function_error("Unknown filter");
2703    return(-2);
2704  }
2705
2706  /* don't touch the all filter */
2707  if (!strcmp(filtname, "all")) {
2708    owl_function_error("You may not change the 'all' filter.");
2709    return(-2);
2710  }
2711
2712  if (owl_util_string_to_color(fgcolor)==OWL_COLOR_INVALID) {
2713    owl_function_error("No color named '%s' avilable.", fgcolor);
2714    return(-1);
2715  }
2716
2717
2718  if (bgcolor != NULL) {
2719    if (owl_util_string_to_color(bgcolor)==OWL_COLOR_INVALID) {
2720      owl_function_error("No color named '%s' avilable.", bgcolor);
2721      return(-1);
2722    }
2723    owl_filter_set_bgcolor(f, owl_util_string_to_color(bgcolor));
2724  }
2725  owl_filter_set_fgcolor(f, owl_util_string_to_color(fgcolor));
2726 
2727  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2728  return(0);
2729}
2730
2731void owl_function_show_colors(void)
2732{
2733  owl_fmtext fm;
2734  int i; 
2735 
2736  owl_fmtext_init_null(&fm);
2737  owl_fmtext_append_normal(&fm,"default:  ");
2738  owl_fmtext_append_normal_color(&fm, "default\n", OWL_COLOR_DEFAULT, OWL_COLOR_DEFAULT);
2739
2740  owl_fmtext_append_normal(&fm,"black:    ");
2741  owl_fmtext_append_normal_color(&fm, "black\n", OWL_COLOR_BLACK, OWL_COLOR_DEFAULT);
2742
2743  owl_fmtext_append_normal(&fm,"red:      ");
2744  owl_fmtext_append_normal_color(&fm, "red\n", OWL_COLOR_RED, OWL_COLOR_DEFAULT);
2745
2746  owl_fmtext_append_normal(&fm,"green:    ");
2747  owl_fmtext_append_normal_color(&fm, "green\n", OWL_COLOR_GREEN, OWL_COLOR_DEFAULT);
2748
2749  owl_fmtext_append_normal(&fm,"yellow:   ");
2750  owl_fmtext_append_normal_color(&fm, "yellow\n", OWL_COLOR_YELLOW, OWL_COLOR_DEFAULT);
2751
2752  owl_fmtext_append_normal(&fm,"blue:     ");
2753  owl_fmtext_append_normal_color(&fm, "blue\n", OWL_COLOR_BLUE, OWL_COLOR_DEFAULT);
2754
2755  owl_fmtext_append_normal(&fm,"magenta:  ");
2756  owl_fmtext_append_normal_color(&fm, "magenta\n", OWL_COLOR_MAGENTA, OWL_COLOR_DEFAULT);
2757
2758  owl_fmtext_append_normal(&fm,"cyan:     ");
2759  owl_fmtext_append_normal_color(&fm, "cyan\n", OWL_COLOR_CYAN, OWL_COLOR_DEFAULT);
2760
2761  owl_fmtext_append_normal(&fm,"white:    ");
2762  owl_fmtext_append_normal_color(&fm, "white\n", OWL_COLOR_WHITE, OWL_COLOR_DEFAULT);
2763
2764  for(i = 8; i < COLORS; ++i) {
2765    char* str1 = g_strdup_printf("%4i:     ",i);
2766    char* str2 = g_strdup_printf("%i\n",i);
2767    owl_fmtext_append_normal(&fm,str1);
2768    owl_fmtext_append_normal_color(&fm, str2, i, OWL_COLOR_DEFAULT);
2769    g_free(str1);
2770     g_free(str2);
2771  }
2772 
2773  owl_function_popless_fmtext(&fm);
2774  owl_fmtext_cleanup(&fm);
2775}
2776
2777/* add the given class, inst, recip to the punt list for filtering.
2778 *   if direction==0 then punt
2779 *   if direction==1 then unpunt
2780 */
2781void owl_function_zpunt(const char *class, const char *inst, const char *recip, int direction)
2782{
2783  GPtrArray *argv;
2784  char *quoted;
2785
2786  argv = g_ptr_array_new();
2787  if (!strcmp(class, "*")) {
2788    g_ptr_array_add(argv, g_strdup("class"));
2789    g_ptr_array_add(argv, g_strdup(".*"));
2790  } else {
2791    quoted=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2792    g_ptr_array_add(argv, g_strdup("class"));
2793    g_ptr_array_add(argv, g_strdup_printf("^(un)*%s(\\.d)*$", quoted));
2794    g_free(quoted);
2795  }
2796  if (!strcmp(inst, "*")) {
2797    g_ptr_array_add(argv, g_strdup("and"));
2798    g_ptr_array_add(argv, g_strdup("instance"));
2799    g_ptr_array_add(argv, g_strdup(".*"));
2800  } else {
2801    quoted=owl_text_quote(inst, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2802    g_ptr_array_add(argv, g_strdup("and"));
2803    g_ptr_array_add(argv, g_strdup("instance"));
2804    g_ptr_array_add(argv, g_strdup_printf("^(un)*%s(\\.d)*$", quoted));
2805    g_free(quoted);
2806  }
2807  if (!strcmp(recip, "*")) {
2808    /* nothing */
2809  } else {
2810    if(!strcmp(recip, "%me%")) {
2811      recip = owl_zephyr_get_sender();
2812    }
2813    quoted=owl_text_quote(recip, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2814    g_ptr_array_add(argv, g_strdup("and"));
2815    g_ptr_array_add(argv, g_strdup("recipient"));
2816    g_ptr_array_add(argv, g_strdup_printf("^%s$", quoted));
2817    g_free(quoted);
2818  }
2819
2820  owl_function_punt(argv->len, (const char *const*) argv->pdata, direction);
2821  g_ptr_array_foreach(argv, (GFunc)g_free, NULL);
2822  g_ptr_array_free(argv, true);
2823}
2824
2825void owl_function_punt(int argc, const char *const *argv, int direction)
2826{
2827  owl_filter *f;
2828  owl_list *fl;
2829  int i, j;
2830  fl=owl_global_get_puntlist(&g);
2831
2832  /* first, create the filter */
2833  f = owl_filter_new("punt-filter", argc, argv);
2834  if (f == NULL) {
2835    owl_function_error("Error creating filter for zpunt");
2836    return;
2837  }
2838
2839  /* Check for an identical filter */
2840  j=owl_list_get_size(fl);
2841  for (i=0; i<j; i++) {
2842    if (owl_filter_equiv(f, owl_list_get_element(fl, i))) {
2843      owl_function_debugmsg("found an equivalent punt filter");
2844      /* if we're punting, then just silently bow out on this duplicate */
2845      if (direction==0) {
2846        owl_filter_delete(f);
2847        return;
2848      }
2849
2850      /* if we're unpunting, then remove this filter from the puntlist */
2851      if (direction==1) {
2852        owl_filter_delete(owl_list_get_element(fl, i));
2853        owl_list_remove_element(fl, i);
2854        owl_filter_delete(f);
2855        return;
2856      }
2857    }
2858  }
2859
2860  owl_function_debugmsg("punting");
2861  /* If we're punting, add the filter to the global punt list */
2862  if (direction==0) {
2863    owl_list_append_element(fl, f);
2864  }
2865}
2866
2867void owl_function_show_keymaps(void)
2868{
2869  owl_list l;
2870  owl_fmtext fm;
2871  const owl_keymap *km;
2872  const owl_keyhandler *kh;
2873  int i, numkm;
2874  const char *kmname;
2875
2876  kh = owl_global_get_keyhandler(&g);
2877  owl_fmtext_init_null(&fm);
2878  owl_fmtext_append_bold(&fm, "Keymaps:   ");
2879  owl_fmtext_append_normal(&fm, "(use 'show keymap <name>' for details)\n");
2880  owl_list_create(&l);
2881  owl_keyhandler_get_keymap_names(kh, &l);
2882  owl_fmtext_append_list(&fm, &l, "\n", owl_function_keymap_summary);
2883  owl_fmtext_append_normal(&fm, "\n");
2884
2885  numkm = owl_list_get_size(&l);
2886  for (i=0; i<numkm; i++) {
2887    kmname = owl_list_get_element(&l, i);
2888    km = owl_keyhandler_get_keymap(kh, kmname);
2889    owl_fmtext_append_bold(&fm, "\n\n----------------------------------------------------------------------------------------------------\n\n");
2890    owl_keymap_get_details(km, &fm, 0);
2891  }
2892  owl_fmtext_append_normal(&fm, "\n");
2893 
2894  owl_function_popless_fmtext(&fm);
2895  owl_list_cleanup(&l, g_free);
2896  owl_fmtext_cleanup(&fm);
2897}
2898
2899char *owl_function_keymap_summary(const char *name)
2900{
2901  const owl_keymap *km
2902    = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2903  if (km) return owl_keymap_summary(km);
2904  else return(NULL);
2905}
2906
2907/* TODO: implement for real */
2908void owl_function_show_keymap(const char *name)
2909{
2910  owl_fmtext fm;
2911  const owl_keymap *km;
2912
2913  owl_fmtext_init_null(&fm);
2914  km = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2915  if (km) {
2916    owl_keymap_get_details(km, &fm, 1);
2917  } else {
2918    owl_fmtext_append_normal(&fm, "No such keymap...\n");
2919  } 
2920  owl_function_popless_fmtext(&fm);
2921  owl_fmtext_cleanup(&fm);
2922}
2923
2924void owl_function_help_for_command(const char *cmdname)
2925{
2926  owl_fmtext fm;
2927
2928  owl_fmtext_init_null(&fm);
2929  owl_cmd_get_help(owl_global_get_cmddict(&g), cmdname, &fm);
2930  owl_function_popless_fmtext(&fm); 
2931  owl_fmtext_cleanup(&fm);
2932}
2933
2934void owl_function_set_search(const char *string)
2935{
2936  owl_regex re;
2937
2938  if (string && owl_regex_create_quoted(&re, string) == 0) {
2939    owl_global_set_search_re(&g, &re);
2940    owl_regex_cleanup(&re);
2941  } else {
2942    owl_global_set_search_re(&g, NULL);
2943  }
2944}
2945
2946void owl_function_search_helper(int consider_current, int direction)
2947{
2948  /* move to a message that contains the string.  If direction is
2949   * OWL_DIRECTION_DOWNWARDS then search fowards, if direction is
2950   * OWL_DIRECTION_UPWARDS then search backwards.
2951   *
2952   * If consider_current is true then it will stay on the
2953   * current message if it contains the string.
2954   */
2955
2956  const owl_view *v;
2957  int viewsize, i, curmsg, start;
2958  owl_message *m;
2959
2960  v=owl_global_get_current_view(&g);
2961  viewsize=owl_view_get_size(v);
2962  curmsg=owl_global_get_curmsg(&g);
2963 
2964  if (viewsize==0) {
2965    owl_function_makemsg("No messages present");
2966    return;
2967  }
2968
2969  if (consider_current) {
2970    start=curmsg;
2971  } else if (direction==OWL_DIRECTION_DOWNWARDS) {
2972    start=curmsg+1;
2973  } else {
2974    start=curmsg-1;
2975  }
2976
2977  /* bounds check */
2978  if (start>=viewsize || start<0) {
2979    owl_function_makemsg("No further matches found");
2980    return;
2981  }
2982
2983  for (i=start; i<viewsize && i>=0;) {
2984    m=owl_view_get_element(v, i);
2985    if (owl_message_search(m, owl_global_get_search_re(&g))) {
2986      owl_global_set_curmsg(&g, i);
2987      owl_function_calculate_topmsg(direction);
2988      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2989      if (direction==OWL_DIRECTION_DOWNWARDS) {
2990        owl_global_set_direction_downwards(&g);
2991      } else {
2992        owl_global_set_direction_upwards(&g);
2993      }
2994      return;
2995    }
2996    if (direction==OWL_DIRECTION_DOWNWARDS) {
2997      i++;
2998    } else {
2999      i--;
3000    }
3001    if (owl_global_take_interrupt(&g)) {
3002      owl_function_makemsg("Search interrupted!");
3003      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3004      return;
3005    }
3006  }
3007  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3008  owl_function_makemsg("No matches found");
3009}
3010
3011/* strips formatting from ztext and returns the unformatted text.
3012 * caller is responsible for freeing. */
3013char *owl_function_ztext_stylestrip(const char *zt)
3014{
3015  owl_fmtext fm;
3016  char *plaintext;
3017
3018  owl_fmtext_init_null(&fm);
3019  owl_fmtext_append_ztext(&fm, zt);
3020  plaintext = owl_fmtext_print_plain(&fm);
3021  owl_fmtext_cleanup(&fm);
3022  return(plaintext);
3023}
3024
3025/* Popup a buddylisting.  If filename is NULL use the default .anyone */
3026void owl_function_buddylist(int aim, int zephyr, const char *filename)
3027{
3028  int i, j, idle;
3029  int interrupted = 0;
3030  owl_fmtext fm;
3031  const owl_buddylist *bl;
3032  const owl_buddy *b;
3033  char *timestr;
3034#ifdef HAVE_LIBZEPHYR
3035  int x;
3036  owl_list anyone;
3037  const char *user;
3038  char *tmp;
3039  ZLocations_t location[200];
3040  int numlocs, ret;
3041#endif
3042
3043  owl_fmtext_init_null(&fm);
3044
3045  /* AIM first */
3046  if (aim && owl_global_is_aimloggedin(&g)) {
3047    bl=owl_global_get_buddylist(&g);
3048
3049    owl_fmtext_append_bold(&fm, "AIM users logged in:\n");
3050    /* we're assuming AIM for now */
3051    j=owl_buddylist_get_size(bl);
3052    for (i=0; i<j; i++) {
3053      b=owl_buddylist_get_buddy_n(bl, i);
3054      idle=owl_buddy_get_idle_time(b);
3055      if (idle!=0) {
3056        timestr=owl_util_minutes_to_timestr(idle);
3057      } else {
3058        timestr=g_strdup("");
3059      }
3060      owl_fmtext_appendf_normal(&fm, "  %-20.20s %-12.12s\n", owl_buddy_get_name(b), timestr);
3061      g_free(timestr);
3062    }
3063  }
3064
3065#ifdef HAVE_LIBZEPHYR
3066  if (zephyr) {
3067    if(!owl_global_is_havezephyr(&g)) {
3068      owl_function_error("Zephyr currently not available.");
3069    } else {
3070      owl_fmtext_append_bold(&fm, "Zephyr users logged in:\n");
3071      owl_list_create(&anyone);
3072      ret=owl_zephyr_get_anyone_list(&anyone, filename);
3073      if (ret) {
3074        if (errno == ENOENT) {
3075          owl_fmtext_append_normal(&fm, " You have not added any zephyr buddies.  Use the\n");
3076          owl_fmtext_append_normal(&fm, " command ':addbuddy zephyr ");
3077          owl_fmtext_append_bold(  &fm, "<username>");
3078          owl_fmtext_append_normal(&fm, "'.\n");
3079        } else {
3080          owl_fmtext_append_normal(&fm, " Could not read zephyr buddies from the .anyone file.\n");
3081        }
3082      } else {
3083        j=owl_list_get_size(&anyone);
3084        for (i=0; i<j; i++) {
3085          user=owl_list_get_element(&anyone, i);
3086          ret=ZLocateUser(zstr(user), &numlocs, ZAUTH);
3087
3088          if (owl_global_take_interrupt(&g)) {
3089            interrupted = 1;
3090            owl_function_makemsg("Interrupted!");
3091            break;
3092          }
3093
3094          if (ret!=ZERR_NONE) {
3095            owl_function_error("Error getting location for %s", user);
3096            continue;
3097          }
3098
3099          numlocs=200;
3100          ret=ZGetLocations(location, &numlocs);
3101          if (ret==0) {
3102            for (x=0; x<numlocs; x++) {
3103              tmp=short_zuser(user);
3104              owl_fmtext_appendf_normal(&fm, "  %-10.10s %-24.24s %-12.12s  %20.20s\n",
3105                                        tmp,
3106                                        location[x].host,
3107                                        location[x].tty,
3108                                        location[x].time);
3109              g_free(tmp);
3110            }
3111            if (numlocs>=200) {
3112              owl_fmtext_append_normal(&fm, "  Too many locations found for this user, truncating.\n");
3113            }
3114          }
3115        }
3116      }
3117      owl_list_cleanup(&anyone, g_free);
3118    }
3119  }
3120#endif
3121
3122  if (aim && zephyr) {
3123    if (owl_perlconfig_is_function("BarnOwl::Hooks::_get_blist")) {
3124      char * perlblist = owl_perlconfig_execute("BarnOwl::Hooks::_get_blist()");
3125      if (perlblist) {
3126        owl_fmtext_append_ztext(&fm, perlblist);
3127        g_free(perlblist);
3128      }
3129    }
3130  }
3131
3132  if(!interrupted) {
3133    owl_function_popless_fmtext(&fm);
3134  }
3135  owl_fmtext_cleanup(&fm);
3136}
3137
3138/* Dump messages in the current view to the file 'filename'. */
3139void owl_function_dump(const char *filename) 
3140{
3141  int i, j;
3142  owl_message *m;
3143  const owl_view *v;
3144  FILE *file;
3145  char *plaintext;
3146
3147  v=owl_global_get_current_view(&g);
3148
3149  /* in the future make it ask yes/no */
3150  /*
3151  ret=stat(filename, &sbuf);
3152  if (!ret) {
3153    ret=owl_function_askyesno("File exists, continue? [Y/n]");
3154    if (!ret) return;
3155  }
3156  */
3157
3158  file=fopen(filename, "w");
3159  if (!file) {
3160    owl_function_error("Error opening file");
3161    return;
3162  }
3163
3164  j=owl_view_get_size(v);
3165  for (i=0; i<j; i++) {
3166    m=owl_view_get_element(v, i);
3167    plaintext = owl_strip_format_chars(owl_message_get_text(m));
3168    if (plaintext) {
3169      fputs(plaintext, file);
3170      g_free(plaintext);
3171    }
3172  }
3173  fclose(file);
3174  owl_function_makemsg("Messages dumped to %s", filename);
3175}
3176
3177void owl_function_do_newmsgproc(void)
3178{
3179  if (owl_global_get_newmsgproc(&g) && strcmp(owl_global_get_newmsgproc(&g), "")) {
3180    /* if there's a process out there, we need to check on it */
3181    if (owl_global_get_newmsgproc_pid(&g)) {
3182      owl_function_debugmsg("Checking on newmsgproc pid==%i", owl_global_get_newmsgproc_pid(&g));
3183      owl_function_debugmsg("Waitpid return is %i", waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG));
3184      waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG);
3185      if (waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG)==-1) {
3186        /* it exited */
3187        owl_global_set_newmsgproc_pid(&g, 0);
3188        owl_function_debugmsg("newmsgproc exited");
3189      } else {
3190        owl_function_debugmsg("newmsgproc did not exit");
3191      }
3192    }
3193   
3194    /* if it exited, fork & exec a new one */
3195    if (owl_global_get_newmsgproc_pid(&g)==0) {
3196      pid_t i;
3197      int myargc;
3198      i=fork();
3199      if (i) {
3200        /* parent set the child's pid */
3201        owl_global_set_newmsgproc_pid(&g, i);
3202        owl_function_debugmsg("I'm the parent and I started a new newmsgproc with pid %i", i);
3203      } else {
3204        /* child exec's the program */
3205        char **parsed;
3206        parsed=owl_parseline(owl_global_get_newmsgproc(&g), &myargc);
3207        if (myargc < 0) {
3208          owl_function_debugmsg("Could not parse newmsgproc '%s': unbalanced quotes?", owl_global_get_newmsgproc(&g));
3209        }
3210        if (myargc <= 0) {
3211          _exit(127);
3212        }
3213        owl_function_debugmsg("About to exec \"%s\" with %d arguments", parsed[0], myargc);
3214       
3215        execvp(parsed[0], parsed);
3216       
3217       
3218        /* was there an error exec'ing? */
3219        owl_function_debugmsg("Cannot run newmsgproc '%s': cannot exec '%s': %s", 
3220                              owl_global_get_newmsgproc(&g), parsed[0], strerror(errno));
3221        _exit(127);
3222      }
3223    }
3224  }
3225}
3226
3227/* print the xterm escape sequence to raise the window */
3228void owl_function_xterm_raise(void)
3229{
3230  printf("\033[5t");
3231}
3232
3233/* print the xterm escape sequence to deiconify the window */
3234void owl_function_xterm_deiconify(void)
3235{
3236  printf("\033[1t");
3237}
3238
3239/* Add the specified command to the startup file.  Eventually this
3240 * should be clever, and rewriting settings that will obviosly
3241 * override earlier settings with 'set' 'bindkey' and 'alias'
3242 * commands.  For now though we just remove any line that would
3243 * duplicate this one and then append this line to the end of
3244 * startupfile.
3245 */
3246void owl_function_addstartup(const char *buff)
3247{
3248  FILE *file;
3249  const char *filename;
3250
3251  filename=owl_global_get_startupfile(&g);
3252
3253  /* delete earlier copies */
3254  owl_util_file_deleteline(filename, buff, 1);
3255
3256  file=fopen(filename, "a");
3257  if (!file) {
3258    owl_function_error("Error opening startupfile for new command");
3259    return;
3260  }
3261
3262  /* add this line */
3263  fprintf(file, "%s\n", buff);
3264
3265  fclose(file);
3266}
3267
3268/* Remove the specified command from the startup file. */
3269void owl_function_delstartup(const char *buff)
3270{
3271  const char *filename;
3272  filename=owl_global_get_startupfile(&g);
3273  owl_util_file_deleteline(filename, buff, 1);
3274}
3275
3276/* Execute owl commands from the given filename.  If the filename
3277 * is NULL, use the default owl startup commands file.
3278 */
3279void owl_function_source(const char *filename)
3280{
3281  char *path;
3282  FILE *file;
3283  char *s = NULL;
3284  int fail_silent = 0;
3285
3286  if (!filename) {
3287    fail_silent = 1;
3288    path = g_strdup(owl_global_get_startupfile(&g));
3289  } else {
3290    path = owl_util_makepath(filename);
3291  }
3292  file = fopen(path, "r");
3293  g_free(path);
3294  if (!file) {
3295    if (!fail_silent) {
3296      owl_function_error("Error opening file: %s", filename);
3297    }
3298    return;
3299  }
3300  while (owl_getline_chomp(&s, file)) {
3301    if (s[0] == '\0' || s[0] == '#')
3302      continue;
3303    owl_function_command_norv(s);
3304  }
3305
3306  g_free(s);
3307  fclose(file);
3308}
3309
3310void owl_function_change_style(owl_view *v, const char *stylename)
3311{
3312  const owl_style *s;
3313
3314  s=owl_global_get_style_by_name(&g, stylename);
3315  if (!s) {
3316    owl_function_error("No style named %s", stylename);
3317    return;
3318  }
3319  owl_view_set_style(v, s);
3320  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3321  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3322  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3323}
3324
3325void owl_function_toggleoneline(void)
3326{
3327  owl_view *v;
3328  const owl_style *s;
3329
3330  v=owl_global_get_current_view(&g);
3331  s=owl_view_get_style(v);
3332
3333  if (!owl_style_matches_name(s, "oneline")) {
3334    owl_function_change_style(v, "oneline");
3335  } else {
3336    owl_function_change_style(v, owl_global_get_default_style(&g));
3337  }
3338
3339  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3340  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3341  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3342}
3343
3344void G_GNUC_PRINTF(1, 2) owl_function_error(const char *fmt, ...)
3345{
3346  static int in_error = 0;
3347  va_list ap;
3348  char *buff;
3349  const char *nl;
3350
3351  if (++in_error > 2) {
3352    /* More than two nested errors, bail immediately. */
3353    in_error--;
3354    return;
3355  }
3356
3357  va_start(ap, fmt);
3358  buff = g_strdup_vprintf(fmt, ap);
3359  va_end(ap);
3360
3361  owl_function_debugmsg("ERROR: %s", buff);
3362  owl_function_log_err(buff);
3363
3364  nl = strchr(buff, '\n');
3365
3366  /*
3367    Showing admin messages triggers a lot of code. If we have a
3368    recursive error call, that's the most likely candidate, so
3369    suppress the call in that case, to try to avoid infinite looping.
3370  */
3371
3372  if(nl && *(nl + 1) && in_error == 1) {
3373    /* Multiline error */
3374    owl_function_adminmsg("ERROR", buff);
3375  } else {
3376    owl_function_makemsg("[Error] %s", buff);
3377  }
3378
3379  g_free(buff);
3380
3381  in_error--;
3382}
3383
3384void owl_function_log_err(const char *string)
3385{
3386  char *date;
3387  time_t now;
3388  char *buff;
3389
3390  now=time(NULL);
3391  date=g_strdup(ctime(&now));
3392  date[strlen(date)-1]='\0';
3393
3394  buff = g_strdup_printf("%s %s", date, string);
3395
3396  owl_errqueue_append_err(owl_global_get_errqueue(&g), buff);
3397
3398  g_free(buff);
3399  g_free(date);
3400}
3401
3402void owl_function_showerrs(void)
3403{
3404  owl_fmtext fm;
3405
3406  owl_fmtext_init_null(&fm);
3407  owl_fmtext_append_normal(&fm, "Errors:\n\n");
3408  owl_errqueue_to_fmtext(owl_global_get_errqueue(&g), &fm);
3409  owl_function_popless_fmtext(&fm);
3410}
3411
3412void G_GNUC_PRINTF(1, 2) owl_function_makemsg(const char *fmt, ...)
3413{
3414  va_list ap;
3415  char *str;
3416
3417  va_start(ap, fmt);
3418  str = g_strdup_vprintf(fmt, ap);
3419  va_end(ap);
3420
3421  owl_function_debugmsg("makemsg: %s", str);
3422  owl_msgwin_set_text_nocopy(&g.msgwin, str);
3423}
3424
3425/* get locations for everyone in .anyone.  If 'notify' is '1' then
3426 * send a pseudo login or logout message for everyone not in sync with
3427 * the global zephyr buddy list.  The list is updated regardless of
3428 * the status of 'notify'.
3429 */
3430void owl_function_zephyr_buddy_check(int notify)
3431{
3432#ifdef HAVE_LIBZEPHYR
3433  int i, j;
3434  owl_list anyone;
3435  GList **zaldlist;
3436  GList *zaldptr;
3437  ZAsyncLocateData_t *zald;
3438  const char *user;
3439
3440  if (!owl_global_is_havezephyr(&g)) return;
3441  owl_global_set_pseudologin_notify(&g, notify);
3442  zaldlist = owl_global_get_zaldlist(&g);
3443
3444  /* Clear the existing ZALDs first. */
3445  zaldptr = g_list_first(*zaldlist);
3446  while (zaldptr) {
3447    ZFreeALD(zaldptr->data);
3448    g_free(zaldptr->data);
3449    zaldptr = g_list_next(zaldptr);
3450  }
3451  g_list_free(*zaldlist);
3452  *zaldlist = NULL;
3453
3454  owl_list_create(&anyone);
3455  owl_zephyr_get_anyone_list(&anyone, NULL);
3456  j = owl_list_get_size(&anyone);
3457  for (i = 0; i < j; i++) {
3458    user = owl_list_get_element(&anyone, i);
3459    zald = g_new(ZAsyncLocateData_t, 1);
3460    if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
3461      *zaldlist = g_list_append(*zaldlist, zald);
3462    } else {
3463      g_free(zald);
3464    }
3465  }
3466
3467  owl_list_cleanup(&anyone, g_free);
3468#endif
3469}
3470
3471void owl_function_aimsearch_results(const char *email, owl_list *namelist)
3472{
3473  owl_fmtext fm;
3474  int i, j;
3475
3476  owl_fmtext_init_null(&fm);
3477  owl_fmtext_append_normal(&fm, "AIM screennames associated with ");
3478  owl_fmtext_append_normal(&fm, email);
3479  owl_fmtext_append_normal(&fm, ":\n");
3480
3481  j=owl_list_get_size(namelist);
3482  for (i=0; i<j; i++) {
3483    owl_fmtext_append_normal(&fm, "  ");
3484    owl_fmtext_append_normal(&fm, owl_list_get_element(namelist, i));
3485    owl_fmtext_append_normal(&fm, "\n");
3486  }
3487
3488  owl_function_popless_fmtext(&fm);
3489  owl_fmtext_cleanup(&fm);
3490}
3491
3492int owl_function_get_color_count(void)
3493{
3494     return COLORS;
3495}
3496
3497void _owl_function_mark_message(const owl_message *m)
3498{
3499  if (m) {
3500    owl_global_set_markedmsgid(&g, owl_message_get_id(m));
3501    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3502  }
3503}
3504
3505void owl_function_mark_message(void)
3506{
3507  const owl_message *m;
3508  const owl_view *v;
3509
3510  v=owl_global_get_current_view(&g);
3511
3512  /* bail if there's no current message */
3513  if (owl_view_get_size(v) < 1) {
3514    owl_function_error("No messages to mark");
3515    return;
3516  }
3517
3518  /* mark the message */
3519  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
3520  _owl_function_mark_message(m);
3521  owl_function_makemsg("Mark set");
3522}
3523
3524void owl_function_swap_cur_marked(void)
3525{
3526  int marked_id;
3527  const owl_message *m;
3528  const owl_view *v;
3529
3530  marked_id=owl_global_get_markedmsgid(&g);
3531  if (marked_id == -1) {
3532    owl_function_error("Mark not set.");
3533    return;
3534  }
3535
3536  v=owl_global_get_current_view(&g);
3537  /* bail if there's no current message */
3538  if (owl_view_get_size(v) < 1) {
3539    return;
3540  }
3541
3542  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
3543  _owl_function_mark_message(m);
3544  owl_global_set_curmsg(&g, owl_view_get_nearest_to_msgid(v, marked_id));
3545  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
3546  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3547  owl_global_set_direction_downwards(&g);
3548}
Note: See TracBrowser for help on using the repository browser.