/** \file dlayer.c
 * Functions and dialogs for handling layers.
 */

/*  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "common.h"
#include "cselect.h"
#include "custom.h"
#include "paths.h"
#include "dynstring.h"
#include "fileio.h"
#include "layout.h"
#include "param.h"
#include "track.h"
#include "include/partcatalog.h"
#include "include/stringxtc.h"
#include "common-ui.h"

/*****************************************************************************
 *
 * LAYERS
 *
 */

#define NUM_BUTTONS		(99)
#define LAYERPREF_FROZEN  (1)
#define LAYERPREF_ONMAP	  (2)
#define LAYERPREF_VISIBLE (4)
#define LAYERPREF_MODULE  (8)
#define LAYERPREF_NOBUTTON (16)
#define LAYERPREF_DEFAULT (32)
#define LAYERPREF_SECTION ("Layers")
#define LAYERPREF_NAME 	"name"
#define LAYERPREF_COLOR "color"
#define LAYERPREF_FLAGS "flags"
#define LAYERPREF_SCALEINX "scaleInx"
#define LAYERPREF_SCLDESCINX "sclDescInx"
#define LAYERPREF_GAUGEINX "gaugeInx"
#define LAYERPREF_MINRADIUS "minRadius"
#define LAYERPREF_MAXGRADE "maxGrade"
#define LAYERPREF_TIELENGTH "tieLength"
#define LAYERPREF_TIEWIDTH "tieWidth"
#define LAYERPREF_TIESPACING "tieSpacing"
#define LAYERPREF_LIST "list"
#define LAYERPREF_SETTINGS "settings"

static paramIntegerRange_t r_nocheck = { 0, 1, 100, PDO_NORANGECHECK_LOW | PDO_NORANGECHECK_HIGH };
static paramFloatRange_t r_tieData = { 0.05, 100.0, 100, PDO_NORANGECHECK_LOW | PDO_NORANGECHECK_HIGH };

static paramFloatRange_t r0_10000 = { 0.0, 10000.0 };
static paramFloatRange_t r0_90 = { 0.0, 90.0 };

EXPORT unsigned int maxLayer;

unsigned int curLayer;
long layerCount = 10;
static long newLayerCount = 10;
static unsigned int layerSelected = 0;


static BOOL_T layoutLayerChanged = FALSE;

static wIcon_p show_layer_bmps[NUM_BUTTONS];
static wButton_p layer_btns[NUM_BUTTONS];	/**< layer buttons on toolbar */

/** Layer selector on toolbar */
static wList_p setLayerL;

/** Describe the properties of a layer
  * Defaults for layout track grade and min radius are in scale.c: SetScale
  */
typedef struct {
	char name[STR_SHORT_SIZE];			/**< Layer name */
	wDrawColor color;					/**< layer color, is an index into a color table */
	BOOL_T useColor;					/**< Use Layer color */
	BOOL_T frozen;						/**< Frozen flag */
	BOOL_T visible;						/**< visible flag */
	BOOL_T onMap;						/**< is layer shown map */
	BOOL_T module;						/**< is layer a module (all or nothing) */
	BOOL_T button_off;					/**< hide button */
	BOOL_T inherit;					    /**< inherit layout defaults */
	SCALEINX_T scaleInx;                /**< scale override */
	SCALEDESCINX_T scaleDescInx;        /**< the scale description */
	GAUGEINX_T gaugeInx;                /**< the gauge desc index */
	DIST_T minTrackRadius;              /**< minimum track radius */
	ANGLE_T maxTrackGrade;              /**< maximum track grade */
	tieData_t tieData;                  /**< tie data structure */
	long objCount;						/**< number of objects on layer */
	dynArr_t layerLinkList;				/**< other layers that show/hide with this one, 1-based index */
	char settingsName[STR_SHORT_SIZE];  /**< name of settings file to load when this is current */
} layer_t;

static layer_t layers[NUM_LAYERS];
static layer_t *layers_save = NULL;

static Catalog * settingsCatalog;


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);
void UpdateLayerDlg(unsigned int);

static void InitializeLayers(void LayerInitFunc(void), int newCurrLayer);
static void LayerPrefSave(void);
static void LayerPrefLoad(void);

int IsLayerValid(unsigned int layer)
{
	return (layer <= NUM_LAYERS && layer != -1);
}

BOOL_T GetLayerVisible(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].visible;
	}
}

BOOL_T GetLayerHidden(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].button_off;
	}
}


BOOL_T GetLayerFrozen(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].frozen;
	}
}

BOOL_T GetLayerOnMap(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].onMap;
	}
}

EXPORT BOOL_T GetLayerUseDefault(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].inherit;
	}
}


EXPORT SCALEINX_T GetLayerScale( unsigned int layer )
{
	if ( IsLayerValid(layer) && !GetLayerUseDefault(layer) ) {
		return layers[layer].scaleInx;
	}
	return GetLayoutCurScale(); // layout scale
}

EXPORT DIST_T GetLayerMinTrackRadius( unsigned int layer )
{
	if ( IsLayerValid(layer) && !GetLayerUseDefault(layer) ) {
		return layers[layer].minTrackRadius;
	}
	return GetLayoutMinTrackRadius();
}

EXPORT ANGLE_T GetLayerMaxTrackGrade( unsigned int layer )
{
	if ( IsLayerValid(layer) && !GetLayerUseDefault(layer) ) {
		return layers[layer].maxTrackGrade;
	}
	return GetLayoutMaxTrackGrade();
}

EXPORT tieData_t GetLayerTieData( unsigned int layer )
{
	if ( IsLayerValid(layer) && !GetLayerUseDefault(layer)
	     && layers[layer].tieData.valid ) {
		return layers[layer].tieData;
	}
	return GetScaleTieData(GetLayoutCurScale()); // layout scale default tie data
}

BOOL_T GetLayerModule(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return TRUE;
	} else {
		return layers[layer].module;
	}
}

void SetLayerModule(unsigned int layer, BOOL_T module)
{
	if (IsLayerValid(layer)) {
		layers[layer].module = module;
	}
}

void SetLayerDefault(unsigned int layer, BOOL_T inherit)
{
	if (IsLayerValid(layer)) {
		layers[layer].inherit = inherit;
	}
}


char * GetLayerName(unsigned int layer)
{
	if (!IsLayerValid(layer)) {
		return NULL;
	} else {
		return layers[layer].name;
	}
}

void SetLayerName(unsigned int layer, char* name)
{
	if (IsLayerValid(layer)) {
		strcpy(layers[layer].name, name);
	}
}

BOOL_T GetLayerUseColor(unsigned int layer)
{
	return layers[layer].useColor;
}

wDrawColor GetLayerColor(unsigned int layer)
{
	return layers[layer].color;
}

static void RedrawLayer( unsigned int l, BOOL_T draw )
{
	DoRedraw();
}


EXPORT void FlipLayer( void * layerVP )
{
	unsigned int layer = (unsigned int)VP2L(layerVP);
	wBool_t visible;

	if (!IsLayerValid(layer)) {
		return;
	}

	if (layer == curLayer && layers[layer].visible) {
		if (!layers[layer].button_off) {
			wButtonSetBusy(layer_btns[layer], layers[layer].visible);
		}
		NoticeMessage(MSG_LAYER_HIDE, _("Ok"), NULL);
		return;
	}

	RedrawLayer(layer, FALSE);
	visible = !layers[layer].visible;
	layers[layer].visible = visible;

	if (layer < NUM_BUTTONS) {
		if (!layers[layer].button_off) {
			wButtonSetBusy(layer_btns[layer], visible != 0);
			wButtonSetLabel(layer_btns[layer], (char *)show_layer_bmps[layer]);
		}
	}

	/* Set visible on related layers other than current */
	for (int i = 0; i < layers[layer].layerLinkList.cnt; i++) {
		// .layerLinkList values are 1-based layer indices
		int l = DYNARR_N(int, layers[layer].layerLinkList, i) - 1;
		if ((l != curLayer) && (l >= 0) && (l < NUM_LAYERS)) {
			layers[l].visible = layers[layer].visible;
			if (!layers[l].button_off) {
				wButtonSetBusy(layer_btns[l], layers[l].visible);
			}
		}
	}

	RedrawLayer(layer, TRUE);
}

