irssi/src/fe-text/mainwindows.c

/*
 mainwindows.c : irssi

    Copyright (C) 1999-2000 Timo Sirainen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "module.h"
#include "module-formats.h"
#include "signals.h"
#include "commands.h"
#include "levels.h"
#include "misc.h"
#include "settings.h"
#include "printtext.h"

#include "screen.h"
#include "statusbar.h"
#include "gui-windows.h"

#define NEW_WINDOW_SIZE (WINDOW_MIN_SIZE + 1)

GSList *mainwindows;
MAIN_WINDOW_REC *active_mainwin;

static int reserved_up, reserved_down;
static int screen_width, screen_height;

static MAIN_WINDOW_REC *find_window_with_room(void)
{
	MAIN_WINDOW_REC *biggest_rec;
	GSList *tmp;
	int space, biggest;

	biggest = 0; biggest_rec = NULL;
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		space = rec->height;
		if (space >= WINDOW_MIN_SIZE+NEW_WINDOW_SIZE && space > biggest) {
			biggest = space;
			biggest_rec = rec;
		}
	}

	return biggest_rec;
}

#ifdef USE_CURSES_WINDOWS
static void create_curses_window(MAIN_WINDOW_REC *window)
{
	window->curses_win = newwin(window->height, window->width,
				    window->first_line, 0);
        idlok(window->curses_win, 1);
}
#endif

static void mainwindow_resize(MAIN_WINDOW_REC *window, int xdiff, int ydiff)
{
	GSList *tmp;

	if (xdiff == 0 && ydiff == 0)
                return;

        window->width += xdiff;
	window->height = window->last_line-window->first_line+1;
#ifdef USE_CURSES_WINDOWS
#ifdef HAVE_CURSES_WRESIZE
	wresize(window->curses_win, window->height, window->width);
	mvwin(window->curses_win, window->first_line, 0);
#else
	delwin(window->curses_win);
	create_curses_window(window);
#endif
#endif

	for (tmp = windows; tmp != NULL; tmp = tmp->next) {
		WINDOW_REC *rec = tmp->data;

		if (rec->gui_data != NULL &&
		    WINDOW_GUI(rec)->parent == window)
			gui_window_resize(rec, window->width, window->height);
	}

	textbuffer_view_set_window(WINDOW_GUI(window->active)->view,
				   window->curses_win);
	signal_emit("mainwindow resized", 1, window);
}

void mainwindows_recreate(void)
{
	GSList *tmp;

	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

#ifdef USE_CURSES_WINDOWS
		create_curses_window(rec);
#endif
		textbuffer_view_set_window(WINDOW_GUI(rec->active)->view,
					   rec->curses_win);
	}
}

MAIN_WINDOW_REC *mainwindow_create(void)
{
	MAIN_WINDOW_REC *rec, *parent;
	int space;

	rec = g_new0(MAIN_WINDOW_REC, 1);
	rec->width = screen_width;
	rec->statusbar_lines = 1;

	if (mainwindows == NULL) {
		active_mainwin = rec;

		rec->first_line = reserved_up;
		rec->last_line = screen_height-1 -
			reserved_down-rec->statusbar_lines;
		rec->height = rec->last_line-rec->first_line+1;
	} else {
		parent = WINDOW_GUI(active_win)->parent;
		if (parent->height < WINDOW_MIN_SIZE+NEW_WINDOW_SIZE)
			parent = find_window_with_room();
		if (parent == NULL)
			return NULL; /* not enough space */

		space = (parent->height-parent->statusbar_lines)/2;
		rec->first_line = parent->first_line;
		rec->last_line = rec->first_line + space-rec->statusbar_lines;
		rec->height = rec->last_line-rec->first_line+1;
		parent->first_line = rec->last_line+1+rec->statusbar_lines;
		parent->height = parent->last_line-parent->first_line+1;

		mainwindow_resize(parent, 0, -space-1);
	}

#ifdef USE_CURSES_WINDOWS
	rec->curses_win = newwin(rec->height, rec->width, rec->first_line, 0);
	refresh();
#endif

	mainwindows = g_slist_append(mainwindows, rec);
	signal_emit("mainwindow created", 1, rec);
	return rec;
}

