path: root/app/wlib/gtklib/gtkwindow.c

/** \file gtkwindow.c
 * Basic window handling stuff.
 *
 * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/wlib/gtklib/gtkwindow.c,v 1.12 2010-04-28 04:04:38 dspagnol Exp $
 */

/*  XTrkCad - Model Railroad CAD
 *  Copyright (C) 2005 Dave Bullis
 *
 *  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 <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>

#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>

#include "gtkint.h"

wWin_p gtkMainW;

#define FOUR	(4)
#define MENUH	(24)

#define MIN_WIN_WIDTH (50)
#define MIN_WIN_HEIGHT (50)

#define SECTIONWINDOWSIZE  "gtklib window size"
#define SECTIONWINDOWPOS   "gtklib window pos"

extern wBool_t listHelpStrings;
		
static wControl_p firstWin = NULL, lastWin;
static int keyState;
static wBool_t gtkBlockEnabled = TRUE;

/*
 *****************************************************************************
 *
 * Window Utilities
 *
 *****************************************************************************
 */

/**
 * Get the window size from the resource (.rc) file.  The size is saved under the key 
 * SECTIONWINDOWSIZE.window name
 *
 * \param win IN window
 * \param nameStr IN window name
 */

static void getWinSize( wWin_p win, const char * nameStr )
{
	int w, h;
	const char *cp;
    char *cp1, *cp2;

	if ( (win->option&F_RESIZE) &&
		 (win->option&F_RECALLPOS) &&
		 (cp = wPrefGetString( SECTIONWINDOWSIZE, nameStr)) &&
		 (w = strtod( cp, &cp1 ), cp != cp1) &&
		 (h = strtod( cp1, &cp2 ), cp1 != cp2) ) {
		if (w < 10)
			w = 10;
		if (h < 10)
			h = 10;
		win->w = win->origX = w;
		win->h = win->origY = h;
		win->option &= ~F_AUTOSIZE;
	}
}

/**
 * Save the window size to the resource (.rc) file.  The size is saved under the key 
 * SECTIONWINDOWSIZE.window name
 *
 * \param win IN window
 */

static void saveSize( wWin_p win )
{
	char pos_s[20];
	if ( (win->option&F_RESIZE) &&
		 (win->option&F_RECALLPOS) &&
		 GTK_WIDGET_VISIBLE( GTK_WIDGET(win->gtkwin) ) ) {
		sprintf( pos_s, "%d %d", win->w, win->h-(FOUR + ((win->option&F_MENUBAR)?MENUH:0) ) );
		wPrefSetString( SECTIONWINDOWSIZE, win->nameStr, pos_s );
	}
}

/**
 * Get the window position from the resource (.rc) file.  The position is saved under the key 
 * SECTIONWINDOWPOS.window name
 *
 * \param win IN window
 */

static void getPos( wWin_p win )
{
	int x, y;
	const char *cp;
    char *cp1, *cp2;
	wPos_t gtkDisplayWidth = gdk_screen_width();
	wPos_t gtkDisplayHeight = gdk_screen_height();

	if ( (win->option&F_RECALLPOS) &&
			(!win->shown) ) {
		if ((cp = wPrefGetString( SECTIONWINDOWPOS, win->nameStr))) {
			x = strtod( cp, &cp1 );
			if (cp == cp1)
				return;
			y = strtod( cp1, &cp2 );
			if (cp2 == cp1)
				return;
			if ( y > gtkDisplayHeight-win->h )
				y = gtkDisplayHeight-win->h;
			if ( x > gtkDisplayWidth-win->w )
				x = gtkDisplayWidth-win->w;
			if ( x <= 0 )
				x = 1;
			if ( y <= 0 )
				y = 1;
			gtk_window_move( GTK_WINDOW(win->gtkwin), x, y );
			gtk_window_resize( GTK_WINDOW(win->gtkwin), win->w, win->h );
		}
	}
}

/**
 * Save the window position to the resource (.rc) file.  The position is saved under the key 
 * SECTIONWINDOWPOS.window name
 *
 * \param win IN window
 */

