4 Copyright (C) 1999-2000 Timo Sirainen
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "module-formats.h"
28 #include "printtext.h"
31 #include "gui-windows.h"
33 #define NEW_WINDOW_SIZE (WINDOW_MIN_SIZE + 1)
36 MAIN_WINDOW_REC *active_mainwin;
38 int screen_reserved_top, screen_reserved_bottom;
39 static int old_screen_width, old_screen_height;
41 #define mainwindow_create_screen(window) \
42 term_window_create(0, \
43 (window)->first_line + (window)->statusbar_lines_top, \
45 (window)->height - (window)->statusbar_lines)
47 #define mainwindow_set_screen_size(window) \
48 term_window_move((window)->screen_win, 0, \
49 (window)->first_line + (window)->statusbar_lines_top, \
51 (window)->height - (window)->statusbar_lines);
54 static MAIN_WINDOW_REC *find_window_with_room(void)
56 MAIN_WINDOW_REC *biggest_rec;
60 biggest = 0; biggest_rec = NULL;
61 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
62 MAIN_WINDOW_REC *rec = tmp->data;
64 space = MAIN_WINDOW_TEXT_HEIGHT(rec);
65 if (space >= WINDOW_MIN_SIZE+NEW_WINDOW_SIZE && space > biggest) {
74 #define window_size_equals(window, mainwin) \
75 ((window)->width == (mainwin)->width && \
76 (window)->height == MAIN_WINDOW_TEXT_HEIGHT(mainwin))
78 static void mainwindow_resize_windows(MAIN_WINDOW_REC *window)
83 mainwindow_set_screen_size(window);
86 for (tmp = windows; tmp != NULL; tmp = tmp->next) {
87 WINDOW_REC *rec = tmp->data;
89 if (rec->gui_data != NULL &&
90 WINDOW_GUI(rec)->parent == window &&
91 !window_size_equals(rec, window)) {
93 gui_window_resize(rec, window->width,
94 MAIN_WINDOW_TEXT_HEIGHT(window));
99 signal_emit("mainwindow resized", 1, window);
102 static void mainwindow_resize(MAIN_WINDOW_REC *window, int xdiff, int ydiff)
104 if (quitting || (xdiff == 0 && ydiff == 0))
107 window->width += xdiff;
108 window->height = window->last_line-window->first_line+1;
109 window->size_dirty = TRUE;
112 static GSList *get_sticky_windows_sorted(MAIN_WINDOW_REC *mainwin)
117 for (tmp = windows; tmp != NULL; tmp = tmp->next) {
118 WINDOW_REC *rec = tmp->data;
120 if (WINDOW_GUI(rec)->sticky && WINDOW_MAIN(rec) == mainwin) {
121 list = g_slist_insert_sorted(list, rec, (GCompareFunc)
129 void mainwindow_change_active(MAIN_WINDOW_REC *mainwin,
130 WINDOW_REC *skip_window)
132 WINDOW_REC *window, *other;
135 mainwin->active = NULL;
136 if (mainwin->sticky_windows) {
138 tmp = get_sticky_windows_sorted(mainwin);
140 if (window == skip_window) {
141 window = tmp->next == NULL ? NULL :
146 if (window != NULL) {
147 window_set_active(window);
153 for (tmp = windows; tmp != NULL; tmp = tmp->next) {
154 WINDOW_REC *rec = tmp->data;
156 if (rec != skip_window) {
162 window_set_active(other);
163 if (mainwindows->next != NULL)
164 mainwindow_destroy(mainwin);
167 void mainwindows_recreate(void)
171 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
172 MAIN_WINDOW_REC *rec = tmp->data;
174 rec->screen_win = mainwindow_create_screen(rec);
176 textbuffer_view_set_window(WINDOW_GUI(rec->active)->view,
181 MAIN_WINDOW_REC *mainwindow_create(void)
183 MAIN_WINDOW_REC *rec, *parent;
186 rec = g_new0(MAIN_WINDOW_REC, 1);
188 rec->width = term_width;
190 if (mainwindows == NULL) {
191 active_mainwin = rec;
193 rec->first_line = screen_reserved_top;
194 rec->last_line = term_height-1 - screen_reserved_bottom;
195 rec->height = rec->last_line-rec->first_line+1;
197 parent = WINDOW_MAIN(active_win);
198 if (MAIN_WINDOW_TEXT_HEIGHT(parent) <
199 WINDOW_MIN_SIZE+NEW_WINDOW_SIZE)
200 parent = find_window_with_room();
202 return NULL; /* not enough space */
204 space = parent->height / 2;
205 rec->first_line = parent->first_line;
206 rec->last_line = rec->first_line + space;
207 rec->height = rec->last_line-rec->first_line+1;
209 parent->first_line = rec->last_line+1;
210 parent->height = parent->last_line-parent->first_line+1;
212 mainwindow_resize(parent, 0, -space-1);
215 rec->screen_win = mainwindow_create_screen(rec);
218 mainwindows = g_slist_append(mainwindows, rec);
219 signal_emit("mainwindow created", 1, rec);
223 static MAIN_WINDOW_REC *mainwindows_find_lower(int line)
225 MAIN_WINDOW_REC *best;
229 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
230 MAIN_WINDOW_REC *rec = tmp->data;
232 if (rec->first_line > line &&
233 (best == NULL || rec->first_line < best->first_line))
240 static MAIN_WINDOW_REC *mainwindows_find_upper(int line)
242 MAIN_WINDOW_REC *best;
246 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
247 MAIN_WINDOW_REC *rec = tmp->data;
249 if (rec->last_line < line &&
250 (best == NULL || rec->last_line > best->last_line))
257 static void mainwindows_add_space(int first_line, int last_line)
259 MAIN_WINDOW_REC *rec;
262 if (last_line < first_line)
265 size = last_line-first_line+1;
267 rec = mainwindows_find_lower(last_line);
269 rec->first_line = first_line;
270 mainwindow_resize(rec, 0, size);
274 rec = mainwindows_find_upper(first_line);
276 rec->last_line = last_line;
277 mainwindow_resize(rec, 0, size);
281 static void gui_windows_remove_parent(MAIN_WINDOW_REC *window)
283 MAIN_WINDOW_REC *new_parent;
286 new_parent = mainwindows->data;
287 for (tmp = windows; tmp != NULL; tmp = tmp->next) {
288 WINDOW_REC *rec = tmp->data;
290 if (rec->gui_data != NULL && WINDOW_MAIN(rec) == window)
291 gui_window_reparent(rec, new_parent);
295 void mainwindow_destroy(MAIN_WINDOW_REC *window)
297 g_return_if_fail(window != NULL);
299 mainwindows = g_slist_remove(mainwindows, window);
300 signal_emit("mainwindow destroyed", 1, window);
302 term_window_destroy(window->screen_win);
304 if (mainwindows != NULL) {
305 gui_windows_remove_parent(window);
307 mainwindows_add_space(window->first_line,
309 mainwindows_redraw();
315 if (active_mainwin == window) active_mainwin = NULL;
318 void mainwindows_redraw(void)
323 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
324 MAIN_WINDOW_REC *rec = tmp->data;
330 static int mainwindows_compare(MAIN_WINDOW_REC *w1, MAIN_WINDOW_REC *w2)
332 return w1->first_line < w2->first_line ? -1 : 1;
335 static int mainwindows_compare_reverse(MAIN_WINDOW_REC *w1, MAIN_WINDOW_REC *w2)
337 return w1->first_line < w2->first_line ? 1 : -1;
340 GSList *mainwindows_get_sorted(int reverse)
345 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
346 list = g_slist_insert_sorted(list, tmp->data, (GCompareFunc)
347 (reverse ? mainwindows_compare_reverse : mainwindows_compare));
353 static void mainwindows_resize_smaller(int xdiff, int ydiff)
355 MAIN_WINDOW_REC *rec;
356 GSList *sorted, *tmp;
360 sorted = mainwindows_get_sorted(TRUE);
362 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
364 space += MAIN_WINDOW_TEXT_HEIGHT(rec)-WINDOW_MIN_SIZE;
371 sorted = g_slist_remove(sorted, rec);
373 if (sorted != NULL) {
374 /* terminal is too small - destroy the
375 uppest window and try again */
376 mainwindow_destroy(rec);
378 /* only one window in screen.. just force the resize */
379 rec->last_line += ydiff;
380 mainwindow_resize(rec, xdiff, ydiff);
385 /* resize windows that have space */
386 for (tmp = sorted; tmp != NULL && ydiff < 0; tmp = tmp->next) {
389 space = MAIN_WINDOW_TEXT_HEIGHT(rec)-WINDOW_MIN_SIZE;
391 mainwindow_resize(rec, xdiff, 0);
393 rec->first_line += ydiff;
394 rec->last_line += ydiff;
395 signal_emit("mainwindow moved", 1, rec);
399 if (space <= 0) space = 1;
400 if (space > -ydiff) space = -ydiff;
401 rec->last_line += ydiff;
403 rec->first_line += ydiff;
405 mainwindow_resize(rec, xdiff, -space);
409 while (tmp != NULL) {
410 mainwindow_resize(tmp->data, xdiff, 0);
415 g_slist_free(sorted);
418 static void mainwindows_resize_bigger(int xdiff, int ydiff)
420 GSList *sorted, *tmp;
423 sorted = mainwindows_get_sorted(FALSE);
425 for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
426 MAIN_WINDOW_REC *rec = tmp->data;
428 space = MAIN_WINDOW_TEXT_HEIGHT(rec)-WINDOW_MIN_SIZE;
429 if (ydiff == 0 || (space >= 0 && tmp->next != NULL)) {
430 mainwindow_resize(rec, xdiff, 0);
432 rec->first_line += moved;
433 rec->last_line += moved;
434 signal_emit("mainwindow moved", 1, rec);
439 if (space < 0 && tmp->next != NULL) {
440 /* space below minimum */
442 if (space > ydiff) space = ydiff;
444 /* lowest window - give all the extra space for it */
448 rec->first_line += moved;
450 rec->last_line += moved;
452 mainwindow_resize(rec, xdiff, space);
454 g_slist_free(sorted);
457 void mainwindows_resize_horiz(int xdiff)
461 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
462 MAIN_WINDOW_REC *rec = tmp->data;
464 mainwindow_resize(rec, xdiff, 0);
468 void mainwindows_resize(int width, int height)
472 xdiff = width-old_screen_width;
473 ydiff = height-old_screen_height;
474 old_screen_width = width;
475 old_screen_height = height;
478 mainwindows_resize_smaller(xdiff, ydiff);
480 mainwindows_resize_bigger(xdiff, ydiff);
482 mainwindows_resize_horiz(xdiff);
484 signal_emit("terminal resized", 0);
489 int mainwindows_reserve_lines(int top, int bottom)
491 MAIN_WINDOW_REC *window;
496 g_return_val_if_fail(top > 0 || screen_reserved_top > top, -1);
498 ret = screen_reserved_top;
499 screen_reserved_top += top;
501 window = mainwindows_find_lower(-1);
502 if (window != NULL) {
503 window->first_line += top;
504 mainwindow_resize(window, 0, -top);
509 g_return_val_if_fail(bottom > 0 || screen_reserved_bottom > bottom, -1);
511 ret = screen_reserved_bottom;
512 screen_reserved_bottom += bottom;
514 window = mainwindows_find_upper(term_height);
515 if (window != NULL) {
516 window->last_line -= bottom;
517 mainwindow_resize(window, 0, -bottom);
524 int mainwindow_set_statusbar_lines(MAIN_WINDOW_REC *window,
531 ret = window->statusbar_lines_top;
532 window->statusbar_lines_top += top;
533 window->statusbar_lines += top;
537 ret = window->statusbar_lines_bottom;
538 window->statusbar_lines_bottom += bottom;
539 window->statusbar_lines += bottom;
543 window->size_dirty = TRUE;
548 static void mainwindows_resize_two(MAIN_WINDOW_REC *grow_win,
549 MAIN_WINDOW_REC *shrink_win, int count)
553 mainwindow_resize(grow_win, 0, count);
554 mainwindow_resize(shrink_win, 0, -count);
555 grow_win->dirty = TRUE;
556 shrink_win->dirty = TRUE;
559 static int try_shrink_lower(MAIN_WINDOW_REC *window, int count)
561 MAIN_WINDOW_REC *shrink_win;
563 shrink_win = mainwindows_find_lower(window->last_line);
564 if (shrink_win != NULL &&
565 MAIN_WINDOW_TEXT_HEIGHT(shrink_win)-count >= WINDOW_MIN_SIZE) {
566 window->last_line += count;
567 shrink_win->first_line += count;
568 mainwindows_resize_two(window, shrink_win, count);
575 static int try_shrink_upper(MAIN_WINDOW_REC *window, int count)
577 MAIN_WINDOW_REC *shrink_win;
579 shrink_win = mainwindows_find_upper(window->first_line);
580 if (shrink_win != NULL &&
581 MAIN_WINDOW_TEXT_HEIGHT(shrink_win)-count >= WINDOW_MIN_SIZE) {
582 window->first_line -= count;
583 shrink_win->last_line -= count;
584 mainwindows_resize_two(window, shrink_win, count);
591 static int mainwindow_grow(MAIN_WINDOW_REC *window, int count,
594 if (!resize_lower || !try_shrink_lower(window, count)) {
595 if (!try_shrink_upper(window, count)) {
596 if (resize_lower || !try_shrink_lower(window, count))
604 static int try_grow_lower(MAIN_WINDOW_REC *window, int count)
606 MAIN_WINDOW_REC *grow_win;
608 grow_win = mainwindows_find_lower(window->last_line);
609 if (grow_win != NULL) {
610 window->last_line -= count;
611 grow_win->first_line -= count;
612 mainwindows_resize_two(grow_win, window, count);
615 return grow_win != NULL;
618 static int try_grow_upper(MAIN_WINDOW_REC *window, int count)
620 MAIN_WINDOW_REC *grow_win;
622 grow_win = mainwindows_find_upper(window->first_line);
623 if (grow_win != NULL) {
624 window->first_line += count;
625 grow_win->last_line += count;
626 mainwindows_resize_two(grow_win, window, count);
629 return grow_win != NULL;
632 static int mainwindow_shrink(MAIN_WINDOW_REC *window, int count, int resize_lower)
634 if (MAIN_WINDOW_TEXT_HEIGHT(window)-count < WINDOW_MIN_SIZE)
637 if (!resize_lower || !try_grow_lower(window, count)) {
638 if (!try_grow_upper(window, count)) {
639 if (resize_lower || !try_grow_lower(window, count))
647 /* Change the window height - the height includes the lines needed for
648 statusbars. If resize_lower is TRUE, the lower window is first tried
649 to be resized instead of upper window. */
650 void mainwindow_set_size(MAIN_WINDOW_REC *window, int height, int resize_lower)
652 height -= window->height;
654 mainwindow_shrink(window, -height, resize_lower);
656 mainwindow_grow(window, height, resize_lower);
659 void mainwindows_redraw_dirty(void)
663 for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
664 MAIN_WINDOW_REC *rec = tmp->data;
666 if (rec->size_dirty) {
667 rec->size_dirty = FALSE;
668 mainwindow_resize_windows(rec);
672 gui_window_redraw(rec->active);
677 /* SYNTAX: WINDOW GROW [<lines>] */
678 static void cmd_window_grow(const char *data)
680 MAIN_WINDOW_REC *window;
683 count = *data == '\0' ? 1 : atoi(data);
684 window = WINDOW_MAIN(active_win);
686 if (!mainwindow_grow(window, count, FALSE)) {
687 printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
688 TXT_WINDOW_TOO_SMALL);
692 /* SYNTAX: WINDOW SHRINK [<lines>] */
693 static void cmd_window_shrink(const char *data)
697 count = *data == '\0' ? 1 : atoi(data);
698 if (!mainwindow_shrink(WINDOW_MAIN(active_win), count, FALSE)) {
699 printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
700 TXT_WINDOW_TOO_SMALL);
704 /* SYNTAX: WINDOW SIZE <lines> */
705 static void cmd_window_size(const char *data)
707 char sizestr[MAX_INT_STRLEN];
710 if (!is_numeric(data, 0)) return;
713 size -= WINDOW_MAIN(active_win)->height -
714 WINDOW_MAIN(active_win)->statusbar_lines;
715 if (size == 0) return;
717 ltoa(sizestr, size < 0 ? -size : size);
719 cmd_window_shrink(sizestr);
721 cmd_window_grow(sizestr);
724 /* SYNTAX: WINDOW BALANCE */
725 static void cmd_window_balance(void)
727 GSList *sorted, *tmp;
728 int avail_size, unit_size, bigger_units;
729 int windows, last_line, old_size;
731 windows = g_slist_length(mainwindows);
732 if (windows == 1) return;
734 avail_size = term_height - screen_reserved_top-screen_reserved_bottom;
735 unit_size = avail_size/windows;
736 bigger_units = avail_size%windows;
738 sorted = mainwindows_get_sorted(FALSE);
739 last_line = screen_reserved_top;
740 for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
741 MAIN_WINDOW_REC *rec = tmp->data;
743 old_size = rec->height;
744 rec->first_line = last_line;
745 rec->last_line = rec->first_line + unit_size-1;
747 if (bigger_units > 0) {
752 rec->height = rec->last_line-rec->first_line+1;
753 last_line = rec->last_line+1;
755 mainwindow_resize(rec, 0, rec->height-old_size);
757 g_slist_free(sorted);
759 mainwindows_redraw();
762 /* SYNTAX: WINDOW HIDE [<number>|<name>] */
763 static void cmd_window_hide(const char *data)
767 if (mainwindows->next == NULL) {
768 printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
775 else if (is_numeric(data, 0)) {
776 window = window_find_refnum(atoi(data));
777 if (window == NULL) {
778 printformat_window(active_win, MSGLEVEL_CLIENTERROR,
779 TXT_REFNUM_NOT_FOUND, data);
782 window = window_find_item(active_win->active_server, data);
785 if (window == NULL || !is_window_visible(window))
788 if (WINDOW_MAIN(window)->sticky_windows) {
789 printformat_window(active_win, MSGLEVEL_CLIENTERROR,
790 TXT_CANT_HIDE_STICKY_WINDOWS);
794 mainwindow_destroy(WINDOW_MAIN(window));
796 if (active_mainwin == NULL) {
797 active_mainwin = WINDOW_MAIN(active_win);
798 window_set_active(active_mainwin->active);
802 /* SYNTAX: WINDOW SHOW <number>|<name> */
803 static void cmd_window_show(const char *data)
805 MAIN_WINDOW_REC *parent;
808 if (*data == '\0') cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
810 if (is_numeric(data, '\0')) {
811 window = window_find_refnum(atoi(data));
812 if (window == NULL) {
813 printformat_window(active_win, MSGLEVEL_CLIENTERROR,
814 TXT_REFNUM_NOT_FOUND, data);
817 window = window_find_item(active_win->active_server, data);
820 if (window == NULL || is_window_visible(window))
823 if (WINDOW_MAIN(window)->sticky_windows) {
824 printformat_window(active_win, MSGLEVEL_CLIENTERROR,
825 TXT_CANT_SHOW_STICKY_WINDOWS);
829 parent = mainwindow_create();
830 parent->active = window;
831 gui_window_reparent(window, parent);
833 if (settings_get_bool("autostick_split_windows"))
834 gui_window_set_sticky(window);
836 active_mainwin = NULL;
837 window_set_active(window);
840 /* SYNTAX: WINDOW UP */
841 static void cmd_window_up(void)
843 MAIN_WINDOW_REC *rec;
845 rec = mainwindows_find_upper(active_mainwin->first_line);
847 rec = mainwindows_find_upper(term_height);
849 window_set_active(rec->active);
852 /* SYNTAX: WINDOW DOWN */
853 static void cmd_window_down(void)
855 MAIN_WINDOW_REC *rec;
857 rec = mainwindows_find_lower(active_mainwin->last_line);
859 rec = mainwindows_find_lower(-1);
861 window_set_active(rec->active);
864 #define WINDOW_STICKY_MATCH(window, sticky_parent) \
865 ((!WINDOW_GUI(window)->sticky && (sticky_parent) == NULL) || \
866 (WINDOW_GUI(window)->sticky && \
867 WINDOW_MAIN(window) == (sticky_parent)))
869 static int window_refnum_left(int refnum, int wrap)
871 MAIN_WINDOW_REC *find_sticky;
874 window = window_find_refnum(refnum);
875 g_return_val_if_fail(window != NULL, -1);
877 find_sticky = WINDOW_MAIN(window)->sticky_windows ?
878 WINDOW_MAIN(window) : NULL;
881 refnum = window_refnum_prev(refnum, wrap);
885 window = window_find_refnum(refnum);
886 } while (!WINDOW_STICKY_MATCH(window, find_sticky));
891 static int window_refnum_right(int refnum, int wrap)
893 MAIN_WINDOW_REC *find_sticky;
896 window = window_find_refnum(refnum);
897 g_return_val_if_fail(window != NULL, -1);
899 find_sticky = WINDOW_MAIN(window)->sticky_windows ?
900 WINDOW_MAIN(window) : NULL;
903 refnum = window_refnum_next(refnum, wrap);
907 window = window_find_refnum(refnum);
908 } while (!WINDOW_STICKY_MATCH(window, find_sticky));
913 /* SYNTAX: WINDOW LEFT */
914 static void cmd_window_left(const char *data, SERVER_REC *server, void *item)
918 refnum = window_refnum_left(active_win->refnum, TRUE);
920 window_set_active(window_find_refnum(refnum));
923 /* SYNTAX: WINDOW RIGHT */
924 static void cmd_window_right(void)
928 refnum = window_refnum_right(active_win->refnum, TRUE);
930 window_set_active(window_find_refnum(refnum));
933 static void window_reparent(WINDOW_REC *win, MAIN_WINDOW_REC *mainwin)
935 MAIN_WINDOW_REC *old_mainwin;
937 old_mainwin = WINDOW_MAIN(win);
939 if (old_mainwin != mainwin) {
940 gui_window_set_unsticky(win);
942 if (old_mainwin->active == win) {
943 mainwindow_change_active(old_mainwin, win);
944 if (active_mainwin == NULL) {
945 active_mainwin = mainwin;
946 window_set_active(mainwin->active);
950 gui_window_reparent(win, mainwin);
951 window_set_active(win);
955 /* SYNTAX: WINDOW STICK [<ref#>] [ON|OFF] */
956 static void cmd_window_stick(const char *data)
958 MAIN_WINDOW_REC *mainwin;
961 mainwin = active_mainwin;
962 win = active_mainwin->active;
964 if (is_numeric(data, ' ')) {
966 win = window_find_refnum(atoi(data));
968 printformat_window(active_win, MSGLEVEL_CLIENTERROR,
969 TXT_REFNUM_NOT_FOUND, data);
973 while (*data != ' ' && *data != '\0') data++;
974 while (*data == ' ') data++;
977 if (g_strncasecmp(data, "OF", 2) == 0 || i_toupper(*data) == 'N') {
979 if (!WINDOW_GUI(win)->sticky) {
980 printformat_window(win, MSGLEVEL_CLIENTERROR,
981 TXT_WINDOW_NOT_STICKY);
983 gui_window_set_unsticky(win);
984 printformat_window(win, MSGLEVEL_CLIENTNOTICE,
985 TXT_WINDOW_UNSET_STICKY);
989 window_reparent(win, mainwin);
990 gui_window_set_sticky(win);
992 printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
993 TXT_WINDOW_SET_STICKY);
997 /* SYNTAX: WINDOW MOVE LEFT */
998 static void cmd_window_move_left(void)
1002 refnum = window_refnum_left(active_win->refnum, TRUE);
1004 window_set_refnum(active_win, refnum);
1007 /* SYNTAX: WINDOW MOVE RIGHT */
1008 static void cmd_window_move_right(void)
1012 refnum = window_refnum_right(active_win->refnum, TRUE);
1014 window_set_refnum(active_win, refnum);
1017 /* SYNTAX: WINDOW MOVE UP */
1018 static void cmd_window_move_up(void)
1020 MAIN_WINDOW_REC *rec;
1022 rec = mainwindows_find_upper(active_mainwin->first_line);
1024 window_reparent(active_win, rec);
1027 /* SYNTAX: WINDOW MOVE DOWN */
1028 static void cmd_window_move_down(void)
1030 MAIN_WINDOW_REC *rec;
1032 rec = mainwindows_find_lower(active_mainwin->last_line);
1034 window_reparent(active_win, rec);
1037 static void windows_print_sticky(WINDOW_REC *win)
1039 MAIN_WINDOW_REC *mainwin;
1043 mainwin = WINDOW_MAIN(win);
1045 /* convert to string */
1046 str = g_string_new(NULL);
1047 list = get_sticky_windows_sorted(mainwin);
1048 for (tmp = list; tmp != NULL; tmp = tmp->next) {
1049 WINDOW_REC *rec = tmp->data;
1051 g_string_sprintfa(str, "#%d, ", rec->refnum);
1053 g_string_truncate(str, str->len-2);
1056 printformat_window(win, MSGLEVEL_CLIENTCRAP,
1057 TXT_WINDOW_INFO_STICKY, str->str);
1058 g_string_free(str, TRUE);
1061 static void sig_window_print_info(WINDOW_REC *win)
1063 GUI_WINDOW_REC *gui;
1065 gui = WINDOW_GUI(win);
1066 if (gui->use_scroll) {
1067 printformat_window(win, MSGLEVEL_CLIENTCRAP,
1068 TXT_WINDOW_INFO_SCROLL,
1069 gui->scroll ? "yes" : "no");
1072 if (WINDOW_MAIN(win)->sticky_windows)
1073 windows_print_sticky(win);
1076 void mainwindows_init(void)
1078 old_screen_width = term_width;
1079 old_screen_height = term_height;
1082 active_mainwin = NULL;
1083 screen_reserved_top = screen_reserved_bottom = 0;
1085 command_bind("window grow", NULL, (SIGNAL_FUNC) cmd_window_grow);
1086 command_bind("window shrink", NULL, (SIGNAL_FUNC) cmd_window_shrink);
1087 command_bind("window size", NULL, (SIGNAL_FUNC) cmd_window_size);
1088 command_bind("window balance", NULL, (SIGNAL_FUNC) cmd_window_balance);
1089 command_bind("window hide", NULL, (SIGNAL_FUNC) cmd_window_hide);
1090 command_bind("window show", NULL, (SIGNAL_FUNC) cmd_window_show);
1091 command_bind("window up", NULL, (SIGNAL_FUNC) cmd_window_up);
1092 command_bind("window down", NULL, (SIGNAL_FUNC) cmd_window_down);
1093 command_bind("window left", NULL, (SIGNAL_FUNC) cmd_window_left);
1094 command_bind("window right", NULL, (SIGNAL_FUNC) cmd_window_right);
1095 command_bind("window stick", NULL, (SIGNAL_FUNC) cmd_window_stick);
1096 command_bind("window move left", NULL, (SIGNAL_FUNC) cmd_window_move_left);
1097 command_bind("window move right", NULL, (SIGNAL_FUNC) cmd_window_move_right);
1098 command_bind("window move up", NULL, (SIGNAL_FUNC) cmd_window_move_up);
1099 command_bind("window move down", NULL, (SIGNAL_FUNC) cmd_window_move_down);
1100 signal_add("window print info", (SIGNAL_FUNC) sig_window_print_info);
1103 void mainwindows_deinit(void)
1105 while (mainwindows != NULL)
1106 mainwindow_destroy(mainwindows->data);
1108 command_unbind("window grow", (SIGNAL_FUNC) cmd_window_grow);
1109 command_unbind("window shrink", (SIGNAL_FUNC) cmd_window_shrink);
1110 command_unbind("window size", (SIGNAL_FUNC) cmd_window_size);
1111 command_unbind("window balance", (SIGNAL_FUNC) cmd_window_balance);
1112 command_unbind("window hide", (SIGNAL_FUNC) cmd_window_hide);
1113 command_unbind("window show", (SIGNAL_FUNC) cmd_window_show);
1114 command_unbind("window up", (SIGNAL_FUNC) cmd_window_up);
1115 command_unbind("window down", (SIGNAL_FUNC) cmd_window_down);
1116 command_unbind("window left", (SIGNAL_FUNC) cmd_window_left);
1117 command_unbind("window right", (SIGNAL_FUNC) cmd_window_right);
1118 command_unbind("window stick", (SIGNAL_FUNC) cmd_window_stick);
1119 command_unbind("window move left", (SIGNAL_FUNC) cmd_window_move_left);
1120 command_unbind("window move right", (SIGNAL_FUNC) cmd_window_move_right);
1121 command_unbind("window move up", (SIGNAL_FUNC) cmd_window_move_up);
1122 command_unbind("window move down", (SIGNAL_FUNC) cmd_window_move_down);
1123 signal_remove("window print info", (SIGNAL_FUNC) sig_window_print_info);