static MAIN_WINDOW_REC *mainwindows_find_lower(int line)
{
	MAIN_WINDOW_REC *best;
	GSList *tmp;

	best = NULL;
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		if (rec->first_line > line &&
		    (best == NULL || rec->first_line < best->first_line))
			best = rec;
	}

	return best;
}

static MAIN_WINDOW_REC *mainwindows_find_upper(int line)
{
	MAIN_WINDOW_REC *best;
	GSList *tmp;

	best = NULL;
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		if (rec->last_line < line &&
		    (best == NULL || rec->last_line > best->last_line))
			best = rec;
	}

	return best;
}

static void mainwindows_add_space(int first_line, int last_line)
{
	MAIN_WINDOW_REC *rec;
	int size;

	if (last_line < first_line)
		return;

	size = last_line-first_line+1;

	rec = mainwindows_find_lower(last_line);
	if (rec != NULL) {
		rec->first_line = first_line;
		mainwindow_resize(rec, 0, size);
		return;
	}

	rec = mainwindows_find_upper(first_line);
	if (rec != NULL) {
		rec->last_line = last_line-rec->statusbar_lines;
		mainwindow_resize(rec, 0, size);
	}
}

static void gui_windows_remove_parent(MAIN_WINDOW_REC *window)
{
        MAIN_WINDOW_REC *new_parent;
	GSList *tmp;

        new_parent = mainwindows->data;
	for (tmp = windows; tmp != NULL; tmp = tmp->next) {
		WINDOW_REC *rec = tmp->data;

		if (rec->gui_data != NULL && WINDOW_GUI(rec)->parent == window)
                        gui_window_reparent(rec, new_parent);
	}
}

void mainwindow_destroy(MAIN_WINDOW_REC *window)
{
	g_return_if_fail(window != NULL);

#ifdef USE_CURSES_WINDOWS
	delwin(window->curses_win);
#endif

	mainwindows = g_slist_remove(mainwindows, window);
	signal_emit("mainwindow destroyed", 1, window);

	if (!quitting && mainwindows != NULL) {
		gui_windows_remove_parent(window);
		mainwindows_add_space(window->first_line, window->last_line+window->statusbar_lines);

		mainwindows_redraw();
		statusbar_redraw(NULL);
	}
	g_free(window);

	if (active_mainwin == window) active_mainwin = NULL;
}

void mainwindows_redraw(void)
{
        GSList *tmp;

	screen_refresh_freeze();
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

                gui_window_redraw(rec->active);
	}
	screen_refresh_thaw();
}

static int mainwindows_compare(MAIN_WINDOW_REC *w1, MAIN_WINDOW_REC *w2)
{
	return w1->first_line < w2->first_line ? -1 : 1;
}

static int mainwindows_compare_reverse(MAIN_WINDOW_REC *w1, MAIN_WINDOW_REC *w2)
{
	return w1->first_line < w2->first_line ? 1 : -1;
}

GSList *mainwindows_get_sorted(int reverse)
{
	GSList *tmp, *list;

	list = NULL;
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		list = g_slist_insert_sorted(list, tmp->data, (GCompareFunc)
					     (reverse ? mainwindows_compare_reverse : mainwindows_compare));
	}

	return list;
}

static void mainwindows_resize_too_small(int xdiff, int ydiff)
{
	GSList *sorted, *tmp;
        int space, moved;

	/* terminal is too small - just take the space whereever possible */
	sorted = mainwindows_get_sorted(FALSE);
	moved = 0;
	for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		space = rec->height;
		if (ydiff == 0 || space <= 0) {
			if (moved > 0) {
				rec->first_line -= moved;
				rec->last_line -= moved;
				signal_emit("mainwindow moved", 1, rec);
			}
			continue;
		}

		if (space > -ydiff) space = -ydiff;
		ydiff += space;
		rec->first_line -= moved;
		moved += space;
		rec->last_line -= space;
		mainwindow_resize(rec, xdiff, -space);
	}
	g_slist_free(sorted);
}