static void savePos( wWin_p win )
{
	int x, y;
	char pos_s[20];
	if ( (win->option&F_RECALLPOS) ) {
		gdk_window_get_position( GTK_WIDGET(win->gtkwin)->window, &x, &y );
		x -= 5;
		y -= 25;
		sprintf( pos_s, "%d %d", x, y );
		wPrefSetString( SECTIONWINDOWPOS, win->nameStr, pos_s );
	}
}

/**
 * Returns the dimensions of <win>.
 *
 * \param win IN window handle
 * \param width OUT width of window
 * \param height OUT height of window minus menu bar size
 */

EXPORT void wWinGetSize(
		wWin_p win,		/* Window */
		wPos_t * width,		/* Returned window width */
		wPos_t * height )	/* Returned window height */
{
	GtkRequisition requisition;
	wPos_t w, h;
	gtk_widget_size_request( win->gtkwin, &requisition );
	w = win->w;
	h = win->h;
	if ( win->option&F_AUTOSIZE ) {
		if ( win->realX > w )
			w = win->realX;
		if ( win->realY > h )
			h = win->realY;
	}
	*width = w;
	*height = h - FOUR - ((win->option&F_MENUBAR)?MENUH:0);
}

/**
 * Sets the dimensions of <w> to <widht> and <height>.
 *
 * \param win IN window
 * \param width IN new width
 * \param height IN new height
 */

EXPORT void wWinSetSize(
		wWin_p win,		/* Window */
		wPos_t width,		/* Window width */
		wPos_t height )		/* Window height */
{
	win->busy = TRUE;
	win->w = width;
	win->h = height + FOUR + ((win->option&F_MENUBAR)?MENUH:0);
	gtk_widget_set_size_request( win->gtkwin, win->w, win->h );
	gtk_widget_set_size_request( win->widget, win->w, win->h ); 
	win->busy = FALSE;

}

/**
 * Shows or hides window <win>. If <win> is created with 'F_BLOCK' option then the applications other
 * windows are disabled and 'wWinShow' doesnot return until the window <win> is closed by calling 
 * 'wWinShow(<win>,FALSE)'.
 *
 * \param win IN window
 * \param show IN visibility state
 */

EXPORT void wWinShow(
		wWin_p win,		/* Window */
		wBool_t show )		/* Command */
{
	GtkRequisition requisition;
	if (debugWindow >= 2) printf("Set Show %s\n", win->labelStr?win->labelStr:"No label" );
	if (win->widget == 0) abort();
	if (show) {
		keyState = 0;
		getPos( win );
		if ( win->option & F_AUTOSIZE ) {
			gtk_widget_size_request( win->gtkwin, &requisition );
			if ( requisition.width != win->w || requisition.height != win->h ) {
				gtk_widget_set_size_request( win->gtkwin, win->w, win->h );
				gtk_widget_set_size_request( win->widget, win->w, win->h );
				if (win->option&F_MENUBAR) {
					gtk_widget_set_size_request( win->menubar, win->w, MENUH );
				}
			}
		}
		if ( !win->shown ) {
			gtk_widget_show( win->gtkwin );
			gtk_widget_show( win->widget );
		}
		gdk_window_raise( win->gtkwin->window );
		if ( win->shown && win->modalLevel > 0 )
			gtk_widget_set_sensitive( GTK_WIDGET(win->gtkwin), TRUE );
		win->shown = show;
		win->modalLevel = 0;

		if ( (!gtkBlockEnabled) || (win->option & F_BLOCK) == 0) {
			wFlush();
		} else {
			gtkDoModal( win, TRUE );
		}
	} else {
		wFlush();
		saveSize( win );
		savePos( win );
		win->shown = show;
		if ( gtkBlockEnabled && (win->option & F_BLOCK) != 0) {
			gtkDoModal( win, FALSE );
		}
		gtk_widget_hide( win->gtkwin );
		gtk_widget_hide( win->widget );
	}
}

/**
 * Block windows against user interactions. Done during demo mode etc.
 *
 * \param enabled IN blocked if TRUE
 */

EXPORT void wWinBlockEnable(
		wBool_t enabled )
{
	gtkBlockEnabled = enabled;
}

/**
 * Returns whether the window is visible.
 *
 * \param win IN window
 * \return    TRUE if visible, FALSE otherwise
 */