static char lastSettings[STR_SHORT_SIZE];
void SetCurrLayer(wIndex_t inx, const char * name, wIndex_t op,
                  void * listContext, void * arg)
{
	unsigned int newLayer = (unsigned int)inx;

	if (layers[newLayer].frozen) {
		NoticeMessage(MSG_LAYER_SEL_FROZEN, _("Ok"), NULL);
		wListSetIndex(setLayerL, curLayer);
		return;
	}

	char *array[1];
	if (!layers[inx].settingsName[0]
	    || strcmp(layers[inx].settingsName, " ") == 0) {
		if (lastSettings[0]) {
			DoSettingsRead(1, NULL, NULL);
		}
		lastSettings[0] = '\0';
	} else {
		if (strcmp(layers[inx].settingsName, lastSettings) != 0) {
			if (!lastSettings[0]) { wPrefFlush(""); }  // Save Last Settings for no settings file
			array[0] = layers[inx].settingsName;
			DoSettingsRead(1, array, NULL);
		}
		strcpy(lastSettings, layers[inx].settingsName);
	}


	curLayer = newLayer;

	if (!IsLayerValid(curLayer)) {
		curLayer = 0;							//Too big or -1
		layers[curLayer].frozen = FALSE;        //Make sure the layer is not frozen
	}


	if (!layers[curLayer].visible) {
		FlipLayer(I2VP(inx));
	}

	/* Set visible on related layers other than current */
	for (int i = 0; i < layers[curLayer].layerLinkList.cnt; i++) {
		// .layerLinkList values are 1-based layer indices
		int l = DYNARR_N(int, layers[curLayer].layerLinkList, i) - 1;
		if (l != curLayer && l >= 0 && l < NUM_LAYERS) {
			layers[l].visible = layers[curLayer].visible;
			if (!layers[l].button_off) {
				wButtonSetBusy(layer_btns[l], layers[l].visible);
			}
		}
	}

	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(unsigned 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;
	}
}

static void SetLayerHideButton(unsigned int inx, wBool_t hide)
{
	if (hide != layers[inx].button_off) {
		if (inx < NUM_BUTTONS) {
			wControlShow((wControl_p)layer_btns[inx], !hide);
			if (!hide) { wButtonSetBusy(layer_btns[inx], layers[inx].visible); }
		}
		layers[inx].button_off = hide;
		layoutLayerChanged = TRUE;
	}
}

char *
FormatLayerName(unsigned int layerNumber)
{
	DynString string;// = NaS;
	char *result;
	DynStringMalloc(&string, 0);
	DynStringPrintf(&string,
	                "%2d %c %s",
	                layerNumber + 1,
	                (layers[layerNumber].frozen ? '*' : layers[layerNumber].module ? 'm' :
	                 layers[layerNumber].objCount > 0 ? '+' : '-'),
	                layers[layerNumber].name);
	result = strdup(DynStringToCStr(&string));
	DynStringFree(&string);
	return result;
}

static char *show_layer_bits;

static  long layerRawColorTab[] = {
	wRGB(  0,   0, 192),    /* blue */
	wRGB(  0, 192,   0),    /* green */
	wRGB(192,   0,   0),    /* red */
	wRGB(128, 128,   0),    /* yellow */
	wRGB(  0, 128, 128),    /* cyan */
	wRGB(  0,   0, 128),    /* dk blue */
	wRGB(  0, 128,   0),    /* dk green */
	wRGB(128,   0,   0),    /* dk red */
	wRGB( 96,  96,   0),    /* green-brown */
	wRGB(  0,  96,  96)     /* dk cyan */
};
static  wDrawColor layerColorTab[COUNT(layerRawColorTab)];


static wWin_p layerW;
static char layerName[STR_SHORT_SIZE];
static char layerLinkList[STR_LONG_SIZE];
static char settingsName[STR_SHORT_SIZE];
static wDrawColor layerColor;
static long layerUseColor = TRUE;
static long layerVisible = TRUE;
static long layerFrozen = FALSE;
static long layerOnMap = TRUE;
static long layerModule = FALSE;
static long layerNoButton = FALSE;
static long layerInherit = FALSE;

static SCALEINX_T layerScaleInx;
static SCALEDESCINX_T layerScaleDescInx;
static GAUGEINX_T layerGaugeInx;
static DIST_T layerMinRadius;
static ANGLE_T layerMaxGrade;
static tieData_t layerTieData;

static long layerObjectCount;
static void LayerOk(void * unused);
static BOOL_T layerRedrawMap = FALSE;

#define ENUMLAYER_RELOAD (1)
#define ENUMLAYER_SAVE	(2)
#define ENUMLAYER_CLEAR (3)
#define ENUMLAYER_ADD (4)
#define ENUMLAYER_DELETE (5)
#define ENUMLAYER_DEFAULT (6)

static char *visibleLabels[] = { "", NULL };
static char *frozenLabels[] = { "", NULL };
static char *onMapLabels[] = { "", NULL };
static char *moduleLabels[] = { "", NULL };
static char *noButtonLabels[] = { "", NULL };
static char *defaultLabels[] = { "", NULL };
static char *layerColorLabels[] = { "", NULL };
static paramIntegerRange_t i0_20 = { 0, NUM_BUTTONS };
//static paramListData_t layerUiListData = { 10, 370, 0 };

static paramData_t layerPLs[] = {
#define I_LIST	(0)
	{ PD_DROPLIST, NULL, "layer", PDO_LISTINDEX, I2VP(250), N_("Select Layer:") },
#define I_NAME	(1)
	{ PD_STRING, layerName, "name", PDO_NOPREF | PDO_STRINGLIMITLENGTH | PDO_DLGBOXEND, I2VP(250 - 54), N_("Name"), 0, 0, sizeof(layerName) },
#define I_COLOR	(2)
	{ PD_COLORLIST, &layerColor, "color", PDO_NOPREF, NULL, N_("Color") },
#define I_USE_COLOR (3)
	{ PD_TOGGLE, &layerUseColor, "layercolor", PDO_NOPREF | PDO_DLGHORZ, layerColorLabels, N_("Use Color"), BC_HORZ | BC_NOBORDER },
#define I_VIS	(4)
	{ PD_TOGGLE, &layerVisible, "visible", PDO_NOPREF, visibleLabels, N_("Visible"), BC_HORZ | BC_NOBORDER },
#define I_FRZ	(5)
	{ PD_TOGGLE, &layerFrozen, "frozen", PDO_NOPREF | PDO_DLGHORZ, frozenLabels, N_("Frozen"), BC_HORZ | BC_NOBORDER },
#define I_MAP	(6)
	{ PD_TOGGLE, &layerOnMap, "onmap", PDO_NOPREF | PDO_DLGHORZ, onMapLabels, N_("On Map"), BC_HORZ | BC_NOBORDER },
#define I_MOD 	(7)
	{ PD_TOGGLE, &layerModule, "module", PDO_NOPREF | PDO_DLGHORZ, moduleLabels, N_("Module"), BC_HORZ | BC_NOBORDER },
#define I_BUT   (8)
	{ PD_TOGGLE, &layerNoButton, "button", PDO_NOPREF | PDO_DLGHORZ, noButtonLabels, N_("No Button"), BC_HORZ | BC_NOBORDER },
#define I_DEF   (9)
	{ PD_TOGGLE, &layerInherit, "inherit", PDO_NOPREF | PDO_DLGHORZ | PDO_DLGBOXEND, defaultLabels, N_("Inherit"), BC_HORZ | BC_NOBORDER },
#define I_SCALE (10)
	{ PD_DROPLIST, &layerScaleDescInx, "scale", PDO_NOPREF | PDO_NOPSHUPD | PDO_NORECORD | PDO_NOUPDACT, I2VP(180), N_("Scale"), 0, I2VP(CHANGE_LAYER) },
#define I_GAUGE (11)
	{ PD_DROPLIST, &layerGaugeInx, "gauge", PDO_NOPREF | PDO_NOPSHUPD | PDO_NORECORD | PDO_NOUPDACT | PDO_DLGHORZ, I2VP(180), N_("     Gauge") },
#define I_MINRADIUSENTRY (12)
	{ PD_FLOAT, &layerMinRadius, "mintrackradius", PDO_DIM | PDO_NOPSHUPD | PDO_NOPREF, &r0_10000, N_("Min Track Radius"), 0, I2VP(CHANGE_MAIN | CHANGE_LIMITS) },
#define I_MAXGRADEENTRY (13)
	{ PD_FLOAT, &layerMaxGrade, "maxtrackgrade", PDO_NOPSHUPD | PDO_DLGHORZ | PDO_NOPREF, &r0_90, N_("  Max Track Grade (%)"), 0, I2VP(CHANGE_MAIN) },
#define I_TIELEN (14)
	{ PD_FLOAT, &layerTieData.length, "tielength", PDO_NOPREF, &r_tieData, N_( "Tie Length" ), 0, I2VP( CHANGE_MAIN ) },
#define I_TIEWID (15)
	{ PD_FLOAT, &layerTieData.width, "tiewidth", PDO_NOPREF | PDO_DLGHORZ, &r_tieData, N_( "  Width" ), 0, I2VP( CHANGE_MAIN ) },
#define I_TIESPC (16)
	{ PD_FLOAT, &layerTieData.spacing, "tiespacing", PDO_NOPREF | PDO_DLGHORZ | PDO_DLGBOXEND, &r_tieData, N_( "  Spacing" ), 0, I2VP( CHANGE_MAIN ) },

	{ PD_MESSAGE, N_("Layer Actions"), NULL, PDO_DLGRESETMARGIN, I2VP(180) },
#define I_ADD (18)
	{ PD_BUTTON, DoLayerOp, "add", PDO_DLGRESETMARGIN, 0, N_("Add Layer"), 0, I2VP(ENUMLAYER_ADD) },
#define I_DELETE (19)
	{ PD_BUTTON, DoLayerOp, "delete", PDO_DLGHORZ, 0, N_("Delete Layer"), 0, I2VP(ENUMLAYER_DELETE) },
#define I_DEFAULT (20)
	{ PD_BUTTON, DoLayerOp, "default", PDO_DLGHORZ | PDO_DLGBOXEND, 0, N_("Default Values"), 0, I2VP(ENUMLAYER_DEFAULT) },
	{ PD_LONG, &newLayerCount, "button-count", PDO_DLGBOXEND | PDO_DLGRESETMARGIN, &i0_20, N_("Number of Layer Buttons") },
#define I_LINKLIST (22)
	{ PD_STRING, layerLinkList, "layerlist", PDO_NOPREF | PDO_STRINGLIMITLENGTH, I2VP(250 - 54), N_("Linked Layers"), 0, 0, sizeof(layerLinkList) },
#define I_SETTINGS (23)
	{ PD_DROPLIST, NULL, "settings", PDO_LISTINDEX, I2VP(250), N_("Settings when Current") },
#define I_COUNT (24)
	{ PD_LONG, &layerObjectCount, "objectCount", PDO_DLGBOXEND, &r_nocheck, N_("Object Count:"), 0, 0 },
	{ PD_MESSAGE, N_("All Layer Preferences"), NULL, PDO_DLGRESETMARGIN, I2VP(180) },
	{ PD_BUTTON, DoLayerOp, "load", PDO_DLGRESETMARGIN, 0, N_("Load"), 0, I2VP(ENUMLAYER_RELOAD) },
	{ PD_BUTTON, DoLayerOp, "save", PDO_DLGHORZ, 0, N_("Save"), 0, I2VP(ENUMLAYER_SAVE) },
	{ PD_BUTTON, DoLayerOp, "clear", PDO_DLGHORZ | PDO_DLGBOXEND, 0, N_("Defaults"), 0, I2VP(ENUMLAYER_CLEAR) },
};