static void mainwindows_resize_smaller(int xdiff, int ydiff)
{
	GSList *sorted, *tmp;
        int space;

        space = 0;
	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		space += rec->height-WINDOW_MIN_SIZE;
	}

	if (space < -ydiff) {
		/* not enough space, use different algorithm */
		mainwindows_resize_too_small(xdiff, ydiff);
		return;
	}

	/* resize windows that have space */
	sorted = mainwindows_get_sorted(TRUE);
	for (tmp = sorted; tmp != NULL && ydiff < 0; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		space = rec->height-WINDOW_MIN_SIZE;
		if (space <= 0) {
			rec->first_line += ydiff;
			rec->last_line += ydiff;
			signal_emit("mainwindow moved", 1, rec);
			continue;
		}

		if (space <= 0) space = 1;
		if (space > -ydiff) space = -ydiff;
		rec->last_line += ydiff;
		ydiff += space;
		rec->first_line += ydiff;

		mainwindow_resize(rec, xdiff, -space);
	}
	g_slist_free(sorted);
}

static void mainwindows_resize_bigger(int xdiff, int ydiff)
{
	GSList *sorted, *tmp;
        int moved, space;

	sorted = mainwindows_get_sorted(FALSE);
	moved = 0;
	for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		space = rec->height-WINDOW_MIN_SIZE;
		if (ydiff == 0 || (space >= 0 && tmp->next != NULL)) {
			if (moved > 0) {
				rec->first_line += moved;
				rec->last_line += moved;
				signal_emit("mainwindow moved", 1, rec);
			}
			continue;
		}

		if (space < 0 && tmp->next != NULL) {
                        /* space below minimum */
			space = -space;
			if (space > ydiff) space = ydiff;
		} else {
			/* lowest window - give all the extra space for it */
			space = ydiff;
		}
		ydiff -= space;
		rec->first_line += moved;
                moved += space;
		rec->last_line += moved;

		mainwindow_resize(rec, xdiff, space);
	}
	g_slist_free(sorted);
}

void mainwindows_resize_horiz(int xdiff)
{
	GSList *tmp;

	for (tmp = mainwindows; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		mainwindow_resize(rec, xdiff, 0);
	}
}

void mainwindows_resize(int width, int height)
{
	int xdiff, ydiff;

	xdiff = width-screen_width;
	ydiff = height-screen_height;
        screen_width = width;
        screen_height = height;

	screen_refresh_freeze();
	if (ydiff < 0)
		mainwindows_resize_smaller(xdiff, ydiff);
	else if (ydiff > 0)
		mainwindows_resize_bigger(xdiff, ydiff);
        else if (xdiff != 0)
		mainwindows_resize_horiz(xdiff);

	irssi_redraw();
	screen_refresh_thaw();
}

int mainwindows_reserve_lines(int count, int up)
{
	MAIN_WINDOW_REC *window;
	int ret;

	if (up) {
		g_return_val_if_fail(count > 0 || reserved_up > count, -1);

		ret = reserved_up;
		reserved_up += count;

		window = mainwindows_find_lower(-1);
		if (window != NULL) window->first_line += count;
	} else {
		g_return_val_if_fail(count > 0 || reserved_down > count, -1);

		ret = reserved_down;
		reserved_down += count;

		window = mainwindows_find_upper(screen_height);
		if (window != NULL) window->last_line -= count;
	}

	if (window != NULL)
		mainwindow_resize(window, 0, -count);

	return ret;
}

static void mainwindows_resize_two(MAIN_WINDOW_REC *grow_win,
				   MAIN_WINDOW_REC *shrink_win, int count)
{
	mainwindow_resize(grow_win, 0, count);
	mainwindow_resize(shrink_win, 0, -count);
	gui_window_redraw(grow_win->active);
	gui_window_redraw(shrink_win->active);
	statusbar_redraw(grow_win->statusbar);
	statusbar_redraw(shrink_win->statusbar);
}

static int mainwindow_grow(MAIN_WINDOW_REC *window, int count)
{
	MAIN_WINDOW_REC *shrink_win;

	/* shrink lower window */
	shrink_win = mainwindows_find_lower(window->last_line);
	if (shrink_win != NULL && shrink_win->height-count >= WINDOW_MIN_SIZE) {
                window->last_line += count;
		shrink_win->first_line += count;
	} else {
		/* shrink upper window */
		shrink_win = mainwindows_find_upper(window->first_line);
		if (shrink_win == NULL ||
		    shrink_win->height-count < WINDOW_MIN_SIZE)
			return FALSE;

		window->first_line -= count;
		shrink_win->last_line -= count;
	}

	mainwindows_resize_two(window, shrink_win, count);
        return TRUE;
}

