source: global.c @ f25df21

release-1.8release-1.9
Last change on this file since f25df21 was f25df21, checked in by David Benjamin <davidben@mit.edu>, 10 years ago
Don't call owl_list_create in owl_dict_get_keys Until we get rid of this owl_list thing altogether, there should be a convention as to who initializes the thing. Otherwise, we leak memory from people initializing it too many times. Whoever reviews this probably wants to look over this very carefully in case I missed one of the owl_list_creates. Also kill the various wrappers over owl_list_cleanup as they are not the inverse of any operation.
  • Property mode set to 100644
File size: 21.7 KB
Line 
1#include <stdio.h>
2#include <unistd.h>
3#include <stdlib.h>
4#include <string.h>
5#include <netdb.h>
6#include <termios.h>
7#include <sys/ioctl.h>
8#include <time.h>
9#include "owl.h"
10
11static void _owl_global_init_windows(owl_global *g);
12
13void owl_global_init(owl_global *g) {
14  char *cd;
15  const char *homedir;
16
17  g_type_init();
18
19  g->lines=LINES;
20  g->cols=COLS;
21  /* We shouldn't need this if we initialize lines and cols before the first
22   * owl_window_get_screen, but to be safe, we synchronize. */
23  owl_window_resize(owl_window_get_screen(), g->lines, g->cols);
24
25  g->context_stack = NULL;
26  owl_global_push_context(g, OWL_CTX_STARTUP, NULL, NULL, NULL);
27
28  g->curmsg=0;
29  g->topmsg=0;
30  g->markedmsgid=-1;
31  g->startupargs=NULL;
32
33  owl_variable_dict_setup(&(g->vars));
34
35  g->rightshift=0;
36
37  g->pw = NULL;
38  g->vw = NULL;
39  g->tw = NULL;
40
41  owl_keyhandler_init(&g->kh);
42  owl_keys_setup_keymaps(&g->kh);
43
44  owl_dict_create(&(g->filters));
45  g->filterlist = NULL;
46  owl_list_create(&(g->puntlist));
47  g->messagequeue = g_queue_new();
48  owl_dict_create(&(g->styledict));
49  g->curmsg_vert_offset=0;
50  g->resizepending=0;
51  g->direction=OWL_DIRECTION_DOWNWARDS;
52  g->zaway=0;
53  if (has_colors()) {
54    g->hascolors=1;
55  }
56  g->colorpairs=COLOR_PAIRS;
57  owl_fmtext_init_colorpair_mgr(&(g->cpmgr));
58  g->debug=OWL_DEBUG;
59  owl_regex_init(&g->search_re);
60  g->starttime=time(NULL); /* assumes we call init only a start time */
61  g->lastinputtime=g->starttime;
62  g->newmsgproc_pid=0;
63 
64  owl_global_set_config_format(g, 0);
65  owl_global_set_no_have_config(g);
66  owl_history_init(&(g->msghist));
67  owl_history_init(&(g->cmdhist));
68  owl_history_set_norepeats(&(g->cmdhist));
69  g->nextmsgid=0;
70
71  /* Fill in some variables which don't have constant defaults */
72
73  /* glib's g_get_home_dir prefers passwd entries to $HOME, so we
74   * explicitly check getenv first. */
75  homedir = getenv("HOME");
76  if (!homedir)
77    homedir = g_get_home_dir();
78  g->homedir = g_strdup(homedir);
79
80  g->confdir = NULL;
81  g->startupfile = NULL;
82  cd = g_strdup_printf("%s/%s", g->homedir, OWL_CONFIG_DIR);
83  owl_global_set_confdir(g, cd);
84  g_free(cd);
85
86  owl_messagelist_create(&(g->msglist));
87
88  _owl_global_init_windows(g);
89
90  g->aim_screenname=NULL;
91  g->aim_screenname_for_filters=NULL;
92  g->aim_loggedin=0;
93  owl_buddylist_init(&(g->buddylist));
94
95  g->havezephyr=0;
96  g->haveaim=0;
97  g->ignoreaimlogin=0;
98  owl_global_set_no_doaimevents(g);
99
100  owl_errqueue_init(&(g->errqueue));
101  g->got_err_signal=0;
102
103  owl_zbuddylist_create(&(g->zbuddies));
104
105  g->zaldlist = NULL;
106  g->pseudologin_notify = 0;
107
108  owl_message_init_fmtext_cache();
109  owl_list_create(&(g->io_dispatch_list));
110  owl_list_create(&(g->psa_list));
111  g->timerlist = NULL;
112  g->interrupted = FALSE;
113  g->kill_buffer = NULL;
114}
115
116static void _owl_global_init_windows(owl_global *g)
117{
118  /* Create the main window */
119  owl_mainpanel_init(&(g->mainpanel));
120
121  /* Create the widgets */
122  owl_mainwin_init(&(g->mw), g->mainpanel.recwin);
123  owl_msgwin_init(&(g->msgwin), g->mainpanel.msgwin);
124  owl_sepbar_init(g->mainpanel.sepwin);
125
126  owl_window_set_default_cursor(g->mainpanel.sepwin);
127
128  /* set up a pad for input */
129  g->input_pad = newpad(1, 1);
130  nodelay(g->input_pad, 1);
131  keypad(g->input_pad, 1);
132  meta(g->input_pad, 1);
133}
134
135void owl_global_sepbar_dirty(owl_global *g)
136{
137  owl_window_dirty(g->mainpanel.sepwin);
138}
139
140/* Called once perl has been initialized */
141void owl_global_complete_setup(owl_global *g)
142{
143  owl_cmddict_setup(&(g->cmds));
144}
145
146owl_context *owl_global_get_context(const owl_global *g) {
147  if (!g->context_stack)
148    return NULL;
149  return g->context_stack->data;
150}
151
152static void owl_global_activate_context(owl_global *g, owl_context *c) {
153  if (!c)
154    return;
155
156  if (c->keymap) {
157    if (!owl_keyhandler_activate(owl_global_get_keyhandler(g), c->keymap)) {
158      owl_function_error("Unable to activate keymap '%s'", c->keymap);
159    }
160  }
161  owl_window_set_cursor(c->cursor);
162}
163
164void owl_global_push_context(owl_global *g, int mode, void *data, const char *keymap, owl_window *cursor) {
165  owl_context *c;
166  c = owl_context_new(mode, data, keymap, cursor);
167  owl_global_push_context_obj(g, c);
168}
169
170void owl_global_push_context_obj(owl_global *g, owl_context *c)
171{
172  g->context_stack = g_list_prepend(g->context_stack, c);
173  owl_global_activate_context(g, owl_global_get_context(g));
174}
175
176/* Pops the current context from the context stack and returns it. Caller is
177 * responsible for freeing. */
178owl_context *owl_global_pop_context_no_delete(owl_global *g) {
179  owl_context *c;
180  if (!g->context_stack)
181    return NULL;
182  c = owl_global_get_context(g);
183  owl_context_deactivate(c);
184  g->context_stack = g_list_delete_link(g->context_stack,
185                                        g->context_stack);
186  owl_global_activate_context(g, owl_global_get_context(g));
187  return c;
188}
189
190/* Pops the current context from the context stack and deletes it. */
191void owl_global_pop_context(owl_global *g) {
192  owl_context *c;
193  c = owl_global_pop_context_no_delete(g);
194  if (c)
195    owl_context_delete(c);
196}
197
198int owl_global_get_lines(const owl_global *g) {
199  return(g->lines);
200}
201
202int owl_global_get_cols(const owl_global *g) {
203  return(g->cols);
204}
205
206int owl_global_get_recwin_lines(const owl_global *g) {
207  return g->mainpanel.recwinlines;
208}
209
210/* curmsg */
211
212int owl_global_get_curmsg(const owl_global *g) {
213  return(g->curmsg);
214}
215
216void owl_global_set_curmsg(owl_global *g, int i) {
217  g->curmsg=i;
218  /* we will reset the vertical offset from here */
219  /* we might want to move this out to the functions later */
220  owl_global_set_curmsg_vert_offset(g, 0);
221}
222
223/* topmsg */
224
225int owl_global_get_topmsg(const owl_global *g) {
226  return(g->topmsg);
227}
228
229void owl_global_set_topmsg(owl_global *g, int i) {
230  g->topmsg=i;
231}
232
233/* markedmsgid */
234
235int owl_global_get_markedmsgid(const owl_global *g) {
236  return(g->markedmsgid);
237}
238
239void owl_global_set_markedmsgid(owl_global *g, int i) {
240  g->markedmsgid=i;
241  /* i; index of message in the current view.
242  const owl_message *m;
243  owl_view *v;
244
245  v = owl_global_get_current_view(&g);
246  m = owl_view_get_element(v, i);
247  g->markedmsgid = m ? owl_message_get_id(m) : 0;
248  */
249}
250
251/* windows */
252
253owl_mainwin *owl_global_get_mainwin(owl_global *g) {
254  return(&(g->mw));
255}
256
257owl_popwin *owl_global_get_popwin(owl_global *g) {
258  return g->pw;
259}
260
261void owl_global_set_popwin(owl_global *g, owl_popwin *pw) {
262  g->pw = pw;
263}
264
265/* msglist */
266
267owl_messagelist *owl_global_get_msglist(owl_global *g) {
268  return(&(g->msglist));
269}
270
271/* keyhandler */
272
273owl_keyhandler *owl_global_get_keyhandler(owl_global *g) {
274  return(&(g->kh));
275}
276
277/* Gets the currently active typwin out of the current context. */
278owl_editwin *owl_global_current_typwin(const owl_global *g) {
279  owl_context *ctx = owl_global_get_context(g);
280  return owl_editcontext_get_editwin(ctx);
281}
282
283/* variable dictionary */
284
285owl_vardict *owl_global_get_vardict(owl_global *g) {
286  return &(g->vars);
287}
288
289/* command dictionary */
290
291owl_cmddict *owl_global_get_cmddict(owl_global *g) {
292  return &(g->cmds);
293}
294
295/* rightshift */
296
297void owl_global_set_rightshift(owl_global *g, int i) {
298  g->rightshift = i;
299  owl_mainwin_redisplay(owl_global_get_mainwin(g));
300}
301
302int owl_global_get_rightshift(const owl_global *g) {
303  return(g->rightshift);
304}
305
306/* typwin */
307
308owl_editwin *owl_global_set_typwin_active(owl_global *g, int style, owl_history *hist) {
309  int d;
310  d = owl_global_get_typewindelta(g);
311  if (d > 0 && style == OWL_EDITWIN_STYLE_MULTILINE)
312      owl_function_resize_typwin(owl_global_get_typwin_lines(g) + d);
313
314  if (g->typwin_erase_id) {
315    g_signal_handler_disconnect(g->mainpanel.typwin, g->typwin_erase_id);
316    g->typwin_erase_id = 0;
317  }
318
319  g->tw = owl_editwin_new(g->mainpanel.typwin,
320                          owl_global_get_typwin_lines(g),
321                          g->cols,
322                          style,
323                          hist);
324  return g->tw;
325}
326
327void owl_global_deactivate_editcontext(owl_context *ctx) {
328  owl_global *g = ctx->cbdata;
329  owl_global_set_typwin_inactive(g);
330}
331
332void owl_global_set_typwin_inactive(owl_global *g) {
333  int d = owl_global_get_typewindelta(g);
334  if (d > 0 && owl_editwin_get_style(g->tw) == OWL_EDITWIN_STYLE_MULTILINE)
335      owl_function_resize_typwin(owl_global_get_typwin_lines(g) - d);
336
337  if (!g->typwin_erase_id) {
338    g->typwin_erase_id =
339      g_signal_connect(g->mainpanel.typwin, "redraw", G_CALLBACK(owl_window_erase_cb), NULL);
340  }
341  owl_window_dirty(g->mainpanel.typwin);
342
343  owl_editwin_unref(g->tw);
344  g->tw = NULL;
345}
346
347/* resize */
348
349void owl_global_set_resize_pending(owl_global *g) {
350  g->resizepending=1;
351}
352
353const char *owl_global_get_homedir(const owl_global *g) {
354  if (g->homedir) return(g->homedir);
355  return("/");
356}
357
358const char *owl_global_get_confdir(const owl_global *g) {
359  if (g->confdir) return(g->confdir);
360  return("/");
361}
362
363/*
364 * Setting this also sets startupfile to confdir/startup
365 */
366void owl_global_set_confdir(owl_global *g, const char *cd) {
367  g_free(g->confdir);
368  g->confdir = g_strdup(cd);
369  g_free(g->startupfile);
370  g->startupfile = g_strdup_printf("%s/startup", cd);
371}
372
373const char *owl_global_get_startupfile(const owl_global *g) {
374  if(g->startupfile) return(g->startupfile);
375  return("/");
376}
377
378int owl_global_get_direction(const owl_global *g) {
379  return(g->direction);
380}
381
382void owl_global_set_direction_downwards(owl_global *g) {
383  g->direction=OWL_DIRECTION_DOWNWARDS;
384}
385
386void owl_global_set_direction_upwards(owl_global *g) {
387  g->direction=OWL_DIRECTION_UPWARDS;
388}
389
390/* perl stuff */
391
392void owl_global_set_perlinterp(owl_global *g, void *p) {
393  g->perl=p;
394}
395
396void *owl_global_get_perlinterp(const owl_global *g) {
397  return(g->perl);
398}
399
400int owl_global_is_config_format(const owl_global *g) {
401  if (g->config_format) return(1);
402  return(0);
403}
404
405void owl_global_set_config_format(owl_global *g, int state) {
406  if (state==1) {
407    g->config_format=1;
408  } else {
409    g->config_format=0;
410  }
411}
412
413void owl_global_set_have_config(owl_global *g) {
414  g->haveconfig=1;
415}
416
417void owl_global_set_no_have_config(owl_global *g) {
418  g->haveconfig=0;
419}
420
421int owl_global_have_config(owl_global *g) {
422  if (g->haveconfig) return(1);
423  return(0);
424}
425
426/*
427 * Compute the size of the terminal. Try a ioctl, fallback to other stuff on
428 * fail.
429 */
430void owl_global_get_terminal_size(int *lines, int *cols) {
431  struct winsize size;
432  /* get the new size */
433  ioctl(STDIN_FILENO, TIOCGWINSZ, &size);
434  if (size.ws_row) {
435    *lines = size.ws_row;
436  } else {
437    *lines = LINES;
438  }
439
440  if (size.ws_col) {
441    *cols = size.ws_col;
442  } else {
443    *cols = COLS;
444  }
445}
446
447void owl_global_check_resize(owl_global *g) {
448  /* resize the screen.  If lines or cols is 0 use the terminal size */
449  if (!g->resizepending) return;
450  g->resizepending = 0;
451
452  owl_global_get_terminal_size(&g->lines, &g->cols);
453  owl_window_resize(owl_window_get_screen(), g->lines, g->cols);
454
455  owl_function_debugmsg("New size is %i lines, %i cols.", g->lines, g->cols);
456}
457
458/* debug */
459
460int owl_global_is_debug_fast(const owl_global *g) {
461  if (g->debug) return(1);
462  return(0);
463}
464
465/* starttime */
466
467time_t owl_global_get_starttime(const owl_global *g) {
468  return(g->starttime);
469}
470
471time_t owl_global_get_runtime(const owl_global *g) {
472  return(time(NULL)-g->starttime);
473}
474
475time_t owl_global_get_lastinputtime(const owl_global *g) {
476  return(g->lastinputtime);
477}
478
479void owl_global_set_lastinputtime(owl_global *g, time_t time) {
480  g->lastinputtime = time;
481}
482
483time_t owl_global_get_idletime(const owl_global *g) {
484  return(time(NULL)-g->lastinputtime);
485}
486
487/* viewwin */
488
489owl_viewwin *owl_global_get_viewwin(owl_global *g) {
490  return g->vw;
491}
492
493void owl_global_set_viewwin(owl_global *g, owl_viewwin *vw) {
494  g->vw = vw;
495}
496
497
498/* vert offset */
499
500int owl_global_get_curmsg_vert_offset(const owl_global *g) {
501  return(g->curmsg_vert_offset);
502}
503
504void owl_global_set_curmsg_vert_offset(owl_global *g, int i) {
505  g->curmsg_vert_offset = i;
506}
507
508/* startup args */
509
510void owl_global_set_startupargs(owl_global *g, int argc, char **argv) {
511  if (g->startupargs) g_free(g->startupargs);
512  g->startupargs = g_strjoinv(" ", argv);
513}
514
515const char *owl_global_get_startupargs(const owl_global *g) {
516  if (g->startupargs) return(g->startupargs);
517  return("");
518}
519
520/* history */
521
522owl_history *owl_global_get_msg_history(owl_global *g) {
523  return(&(g->msghist));
524}
525
526owl_history *owl_global_get_cmd_history(owl_global *g) {
527  return(&(g->cmdhist));
528}
529
530/* filterlist */
531typedef struct _owl_global_filter_ent {         /* noproto */
532  owl_global *g;
533  owl_filter *f;
534} owl_global_filter_ent;
535
536owl_filter *owl_global_get_filter(const owl_global *g, const char *name) {
537  owl_global_filter_ent *e = owl_dict_find_element(&(g->filters), name);
538  if (e) return e->f;
539  return NULL;
540}
541
542static void owl_global_delete_filter_ent(void *data)
543{
544  owl_global_filter_ent *e = data;
545  e->g->filterlist = g_list_remove(e->g->filterlist, e->f);
546  owl_filter_delete(e->f);
547  g_free(e);
548}
549
550void owl_global_add_filter(owl_global *g, owl_filter *f) {
551  owl_global_filter_ent *e = g_new(owl_global_filter_ent, 1);
552  e->g = g;
553  e->f = f;
554
555  owl_dict_insert_element(&(g->filters), owl_filter_get_name(f),
556                          e, owl_global_delete_filter_ent);
557  g->filterlist = g_list_append(g->filterlist, f);
558}
559
560void owl_global_remove_filter(owl_global *g, const char *name) {
561  owl_global_filter_ent *e = owl_dict_remove_element(&(g->filters), name);
562  if (e)
563    owl_global_delete_filter_ent(e);
564}
565
566/* nextmsgid */
567
568int owl_global_get_nextmsgid(owl_global *g) {
569  return(g->nextmsgid++);
570}
571
572/* current view */
573
574owl_view *owl_global_get_current_view(owl_global *g) {
575  return(&(g->current_view));
576}
577
578/* has colors */
579
580int owl_global_get_hascolors(const owl_global *g) {
581  if (g->hascolors) return(1);
582  return(0);
583}
584
585/* color pairs */
586
587int owl_global_get_colorpairs(const owl_global *g) {
588  return(g->colorpairs);
589}
590
591owl_colorpair_mgr *owl_global_get_colorpair_mgr(owl_global *g) {
592  return(&(g->cpmgr));
593}
594
595/* puntlist */
596
597owl_list *owl_global_get_puntlist(owl_global *g) {
598  return(&(g->puntlist));
599}
600
601int owl_global_message_is_puntable(owl_global *g, const owl_message *m) {
602  const owl_list *pl;
603  int i, j;
604
605  pl=owl_global_get_puntlist(g);
606  j=owl_list_get_size(pl);
607  for (i=0; i<j; i++) {
608    if (owl_filter_message_match(owl_list_get_element(pl, i), m)) return(1);
609  }
610  return(0);
611}
612
613int owl_global_should_followlast(owl_global *g) {
614  const owl_view *v;
615 
616  if (!owl_global_is__followlast(g)) return(0);
617 
618  v=owl_global_get_current_view(g);
619 
620  if (owl_global_get_curmsg(g)==owl_view_get_size(v)-1) return(1);
621  return(0);
622}
623
624int owl_global_is_search_active(const owl_global *g) {
625  if (owl_regex_is_set(&g->search_re)) return(1);
626  return(0);
627}
628
629void owl_global_set_search_re(owl_global *g, const owl_regex *re) {
630  if (owl_regex_is_set(&g->search_re)) {
631    owl_regex_cleanup(&g->search_re);
632    owl_regex_init(&g->search_re);
633  }
634  if (re != NULL)
635    owl_regex_copy(re, &g->search_re);
636  /* TODO: Emit a signal so we don't depend on the viewwin and mainwin */
637  if (owl_global_get_viewwin(g))
638    owl_viewwin_dirty(owl_global_get_viewwin(g));
639  owl_mainwin_redisplay(owl_global_get_mainwin(g));
640}
641
642const owl_regex *owl_global_get_search_re(const owl_global *g) {
643  return &g->search_re;
644}
645
646void owl_global_set_newmsgproc_pid(owl_global *g, pid_t i) {
647  g->newmsgproc_pid=i;
648}
649
650pid_t owl_global_get_newmsgproc_pid(const owl_global *g) {
651  return(g->newmsgproc_pid);
652}
653
654/* AIM stuff */
655
656int owl_global_is_aimloggedin(const owl_global *g)
657{
658  if (g->aim_loggedin) return(1);
659  return(0);
660}
661
662const char *owl_global_get_aim_screenname(const owl_global *g)
663{
664  if (owl_global_is_aimloggedin(g)) {
665    return (g->aim_screenname);
666  }
667  return("");
668}
669
670const char *owl_global_get_aim_screenname_for_filters(const owl_global *g)
671{
672  if (owl_global_is_aimloggedin(g)) {
673    return (g->aim_screenname_for_filters);
674  }
675  return("");
676}
677
678void owl_global_set_aimloggedin(owl_global *g, const char *screenname)
679{
680  char *sn_escaped;
681  g->aim_loggedin=1;
682  if (g->aim_screenname) g_free(g->aim_screenname);
683  if (g->aim_screenname_for_filters) g_free(g->aim_screenname_for_filters);
684  g->aim_screenname=g_strdup(screenname);
685  sn_escaped = owl_text_quote(screenname, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
686  g->aim_screenname_for_filters = owl_arg_quote(sn_escaped);
687  g_free(sn_escaped);
688}
689
690void owl_global_set_aimnologgedin(owl_global *g)
691{
692  g->aim_loggedin=0;
693}
694
695int owl_global_is_doaimevents(const owl_global *g)
696{
697  if (g->aim_doprocessing) return(1);
698  return(0);
699}
700
701void owl_global_set_doaimevents(owl_global *g)
702{
703  g->aim_doprocessing=1;
704}
705
706void owl_global_set_no_doaimevents(owl_global *g)
707{
708  g->aim_doprocessing=0;
709}
710
711aim_session_t *owl_global_get_aimsess(owl_global *g)
712{
713  return(&(g->aimsess));
714}
715
716aim_conn_t *owl_global_get_bosconn(owl_global *g)
717{
718  return(&(g->bosconn));
719}
720
721void owl_global_set_bossconn(owl_global *g, aim_conn_t *conn)
722{
723  g->bosconn=*conn;
724}
725
726/* message queue */
727
728void owl_global_messagequeue_addmsg(owl_global *g, owl_message *m)
729{
730  g_queue_push_tail(g->messagequeue, m);
731}
732
733/* pop off the first message and return it.  Return NULL if the queue
734 * is empty.  The caller should free the message after using it, if
735 * necessary.
736 */
737owl_message *owl_global_messagequeue_popmsg(owl_global *g)
738{
739  owl_message *out;
740
741  if (g_queue_is_empty(g->messagequeue))
742    return NULL;
743  out = g_queue_pop_head(g->messagequeue);
744  return out;
745}
746
747int owl_global_messagequeue_pending(owl_global *g)
748{
749  return !g_queue_is_empty(g->messagequeue);
750}
751
752owl_buddylist *owl_global_get_buddylist(owl_global *g)
753{
754  return(&(g->buddylist));
755}
756 
757/* style */
758
759/* Return the style with name 'name'.  If it does not exist return
760 * NULL */
761const owl_style *owl_global_get_style_by_name(const owl_global *g, const char *name)
762{
763  return owl_dict_find_element(&(g->styledict), name);
764}
765
766int owl_global_get_style_names(const owl_global *g, owl_list *l) {
767  return owl_dict_get_keys(&(g->styledict), l);
768}
769
770void owl_global_add_style(owl_global *g, owl_style *s)
771{
772  /*
773   * If we're redefining the current style, make sure to update
774   * pointers to it.
775   */
776  if(g->current_view.style
777     && !strcmp(owl_style_get_name(g->current_view.style),
778                owl_style_get_name(s)))
779    g->current_view.style = s;
780  owl_dict_insert_element(&(g->styledict), owl_style_get_name(s),
781                          s, (void (*)(void *))owl_style_delete);
782}
783
784void owl_global_set_haveaim(owl_global *g)
785{
786  g->haveaim=1;
787}
788
789int owl_global_is_haveaim(const owl_global *g)
790{
791  if (g->haveaim) return(1);
792  return(0);
793}
794
795void owl_global_set_ignore_aimlogin(owl_global *g)
796{
797    g->ignoreaimlogin = 1;
798}
799
800void owl_global_unset_ignore_aimlogin(owl_global *g)
801{
802    g->ignoreaimlogin = 0;
803}
804
805int owl_global_is_ignore_aimlogin(const owl_global *g)
806{
807    return g->ignoreaimlogin;
808}
809
810void owl_global_set_havezephyr(owl_global *g)
811{
812  g->havezephyr=1;
813}
814
815int owl_global_is_havezephyr(const owl_global *g)
816{
817  if (g->havezephyr) return(1);
818  return(0);
819}
820
821owl_errqueue *owl_global_get_errqueue(owl_global *g)
822{
823  return(&(g->errqueue));
824}
825
826void owl_global_set_errsignal(owl_global *g, int signum, siginfo_t *siginfo)
827{
828  g->got_err_signal = signum;
829  if (siginfo) {
830    g->err_signal_info = *siginfo;
831  } else {
832    siginfo_t si;
833    memset(&si, 0, sizeof(si));
834    g->err_signal_info = si;
835  }
836}
837
838int owl_global_get_errsignal_and_clear(owl_global *g, siginfo_t *siginfo)
839{
840  int signum;
841  if (siginfo && g->got_err_signal) {
842    *siginfo = g->err_signal_info;
843  } 
844  signum = g->got_err_signal;
845  g->got_err_signal = 0;
846  return signum;
847}
848
849
850owl_zbuddylist *owl_global_get_zephyr_buddylist(owl_global *g)
851{
852  return(&(g->zbuddies));
853}
854
855GList **owl_global_get_zaldlist(owl_global *g)
856{
857  return &(g->zaldlist);
858}
859
860int owl_global_get_pseudologin_notify(owl_global *g)
861{
862  return g->pseudologin_notify;
863}
864
865void owl_global_set_pseudologin_notify(owl_global *g, int notify)
866{
867  g->pseudologin_notify = notify;
868}
869
870struct termios *owl_global_get_startup_tio(owl_global *g)
871{
872  return(&(g->startup_tio));
873}
874
875owl_list *owl_global_get_io_dispatch_list(owl_global *g)
876{
877  return &(g->io_dispatch_list);
878}
879
880owl_list *owl_global_get_psa_list(owl_global *g)
881{
882  return &(g->psa_list);
883}
884
885GList **owl_global_get_timerlist(owl_global *g)
886{
887  return &(g->timerlist);
888}
889
890int owl_global_is_interrupted(const owl_global *g) {
891  return g->interrupted;
892}
893
894void owl_global_set_interrupted(owl_global *g) {
895  g->interrupted = 1;
896}
897
898void owl_global_unset_interrupted(owl_global *g) {
899  g->interrupted = 0;
900}
901
902void owl_global_setup_default_filters(owl_global *g)
903{
904  int i;
905  static const struct {
906    const char *name;
907    const char *desc;
908  } filters[] = {
909    { "personal",
910      "isprivate ^true$ and ( not type ^zephyr$ or ( class ^message  ) )" },
911    { "trash",
912      "class ^mail$ or opcode ^ping$ or type ^admin$ or ( not login ^none$ )" },
913    { "wordwrap", "not ( type ^admin$ or type ^zephyr$ )" },
914    { "ping", "opcode ^ping$" },
915    { "auto", "opcode ^auto$" },
916    { "login", "not login ^none$" },
917    { "reply-lockout", "class ^noc or class ^mail$" },
918    { "out", "direction ^out$" },
919    { "aim", "type ^aim$" },
920    { "zephyr", "type ^zephyr$" },
921    { "none", "false" },
922    { "all", "true" },
923    { NULL, NULL }
924  };
925
926  owl_function_debugmsg("startup: creating default filters");
927
928  for (i = 0; filters[i].name != NULL; i++)
929    owl_global_add_filter(g, owl_filter_new_fromstring(filters[i].name,
930                                                       filters[i].desc));
931}
932
933FILE *owl_global_get_debug_file_handle(owl_global *g) {
934  static char *open_file = NULL;
935  const char *filename = owl_global_get_debug_file(g);
936  if (g->debug_file == NULL ||
937      (open_file && strcmp(filename, open_file) != 0)) {
938    char *path;
939    int fd;
940
941    if (g->debug_file)
942      fclose(g->debug_file);
943
944    g->debug_file = NULL;
945
946    path = g_strdup_printf("%s.%d", filename, getpid());
947    fd = open(path, O_CREAT|O_WRONLY|O_EXCL, 0600);
948    g_free(path);
949
950    if (fd >= 0)
951      g->debug_file = fdopen(fd, "a");
952
953    g_free(open_file);
954    open_file = g_strdup(filename);
955  }
956  return g->debug_file;
957}
958
959char *owl_global_get_kill_buffer(owl_global *g) {
960  return g->kill_buffer;
961}
962
963void owl_global_set_kill_buffer(owl_global *g,char *kill) {
964  g->kill_buffer = kill;
965}
Note: See TracBrowser for help on using the repository browser.