source: global.c @ 4e33cb2

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