static int mainwindow_shrink(MAIN_WINDOW_REC *window, int count)
{
	MAIN_WINDOW_REC *grow_win;

	if (window->height-count < WINDOW_MIN_SIZE)
                return FALSE;

	grow_win = mainwindows_find_lower(window->last_line);
	if (grow_win != NULL) {
                window->last_line -= count;
		grow_win->first_line -= count;
	} else {
		grow_win = mainwindows_find_upper(window->first_line);
		if (grow_win == NULL) return FALSE;

		window->first_line += count;
		grow_win->last_line += count;
	}

	mainwindows_resize_two(grow_win, window, count);
        return TRUE;
}

void mainwindow_set_size(MAIN_WINDOW_REC *window, int size)
{
        size -= window->height;
	if (size < 0)
		mainwindow_shrink(window, size);
	else
		mainwindow_grow(window, size);
}

/* SYNTAX: WINDOW GROW [<lines>] */
static void cmd_window_grow(const char *data)
{
	MAIN_WINDOW_REC *window;
	int count;

	count = *data == '\0' ? 1 : atoi(data);
	window = WINDOW_GUI(active_win)->parent;

	if (!mainwindow_grow(window, count)) {
		printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
				   TXT_WINDOW_TOO_SMALL);
	}
}

/* SYNTAX: WINDOW SHRINK [<lines>] */
static void cmd_window_shrink(const char *data)
{
	MAIN_WINDOW_REC *window;
	int count;

	count = *data == '\0' ? 1 : atoi(data);
	window = WINDOW_GUI(active_win)->parent;

	if (!mainwindow_shrink(window, count)) {
		printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
				   TXT_WINDOW_TOO_SMALL);
	}
}

/* SYNTAX: WINDOW SIZE <lines> */
static void cmd_window_size(const char *data)
{
        char sizestr[MAX_INT_STRLEN];
	int size;

	if (!is_numeric(data, 0)) return;
	size = atoi(data);

	size -= WINDOW_GUI(active_win)->parent->height;
	if (size == 0) return;

	ltoa(sizestr, size < 0 ? -size : size);
	if (size < 0)
		cmd_window_shrink(sizestr);
	else
		cmd_window_grow(sizestr);
}

/* SYNTAX: WINDOW BALANCE */
static void cmd_window_balance(void)
{
	GSList *sorted, *tmp;
	int avail_size, unit_size, bigger_units;
	int windows, last_line, old_size;

	windows = g_slist_length(mainwindows);
	if (windows == 1) return;

	avail_size = screen_height - reserved_up-reserved_down;
	unit_size = avail_size/windows;
	bigger_units = avail_size%windows;

	sorted = mainwindows_get_sorted(FALSE);
        last_line = 0;
	for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
		MAIN_WINDOW_REC *rec = tmp->data;

		old_size = rec->height;
		rec->first_line = last_line+1;
		rec->last_line = rec->first_line-1 + unit_size -
			rec->statusbar_lines;
		rec->height = rec->last_line-rec->first_line+1;

		if (bigger_units > 0) {
			rec->last_line++;
                        bigger_units--;
		}
		last_line = rec->last_line + rec->statusbar_lines;

		mainwindow_resize(rec, 0, rec->height-old_size);
	}
	g_slist_free(sorted);

	mainwindows_redraw();
	statusbar_redraw(NULL);
}

/* SYNTAX: WINDOW HIDE [<number>|<name>] */
static void cmd_window_hide(const char *data)
{
	WINDOW_REC *window;

	if (mainwindows->next == NULL) {
		printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
				   TXT_CANT_HIDE_LAST);
		return;
	}

	if (*data == '\0')
		window = active_win;
	else if (is_numeric(data, 0)) {
		window = window_find_refnum(atoi(data));
		if (window == NULL) {
			printformat_window(active_win, MSGLEVEL_CLIENTERROR,
					   TXT_REFNUM_NOT_FOUND, data);
		}
	} else {
		window = window_find_item(active_win->active_server, data);
	}

	if (window == NULL || !is_window_visible(window))
		return;

	if (WINDOW_GUI(window)->parent->sticky_windows != NULL) {
		printformat_window(active_win, MSGLEVEL_CLIENTERROR,
				   TXT_CANT_HIDE_STICKY_WINDOWS);
                return;
	}

	mainwindow_destroy(WINDOW_GUI(window)->parent);

	if (active_mainwin == NULL) {
		active_mainwin = WINDOW_GUI(active_win)->parent;
                window_set_active(active_mainwin->active);
	}
}

