From 7b358424ebad9349421acd533c2fa1cbf6cf3e3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Wed, 28 Dec 2016 16:52:56 +0100 Subject: Initial import of xtrkcad version 1:4.0.2-2 --- app/bin/dlayer.c | 978 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 978 insertions(+) create mode 100644 app/bin/dlayer.c (limited to 'app/bin/dlayer.c') 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 + +#include "track.h" +#include "i18n.h" + +#include + + +/***************************************************************************** + * + * 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_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;inx0?'+':'-', 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= 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_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_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 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; inx0; + 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