source: global.c @ d83621c4

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