#define settingsListL	((wList_p)layerPLs[I_SETTINGS].control)

static paramGroup_t layerPG = { "layer", 0, layerPLs, COUNT( layerPLs ) };

/**
 * Reload the listbox showing the current catalog
 */
static int LoadFileListLoad(Catalog *catalog, char * name)
{
	CatalogEntry *currentEntry = catalog->head;
	DynString description;
	DynStringMalloc(&description, STR_SHORT_SIZE);

	wControlShow((wControl_p)settingsListL, FALSE);
	wListClear(settingsListL);

	int currset = 0;

	int i = 0;

	wListAddValue(settingsListL, " ", NULL, " ");

	while (currentEntry) {
		i++;
		DynStringClear(&description);
		DynStringCatCStr(&description,
		                 currentEntry->contents) ;
		wListAddValue(settingsListL,
		              DynStringToCStr(&description),
		              NULL,
		              currentEntry->fullFileName[0]);
		if (strcmp(currentEntry->fullFileName[0], name) == 0) { currset = i; }
		currentEntry = currentEntry->next;
	}


	wListSetIndex(settingsListL, currset);

	wControlShow((wControl_p)settingsListL, TRUE);

	DynStringFree(&description);

	if (currset == 0 && strcmp(" ", name) != 0) { return FALSE; }
	return TRUE;
}

#define layerL	((wList_p)layerPLs[I_LIST].control)

#define layerS  ((wList_p)layerPLs[I_SETTINGS].control)

#define scaleL	((wList_p)layerPLs[I_SCALE].control)

#define gaugeL	((wList_p)layerPLs[I_GAUGE].control)

/**
* @brief Reload Layer parameters if changes
* @param changes
*/
static void LayerChange(long changes)
{
	if (changes & (CHANGE_LAYER))
		if (layerW != NULL && wWinIsVisible(layerW)) {
			ParamLoadControls(&layerPG);
		}
}

void GetLayerLinkString(int inx, char * list)
{
	char * cp = &list[0];
	cp[0] = '\0';
	int len = 0;
	for (int i = 0; i < layers[inx].layerLinkList.cnt
	     && len < STR_LONG_SIZE - 5; i++) {
		int l = DYNARR_N(int, layers[inx].layerLinkList, i);
		if (i == 0) {
			cp += sprintf(cp, "%d", l);
		} else {
			cp += sprintf(cp, ";%d", l);
		}
		cp[0] = '\0';
	}
}

void PutLayerListArray(int inx, char * list)
{
	char * cp = &list[0];
	DYNARR_RESET(int, layers[inx].layerLinkList);
	while (cp) {
		cp = strpbrk(list, ",; ");
		if (cp) {
			cp[0] = '\0';
			int i =  abs((int)strtol(list, &list, 0));
			if (i > 0 && i != inx - 1 && i < NUM_LAYERS) {
				DYNARR_APPEND(int, layers[inx].layerLinkList, 1);
				DYNARR_LAST(int, layers[inx].layerLinkList) = i;
			}
			cp[0] = ';';
			list = cp + 1;
		} else {
			int i =  abs((int)strtol(list, &list, 0));
			if (i > 0 && i != inx - 1 && i < NUM_LAYERS) {
				DYNARR_APPEND(int, layers[inx].layerLinkList, 1);
				DYNARR_LAST(int, layers[inx].layerLinkList) = i;
			}
			cp = 0;
		}
	}
}

/**
 * Set a Layer to System Default
 */
void LayerSystemDefault( unsigned int inx )
{

	strcpy(layers[inx].name, inx == 0 ? _("Main") : "");
	layers[inx].visible = TRUE;
	layers[inx].frozen = FALSE;
	layers[inx].onMap = TRUE;
	layers[inx].module = FALSE;
	layers[inx].button_off = FALSE;
	layers[inx].inherit = TRUE;
	layers[inx].scaleInx = 0;
	GetScaleGauge(layers[inx].scaleInx, &layers[inx].scaleDescInx,
	              &layers[inx].gaugeInx);
	layers[inx].minTrackRadius = GetLayoutMinTrackRadius();
	layers[inx].maxTrackGrade = GetLayoutMaxTrackGrade();
	layers[inx].tieData.valid = FALSE;
	layers[inx].tieData.length = 0.0;
	layers[inx].tieData.width = 0.0;
	layers[inx].tieData.spacing = 0.0;
	layers[inx].objCount = 0;
	DYNARR_RESET(int, layers[inx].layerLinkList);
	SetLayerColor(inx, layerColorTab[inx % COUNT(layerColorTab)]);
}

/**
 * Is a layer the system default?
 */
BOOL_T IsLayerDefault( unsigned int inx )
{
	return (!layers[inx].name[0]) &&
	       layers[inx].visible &&
	       !layers[inx].frozen &&
	       layers[inx].onMap &&
	       !layers[inx].module &&
	       !layers[inx].button_off &&
	       layers[inx].inherit &&
	       (!layers[inx].layerLinkList.cnt) &&
	       (layers[inx].color == layerColorTab[inx % COUNT(layerColorTab)]) &&
	       layers[inx].scaleInx == 0 &&
	       //layers[inx].scaleDescInx != layerScaleDescInx ||
	       //layers[inx].gaugeInx != layerGaugeInx ||
	       layers[inx].minTrackRadius == GetLayoutMinTrackRadius() &&
	       layers[inx].maxTrackGrade == GetLayoutMaxTrackGrade() &&
	       layers[inx].tieData.valid == FALSE &&
	       layers[inx].tieData.length == 0.0 &&
	       layers[inx].tieData.width == 0.0 &&
	       layers[inx].tieData.spacing == 0.0;
}

/**
 * Load the layer settings to hard coded system defaults
 */
EXPORT void LayerAllDefaults(void)
{
	int inx;

	for (inx = 0; inx < NUM_LAYERS; inx++) {
		LayerSystemDefault(inx);
	}
}

/**
 * Load the layer listboxes in Manage Layers and the Toolbar with up-to-date information.
 */
void LoadLayerLists(void)
{
	int inx;
	/* clear both lists */
	wListClear(setLayerL);

	if (layerL) {
		wListClear(layerL);
	}

	if (layerS) {
		wListClear(layerS);
	}


	/* add all layers to both lists */
	for (inx = 0; inx < NUM_LAYERS; inx++) {
		char *layerLabel;
		layerLabel = FormatLayerName(inx);

		if (layerL) {
			wListAddValue(layerL, layerLabel, NULL, NULL);
		}

		wListAddValue(setLayerL, layerLabel, NULL, NULL);
		free(layerLabel);
	}

	/* set current layer to selected */
	wListSetIndex(setLayerL, curLayer);

	if (layerL) {
		wListSetIndex(layerL, curLayer);
	}
}

/**
 * Add a layer after selected layer
 */
static void LayerAdd( )
{
	unsigned int inx;
	unsigned int newLayer = layerSelected + 1;

	// UndoStart( _("Add Layer"), "addlayer" );
	maxLayer++;
	for ( inx = maxLayer; inx > newLayer; inx-- ) {
		layers[inx] = layers[inx - 1];
	}

	TrackInsertLayer(newLayer);

	LayerSystemDefault(newLayer);
	strcpy(layers[newLayer].name, "New Layer");
	layers[newLayer].objCount = 0;

	UpdateLayerDlg( newLayer );

	layerSelected = newLayer;
	layoutLayerChanged = TRUE;
	// UndoEnd();
}

