Initial import of xtrkcad version 1:4.0.2-2

1 files changed, 978 insertions, 0 deletions

diff --git a/app/bin/dlayer.c b/app/bin/dlayer.c
new file mode 100644
index 0000000..17d787c
--- /dev/null
+++ b/app/bin/dlayer.c
@@ -0,0 +1,978 @@
+/** \file dlayer.c
+ * Functions and dialogs for handling layers.
+ *
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/dlayer.c,v 1.9 2009-06-15 19:29:57 m_fischer Exp $
+ */
+
+/*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2005 Dave Bullis and (C) 2007 Martin Fischer
+ *
+ *  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 <assert.h>
+
+#include "track.h"
+#include "i18n.h"
+
+#include <stdint.h>
+
+
+/*****************************************************************************
+ *
+ * LAYERS
+ *
+ */
+
+#define NUM_BUTTONS		(20)
+#define LAYERPREF_FROZEN  (1)
+#define LAYERPREF_ONMAP	  (2)
+#define LAYERPREF_VISIBLE (4)
+#define LAYERPREF_SECTION ("Layers")
+#define LAYERPREF_NAME 	"name"
+#define LAYERPREF_COLOR "color"
+#define LAYERPREF_FLAGS "flags"
+
+EXPORT LAYER_T curLayer;
+EXPORT long layerCount = 10;
+static long newLayerCount = 10;
+static LAYER_T layerCurrent = NUM_LAYERS;
+
+
+static BOOL_T layoutLayerChanged = FALSE;
+
+static wIcon_p show_layer_bmps[NUM_BUTTONS];		
+/*static wIcon_p hide_layer_bmps[NUM_BUTTONS]; */
+static wButton_p layer_btns[NUM_BUTTONS];	/**< layer buttons on toolbar */
+
+/** Layer selector on toolbar */
+static wList_p setLayerL;				
+
+/*static wMessage_p layerNumM;*/
+/** Describe the properties of a layer */
+typedef struct {
+		char name[STR_SHORT_SIZE];		/**< Layer name */
+		wDrawColor color;					/**< layer color, is an index into a color table */
+		BOOL_T frozen;						/**< Frozen flag */
+		BOOL_T visible;					/**< visible flag */
+		BOOL_T onMap;						/**< is layer shown map */
+		long objCount;						/**< number of objects on layer */
+		} layer_t;
+		
+static layer_t layers[NUM_LAYERS];
+static layer_t *layers_save = NULL;
+
+
+static int oldColorMap[][3] = {
+		{ 255, 255, 255 },		/* White */
+		{   0,   0,   0 },      /* Black */
+		{ 255,   0,   0 },      /* Red */
+		{   0, 255,   0 },      /* Green */
+		{   0,   0, 255 },      /* Blue */
+		{ 255, 255,   0 },      /* Yellow */
+		{ 255,   0, 255 },      /* Purple */
+		{   0, 255, 255 },      /* Aqua */
+		{ 128,   0,   0 },      /* Dk. Red */
+		{   0, 128,   0 },      /* Dk. Green */
+		{   0,   0, 128 },      /* Dk. Blue */
+		{ 128, 128,   0 },      /* Dk. Yellow */
+		{ 128,   0, 128 },      /* Dk. Purple */
+		{   0, 128, 128 },      /* Dk. Aqua */
+		{  65, 105, 225 },      /* Royal Blue */
+		{   0, 191, 255 },      /* DeepSkyBlue */
+		{ 125, 206, 250 },      /* LightSkyBlue */
+		{  70, 130, 180 },      /* Steel Blue */
+		{ 176, 224, 230 },      /* Powder Blue */
+		{ 127, 255, 212 },      /* Aquamarine */
+		{  46, 139,  87 },      /* SeaGreen */
+		{ 152, 251, 152 },      /* PaleGreen */
+		{ 124, 252,   0 },      /* LawnGreen */
+		{  50, 205,  50 },      /* LimeGreen */
+		{  34, 139,  34 },      /* ForestGreen */
+		{ 255, 215,   0 },      /* Gold */
+		{ 188, 143, 143 },      /* RosyBrown */
+		{ 139, 69, 19 },        /* SaddleBrown */
+		{ 245, 245, 220 },      /* Beige */
+		{ 210, 180, 140 },      /* Tan */
+		{ 210, 105, 30 },       /* Chocolate */
+		{ 165, 42, 42 },        /* Brown */
+		{ 255, 165, 0 },        /* Orange */
+		{ 255, 127, 80 },       /* Coral */
+		{ 255, 99, 71 },        /* Tomato */
+		{ 255, 105, 180 },      /* HotPink */
+		{ 255, 192, 203 },      /* Pink */
+		{ 176, 48, 96 },        /* Maroon */
+		{ 238, 130, 238 },      /* Violet */
+		{ 160, 32, 240 },       /* Purple */
+		{  16,  16,  16 },      /* Gray */
+		{  32,  32,  32 },      /* Gray */
+		{  48,  48,  48 },      /* Gray */
+		{  64,  64,  64 },      /* Gray */
+		{  80,  80,  80 },      /* Gray */
+		{  96,  96,  96 },      /* Gray */
+		{ 112, 112, 122 },      /* Gray */
+		{ 128, 128, 128 },      /* Gray */
+		{ 144, 144, 144 },      /* Gray */
+		{ 160, 160, 160 },      /* Gray */
+		{ 176, 176, 176 },      /* Gray */
+		{ 192, 192, 192 },      /* Gray */
+		{ 208, 208, 208 },      /* Gray */
+		{ 224, 224, 224 },      /* Gray */
+		{ 240, 240, 240 },      /* Gray */
+		{   0,   0,   0 }       /* BlackPixel */
+		};
+
+static void DoLayerOp( void * data );
+static void UpdateLayerDlg(void);
+/* static void LoadLayerLists(); */
+static void LayerSetCounts();
+static void InitializeLayers( void LayerInitFunc( void ), int newCurrLayer );
+static void LayerPrefSave( void );
+static void LayerPrefLoad( void );
+
+EXPORT BOOL_T GetLayerVisible( LAYER_T layer )
+{
+	if (layer < 0 || layer >= NUM_LAYERS)
+		return TRUE;
+	else
+		return layers[(int)layer].visible;
+}
+
+
+EXPORT BOOL_T GetLayerFrozen( LAYER_T layer )
+{
+	if (layer < 0 || layer >= NUM_LAYERS)
+		return TRUE;
+	else
+		return layers[(int)layer].frozen;
+}
+
+
+EXPORT BOOL_T GetLayerOnMap( LAYER_T layer )
+{
+	if (layer < 0 || layer >= NUM_LAYERS)
+		return TRUE;
+	else
+		return layers[(int)layer].onMap;
+}
+
+
+EXPORT char * GetLayerName( LAYER_T layer )
+{
+	if (layer < 0 || layer >= NUM_LAYERS)
+		return NULL;
+	else
+		return layers[(int)layer].name;
+}
+
+
+EXPORT void NewLayer( void )
+{
+}
+
+
+EXPORT wDrawColor GetLayerColor( LAYER_T layer )
+{
+	return layers[(int)layer].color;
+}
+
+
+static void FlipLayer( void * arg )
+{
+	LAYER_T l = (LAYER_T)(long)arg;
+	wBool_t visible;
+	if ( l < 0 || l >= NUM_LAYERS )
+		return;
+	if ( l == curLayer && layers[(int)l].visible) {
+		wButtonSetBusy( layer_btns[(int)l], layers[(int)l].visible );
+		NoticeMessage( MSG_LAYER_HIDE, _("Ok"), NULL );
+		return;
+	}
+	RedrawLayer( l, FALSE );
+	visible = !layers[(int)l].visible;
+	layers[(int)l].visible = visible;
+	if (l<NUM_BUTTONS) {
+		wButtonSetBusy( layer_btns[(int)l], visible != 0 );
+		wButtonSetLabel( layer_btns[(int)l], (char *)show_layer_bmps[(int)l]); 
+	}
+	RedrawLayer( l, TRUE );
+}
+
+static void SetCurrLayer( wIndex_t inx, const char * name, wIndex_t op, void * listContext, void * arg )
+{
+	LAYER_T newLayer = (LAYER_T)(long)inx;
+	if (layers[(int)newLayer].frozen) {
+		NoticeMessage( MSG_LAYER_SEL_FROZEN, _("Ok"), NULL );
+		wListSetIndex( setLayerL, curLayer );
+		return;
+	}
+	curLayer = newLayer;
+	
+	if ( curLayer < 0 || curLayer >= NUM_LAYERS )
+		curLayer = 0;
+	if ( !layers[(int)curLayer].visible )
+		FlipLayer( (void*)(intptr_t)inx );
+	if ( recordF )
+		fprintf( recordF, "SETCURRLAYER %d\n", inx );
+}
+
+static void PlaybackCurrLayer( char * line )
+{
+	wIndex_t layer;
+	layer = atoi(line);
+	wListSetIndex( setLayerL, layer );
+	SetCurrLayer( layer, NULL, 0, NULL, NULL );
+}
+
+/**
+ * Change the color of a layer.
+ *
+ * \param inx IN layer to change
+ * \param color IN new color
+ */
+
+static void SetLayerColor( int inx, wDrawColor color )
+{
+	if ( color != layers[inx].color ) {
+		if (inx < NUM_BUTTONS) {
+			wIconSetColor( show_layer_bmps[inx], color );
+			wButtonSetLabel( layer_btns[inx], (char*)show_layer_bmps[inx] ); 
+		}
+		layers[inx].color = color;
+		layoutLayerChanged = TRUE;
+	}
+}
+
+ 
+#include "bitmaps/l1.xbm"
+#include "bitmaps/l2.xbm"
+#include "bitmaps/l3.xbm"
+#include "bitmaps/l4.xbm"
+#include "bitmaps/l5.xbm"
+#include "bitmaps/l6.xbm"
+#include "bitmaps/l7.xbm"
+#include "bitmaps/l8.xbm"
+#include "bitmaps/l9.xbm"
+#include "bitmaps/l10.xbm"
+#include "bitmaps/l11.xbm"
+#include "bitmaps/l12.xbm"
+#include "bitmaps/l13.xbm"
+#include "bitmaps/l14.xbm"
+#include "bitmaps/l15.xbm"
+#include "bitmaps/l16.xbm"
+#include "bitmaps/l17.xbm"
+#include "bitmaps/l18.xbm"
+#include "bitmaps/l19.xbm"
+#include "bitmaps/l20.xbm"
+
+static char * show_layer_bits[NUM_BUTTONS] = { l1_bits, l2_bits, l3_bits, l4_bits, l5_bits, l6_bits, l7_bits, l8_bits, l9_bits, l10_bits,
+ l11_bits, l12_bits, l13_bits, l14_bits, l15_bits, l16_bits, l17_bits, l18_bits, l19_bits, l20_bits };
+ 
+static EXPORT long layerRawColorTab[] = {
+		wRGB(  0,  0,255),      /* blue */
+		wRGB(  0,  0,128),      /* dk blue */
+		wRGB(  0,128,  0),      /* dk green */
+		wRGB(255,255,  0),      /* yellow */
+		wRGB(  0,255,  0),      /* green */
+		wRGB(  0,255,255),      /* lt cyan */
+		wRGB(128,  0,  0),      /* brown */
+		wRGB(128,  0,128),      /* purple */
+		wRGB(128,128,  0),      /* green-brown */
+		wRGB(255,  0,255)};     /* lt-purple */
+static EXPORT wDrawColor layerColorTab[COUNT(layerRawColorTab)];
+
+
+static wWin_p layerW;
+static char layerName[STR_SHORT_SIZE];
+static wDrawColor layerColor;
+static long layerVisible = TRUE;
+static long layerFrozen = FALSE;
+static long layerOnMap = TRUE;
+static void LayerOk( void * );
+static BOOL_T layerRedrawMap = FALSE;
+
+#define ENUMLAYER_RELOAD (1)
+#define ENUMLAYER_SAVE	(2)
+#define ENUMLAYER_CLEAR (3)
+
+static char *visibleLabels[] = { "", NULL };
+static char *frozenLabels[] = { "", NULL };
+static char *onMapLabels[] = { "", NULL };
+static paramIntegerRange_t i0_20 = { 0, NUM_BUTTONS };
+
+static paramData_t layerPLs[] = {
+#define I_LIST	(0)
+	 { PD_DROPLIST, NULL, "layer", PDO_LISTINDEX|PDO_DLGNOLABELALIGN, (void*)250 },
+#define I_NAME	(1)
+	 { PD_STRING, layerName, "name", PDO_NOPREF, (void*)(250-54), N_("Name") },
+#define I_COLOR	(2)
+	 { PD_COLORLIST, &layerColor, "color", PDO_NOPREF, NULL, N_("Color") },
+#define I_VIS	(3)
+	 { PD_TOGGLE, &layerVisible, "visible", PDO_NOPREF, visibleLabels, N_("Visible"), BC_HORZ|BC_NOBORDER },
+#define I_FRZ	(4)
+	 { PD_TOGGLE, &layerFrozen, "frozen", PDO_NOPREF|PDO_DLGHORZ, frozenLabels, N_("Frozen"), BC_HORZ|BC_NOBORDER },
+#define I_MAP	(5)
+	 { PD_TOGGLE, &layerOnMap, "onmap", PDO_NOPREF|PDO_DLGHORZ, onMapLabels, N_("On Map"), BC_HORZ|BC_NOBORDER },
+#define I_COUNT (6)
+	 { PD_STRING, NULL, "object-count", PDO_NOPREF|PDO_DLGBOXEND, (void*)(80), N_("Count"), BO_READONLY },
+	 { PD_MESSAGE, N_("Personal Preferences"), NULL, PDO_DLGRESETMARGIN, (void *)180 },
+	 { PD_BUTTON, (void*)DoLayerOp, "reset", PDO_DLGRESETMARGIN, 0, N_("Load"), 0, (void *)ENUMLAYER_RELOAD },
+	 { PD_BUTTON, (void*)DoLayerOp, "save", PDO_DLGHORZ, 0, N_("Save"), 0, (void *)ENUMLAYER_SAVE }, 
+	 { PD_BUTTON, (void*)DoLayerOp, "clear", PDO_DLGHORZ | PDO_DLGBOXEND, 0, N_("Defaults"), 0, (void *)ENUMLAYER_CLEAR }, 	 
+	 { PD_LONG, &newLayerCount, "button-count", PDO_DLGBOXEND|PDO_DLGRESETMARGIN, &i0_20, N_("Number of Layer Buttons") },	 
+};
+
+static paramGroup_t layerPG = { "layer", 0, layerPLs, sizeof layerPLs/sizeof layerPLs[0] };
+
+#define layerL	((wList_p)layerPLs[I_LIST].control)
+
+/**
+ * Load the layer settings to hard coded system defaults
+ */
+ 
+void
+LayerSystemDefaults( void )
+{
+	int inx;
+	
+	for ( inx=0;inx<NUM_LAYERS; inx++ ) {
+		strcpy( layers[inx].name, inx==0?_("Main"):"" );
+		layers[inx].visible = TRUE;
+		layers[inx].frozen = FALSE;
+		layers[inx].onMap = TRUE;
+		layers[inx].objCount = 0;
+		SetLayerColor( inx, layerColorTab[inx%COUNT(layerColorTab)] );
+	}	
+}
+
+/**
+ * Load the layer listboxes in Manage Layers and the Toolbar with up-to-date information. 
+ */
+
+EXPORT void LoadLayerLists( void )
+{
+	int inx;
+	 
+	/* clear both lists */
+	wListClear(setLayerL);
+	if ( layerL ) 
+		wListClear(layerL);
+
+	/* add all layers to both lists */
+	for ( inx=0; inx<NUM_LAYERS; inx++ ) {
+
+		if ( layerL ) {
+			sprintf( message, "%2d %c %s", inx+1, layers[inx].objCount>0?'+':'-', layers[inx].name );
+			wListAddValue( layerL, message, NULL, NULL );
+		}
+		
+		sprintf( message, "%2d : %s", inx+1,  layers[inx].name );
+		wListAddValue( setLayerL, message, NULL, NULL );
+	}
+
+	/* set current layer to selected */
+	wListSetIndex( setLayerL, curLayer );
+	if ( layerL ) 
+		wListSetIndex( layerL, curLayer );		
+}
+
+/**
+ * Handle button presses for the layer dialog. For all button presses in the layer
+ *	dialog, this function is called. The parameter identifies the button pressed and
+ * the operation is performed. 
+ *
+ * \param[IN] data identifier for the button prerssed
+ * \return    
+ */
+
+static void DoLayerOp( void * data )
+{
+	switch((long)data ) {
+	
+	case ENUMLAYER_CLEAR:
+		InitializeLayers( LayerSystemDefaults, -1 );
+		break;
+	case ENUMLAYER_SAVE:
+		LayerPrefSave();	
+		break;
+	case ENUMLAYER_RELOAD:
+		LayerPrefLoad();
+		break;	
+	}
+	
+	UpdateLayerDlg();	
+	if( layoutLayerChanged ) {
+		MainProc( mainW, wResize_e, NULL );
+		layoutLayerChanged = FALSE;
+		changed = TRUE;
+		SetWindowTitle();
+	}	
+}
+
+/**
+ * Update all dialogs and dialog elements after changing layers preferences. Once the global array containing 
+ * the settings for the labels has been changed, this function needs to be called to update all the user interface
+ * elements to the new settings.
+ */
+
+static void 
+UpdateLayerDlg()
+{
+	int inx;
+	
+	/* update the globals for the layer dialog */
+  	layerVisible = layers[curLayer].visible;
+	layerFrozen = layers[curLayer].frozen;
+	layerOnMap = layers[curLayer].onMap;
+	layerColor = layers[curLayer].color;
+	strcpy( layerName, layers[curLayer].name );
+	layerCurrent = curLayer;
+	
+	/* now re-load the layer list boxes */
+	LoadLayerLists();
+	
+	sprintf( message, "%ld", layers[curLayer].objCount );
+	ParamLoadMessage( &layerPG, I_COUNT, message );
+
+	/* force update of the 'manage layers' dialogbox */
+	if( layerL )
+		ParamLoadControls( &layerPG );
+		
+	/* finally show the layer buttons with ballon text */
+	for( inx = 0; inx < NUM_BUTTONS; inx++ ) {
+		wButtonSetBusy( layer_btns[inx], layers[inx].visible != 0 );
+		wControlSetBalloonText( (wControl_p)layer_btns[inx], (layers[inx].name[0] != '\0' ? layers[inx].name :_("Show/Hide Layer") ));
+	}
+}
+
+/**
+ * Initialize the layer lists.
+ *
+ * \param IN pointer to function that actually initialize tha data structures
+ * \param IN current layer (0...NUM_LAYERS), (-1) for no change
+ */
+
+static void
+InitializeLayers( void LayerInitFunc( void ), int newCurrLayer )
+{
+	/* reset the data structures to default valuses */
+	LayerInitFunc();
+
+	/* count the objects on each layer */
+	LayerSetCounts();
+
+	/* Switch the current layer when requested */
+	if( newCurrLayer != -1 )
+	{
+		curLayer = newCurrLayer;
+	}
+}	
+
+/**
+ * Save the customized layer information to preferences.
+ */
+ 
+static void 
+LayerPrefSave( void )
+{
+	int inx;
+	int flags;
+	char buffer[ 80 ];
+	char layersSaved[ 3 * NUM_LAYERS ];			/* 0..99 plus separator */
+	
+	/* FIXME: values for layers that are configured to default now should be overwritten in the settings */	
+	
+	layersSaved[ 0 ] = '\0';
+	
+	for( inx = 0; inx < NUM_LAYERS; inx++ ) {
+		/* if a name is set that is not the default value or a color different from the default has been set,
+		    information about the layer needs to be saved */
+		if( (layers[inx].name[0] && inx != 0 ) || 
+			 layers[inx].frozen || (!layers[inx].onMap) || (!layers[inx].visible) || 
+			 layers[inx].color != layerColorTab[inx%COUNT(layerColorTab)])
+		{
+				sprintf( buffer, LAYERPREF_NAME ".%0d", inx );
+				wPrefSetString( LAYERPREF_SECTION, buffer, layers[inx].name );
+				
+				sprintf( buffer, LAYERPREF_COLOR ".%0d", inx );
+				wPrefSetInteger( LAYERPREF_SECTION, buffer, wDrawGetRGB(layers[inx].color));
+				
+				flags = 0;
+				if( layers[inx].frozen )
+					flags |= LAYERPREF_FROZEN;
+				if( layers[inx].onMap )
+					flags |= LAYERPREF_ONMAP;
+				if( layers[inx].visible )
+					flags |= LAYERPREF_VISIBLE;
+
+				sprintf( buffer, LAYERPREF_FLAGS ".%0d", inx );
+				wPrefSetInteger( LAYERPREF_SECTION, buffer, flags ); 					
+				
+				/* extend the list of layers that are set up via the preferences */
+				if( layersSaved[ 0 ] )
+					strcat( layersSaved, "," );
+					
+				sprintf( layersSaved, "%s%d", layersSaved, inx );
+		}
+	}
+	
+	wPrefSetString( LAYERPREF_SECTION, "layers", layersSaved );
+}
+
+
+/**
+ * Load the settings for all layers from the preferences. 
+ */
+
+static void
+LayerPrefLoad( void )
+{
+	
+	int inx;
+	char layersSaved[ 3 * NUM_LAYERS ];
+	char layerOption[ 20 ];
+	const char *layerValue;
+	const char *prefString;
+	long rgb;
+	int color;	
+	long flags;
+
+	/* reset layer preferences to system default */
+	LayerSystemDefaults();
+			
+	prefString = wPrefGetString( LAYERPREF_SECTION, "layers" );
+	if( prefString && prefString[ 0 ] ) {
+		strncpy( layersSaved, prefString, sizeof( layersSaved ));
+		prefString = strtok( layersSaved, "," );
+		while( prefString ) {
+			inx = atoi( prefString );
+			sprintf( layerOption, LAYERPREF_NAME ".%d", inx );
+			layerValue = wPrefGetString( LAYERPREF_SECTION, layerOption );
+			if( layerValue )
+				strcpy( layers[inx].name, layerValue );
+			else 
+				*(layers[inx].name) = '\0';
+			
+			/* get and set the color, using the system default color in case color is not available from prefs */
+			sprintf( layerOption, LAYERPREF_COLOR ".%d", inx );
+			wPrefGetInteger( LAYERPREF_SECTION, layerOption, &rgb, layerColorTab[inx%COUNT(layerColorTab)] ); 
+			color = wDrawFindColor(rgb);
+			SetLayerColor( inx, color );
+			
+			/* get and set the flags */
+			sprintf( layerOption, LAYERPREF_FLAGS ".%d", inx );
+			wPrefGetInteger( LAYERPREF_SECTION, layerOption, &flags, LAYERPREF_ONMAP | LAYERPREF_VISIBLE );
+
+			layers[inx].frozen = ((flags & LAYERPREF_FROZEN) != 0 );
+			layers[inx].onMap = ((flags & LAYERPREF_ONMAP) != 0 );
+			layers[inx].visible = (( flags & LAYERPREF_VISIBLE ) != 0 );
+						
+			prefString = strtok( NULL, ",");
+		}
+	}
+}
+
+/**
+ * Count the number of elements on a layer.
+ * NOTE: This function has been implemented but not actually been tested. As it might prove useful in the 
+ * future I left it in place. So you have been warned!
+ * \param IN layer to count
+ * \return number of elements
+ */
+/*
+static int LayerCount( int layer ) 
+{
+	track_p trk;
+	int inx;
+	int count = 0;
+	
+	for( trk = NULL; TrackIterate(&trk); ) {
+		inx = GetTrkLayer( trk );
+		if( inx == layer )
+			count++;
+	}
+	
+	return count;
+}			
+*/
+
+/**
+ *	Count the number of objects on each layer and store result in layers data structure.
+ */
+
+EXPORT void LayerSetCounts( void )
+{
+	int inx;
+	track_p trk;
+	for ( inx=0; inx<NUM_LAYERS; inx++ )
+		layers[inx].objCount = 0;
+	for ( trk=NULL; TrackIterate(&trk); ) {
+		inx = GetTrkLayer(trk);
+		if ( inx >= 0 && inx < NUM_LAYERS )
+			layers[inx].objCount++;
+	}
+}
+
+/**
+ * Reset layer options to their default values. The default values are loaded
+ * from the preferences file.
+ */
+
+EXPORT void
+DefaultLayerProperties(void)
+{
+	InitializeLayers( LayerPrefLoad, 0 );
+
+	UpdateLayerDlg();
+	if( layoutLayerChanged ) {
+		MainProc( mainW, wResize_e, NULL );
+		layoutLayerChanged = FALSE;
+	}	
+}
+
+/**
+ * Update all UI elements after selecting a layer.
+ *
+ */
+
+static void LayerUpdate( void )
+{
+	BOOL_T redraw;
+	ParamLoadData( &layerPG );
+	if (layerCurrent < 0 || layerCurrent >= NUM_LAYERS)
+		return;
+	if (layerCurrent == curLayer && layerFrozen) {
+		NoticeMessage( MSG_LAYER_FREEZE, _("Ok"), NULL );
+		layerFrozen = FALSE;
+		ParamLoadControl( &layerPG, I_FRZ );
+	}
+	if (layerCurrent == curLayer && !layerVisible) {
+		NoticeMessage( MSG_LAYER_HIDE, _("Ok"), NULL );
+		layerVisible = TRUE;
+		ParamLoadControl( &layerPG, I_VIS );
+	}
+	
+	if( strcmp( layers[(int)layerCurrent].name, layerName ) ||
+		layerColor != layers[(int)layerCurrent].color || 
+		layers[(int)layerCurrent].visible != (BOOL_T)layerVisible ||
+		layers[(int)layerCurrent].frozen != (BOOL_T)layerFrozen ||
+		layers[(int)layerCurrent].onMap != (BOOL_T)layerOnMap ) {
+		
+			changed = TRUE;
+			SetWindowTitle();
+	}
+
+	if ( layerL ) {
+		strncpy( layers[(int)layerCurrent].name, layerName, sizeof layers[(int)layerCurrent].name );
+		sprintf( message, "%2d %c %s", (int)layerCurrent+1, layers[(int)layerCurrent].objCount>0?'+':'-', layers[(int)layerCurrent].name );
+		wListSetValues( layerL, layerCurrent, message, NULL, NULL );
+	}
+
+	sprintf( message, "%2d : %s", (int)layerCurrent+1, layers[(int)layerCurrent].name );
+	wListSetValues( setLayerL, layerCurrent, message, NULL, NULL );
+	if (layerCurrent < NUM_BUTTONS) {
+		if (strlen(layers[(int)layerCurrent].name)>0)
+			wControlSetBalloonText( (wControl_p)layer_btns[(int)layerCurrent], layers[(int)layerCurrent].name );
+		else
+			wControlSetBalloonText( (wControl_p)layer_btns[(int)layerCurrent], _("Show/Hide Layer") );
+	}
+	redraw = ( layerColor != layers[(int)layerCurrent].color ||
+			   (BOOL_T)layerVisible != layers[(int)layerCurrent].visible );
+	if ( (!layerRedrawMap) && redraw)
+		RedrawLayer( (LAYER_T)layerCurrent, FALSE );
+
+	SetLayerColor( layerCurrent, layerColor );
+
+	if (layerCurrent<NUM_BUTTONS && layers[(int)layerCurrent].visible!=(BOOL_T)layerVisible) {
+		wButtonSetBusy( layer_btns[(int)layerCurrent], layerVisible );
+	}
+	layers[(int)layerCurrent].visible = (BOOL_T)layerVisible;
+	layers[(int)layerCurrent].frozen = (BOOL_T)layerFrozen;
+	layers[(int)layerCurrent].onMap = (BOOL_T)layerOnMap;
+	if ( layerRedrawMap )
+		DoRedraw();
+	else if (redraw)
+		RedrawLayer( (LAYER_T)layerCurrent, TRUE );
+	layerRedrawMap = FALSE;
+}
+
+
+static void LayerSelect( 
+		wIndex_t inx )
+{
+	LayerUpdate();
+	if (inx < 0 || inx >= NUM_LAYERS)
+		return;
+	layerCurrent = (LAYER_T)inx;
+	strcpy( layerName, layers[inx].name );
+	layerVisible = layers[inx].visible;
+	layerFrozen = layers[inx].frozen;
+	layerOnMap = layers[inx].onMap;
+	layerColor = layers[inx].color;
+	sprintf( message, "%ld", layers[inx].objCount );
+
+	ParamLoadMessage( &layerPG, I_COUNT, message );
+	ParamLoadControls( &layerPG );
+}
+
+EXPORT void ResetLayers( void )
+{
+	int inx;
+	for ( inx=0;inx<NUM_LAYERS; inx++ ) {
+		strcpy( layers[inx].name, inx==0?_("Main"):"" );
+		layers[inx].visible = TRUE;
+		layers[inx].frozen = FALSE;
+		layers[inx].onMap = TRUE;
+		layers[inx].objCount = 0;
+		SetLayerColor( inx, layerColorTab[inx%COUNT(layerColorTab)] );
+		if ( inx<NUM_BUTTONS ) {
+			wButtonSetLabel( layer_btns[inx], (char*)show_layer_bmps[inx] );
+		}
+	}
+	wControlSetBalloonText( (wControl_p)layer_btns[0], _("Main") );
+	for ( inx=1; inx<NUM_BUTTONS; inx++ ) {
+		wControlSetBalloonText( (wControl_p)layer_btns[inx], _("Show/Hide Layer") );
+	}
+	curLayer = 0;
+	layerVisible = TRUE;
+	layerFrozen = FALSE;
+	layerOnMap = TRUE;
+	layerColor = layers[0].color;
+	strcpy( layerName, layers[0].name );
+ 	LoadLayerLists();
+
+	if (layerL) {
+		ParamLoadControls( &layerPG );
+		ParamLoadMessage( &layerPG, I_COUNT, "0" );
+	}
+}
+
+
+EXPORT void SaveLayers( void )
+{
+	layers_save = malloc( NUM_LAYERS * sizeof( layer_t ));
+	assert( layers_save != NULL );
+	
+	memcpy( layers_save, layers, NUM_LAYERS * sizeof layers[0] );
+	ResetLayers();
+}
+
+EXPORT void RestoreLayers( void )
+{
+	int inx;
+	char * label;
+	wDrawColor color;
+
+	assert( layers_save != NULL );
+	memcpy( layers, layers_save, NUM_LAYERS * sizeof layers[0] );
+	free( layers_save );
+	
+	for ( inx=0; inx<NUM_BUTTONS; inx++ ) {
+		color = layers[inx].color;
+		layers[inx].color = -1;
+		SetLayerColor( inx, color );
+		if ( layers[inx].name[0] == '\0' ) {
+			if ( inx == 0 ) {
+				label = _("Main");
+			} else {
+				label = _("Show/Hide Layer");
+			}
+		} else {
+			label = layers[inx].name;
+		}
+		wControlSetBalloonText( (wControl_p)layer_btns[inx], label );
+	}
+	if (layerL) {
+		ParamLoadControls( &layerPG );
+		ParamLoadMessage( &layerPG, I_COUNT, "0" );
+	}
+	LoadLayerLists();
+}
+
+/**
+ * This function is called when the Done button on the layer dialog is pressed. It hides the layer dialog and
+ * updates the layer information.
+ *
+ * \param IN ignored
+ *
+ */
+ 
+static void LayerOk( void * junk )
+{
+	LayerSelect( layerCurrent ); 
+
+	if (newLayerCount != layerCount) {
+		layoutLayerChanged = TRUE;
+		if ( newLayerCount > NUM_BUTTONS )
+			newLayerCount = NUM_BUTTONS;
+		layerCount = newLayerCount;
+	}
+	if (layoutLayerChanged)
+		MainProc( mainW, wResize_e, NULL );
+	wHide( layerW );
+}
+
+
+static void LayerDlgUpdate(
+		paramGroup_p pg,
+		int inx,
+		void * valueP )
+{
+	switch (inx) {
+	case I_LIST:
+		LayerSelect( (wIndex_t)*(long*)valueP );
+		break;
+	case I_NAME:
+		LayerUpdate();
+		break;
+	case I_MAP:
+		layerRedrawMap = TRUE;
+		break;
+	}
+}
+
+
+static void DoLayer( void * junk )
+{
+	if (layerW == NULL)
+		layerW = ParamCreateDialog( &layerPG, MakeWindowTitle(_("Layers")), _("Done"), LayerOk, NULL, TRUE, NULL, 0, LayerDlgUpdate );
+
+	/* set the globals to the values for the current layer */
+	UpdateLayerDlg();
+	
+	layerRedrawMap = FALSE;
+	wShow( layerW );
+
+	layoutLayerChanged = FALSE;
+}
+
+
+EXPORT BOOL_T ReadLayers( char * line )
+{
+	char * name;
+	int inx, visible, frozen, color, onMap;
+	long rgb;
+
+	/* older files didn't support layers */
+
+	if (paramVersion < 7)
+		return TRUE;
+
+	/* set the current layer */
+
+	if ( strncmp( line, "CURRENT", 7 ) == 0 ) {
+		curLayer = atoi( line+7 );
+		if ( curLayer < 0 )
+			curLayer = 0;
+
+		if (layerL)
+			wListSetIndex( layerL, curLayer );
+		if (setLayerL)
+			wListSetIndex( setLayerL, curLayer );
+			
+		return TRUE;
+	}
+
+	/* get the properties for a layer from the file and update the layer accordingly */
+
+	if (!GetArgs( line, "ddddl0000q", &inx, &visible, &frozen, &onMap, &rgb, &name ))
+		return FALSE;
+	if (paramVersion < 9) {
+		if ( rgb >= 0 && (int)rgb < sizeof oldColorMap/sizeof oldColorMap[0] )
+			rgb = wRGB( oldColorMap[(int)rgb][0], oldColorMap[(int)rgb][1], oldColorMap[(int)rgb][2] );
+		else
+			rgb = 0;
+	}
+	if (inx < 0 || inx >= NUM_LAYERS)
+		return FALSE;
+	color = wDrawFindColor(rgb);
+	SetLayerColor( inx, color );
+	strncpy( layers[inx].name, name, sizeof layers[inx].name );
+	layers[inx].visible = visible;
+	layers[inx].frozen = frozen;
+	layers[inx].onMap = onMap;
+	layers[inx].color = color;
+	if (inx<NUM_BUTTONS) {
+		if (strlen(name) > 0) {
+			wControlSetBalloonText( (wControl_p)layer_btns[(int)inx], layers[inx].name );
+		}
+		wButtonSetBusy( layer_btns[(int)inx], visible );
+	}
+	return TRUE;
+}
+
+
+EXPORT BOOL_T WriteLayers( FILE * f )
+{
+	int inx;
+	BOOL_T rc = TRUE;
+	for (inx=0; inx<NUM_LAYERS; inx++) 
+		if ((!layers[inx].visible) || layers[inx].frozen || (!layers[inx].onMap) ||
+			layers[inx].color!=layerColorTab[inx%(COUNT(layerColorTab))] ||
+			layers[inx].name[0] )
+			rc &= fprintf( f, "LAYERS %d %d %d %d %ld %d %d %d %d \"%s\"\n", inx, layers[inx].visible, layers[inx].frozen, layers[inx].onMap, wDrawGetRGB(layers[inx].color), 0, 0, 0, 0, PutTitle(layers[inx].name) )>0;
+	rc &= fprintf( f, "LAYERS CURRENT %d\n", curLayer )>0;
+	return TRUE;
+}
+
+
+EXPORT void InitLayers( void )
+{
+	int i;
+
+	wPrefGetInteger( PREFSECT, "layer-button-count", &layerCount, layerCount );
+	for ( i = 0; i<COUNT(layerRawColorTab); i++ )
+		layerColorTab[i] = wDrawFindColor( layerRawColorTab[i] );
+
+	/* create the bitmaps for the layer buttons */
+	for ( i = 0; i<NUM_BUTTONS; i++ ) {
+		show_layer_bmps[i] = wIconCreateBitMap( l1_width, l1_height, show_layer_bits[i], layerColorTab[i%(COUNT(layerColorTab))] );
+		layers[i].color = layerColorTab[i%(COUNT(layerColorTab))];
+	}
+	
+	/* layer list for toolbar */
+	setLayerL = wDropListCreate( mainW, 0, 0, "cmdLayerSet", NULL, 0, 10, 200, NULL, SetCurrLayer, NULL );
+	wControlSetBalloonText( (wControl_p)setLayerL, GetBalloonHelpStr("cmdLayerSet") );
+	AddToolbarControl( (wControl_p)setLayerL, IC_MODETRAIN_TOO );
+
+	for ( i = 0; i<NUM_LAYERS; i++ ) {
+		if (i<NUM_BUTTONS) {
+			/* create the layer button */
+		   sprintf( message, "cmdLayerShow%d", i );
+		   layer_btns[i] = wButtonCreate( mainW, 0, 0, message,
+				(char*)(show_layer_bmps[i]),
+				BO_ICON, 0, (wButtonCallBack_p)FlipLayer, (void*)(intptr_t)i );
+			
+			/* add the help text */
+			wControlSetBalloonText( (wControl_p)layer_btns[i], _("Show/Hide Layer") );
+			
+			/* put on toolbar */
+			AddToolbarControl( (wControl_p)layer_btns[i], IC_MODETRAIN_TOO );
+			
+			/* set state of button */
+			wButtonSetBusy( layer_btns[i], 1 );
+		}
+		sprintf( message, "%2d : %s", i+1, (i==0?_("Main"):"") );
+		wListAddValue( setLayerL, message, NULL, (void*)(intptr_t)i );
+	}
+	AddPlaybackProc( "SETCURRLAYER", PlaybackCurrLayer, NULL );
+	AddPlaybackProc( "LAYERS", (playbackProc_p)ReadLayers, NULL );
+}
+
+
+EXPORT addButtonCallBack_t InitLayersDialog( void ) {
+	ParamRegister( &layerPG );
+	return &DoLayer;
+}