EXPORT wBool_t wWinIsVisible(
		wWin_p win )
{
	return win->shown;
}

/**
 * Sets the title of <win> to <title>.
 *
 * \param varname1 IN window
 * \param varname2 IN new title
 */

EXPORT void wWinSetTitle(
		wWin_p win,		/* Window */
		const char * title )		/* New title */
{
	gtk_window_set_title( GTK_WINDOW(win->gtkwin), title );
}

/**
 * Sets the window <win> to busy or not busy. Sets the cursor accordingly
 *
 * \param varname1 IN window
 * \param varname2 IN TRUE if busy, FALSE otherwise
 */

EXPORT void wWinSetBusy(
		wWin_p win,		/* Window */
		wBool_t busy )		/* Command */
{
	GdkCursor * cursor;
	if (win->gtkwin == 0) abort();
	if ( busy )
		cursor = gdk_cursor_new ( GDK_WATCH );
	else
		cursor = NULL;
	gdk_window_set_cursor (win->gtkwin->window, cursor);
	if ( cursor )
		gdk_cursor_destroy (cursor);   
	gtk_widget_set_sensitive( GTK_WIDGET(win->gtkwin), busy==0 );
}


EXPORT void gtkDoModal(
		wWin_p win0,
		wBool_t modal )
{
	wWin_p win;
	for ( win=(wWin_p)firstWin; win; win=(wWin_p)win->next ) {
		if ( win->shown && win != win0 ) {
			if ( modal ) {
				if ( win->modalLevel == 0 )
					gtk_widget_set_sensitive( GTK_WIDGET(win->gtkwin), FALSE );
				win->modalLevel++;
			} else {
				if ( win->modalLevel > 0 ) {
					win->modalLevel--;
					if ( win->modalLevel == 0 )
						gtk_widget_set_sensitive( GTK_WIDGET(win->gtkwin), TRUE );
				}
			}
			if ( win->modalLevel < 0 ) {
				fprintf( stderr, "DoModal: %s modalLevel < 0", win->nameStr?win->nameStr:"<NULL>" );
				abort();
			}
		}
	}
	if ( modal ) {
		gtk_main();
	} else {
		gtk_main_quit();
	}
}

/**
 * Returns the Title of <win>.
 *
 * \param win IN window
 * \return    pointer to window title
 */

EXPORT const char * wWinGetTitle(
	 wWin_p win )			/* Window */
{
	return win->labelStr;
}


EXPORT void wWinClear(
		wWin_p win,
		wPos_t x,
		wPos_t y,
		wPos_t width,
		wPos_t height )
{
}


EXPORT void wWinDoCancel(
		wWin_p win )
{
	wControl_p b;
	for (b=win->first; b; b=b->next) {
		if ((b->type == B_BUTTON) && (b->option & BB_CANCEL) ) {
			gtkButtonDoAction( (wButton_p)b );
		}
	}
}

/*
 ******************************************************************************
 *
 * Call Backs
 *
 ******************************************************************************
 */

static gint window_delete_event(
		GtkWidget *widget,
		GdkEvent *event,
		wWin_p win )
{
	wControl_p b;
	/* if you return FALSE in the "delete_event" signal handler,
	 * GTK will emit the "destroy" signal.  Returning TRUE means
	 * you don't want the window to be destroyed.
	 * This is useful for popping up 'are you sure you want to quit ?'
	 * type dialogs. */

	/* Change TRUE to FALSE and the main window will be destroyed with
	 * a "delete_event". */

	for ( b = win->first; b; b=b->next )
		if (b->doneProc)
			b->doneProc( b );
	if (win->winProc) {
		win->winProc( win, wClose_e, win->data );
		if (win != gtkMainW)
			wWinShow( win, FALSE );
	}
	return (TRUE);
}

static int window_redraw(
		wWin_p win,
		wBool_t doWinProc )
{
	wControl_p b;

	if (win==NULL)
		return FALSE;

	for (b=win->first; b != NULL; b = b->next) {
		if (b->repaintProc)
			b->repaintProc( b );
	}

	return FALSE;
}