/**
* Delete the selected layer
*/
static void LayerDelete( )
{
	unsigned int inx;

	if (layers[layerSelected].objCount > 0) {
		NoticeMessage(_("Layer must not have any objects in it."), _("Ok"), NULL);
		return;
	}

	if (layerSelected <= maxLayer) {
		for ( inx = layerSelected; inx < maxLayer; inx++ ) {
			layers[inx] = layers[inx + 1];
		}
		LayerSystemDefault(maxLayer);

		if (maxLayer > 0) {
			maxLayer--;
		}
	}

	TrackDeleteLayer( layerSelected );

	UpdateLayerDlg( layerSelected );

	layoutLayerChanged = TRUE;
}

/**
* Set the Min Radius, Max Grade and Tie values to Layout or Scale defaults
*/
static void LayerDefault( )
{
	if ( layers[layerSelected].inherit ) {
		layers[layerSelected].scaleInx = GetLayoutCurScale( );
		GetScaleGauge(layers[layerSelected].scaleInx,
		              &layers[layerSelected].scaleDescInx,
		              &layers[layerSelected].gaugeInx);
		layers[layerSelected].minTrackRadius = GetLayoutMinTrackRadius();
		layers[layerSelected].maxTrackGrade = GetLayoutMaxTrackGrade();
	} else {
		layers[layerSelected].scaleInx = GetLayerScale( layerSelected );
		GetScaleGauge(layers[layerSelected].scaleInx,
		              &layers[layerSelected].scaleDescInx,
		              &layers[layerSelected].gaugeInx);
		layers[layerSelected].minTrackRadius = GetLayoutMinTrackRadius();
		layers[layerSelected].maxTrackGrade = GetLayoutMaxTrackGrade();
	}
	layers[layerSelected].tieData = GetScaleTieData(layers[layerSelected].scaleInx);

	UpdateLayerDlg( layerSelected );

	layoutLayerChanged = TRUE;
}

/**
 * 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 pressed
 * \return
 */

static void DoLayerOp(void * data)
{
	switch (VP2L(data)) {
	case ENUMLAYER_CLEAR:
		InitializeLayers(LayerAllDefaults, -1);
		break;

	case ENUMLAYER_SAVE:
		LayerPrefSave();
		break;

	case ENUMLAYER_RELOAD:
		LayerPrefLoad();
		break;

	case ENUMLAYER_ADD:
		LayerAdd();
		break;

	case ENUMLAYER_DELETE:
		LayerDelete();
		break;

	case ENUMLAYER_DEFAULT:
		LayerDefault();
		break;
	}

	// UpdateLayerDlg(curLayer);   //Reset to current Layer
	ParamControlActive( &layerPG, I_DELETE, (layerSelected > 0) ? TRUE : FALSE);

	if (layoutLayerChanged) {
		MainProc(mainW, wResize_e, NULL, NULL);
		layoutLayerChanged = FALSE;
		SetFileChanged();
	}
}

/**
 * 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.
 */
EXPORT void UpdateLayerDlg(unsigned int layer)
{
	int inx;
	/* update the globals for the layer dialog */
	layerVisible = layers[layer].visible;
	layerFrozen = layers[layer].frozen;
	layerOnMap = layers[layer].onMap;
	layerModule = layers[layer].module;
	layerColor = layers[layer].color;
	layerUseColor = layers[layer].useColor;
	layerNoButton = layers[layer].button_off;
	layerInherit = layers[layer].inherit;
	layerScaleInx = layers[layer].scaleInx;
	layerScaleDescInx = layers[layer].scaleDescInx;
	layerGaugeInx = layers[layer].gaugeInx;
	layerMinRadius = layers[layer].minTrackRadius;
	layerMaxGrade = layers[layer].maxTrackGrade;
	layerTieData = layers[layer].tieData;
	layerObjectCount = layers[layer].objCount;
	strcpy(layerName, layers[layer].name);
	strcpy(settingsName, layers[layer].settingsName);
	GetLayerLinkString(layer, layerLinkList);

	layerSelected = layer;

	/* now re-load the layer list boxes */
	LoadLayerLists();

	/* Sync Scale and lists */
	if (gaugeL) {
		LoadGaugeList(gaugeL, layerScaleDescInx);
		wListSetIndex(gaugeL, layerGaugeInx);
	}
	/* Sync Scale and lists */
	GetScaleGauge(layerScaleInx, &layerScaleDescInx, &layerGaugeInx);

	/* force update of the 'manage layers' dialogbox */
	if (layerL) {
		wListSetIndex(layerL, layer);
		ParamLoadControls(&layerPG);
	}

	if (layerS) {
		if (!LoadFileListLoad(settingsCatalog, settingsName)) {
			layers[layer].settingsName[0] = '\0';
		}
	}

	ParamControlActive( &layerPG, I_DELETE, (layerSelected > 0) ? TRUE : FALSE);
	ParamControlActive( &layerPG, I_COUNT, FALSE );

	ParamControlActive( &layerPG, I_SCALE, !layerInherit);
	ParamControlActive( &layerPG, I_GAUGE, !layerInherit);
	ParamControlActive( &layerPG, I_MINRADIUSENTRY, !layerInherit);
	ParamControlActive( &layerPG, I_MAXGRADEENTRY, !layerInherit);
	ParamControlActive( &layerPG, I_TIELEN, !layerInherit);
	ParamControlActive( &layerPG, I_TIEWID, !layerInherit);
	ParamControlActive( &layerPG, I_TIESPC, !layerInherit);

	/* finally show the layer buttons with balloon text */
	for (inx = 0; inx < NUM_BUTTONS; inx++) {
		if (!layers[inx].button_off) {
			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")));
		}
	}
}

/**
 * Fill a layer dropbox with the current layer settings
 *
 * \param listLayers the dropbox
 * \return
 */
void FillLayerList( wList_p listLayers)
{
	wListClear(listLayers);  // Rebuild list on each invocation

	for (int inx = 0; inx < NUM_LAYERS; inx++) {
		char *layerFormattedName;
		layerFormattedName = FormatLayerName(inx);
		wListAddValue((wList_p)listLayers, layerFormattedName, NULL, I2VP(inx));
		free(layerFormattedName);
	}

	/* set current layer to selected */
	wListSetIndex(listLayers, curLayer);

	ParamControlActive( &layerPG, I_DELETE, (curLayer > 0) ? TRUE : FALSE);
	if ( layerInherit ) {
		ParamControlActive( &layerPG, I_TIELEN, FALSE);
		ParamControlActive( &layerPG, I_TIEWID, FALSE);
		ParamControlActive( &layerPG, I_TIESPC, FALSE);
	}
}

/**
 * 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 or the first above not frozen*/
	if (newCurrLayer != -1) {
		curLayer = -1;
		for (int i = newCurrLayer; i < NUM_LAYERS; i++) {
			if (!layers[i].frozen) {
				curLayer = i;
				break;
			}
		}
		if (curLayer == -1) {
			ErrorMessage( MSG_NO_EMPTY_LAYER );
			layers[0].frozen = FALSE;
			curLayer = 0;
		}
	}
}

/**
 * Save an integer to Prefs
 */
static void
layerSetInteger( unsigned int inx, char prefName[], int value )
{
	char buffer[80];
	char name[80];
	strcpy(name, prefName);
	strcat(name, ".%0u");
	sprintf( buffer, name, inx );
	wPrefSetInteger( LAYERPREF_SECTION, buffer, value );
}
/**
* Save a float to Prefs
*/
static void
layerSetFloat( unsigned int inx, char prefName[], double value )
{
	char buffer[80];
	char name[20];
	strcpy(name, prefName);
	strcat(name, ".%0u");
	sprintf( buffer, name, inx );
	wPrefSetFloat( LAYERPREF_SECTION, buffer, value );
}

/**
 * Save the customized layer information to preferences.
 */