/* SYNTAX: WINDOW SHOW <number>|<name> */
static void cmd_window_show(const char *data)
{
        MAIN_WINDOW_REC *parent;
	WINDOW_REC *window;

	if (*data == '\0') cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);

	if (is_numeric(data, '\0')) {
                window = window_find_refnum(atoi(data));
		if (window == NULL) {
			printformat_window(active_win, MSGLEVEL_CLIENTERROR,
					   TXT_REFNUM_NOT_FOUND, data);
		}
	} else {
		window = window_find_item(active_win->active_server, data);
	}

	if (window == NULL || is_window_visible(window))
		return;

	if (WINDOW_GUI(window)->parent->sticky_windows != NULL) {
		printformat_window(active_win, MSGLEVEL_CLIENTERROR,
				   TXT_CANT_SHOW_STICKY_WINDOWS);
                return;
	}

	parent = mainwindow_create();
	if (settings_get_bool("autostick_split_windows")) {
		parent->sticky_windows =
			g_slist_append(parent->sticky_windows, window);
	}
        parent->active = window;
        gui_window_reparent(window, parent);

	active_mainwin = NULL;
	window_set_active(window);
}

/* SYNTAX: WINDOW UP */
static void cmd_window_up(void)
{
	MAIN_WINDOW_REC *rec;

	rec = mainwindows_find_upper(active_mainwin->first_line);
	if (rec != NULL)
		window_set_active(rec->active);
}

/* SYNTAX: WINDOW DOWN */
static void cmd_window_down(void)
{
	MAIN_WINDOW_REC *rec;

	rec = mainwindows_find_lower(active_mainwin->last_line);
	if (rec != NULL)
		window_set_active(rec->active);
}

/* SYNTAX: WINDOW LEFT */
static void cmd_window_left(const char *data, SERVER_REC *server, void *item)
{
        MAIN_WINDOW_REC *parent;
        WINDOW_REC *window;
	int pos, num;

        window = NULL;
	if (active_mainwin->sticky_windows == NULL) {
		/* no sticky windows, go to previous non-sticky window */
                num = active_win->refnum;
		do {
			num = window_refnum_prev(num, TRUE);
			if (num < 0) {
                                window = NULL;
				break;
			}
                        window = window_find_refnum(num);
			parent = WINDOW_GUI(window)->parent;
		} while (g_slist_find(parent->sticky_windows, window) != NULL);
	} else {
		pos = g_slist_index(active_mainwin->sticky_windows,
				    active_win);
		if (pos > 0) {
			window = g_slist_nth_data(
					active_mainwin->sticky_windows, pos-1);
		} else {
			window = g_slist_last(
					active_mainwin->sticky_windows)->data;
		}
	}

        if (window != NULL)
		window_set_active(window);
}

/* SYNTAX: WINDOW RIGHT */
static void cmd_window_right(void)
{
        MAIN_WINDOW_REC *parent;
	WINDOW_REC *window;
        GSList *tmp;
	int num;

        window = NULL;
	if (active_mainwin->sticky_windows == NULL) {
		/* no sticky windows, go to next non-sticky window */
                num = active_win->refnum;
		do {
			num = window_refnum_next(num, TRUE);
			if (num < 0) {
                                window = NULL;
				break;
			}
                        window = window_find_refnum(num);
			parent = WINDOW_GUI(window)->parent;
		} while (g_slist_find(parent->sticky_windows, window) != NULL);
	} else {
		tmp = g_slist_find(active_mainwin->sticky_windows, active_win);
		if (tmp != NULL) {
			window = tmp->next != NULL ? tmp->next->data :
				active_mainwin->sticky_windows->data;
		}
	}

        if (window != NULL)
		window_set_active(window);
}

static void mainwindow_change_window(MAIN_WINDOW_REC *mainwin,
				     WINDOW_REC *window)
{
	MAIN_WINDOW_REC *parent;
	GSList *tmp;

	if (mainwin->sticky_windows != NULL) {
		/* sticky window */
		window_set_active(mainwin->sticky_windows->data);
                return;
	}

	for (tmp = windows; tmp != NULL; tmp = tmp->next) {
		WINDOW_REC *rec = tmp->data;

                parent = WINDOW_GUI(rec)->parent;
		if (rec != window &&
		    g_slist_find(parent->sticky_windows, rec) == NULL) {
                        window_set_active(rec);
                        return;
		}
	}

        /* no more non-sticky windows, remove main window */
        mainwindow_destroy(mainwin);
}