static int fixed_expose_event(
		GtkWidget * widget,
		GdkEventExpose * event,
		wWin_p win )
{
	if (event->count==0)
		return window_redraw( win, TRUE );
	else
		return FALSE;
}

static int window_configure_event(
		GtkWidget * widget,
		GdkEventConfigure * event,
		wWin_p win )
{
	wPos_t h;

	if (win==NULL)
		return FALSE;

	h = event->height - FOUR;
	if (win->option&F_MENUBAR)
		h -= MENUH;
	if (win->option&F_RESIZE) {
		if ( event->width < 10 || event->height < 10 )
			return TRUE;
		if (win->w != event->width || win->h != event->height) {
			win->w = event->width;
			win->h = event->height;
			if ( win->w < MIN_WIN_WIDTH )
				win->w = MIN_WIN_WIDTH;
			if ( win->h < MIN_WIN_HEIGHT )
				win->h = MIN_WIN_HEIGHT;
			if (win->option&F_MENUBAR)
				gtk_widget_set_size_request( win->menubar, win->w, MENUH ); 

			if (win->busy==FALSE && win->winProc) {
				win->winProc( win, wResize_e, win->data );
			}
		}
	} 
	return FALSE;
}

/**
 * Get current state of shift, ctrl or alt keys.
 *
 * \return    or'ed value of WKEY_SHIFT, WKEY_CTRL and WKEY_ALT depending on state
 */

int wGetKeyState( void )
{
	return keyState;
}

wBool_t catch_shift_ctrl_alt_keys(
		GtkWidget * widget,
		GdkEventKey *event,
		void * data )
{
	int state;

	state = 0;
	switch (event->keyval) {
	case GDK_Shift_L:
	case GDK_Shift_R:
		state |= WKEY_SHIFT;
		break;
	case GDK_Control_L:
	case GDK_Control_R:
		state |= WKEY_CTRL;
		break;
	case GDK_Alt_L:
	case GDK_Alt_R:
		state |= WKEY_ALT;
		break;
	}
	if ( state != 0 ) {
		if (event->type == GDK_KEY_PRESS)
			keyState |= state;
		else
			keyState &= ~state;
		return TRUE;
	}
	return FALSE;
}
		
static gint window_char_event(
		GtkWidget * widget,
		GdkEventKey *event,
		wWin_p win )
{
	wControl_p bb;
	if ( catch_shift_ctrl_alt_keys( widget, event, win ) )
		return FALSE;
	if (event->type == GDK_KEY_RELEASE)
		return FALSE;

	if ( event->state == 0 ) {
		if ( event->keyval == GDK_Escape ) {
			for ( bb=win->first; bb; bb=bb->next ) {
				if ( bb->type == B_BUTTON && (bb->option&BB_CANCEL) ) {
					gtkButtonDoAction( (wButton_p)bb );
					return TRUE;
				}
			}
		}
	}
	if ( gtkHandleAccelKey( event ) ) {
		return TRUE;
	} else {
		return FALSE;
	}
}


/*
 *******************************************************************************
 *
 * Main and Popup Windows
 *
 *******************************************************************************
 */