static void
LayerPrefSave(void)
{
	unsigned int inx;
	int flags;
	char buffer[ 80 ];
	char links[STR_LONG_SIZE];
	char layersSaved[ 3 * NUM_LAYERS + 1 ];			/* 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 (inx == 0 || !IsLayerDefault(inx)) {
			sprintf(buffer, LAYERPREF_NAME ".%0u", inx);
			wPrefSetString(LAYERPREF_SECTION, buffer, layers[inx].name);

			layerSetInteger(inx, LAYERPREF_COLOR, 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;
			}
			if (layers[inx].module) {
				flags |= LAYERPREF_MODULE;
			}
			if (layers[inx].button_off) {
				flags |= LAYERPREF_NOBUTTON;
			}
			if (layers[inx].inherit) {
				flags |= LAYERPREF_DEFAULT;
			}
			layerSetInteger(inx, LAYERPREF_FLAGS, flags);

			layers[inx].scaleInx = GetScaleInx( layers[inx].scaleDescInx,
			                                    layers[inx].gaugeInx );
			layerSetInteger(inx, LAYERPREF_SCALEINX, layers[inx].scaleInx);
			layerSetInteger(inx, LAYERPREF_SCLDESCINX, layers[inx].scaleDescInx);
			layerSetInteger(inx, LAYERPREF_GAUGEINX, layers[inx].gaugeInx);
			layerSetFloat(inx, LAYERPREF_MINRADIUS, layers[inx].minTrackRadius);
			layerSetFloat(inx, LAYERPREF_MAXGRADE, layers[inx].maxTrackGrade);
			layerSetFloat(inx, LAYERPREF_TIELENGTH, layers[inx].tieData.length);
			layerSetFloat(inx, LAYERPREF_TIEWIDTH, layers[inx].tieData.width);
			layerSetFloat(inx, LAYERPREF_TIESPACING, layers[inx].tieData.spacing);

			if (layers[inx].layerLinkList.cnt > 0) {
				sprintf(buffer, LAYERPREF_LIST ".%0u", inx);
				GetLayerLinkString(inx, links);
				wPrefSetString(LAYERPREF_SECTION, buffer, links);

				if (settingsName[0] && strcmp(settingsName, " ") != 0) {
					sprintf(buffer, LAYERPREF_SETTINGS ".%0u", inx);
					wPrefSetString(LAYERPREF_SECTION, buffer, layers[inx].settingsName);
				}
			}

			/* extend the list of layers that are set up via the preferences */
			if (layersSaved[ 0 ]) {
				strcat(layersSaved, ",");
			}

			sprintf(buffer, "%u", inx);
			strcat(layersSaved, buffer);
		}
	}

	wPrefSetString(LAYERPREF_SECTION, "layers", layersSaved);
}


/**
* Load an integer from Prefs
*/
static void
layerGetInteger( unsigned int inx, char prefName[], long *value, int deflt )
{
	char buffer[80];
	char name[80];
	strcpy(name, prefName);
	strcat(name, ".%0u");
	sprintf( buffer, name, inx );
	wPrefGetInteger( LAYERPREF_SECTION, buffer, value, deflt );
}
/**
* Load a float from Prefs
*/
static void
layerGetFloat( unsigned int inx, char prefName[], double *value, double deflt )
{
	char buffer[80];
	char name[20];
	strcpy(name, prefName);
	strcat(name, ".%0u");
	sprintf( buffer, name, inx );
	wPrefGetFloat( LAYERPREF_SECTION, buffer, value, deflt );
}

/**
 * Load the settings for all layers from the preferences.
 */

static void
LayerPrefLoad(void)
{
	const char *prefString;
	long rgb;
	long flags;
	/* reset layer preferences to system default */
	LayerAllDefaults();
	prefString = wPrefGetString(LAYERPREF_SECTION, "layers");

	if (prefString && prefString[ 0 ]) {
		char layersSaved[3 * NUM_LAYERS];
		strncpy(layersSaved, prefString, sizeof(layersSaved));
		prefString = strtok(layersSaved, ",");

		while (prefString) {
			int inx;
			char layerOption[20];
			const char *layerValue;
			char listValue[STR_LONG_SIZE];
			int color;
			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 */
			layerGetInteger(inx, LAYERPREF_COLOR, &rgb,
			                layerColorTab[inx % COUNT(layerColorTab)]);
			color = wDrawFindColor(rgb);
			SetLayerColor(inx, color);
			/* get and set the flags */
			layerGetInteger(inx, LAYERPREF_FLAGS, &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);
			layers[inx].module = ((flags & LAYERPREF_MODULE) != 0);
			layers[inx].button_off = ((flags & LAYERPREF_NOBUTTON) != 0);
			layers[inx].inherit = ((flags & LAYERPREF_DEFAULT) != 0);

			layerGetInteger(inx, LAYERPREF_SCALEINX, &layers[inx].scaleInx,
			                GetLayoutCurScale());
			layerGetInteger(inx, LAYERPREF_SCLDESCINX, &layers[inx].scaleDescInx,
			                GetLayoutCurScaleDesc());
			layerGetInteger(inx, LAYERPREF_GAUGEINX, &layers[inx].gaugeInx, 0);

			layerGetFloat(inx, LAYERPREF_MINRADIUS, &layers[inx].minTrackRadius,
			              GetLayoutMinTrackRadius());
			layerGetFloat(inx, LAYERPREF_MAXGRADE, &layers[inx].maxTrackGrade,
			              GetLayoutMaxTrackGrade());
			layerGetFloat(inx, LAYERPREF_TIELENGTH, &layers[inx].tieData.length, 0.0);
			layerGetFloat(inx, LAYERPREF_TIEWIDTH, &layers[inx].tieData.width, 0.0);
			layerGetFloat(inx, LAYERPREF_TIESPACING, &layers[inx].tieData.spacing, 0.0);

			sprintf(layerOption, LAYERPREF_LIST ".%d", inx);
			layerValue = wPrefGetString(LAYERPREF_SECTION, layerOption);
			if (layerValue) {
				strcpy(listValue, layerValue);
				PutLayerListArray(inx, listValue);
			} else {
				listValue[0] = '\0';
				PutLayerListArray(inx, listValue);
			}
			sprintf(layerOption, LAYERPREF_SETTINGS ".%d", inx);
			layerValue = wPrefGetString(LAYERPREF_SECTION, layerOption);
			if (layerValue) {
				strcpy(layers[inx].settingsName, layerValue);
			} else {
				layers[inx].settingsName[0] = '\0';
			}

			prefString = strtok(NULL, ",");
		}
	}
	//Make sure curLayer not frozen
	for (int i = curLayer; i < NUM_LAYERS; i++) {
		if (!layers[i].frozen)  {
			curLayer = i;
			break;
		}
	}
	if (layers[curLayer].frozen) {
		ErrorMessage( MSG_NO_EMPTY_LAYER );
		layers[0].frozen = FALSE;
		curLayer = 0;
	}
}

/**
 * Increment the count of objects on a given layer.
 *
 * \param index IN the layer to change
 */

void IncrementLayerObjects(unsigned int layer)
{
	CHECK(layer <= NUM_LAYERS);
	layers[layer].objCount++;
}

/**
* Decrement the count of objects on a given layer.
*
* \param index IN the layer to change
*/

void DecrementLayerObjects(unsigned int layer)
{
	CHECK(layer <= NUM_LAYERS);
	layers[layer].objCount--;
}

/**
 *	Count the number of objects on each layer and store result in layers data structure.
 */

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++;
		}
	}
}

int FindUnusedLayer(unsigned int start)
{
	int inx;
	for (inx = start; inx < NUM_LAYERS; inx++) {
		if (layers[inx].objCount == 0 && !layers[inx].frozen) { return inx; }
	}
	ErrorMessage( MSG_NO_EMPTY_LAYER );
	return -1;
}

/**
 * Reset layer options to their default values. The default values are loaded
 * from the preferences file.
 */

void
DefaultLayerProperties(void)
{
	InitializeLayers(LayerPrefLoad, 0);
	UpdateLayerDlg(curLayer);			//Use Current Layer

	if (layoutLayerChanged) {
		MainProc(mainW, wResize_e, NULL, NULL);
		layoutLayerChanged = FALSE;
	}
}

/**
 * Update all UI elements after selecting a layer.
 *
 */