/* SYNTAX: WINDOW STICK [ON|OFF|<ref#>] */
static void cmd_window_stick(const char *data)
{
	MAIN_WINDOW_REC *window = active_mainwin;

	if (is_numeric(data, '\0')) {
		WINDOW_REC *win = window_find_refnum(atoi(data));
		if (win == NULL) {
			printformat_window(active_win, MSGLEVEL_CLIENTERROR,
					   TXT_REFNUM_NOT_FOUND, data);
			return;
		}
                window = WINDOW_GUI(win)->parent;
	}

	if (g_strncasecmp(data, "OF", 2) == 0 || toupper(*data) == 'N') {
		/* unset sticky */
		if (g_slist_find(window->sticky_windows, active_win) == NULL) {
			printformat_window(active_win, MSGLEVEL_CLIENTERROR,
					   TXT_WINDOW_NOT_STICKY);
		} else {
			window->sticky_windows =
				g_slist_remove(window->sticky_windows,
					       active_win);
			printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
					   TXT_WINDOW_UNSET_STICKY);
		}
	} else {
                /* set sticky */
		active_mainwin->sticky_windows =
			g_slist_remove(active_mainwin->sticky_windows,
				       active_win);

		if (g_slist_find(window->sticky_windows, active_win) == NULL) {
			window->sticky_windows =
				g_slist_append(window->sticky_windows,
					       active_win);
		}
		if (window != active_mainwin) {
                        WINDOW_REC *movewin;

                        movewin = active_win;
			gui_window_reparent(movewin, window);
                        mainwindow_change_window(active_mainwin, movewin);

			active_mainwin = window;
                        window_set_active(movewin);
		}

		printformat_window(active_win, MSGLEVEL_CLIENTNOTICE,
				   TXT_WINDOW_SET_STICKY);
	}
}

void mainwindows_init(void)
{
	screen_width = COLS;
	screen_height = LINES;

	mainwindows = NULL;
	active_mainwin = NULL;
	reserved_up = reserved_down = 0;

	/* for entry line */
	mainwindows_reserve_lines(1, FALSE);

	command_bind("window grow", NULL, (SIGNAL_FUNC) cmd_window_grow);
	command_bind("window shrink", NULL, (SIGNAL_FUNC) cmd_window_shrink);
	command_bind("window size", NULL, (SIGNAL_FUNC) cmd_window_size);
	command_bind("window balance", NULL, (SIGNAL_FUNC) cmd_window_balance);
	command_bind("window hide", NULL, (SIGNAL_FUNC) cmd_window_hide);
	command_bind("window show", NULL, (SIGNAL_FUNC) cmd_window_show);
	command_bind("window up", NULL, (SIGNAL_FUNC) cmd_window_up);
	command_bind("window down", NULL, (SIGNAL_FUNC) cmd_window_down);
	command_bind("window left", NULL, (SIGNAL_FUNC) cmd_window_left);
	command_bind("window right", NULL, (SIGNAL_FUNC) cmd_window_right);
	command_bind("window stick", NULL, (SIGNAL_FUNC) cmd_window_stick);
}

void mainwindows_deinit(void)
{
	while (mainwindows != NULL)
		mainwindow_destroy(mainwindows->data);

	command_unbind("window grow", (SIGNAL_FUNC) cmd_window_grow);
	command_unbind("window shrink", (SIGNAL_FUNC) cmd_window_shrink);
	command_unbind("window size", (SIGNAL_FUNC) cmd_window_size);
	command_unbind("window balance", (SIGNAL_FUNC) cmd_window_balance);
	command_unbind("window hide", (SIGNAL_FUNC) cmd_window_hide);
	command_unbind("window show", (SIGNAL_FUNC) cmd_window_show);
	command_unbind("window up", (SIGNAL_FUNC) cmd_window_up);
	command_unbind("window down", (SIGNAL_FUNC) cmd_window_down);
	command_unbind("window left", (SIGNAL_FUNC) cmd_window_left);
	command_unbind("window right", (SIGNAL_FUNC) cmd_window_right);
	command_unbind("window stick", (SIGNAL_FUNC) cmd_window_stick);
}