static wWin_p wWinCommonCreate(
		wWin_p parent,
		int winType,
		wPos_t x,
		wPos_t y,
		const char * labelStr,
		const char * nameStr,
		long option,
		wWinCallBack_p winProc,
		void * data )
{
	wWin_p w;
	int h;

	w = gtkAlloc( NULL, winType, x, y, labelStr, sizeof *w, data );
	w->busy = TRUE;
	w->option = option;
	getWinSize( w, nameStr );

	h = FOUR;
	if (w->option&F_MENUBAR)
		h += MENUH;

	if ( winType == W_MAIN ) {
		w->gtkwin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
	} else {
		w->gtkwin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
		if ( gtkMainW )
			gtk_window_set_transient_for( GTK_WINDOW(w->gtkwin), GTK_WINDOW(gtkMainW->gtkwin) );
	}
	
	if( option & F_HIDE )
		gtk_widget_hide( w->gtkwin );

	/* center window on top of parent window */
	if( option & F_CENTER )
		gtk_window_set_position(GTK_WINDOW(w->gtkwin), GTK_WIN_POS_CENTER_ON_PARENT );
				
	w->widget = gtk_fixed_new();
	if (w->widget == 0) abort();

	if (w->option&F_MENUBAR) {
		w->menubar = gtk_menu_bar_new();
		gtk_container_add( GTK_CONTAINER(w->widget), w->menubar );
		gtk_widget_show( w->menubar );
		gtk_widget_set_size_request( w->menubar, -1, MENUH );
	}

	gtk_container_add( GTK_CONTAINER(w->gtkwin), w->widget );

	if (w->option&F_AUTOSIZE) {
		w->realX = 0;
		w->w = 0;
		w->realY = h;
		w->h = 0;
	} else {
		w->w = w->realX = w->origX;
		w->h = w->realY = w->origY+h;
		gtk_widget_set_size_request( w->gtkwin, w->w, w->h );
		gtk_widget_set_size_request( w->widget, w->w, w->h );
		if (w->option&F_MENUBAR) {
			gtk_widget_set_size_request( w->menubar, w->w, MENUH );
		}
	}

	w->first = w->last = NULL;

	w->winProc = winProc;

	gtk_signal_connect (GTK_OBJECT (w->gtkwin), "delete_event",
						GTK_SIGNAL_FUNC (window_delete_event), w);
	gtk_signal_connect (GTK_OBJECT (w->widget), "expose_event",
						GTK_SIGNAL_FUNC (fixed_expose_event), w);
	gtk_signal_connect (GTK_OBJECT (w->gtkwin), "configure_event",
						GTK_SIGNAL_FUNC (window_configure_event), w); 
	gtk_signal_connect (GTK_OBJECT (w->gtkwin), "key_press_event",
						GTK_SIGNAL_FUNC (window_char_event), w);
	gtk_signal_connect (GTK_OBJECT (w->gtkwin), "key_release_event",
						GTK_SIGNAL_FUNC (window_char_event), w);
	gtk_widget_set_events (w->widget, GDK_EXPOSURE_MASK );
	gtk_widget_set_events ( GTK_WIDGET(w->gtkwin), GDK_EXPOSURE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK );

	/**
     * \todo { set_policy is deprecated and should be replaced by set_resizable. In order to do that
     * the library has to be cleared up from calls to set_size_request as these set the minimum widget size 
     * to the current size preventing the user from re-sizing the window to a smaller size. At least this
     * is my current assumption ;-) }
     */
	if (w->option & F_RESIZE) {
		gtk_window_set_policy( GTK_WINDOW(w->gtkwin), TRUE, TRUE, TRUE );
//		gtk_window_set_resizable( GTK_WINDOW(w->gtkwin), TRUE );
	} else {
//		gtk_window_set_resizable( GTK_WINDOW(w->gtkwin), FALSE );
		gtk_window_set_policy( GTK_WINDOW(w->gtkwin), FALSE, FALSE, TRUE );
	}
	
	w->lastX = 0;
	w->lastY = h;
	w->shown = FALSE;
	w->nameStr = nameStr?strdup( nameStr ):NULL;
	if (labelStr)
		gtk_window_set_title( GTK_WINDOW(w->gtkwin), labelStr );
	if (listHelpStrings)
		printf( "WINDOW - %s\n", nameStr?nameStr:"<NULL>" );

	if (firstWin) {
		lastWin->next = (wControl_p)w;
	} else {
		firstWin = (wControl_p)w;
	}
	lastWin = (wControl_p)w;
	gtk_widget_show( w->widget );
	gtk_widget_realize( w->gtkwin );

	w->busy = FALSE;
	return w;
}

/**
 * \todo { investigate and implement this function for setting the correct icon as necessary.
 * It looks like these functions are never called at the moment. }
 */

EXPORT void wWinSetBigIcon(
		wWin_p win,		/* Main window */
		wIcon_p ip )		/* The icon */
/*
Create an Icon from a X-bitmap.
*/
{
#ifdef LATER
	GdkPixmap * pixmap;
	GdkBitmap * mask;
	pixmap = gtkMakeIcon( win->gtkwin, ip, &mask );
	gdk_window_set_icon( win->gtkwin->window, NULL, pixmap, mask );
	gdk_pixmap_unref( pixmap );
	gdk_bitmap_unref( mask );
#endif
}