static void LayerUpdate(void)
{
	BOOL_T redraw;
	char *layerFormattedName;
	ParamLoadData(&layerPG);

	if (!IsLayerValid(layerSelected)) {
		return;
	}

	if (layerSelected == curLayer && layerFrozen) {
		NoticeMessage(MSG_LAYER_FREEZE, _("Ok"), NULL);
		layerFrozen = FALSE;
		ParamLoadControl(&layerPG, I_FRZ);
	}

	if (layerSelected == curLayer && !layerVisible) {
		NoticeMessage(MSG_LAYER_HIDE, _("Ok"), NULL);
		layerVisible = TRUE;
		ParamLoadControl(&layerPG, I_VIS);
	}

	if (layerSelected == curLayer && layerModule) {
		NoticeMessage(MSG_LAYER_MODULE, _("Ok"), NULL);
		layerModule = FALSE;
		ParamLoadControl(&layerPG, I_MOD);
	}
	char oldLinkList[STR_LONG_SIZE];
	GetLayerLinkString((int)layerSelected, oldLinkList);

	if (strcmp(layers[(int)layerSelected].name, layerName) ||
	    layerColor != layers[(int)layerSelected].color ||
	    layers[(int)layerSelected].useColor != (BOOL_T)layerUseColor ||
	    layers[(int)layerSelected].visible != (BOOL_T)layerVisible ||
	    layers[(int)layerSelected].frozen != (BOOL_T)layerFrozen ||
	    layers[(int)layerSelected].onMap != (BOOL_T)layerOnMap ||
	    layers[(int)layerSelected].module != (BOOL_T)layerModule ||
	    layers[(int)layerSelected].button_off != (BOOL_T)layerNoButton ||
	    layers[(int)layerSelected].inherit != (BOOL_T)layerInherit ||
	    layers[(int)layerSelected].scaleInx != layerScaleInx ||
	    layers[(int)layerSelected].scaleDescInx != layerScaleDescInx ||
	    layers[(int)layerSelected].gaugeInx != layerGaugeInx ||
	    layers[(int)layerSelected].minTrackRadius != layerMinRadius ||
	    layers[(int)layerSelected].maxTrackGrade != layerMaxGrade ||
	    layers[(int)layerSelected].tieData.length != layerTieData.length ||
	    layers[(int)layerSelected].tieData.width != layerTieData.width ||
	    layers[(int)layerSelected].tieData.spacing != layerTieData.spacing ||
	    strcmp(layers[(int)layerSelected].settingsName, settingsName) ||
	    strcmp(oldLinkList, layerLinkList)) {
		SetFileChanged();
	}

	if (layerL) {
		strncpy(layers[(int)layerSelected].name, layerName,
		        sizeof layers[(int)layerSelected].name);
		layerFormattedName = FormatLayerName(layerSelected);
		wListSetValues(layerL, layerSelected, layerFormattedName, NULL, NULL);
		free(layerFormattedName);
	}


	layerFormattedName = FormatLayerName(layerSelected);
	wListSetValues(setLayerL, layerSelected, layerFormattedName, NULL, NULL);
	free(layerFormattedName);

	if (layerSelected < NUM_BUTTONS && !layers[(int)layerSelected].button_off) {
		if (strlen(layers[(int)layerSelected].name) > 0) {
			wControlSetBalloonText((wControl_p)layer_btns[(int)layerSelected],
			                       layers[(int)layerSelected].name);
		} else {
			wControlSetBalloonText((wControl_p)layer_btns[(int)layerSelected],
			                       _("Show/Hide Layer"));
		}
	}

	redraw = (layerColor != layers[(int)layerSelected].color ||
	          layers[(int)layerSelected].useColor != (BOOL_T)layerUseColor ||
	          (BOOL_T)layerVisible != layers[(int)layerSelected].visible);

	SetLayerColor(layerSelected, layerColor);

	if (layerSelected < NUM_BUTTONS &&
	    layers[(int)layerSelected].visible != (BOOL_T)layerVisible
	    && !layers[(int)layerSelected].button_off) {
		wButtonSetBusy(layer_btns[(int)layerSelected], layerVisible);
	}

	layers[(int)layerSelected].useColor = (BOOL_T)layerUseColor;
	if (layers[(int)layerSelected].visible != (BOOL_T)layerVisible) {
		FlipLayer(I2VP(layerSelected));
	}
	layers[(int)layerSelected].visible = (BOOL_T)layerVisible;
	layers[(int)layerSelected].frozen = (BOOL_T)layerFrozen;
	if (layers[(int)layerSelected].frozen) { DeselectLayer(layerSelected); }
	layers[(int)layerSelected].onMap = (BOOL_T)layerOnMap;
	layers[(int)layerSelected].scaleDescInx = layerScaleDescInx;
	layers[(int)layerSelected].gaugeInx = layerGaugeInx;
	layers[(int)layerSelected].scaleInx = GetScaleInx( layerScaleDescInx,
	                                      layerGaugeInx );
	layers[(int)layerSelected].minTrackRadius = layerMinRadius;
	layers[(int)layerSelected].maxTrackGrade = layerMaxGrade;
	layers[(int)layerSelected].tieData = layerTieData;
	layers[(int)layerSelected].module = (BOOL_T)layerModule;
	layers[(int)layerSelected].inherit = (BOOL_T)layerInherit;
	strcpy(layers[(int)layerSelected].settingsName, settingsName);

	PutLayerListArray((int)layerSelected, layerLinkList);

	SetLayerHideButton(layerSelected, layerNoButton);

	MainProc( mainW, wResize_e, NULL, NULL );

	if (layerRedrawMap) {
		DoRedraw();
	} else if (redraw) {
		RedrawLayer(layerSelected, TRUE);
	}

	layerRedrawMap = FALSE;
}


static void LayerSelect(
        wIndex_t inx)
{
	LayerUpdate();

	if (inx < 0 || inx >= NUM_LAYERS) {
		return;
	}

	layerSelected = (unsigned int)inx;
	strcpy(layerName, layers[inx].name);
	strcpy(settingsName, layers[inx].settingsName);
	layerVisible = layers[inx].visible;
	layerFrozen = layers[inx].frozen;
	layerOnMap = layers[inx].onMap;
	layerModule = layers[inx].module;
	layerColor = layers[inx].color;
	layerUseColor = layers[inx].useColor;
	layerNoButton = layers[inx].button_off;
	layerInherit = layers[inx].inherit;
	layerScaleInx = layers[inx].scaleInx;
	layerScaleDescInx = layers[inx].scaleDescInx;
	layerGaugeInx = layers[inx].gaugeInx;
	layerMinRadius = layers[inx].minTrackRadius;
	layerMaxGrade = layers[inx].maxTrackGrade;
	layerTieData.valid = layers[inx].tieData.valid;
	layerTieData.length = layers[inx].tieData.length;
	layerTieData.width = layers[inx].tieData.width;
	layerTieData.spacing = layers[inx].tieData.spacing;
	layerObjectCount = layers[inx].objCount;

	GetLayerLinkString(inx, layerLinkList);
	// sprintf(message, "%ld", layers[inx].objCount);
	// ParamLoadMessage(&layerPG, I_COUNT, message);
	ParamLoadControls(&layerPG);

	ParamControlActive( &layerPG, I_DELETE, (layerSelected > 0) ? TRUE : FALSE);

	ParamControlActive( &layerPG, I_SCALE, !layerInherit);
	ParamControlActive( &layerPG, I_GAUGE, !layerInherit);
	ParamControlActive( &layerPG, I_MINRADIUSENTRY, !layerInherit);
	ParamControlActive( &layerPG, I_MAXGRADEENTRY, !layerInherit);
	ParamControlActive( &layerPG, I_TIELEN, !layerInherit);
	ParamControlActive( &layerPG, I_TIEWID, !layerInherit);
	ParamControlActive( &layerPG, I_TIESPC, !layerInherit);

	if (layerS) {
		if (!LoadFileListLoad(settingsCatalog, settingsName)) {
			settingsName[0] = '\0';
			layers[inx].settingsName[0] = '\0';
		}

	}
}

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].module = FALSE;
		layers[inx].button_off = FALSE;
		layers[inx].inherit = TRUE;
		layers[inx].objCount = 0;
		strcpy(layers[inx].settingsName, "");
		DYNARR_RESET(int, layers[inx].layerLinkList);
		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 = -1;

	for (int i = 0; i < NUM_LAYERS; i++) {
		if (!layers[i].frozen) {
			curLayer = i;
			break;
		}
	}

	if (curLayer == -1) {
		ErrorMessage( MSG_NO_EMPTY_LAYER );
		layers[0].frozen = FALSE;
		curLayer = 0;
	}

	layerVisible = TRUE;
	layerFrozen = FALSE;
	layerOnMap = TRUE;
	layerModule = FALSE;
	layerInherit = FALSE;
	layerColor = layers[0].color;
	layerUseColor = TRUE;
	strcpy(layerName, layers[0].name);
	strcpy(settingsName, layers[0].settingsName);

	LoadLayerLists();

	if (layerL) {
		ParamLoadControls(&layerPG);
		// ParamLoadMessage(&layerPG, I_COUNT, "0");
	}
}


void SaveLayers(void)
{
	layers_save = malloc(NUM_LAYERS * sizeof(layers[0]));

	CHECK(layers_save != NULL);

	for (int i = 0; i < NUM_LAYERS; i++) {
		layers[i].settingsName[0] = '\0';
	}

	memcpy(layers_save, layers, NUM_LAYERS * sizeof layers[0]);
	ResetLayers();
}

void RestoreLayers(void)
{
	int inx;
	char * label;
	wDrawColor color;
	CHECK(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();
}


/**
 * Scan opened directory for the next settings file
 *
 * \param dir IN opened directory handle
 * \param dirName IN name of directory
 * \param fileName OUT fully qualified filename
 *
 * \return TRUE if file found, FALSE if not
 */

static bool
GetNextSettingsFile(DIR *dir, const char *dirName, char **fileName)
{
	bool done = false;
	bool res = false;

	/*
	* get all files from the directory
	*/
	while (!done) {
		struct stat fileState;
		struct dirent *ent;

		ent = readdir(dir);

		if (ent) {
			if (!XtcStricmp(FindFileExtension(ent->d_name), "xset")) {
				/* create full file name and get the state for that file */
				MakeFullpath(fileName, dirName, ent->d_name, NULL);

				if (stat(*fileName, &fileState) == -1) {
					fprintf(stderr, "Error getting file state for %s\n", *fileName);
					continue;
				}

				/* ignore any directories */
				if (!(fileState.st_mode & S_IFDIR)) {
					done = true;
					res = true;
				}
			}
		} else {
			done = true;
			res = false;
		}
	}
	return (res);
}


/*
 * Get all the settings files in the working directory
 */

static CatalogEntry *
ScanSettingsDirectory(Catalog *catalog, const char *dirName)
{
	DIR *d;
	CatalogEntry *newEntry = catalog->head;
	char contents[STR_SHORT_SIZE];

	d = opendir(dirName);
	if (d) {
		char *fileName = NULL;

		while (GetNextSettingsFile(d, dirName, &fileName)) {
			char *contents_start = strrchr(fileName, PATH_SEPARATOR[0]);
			if (contents_start[0] == '/') { contents_start++; }
			char *contents_end = strchr(contents_start, '.');
			if (contents_end[0] == '.') { contents_end[0] = '\0'; }
			strcpy(contents, contents_start);
			contents_end[0] = '.';
			newEntry = InsertInOrder(catalog, contents, NULL);
			UpdateCatalogEntry(newEntry, fileName, contents, NULL);
			free(fileName);
			fileName = NULL;
		}
		closedir(d);
	}

	return (newEntry);
}



/*****************************************************************************
*
* FILE READ/WRITE
*
*/

BOOL_T ReadLayers(char * line)
{
	char *name, *layerLinkList, *layerSettingsName, *extra;
	int inx, visible, frozen, color, onMap, sclInx, module, dontUseColor,
	    ColorFlags, button_off, inherit;
	double minRad, maxGrd, tieLen, tieWid, tieSpc;
	unsigned 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 (!IsLayerValid(curLayer)) {

			curLayer = 0;
		}

		if (layers[curLayer].frozen) {
			ErrorMessage( MSG_NOT_UNFROZEN_LAYER );
			layers[curLayer].frozen = FALSE;
		}

		if (layerL) {
			wListSetIndex(layerL, curLayer);
		}

		if (setLayerL) {
			wListSetIndex(setLayerL, curLayer);
		}

		return TRUE;
	}

	if (strncmp(line, "LINK", 4) == 0) {
		if (!GetArgs(line + 4, "dq", &inx, &layerLinkList)) {
			return FALSE;
		}
		PutLayerListArray(inx, layerLinkList);
		return TRUE;
	}

	if (strncmp(line, "SET", 3) == 0) {
		if (!GetArgs(line + 3, "dq", &inx, &layerSettingsName)) {
			return FALSE;
		}
		strcpy(layers[inx].settingsName, layerSettingsName);
		return TRUE;
	}

	/* get the properties for a layer from the file and update the layer accordingly */
	/* No Scale/tie data version */
	if (!GetArgs(line, "dddduddddqc", &inx, &visible, &frozen, &onMap, &rgb,
	             &module, &dontUseColor, &ColorFlags, &button_off, &name, &extra)) {
		return FALSE;
	}
	/* Check for old version: name here */
	if (extra && strlen(extra) > 0) {
		/* tie data version */
		if (!GetArgs(extra, "dufffff", &inherit, &sclInx, &minRad, &maxGrd,
		             &tieLen, &tieWid, &tieSpc)) {
			return FALSE;
		}
	} else {
		sclInx = GetLayoutCurScale();
		inherit = TRUE;
		minRad = 0.0;
		maxGrd = 0.0;
		tieLen = 0.0;
		tieWid = 0.0;
		tieSpc = 0.0;
	}

	// Provide defaults
	if ( minRad < EPSILON ) {
		minRad = GetScaleMinRadius(sclInx);
	}

	if (paramVersion < 9) {
		if ((int)rgb < COUNT( oldColorMap ) ) {
			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;
	}

	tieData_t td = {TRUE, tieLen, tieWid, tieSpc};
	ValidateTieData(&td);
	if ( !td.valid ) {
		td = GetScaleTieData(sclInx);
	}
	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].scaleInx = sclInx;
	layers[inx].minTrackRadius = minRad;
	layers[inx].maxTrackGrade = maxGrd;
	layers[inx].tieData = td;
	layers[inx].module = module;
	layers[inx].color = color;
	layers[inx].useColor = !dontUseColor;
	layers[inx].button_off = button_off;
	layers[inx].inherit = inherit;
	GetScaleGauge(sclInx, &layers[inx].scaleDescInx, &layers[inx].gaugeInx);

	colorTrack = ( ColorFlags & 1 ) ? 1 : 0; //Make sure globals are set
	colorDraw = ( ColorFlags & 2 ) ? 1 : 0;

	if (inx < NUM_BUTTONS && !layers[inx].button_off) {
		if (strlen(name) > 0) {
			wControlSetBalloonText((wControl_p)layer_btns[(int)inx], layers[inx].name);
		}
		wButtonSetBusy(layer_btns[(int)inx], visible);
	}
	MyFree(name);

	// The last layer will set this correctly
	maxLayer = inx;

	return TRUE;
}

/**
 * Find out whether layer information should be saved to the layout file.
 * Usually only layers where settings are off from the default are written.
 * NOTE: as a fix for a problem with XTrkCadReader a layer definition is
 * written for each layer that is used.
 *
 * \param layerNumber IN index of the layer
 * \return TRUE if configured, FALSE if not
 */

BOOL_T
IsLayerConfigured(unsigned int layerNumber)
{
	return (layers[layerNumber].name[0] ||
	        !layers[layerNumber].visible ||
	        layers[layerNumber].frozen ||
	        !layers[layerNumber].onMap ||
	        layers[layerNumber].module ||
	        layers[layerNumber].button_off ||
	        layers[layerNumber].color != layerColorTab[layerNumber % (COUNT(
	                                layerColorTab))] ||
	        layers[layerNumber].layerLinkList.cnt > 0 ||
	        layers[layerNumber].objCount);
}


/**
 * Save the layer information to the file.
 *
 * \paran f IN open file handle
 * \return always TRUE
 */

BOOL_T WriteLayers(FILE * f)
{
	unsigned int inx;

	int ColorFlags = 0;

	if (colorTrack) { ColorFlags |= 1; }
	if (colorDraw) { ColorFlags |= 2; }

	for (inx = 0; inx < NUM_LAYERS; inx++) {
		if (IsLayerConfigured(inx)) {
			fprintf(f,
			        "LAYERS %u %d %d %d %ld %d %d %d %d \"%s\" %d %lu %.6f %.6f %.6f %.6f %.6f\n",
			        inx,
			        layers[inx].visible,
			        layers[inx].frozen,
			        layers[inx].onMap,
			        wDrawGetRGB(layers[inx].color),
			        layers[inx].module,
			        layers[inx].useColor ? 0 : 1,
			        ColorFlags,
			        layers[inx].button_off,
			        PutTitle(layers[inx].name),
			        layers[inx].inherit,
			        layers[inx].scaleInx,
			        layers[inx].minTrackRadius,
			        layers[inx].maxTrackGrade,
			        layers[inx].tieData.length,
			        layers[inx].tieData.width,
			        layers[inx].tieData.spacing
			       );
		}
	}

	fprintf(f, "LAYERS CURRENT %u\n", curLayer);

	for (inx = 0; inx < NUM_LAYERS; inx++) {
		unsigned int layerInx = inx;
		GetLayerLinkString(inx, layerLinkList);
		if (IsLayerConfigured(inx) && strlen(layerLinkList) > 0) {
			fprintf(f, "LAYERS LINK %u \"%s\"\n", layerInx, layerLinkList);
		}
		if (IsLayerConfigured(inx) && layers[inx].settingsName[0]) {
			fprintf(f, "LAYERS SET %u \"%s\"\n", layerInx, layers[inx].settingsName);
		}
	}
	return TRUE;
}

/*****************************************************************************
*
* DIALOG & MENU
*
*/

/**
* 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 * unused)
{
	LayerSelect(layerSelected);

	if (newLayerCount != layerCount) {
		layoutLayerChanged = TRUE;

		if (newLayerCount > NUM_BUTTONS) {
			newLayerCount = NUM_BUTTONS;
		}

		layerCount = newLayerCount;
	}

	if (layoutLayerChanged) {
		MainProc(mainW, wResize_e, NULL, 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;
	/* No Break */
	case I_VIS:
	case I_FRZ:
	case I_MOD:
	case I_BUT:
	case I_DEF:
		LayerUpdate();
		UpdateLayerDlg(layerSelected);
		break;

	case I_SCALE:
		LoadGaugeList((wList_p)layerPLs[I_GAUGE].control, *((int *)valueP));
		// set the first entry as default, usually the standard gauge for a scale
		wListSetIndex((wList_p)layerPLs[I_GAUGE].control, 0);
		break;

	case I_TIELEN:
	case I_TIEWID:
	case I_TIESPC:
		ValidateTieData(&layerTieData);
		r_tieData.rangechecks = layerTieData.valid ? PDO_NORANGECHECK_LOW |
		                        PDO_NORANGECHECK_HIGH : 0;
		break;

	case I_SETTINGS:
		if (strcmp((char*)wListGetItemContext(settingsListL,
		                                      (wIndex_t) * (long*)valueP), " ") == 0) {
			settingsName[0] = '\0';
		} else {
			strcpy(settingsName, (char*)wListGetItemContext(settingsListL,
			                (wIndex_t) * (long*)valueP));
		}
		break;
	}
}