/**
 * \todo { investigate and implement this function for setting the correct icon as necessary.
 * It looks like these functions are never called at the moment. }
 */


EXPORT void wWinSetSmallIcon(
		wWin_p win,		/* Main window */
		wIcon_p ip )		/* The icon */
/*
Create an Icon from a X-bitmap.
*/
{
	GdkBitmap * mask;
	if ( ip->gtkIconType == gtkIcon_bitmap ) {
		mask = gdk_bitmap_create_from_data( win->gtkwin->window, ip->bits, ip->w, ip->h );
		gdk_window_set_icon( win->gtkwin->window, NULL, mask, mask );
		/*gdk_bitmap_unref( mask );*/
	}
}

/**
 * Initialize the application's main window. This function does the necessary initialization 
 * of the application including creation of the main window.
 *
 * \param name IN internal name of the application. Used for filenames etc. 
 * \param x    IN Initial window width
 * \param y    IN Initial window height
 * \param helpStr IN Help topic string
 * \param labelStr IN window title
 * \param nameStr IN Window name
 * \param option IN options for window creation
 * \param winProc IN pointer to main window procedure
 * \param data IN User context
 * \return    window handle or NULL on error
 */

EXPORT wWin_p wWinMainCreate(
		const char * name,		/* Application name */
		wPos_t x,				/* Initial window width */
		wPos_t y,				/* Initial window height */
		const char * helpStr,	/* Help topic string */
		const char * labelStr,	/* Window title */
		const char * nameStr,	/* Window name */
		long option,			/* Options */
		wWinCallBack_p winProc,	/* Call back function */
		void * data )			/* User context */
{
	char *pos;

	if( pos = strchr( name, ';' )) {
		/* if found, split application name and configuration name */
		strcpy( wConfigName, pos + 1 );
	} else {
		/* if not found, application name and configuration name are same */
		strcpy( wConfigName, name );
	}

	gtkMainW = wWinCommonCreate( NULL, W_MAIN, x, y, labelStr, nameStr, option, winProc, data );

	wDrawColorWhite = wDrawFindColor( 0xFFFFFF );
	wDrawColorBlack = wDrawFindColor( 0x000000 );

	gdk_window_set_group( gtkMainW->gtkwin->window, gtkMainW->gtkwin->window );
	return gtkMainW;
}

/**
 * Create a new popup window.
 *
 * \param parent IN Parent window (may be NULL)
 * \param x IN Initial window width
 * \param y IN Initial window height
 * \param helpStr IN Help topic string
 * \param labelStr IN Window title
 * \param nameStr IN Window name
 * \param option IN Options
 * \param winProc IN call back function
 * \param data IN User context information
 * \return    handle for new window
 */

EXPORT wWin_p wWinPopupCreate(
		wWin_p parent,		
		wPos_t x,		
		wPos_t y,		
		const char * helpStr,
		const char * labelStr,
		const char * nameStr,
		long option,	
		wWinCallBack_p winProc,
		void * data )		
{
	wWin_p win;

	if (parent == NULL) {
		if (gtkMainW == NULL)
			abort();
		parent = gtkMainW;
	}
	win = wWinCommonCreate( parent, W_POPUP, x, y, labelStr, nameStr, option, winProc, data );
	gdk_window_set_group( win->gtkwin->window, gtkMainW->gtkwin->window );

	return win;
}


/**
 * Terminates the applicaton with code <rc>. Before closing the main window
 * call back is called with wQuit_e. The program is terminated without exiting
 * the main message loop.
 *
 * \param rc IN exit code
 * \return    never returns
 */


EXPORT void wExit(
		int rc )		/* Application return code */
{
	wWin_p win;
	for ( win = (wWin_p)firstWin; win; win = (wWin_p)win->next ) {
		if ( GTK_WIDGET_VISIBLE( GTK_WIDGET(win->gtkwin) ) ) {
			saveSize( win );
			savePos( win );
		}
	}
	wPrefFlush();
	if (gtkMainW && gtkMainW->winProc != NULL)
		gtkMainW->winProc( gtkMainW, wQuit_e, gtkMainW->data );
	
	exit( rc );
}