static void DoLayer(void * unused)
{
	if (layerW == NULL) {
		layerW = ParamCreateDialog(&layerPG, MakeWindowTitle(_("Layers")), _("Done"),
		                           LayerOk, wHide, TRUE, NULL, 0, LayerDlgUpdate);
		GetScaleGauge(layerScaleInx, &layerScaleDescInx, &layerGaugeInx);
		LoadScaleList(scaleL);
		LoadGaugeList(gaugeL, layerScaleDescInx);
	}

	if (settingsCatalog) { CatalogDiscard(settingsCatalog); }
	else { settingsCatalog = InitCatalog(); }
	ScanSettingsDirectory(settingsCatalog, wGetAppWorkDir());


	/* set the globals to the values for the current layer */
	UpdateLayerDlg(curLayer);
	layerRedrawMap = FALSE;
	wShow(layerW);
	layoutLayerChanged = FALSE;
}

#include "bitmaps/background.xpm3"

#if NUM_BUTTONS < 100
static int lbmap_width[3] = { 16, 24, 32 }; // For numbers < 100
#else
static int lbmap_width[3] = { 20, 28, 36 }; // For numbers > 99
#endif
static int lbmap_height[3] = { 16, 24, 32 };

static int lbit0_width[3] = { 6, 10, 14 };
static int lbit1_width[3] = { 4, 5, 6 };

static int lbits_top[3] = { 3, 4, 6 };
static int lbits_height[3] = { 10, 15, 20 };

#include "bitmaps/layer_num.inc"

static char** show_layer_digits[3][10] = {
	{
		n0_x16, n1_x16, n2_x16, n3_x16, n4_x16, n5_x16, n6_x16, n7_x16, n8_x16, n9_x16
	},
	{
		n0_x24, n1_x24, n2_x24, n3_x24, n4_x24, n5_x24, n6_x24, n7_x24, n8_x24, n9_x24
	},
	{
		n0_x32, n1_x32, n2_x32, n3_x32, n4_x32, n5_x32, n6_x32, n7_x32, n8_x32, n9_x32
	}
};

/* Note: If the number of buttons is increased to > ~120, you should
 *       also increase COMMAND_MAX and BUTTON_MAX in command.c
 *       NUM_LAYERS is defined in common.h
 */
#define ONE_PIXEL v *= 2; if (v > 128) { show_layer_bits[xx + yy] = b; xx += 1; v = 1; b = 0; }

void InitLayers(void)
{
	unsigned int i;
	wPrefGetInteger(PREFSECT, "layer-button-count", &layerCount, layerCount);

	for (i = 0; i < COUNT(layerRawColorTab); i++) {
		layerColorTab[i] = wDrawFindColor(layerRawColorTab[i]);
	}

	/* build the adjust table for starting bit */
	int dx_table[] = { 1, 2, 4, 8, 16, 32, 64, 128 };

	/* create the bitmaps for the layer buttons */
	/* all bitmaps have to have the same dimensions */
	for (int i = 0; i < NUM_LAYERS; i++) {
		int n = i + 1;
		int bwid = lbmap_width[iconSize];
		int wb = (bwid + 7) / 8; // width in bytes
		int bhgt = lbmap_height[iconSize];
		int h = lbits_height[iconSize];

		// if (n > 30) n = n + 70; for testing > 100

		show_layer_bits = MyMalloc(bhgt * wb);

		if (n < 10) {
			// width of char
			int wc = 0;     // width of char
			if (n == 1) {
				wc = lbit1_width[iconSize];
			} else {
				wc = lbit0_width[iconSize];
			}

			// X-adjust
			int dx = (bwid - wc) / 2;
			int x0 = 0;
			if (dx > 7) {
				dx -= 8;
				x0++;
			}

			char** cp = show_layer_digits[iconSize][n];

			for (int y = 0; y < h; y++) {
				int v = dx_table[dx]; // power of two
				char b = 0; // bits

				int yy = wb * (y + (bhgt - h) / 2);

				int xx = x0; // starting byte
				for (int x = 0; x < wc; x++) {
					char z = *(*cp + x + y * wc);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				if (v <= 128) {
					show_layer_bits[xx + yy] = b;
				}
			}

		} else if (n < 100) {
			// width of chars
			int wc1 = 0;
			int wc0 = 0;
			if ((n / 10) == 1) {
				wc1 = lbit1_width[iconSize];
			} else {
				wc1 = lbit0_width[iconSize];
			}
			if ((n % 10) == 1) {
				wc0 = lbit1_width[iconSize];
			} else {
				wc0 = lbit0_width[iconSize];
			}

			// X-adjust
			int dx = (bwid - wc1 - wc0 - (iconSize >= 1 ? 2 : 1)) / 2;
			int x0 = 0;
			if (dx > 7) {
				dx -= 8;
				x0++;
			}

			char** cp1 = show_layer_digits[iconSize][n / 10];
			char** cp0 = show_layer_digits[iconSize][n % 10];

			for (int y = 0; y < h; y++) {
				int v = dx_table[dx]; // powers of two
				char b = 0; // bits

				int yy = wb * (y + (bhgt - h) / 2);

				int xx = x0; // starting byte
				for (int x = 0; x < wc1; x++) {
					char z = *(*cp1 + x + y * wc1);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				ONE_PIXEL
				if (iconSize >= 1) {
					ONE_PIXEL
				}
				for (int x = 0; x < wc0; x++) {
					char z = *(*cp0 + x + y * wc0);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				if (v <= 128) {
					show_layer_bits[xx + yy] = b;
				}
			}

		} else { // n >= 100
			// width of chars
			int wc2 = 0;
			int wc1 = 0;
			int wc0 = 0;
			if ((n / 100) == 1) {
				wc2 = lbit1_width[iconSize];
			} else {
				wc2 = lbit0_width[iconSize];
			}
			if (((n / 10) % 10) == 1) {
				wc1 = lbit1_width[iconSize];
			} else {
				wc1 = lbit0_width[iconSize];
			}
			if ((n % 10) == 1) {
				wc0 = lbit1_width[iconSize];
			} else {
				wc0 = lbit0_width[iconSize];
			}

			// X-adjust and start
			int dx = (bwid - wc2 - wc1 - wc0 - 2) / 2;
			int x0 = 0;
			if (dx > 7) {
				dx -= 8;
				x0++;
			}

			char** cp2 = show_layer_digits[iconSize][n / 100];
			char** cp1 = show_layer_digits[iconSize][(n / 10) % 10];
			char** cp0 = show_layer_digits[iconSize][n % 10];

			for (int y = 0; y < h; y++) {
				int v = dx_table[dx]; // powers of two
				char b = 0; // bits

				int yy = wb * (y + (bhgt - h) / 2);

				int xx = x0; // byte
				for (int x = 0; x < wc2; x++) {
					char z = *(*cp2 + x + y * wc2);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				ONE_PIXEL
				for (int x = 0; x < wc1; x++) {
					char z = *(*cp1 + x + y * wc1);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				ONE_PIXEL
				for (int x = 0; x < wc0; x++) {
					char z = *(*cp0 + x + y * wc0);
					if (z != ' ') {
						b |= v;
					}
					ONE_PIXEL
				}
				if (v <= 128) {
					show_layer_bits[xx + yy] = b;
				}
			}
		}

		show_layer_bmps[i] = wIconCreateBitMap(
		                             bwid,
		                             bhgt,
		                             show_layer_bits,
		                             layerColorTab[i % (COUNT(layerColorTab))]);
		layers[i].color = layerColorTab[i % (COUNT(layerColorTab))];
		layers[i].useColor = TRUE;

		MyFree(show_layer_bits);
	}

	/* 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);

	backgroundB = AddToolbarButton("cmdBackgroundShow",
	                               wIconCreatePixMap(background_xpm3[iconSize]), 0,
	                               BackgroundToggleShow, NULL);
	/* add the help text */
	wControlSetBalloonText((wControl_p)backgroundB, _("Show/Hide Background"));
	wControlActive((wControl_p)backgroundB, FALSE);

	for (int i = 0; i < NUM_LAYERS; i++) {
		char *layerName;

		if (i < NUM_BUTTONS) {
			/* create the layer button */
			sprintf(message, "cmdLayerShow%u", i);
			layer_btns[i] = AddToolbarButton(message, show_layer_bmps[i], IC_MODETRAIN_TOO,
			                                 FlipLayer, I2VP(i) );
			/* set state of button */
			wButtonSetBusy(layer_btns[i], 1);
		}

		layerName = FormatLayerName(i);
		wListAddValue(setLayerL, layerName, NULL, I2VP(i));
		free(layerName);
	}

	AddPlaybackProc("SETCURRLAYER", PlaybackCurrLayer, NULL);
	AddPlaybackProc("LAYERS", (playbackProc_p)ReadLayers, NULL);
}

addButtonCallBack_t InitLayersDialog(void)
{
	ParamRegister(&layerPG);
	RegisterChangeNotification(LayerChange);
	return &DoLayer;
}
