summaryrefslogtreecommitdiff
path: root/app/bin/dcar.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/bin/dcar.c')
-rw-r--r--app/bin/dcar.c5150
1 files changed, 5150 insertions, 0 deletions
diff --git a/app/bin/dcar.c b/app/bin/dcar.c
new file mode 100644
index 0000000..2bbf728
--- /dev/null
+++ b/app/bin/dcar.c
@@ -0,0 +1,5150 @@
+/*
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/dcar.c,v 1.6 2008-03-06 19:35:07 m_fischer Exp $
+ *
+ * TRAIN
+ *
+ */
+
+/* XTrkCad - Model Railroad CAD
+ * Copyright (C) 2005 Dave Bullis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef WINDOWS
+#include <errno.h>
+#endif
+#include <ctype.h>
+
+#include <stdint.h>
+
+#include "track.h"
+#include "ctrain.h"
+#include "i18n.h"
+#include "fileio.h"
+
+static int log_carList;
+static int log_carInvList;
+static int log_carDlgState;
+static int log_carDlgList;
+
+static paramFloatRange_t r0_99999 = { 0, 99999, 80 };
+static paramIntegerRange_t i1_999999999 = { 1, 999999999, 80, PDO_NORANGECHECK_HIGH };
+static paramIntegerRange_t i1_9999 = { 1, 9999, 50 };
+static char * isLocoLabels[] = { "", 0 };
+static char * cplrModeLabels[] = { N_("Truck"), N_("Body"), 0 };
+static BOOL_T carProtoListChanged;
+static void CarInvListAdd( carItem_p item );
+static void CarInvListUpdate( carItem_p item );
+
+#define T_MANUF (0)
+#define T_PROTO (1)
+#define T_DESC (2)
+#define T_PART (3)
+#define T_ROADNAME (4)
+#define T_REPMARK (5)
+#define T_NUMBER (6)
+
+typedef struct {
+ char * name;
+ long value;
+ } nameLongMap_t;
+
+
+#define CAR_DESC_COUPLER_MODE_BODY (1L<<0)
+#define CAR_DESC_IS_LOCO (1L<<1)
+#define CAR_DESC_IS_LOCO_MASTER (1L<<2)
+#define CAR_ITEM_HASNOTES (1L<<8)
+#define CAR_ITEM_ONLAYOUT (1L<<9)
+
+#define CAR_DESC_BITS (0x000000FF)
+#define CAR_ITEM_BITS (0x0000FF00)
+
+
+typedef struct carProto_t * carProto_p;
+
+typedef struct {
+ DIST_T carLength;
+ DIST_T carWidth;
+ DIST_T truckCenter;
+ DIST_T coupledLength;
+ } carDim_t;
+typedef struct {
+ char * number;
+ FLOAT_T purchPrice;
+ FLOAT_T currPrice;
+ long condition;
+ long purchDate;
+ long serviceDate;
+ char * notes;
+ } carData_t;
+
+struct carItem_t {
+ long index;
+ SCALEINX_T scaleInx;
+ char * contentsLabel;
+ char * title;
+ carProto_p proto;
+ DIST_T barScale;
+ wDrawColor color;
+ long options;
+ long type;
+ carDim_t dim;
+ carData_t data;
+ wIndex_t segCnt;
+ trkSeg_p segPtr;
+ track_p car;
+ coOrd pos;
+ ANGLE_T angle;
+ };
+
+
+/*
+ * Utilities
+ */
+
+
+
+typedef struct {
+ char * ptr;
+ int len;
+ } tabString_t, *tabString_p;
+
+
+static void TabStringExtract(
+ char * string,
+ int count,
+ tabString_t * tabs )
+{
+ int inx;
+ char * next = string;
+
+ for ( inx=0; inx<count; inx++ ) {
+ tabs[inx].ptr = string;
+ if ( next )
+ next = strchr( string, '\t' );
+ if ( next ) {
+ tabs[inx].len = next-string;
+ string = next+1;
+ } else {
+ tabs[inx].len = strlen( string );
+ string += tabs[inx].len;
+ }
+ }
+ if ( tabs[T_MANUF].len == 0 ) {
+ tabs[T_MANUF].len = 7;
+ tabs[T_MANUF].ptr = N_("Unknown");
+ }
+}
+
+
+static char * TabStringDup(
+ tabString_t * tab )
+{
+ char * ret;
+ ret = MyMalloc( tab->len+1 );
+ memcpy( ret, tab->ptr, tab->len );
+ ret[tab->len] = '\0';
+ return ret;
+}
+
+
+static char * TabStringCpy(
+ char * dst,
+ tabString_t * tab )
+{
+ memcpy( dst, tab->ptr, tab->len );
+ dst[tab->len] = '\0';
+ return dst+tab->len;
+}
+
+
+static int TabStringCmp(
+ char * src,
+ tabString_t * tab )
+{
+ int srclen = strlen(src);
+ int len = srclen;
+ int rc;
+ if ( len > tab->len )
+ len = tab->len;
+ rc = strncasecmp( src, tab->ptr, len );
+ if ( rc != 0 || srclen == tab->len )
+ return rc;
+ else if ( srclen > tab->len )
+ return 1;
+ else
+ return -1;
+}
+
+
+static long TabGetLong(
+ tabString_t * tab )
+{
+ char old_c;
+ long val;
+ if ( tab->len <= 0 )
+ return 0;
+ old_c = tab->ptr[tab->len];
+ tab->ptr[tab->len] = '\0';
+ val = atol( tab->ptr );
+ tab->ptr[tab->len] = old_c;
+ return val;
+}
+
+
+static FLOAT_T TabGetFloat(
+ tabString_t * tab )
+{
+ char old_c;
+ FLOAT_T val;
+ if ( tab->len <= 0 )
+ return 0.0;
+ old_c = tab->ptr[tab->len];
+ tab->ptr[tab->len] = '\0';
+ val = atof( tab->ptr );
+ tab->ptr[tab->len] = old_c;
+ return val;
+}
+
+
+static void RotatePts(
+ int cnt,
+ coOrd * pts,
+ coOrd orig,
+ ANGLE_T angle )
+{
+ int inx;
+ for ( inx=0; inx<cnt; inx++ ) {
+ Rotate( &pts[inx], orig, angle );
+ }
+}
+
+
+static void RescalePts(
+ int cnt,
+ coOrd * pts,
+ FLOAT_T scale_x,
+ FLOAT_T scale_y )
+{
+ int inx;
+ for ( inx=0; inx<cnt; inx++ ) {
+ pts[inx].x *= scale_x;
+ pts[inx].y *= scale_y;
+ }
+}
+
+
+static int lookupListIndex;
+static void * LookupListElem(
+ dynArr_t * da,
+ void * key,
+ int (*cmpFunc)( void *, void * ),
+ int elem_size )
+{
+ int hi, lo, mid, rc;
+ lo = 0;
+ hi = da->cnt-1;
+ while (lo <= hi ) {
+ mid = (lo+hi)/2;
+ rc = cmpFunc( key, DYNARR_N(void*,*da,mid) );
+ if ( rc == 0 ) {
+ lookupListIndex = mid;
+ return DYNARR_N(void*,*da,mid);
+ }
+ if ( rc > 0 )
+ lo = mid+1;
+ else
+ hi = mid-1;
+ }
+ if ( elem_size == 0 ) {
+ lookupListIndex = -1;
+ return NULL;
+ }
+ DYNARR_APPEND( void*, *da, 10 );
+ for ( mid=da->cnt-1; mid>lo; mid-- )
+ DYNARR_N(void*,*da,mid) = DYNARR_N(void*,*da,mid-1);
+ DYNARR_N(void*,*da,lo) = (void*)MyMalloc(elem_size);
+ memset( DYNARR_N(void*,*da,lo), 0, elem_size );
+ lookupListIndex = lo;
+ return DYNARR_N(void*,*da,lo);
+}
+
+static void RemoveListElem(
+ dynArr_t * da,
+ void * elem )
+{
+ int inx;
+ for ( inx=0; inx<da->cnt; inx++ )
+ if ( DYNARR_N(void*,*da,inx) == elem )
+ break;
+ if ( inx>=da->cnt )
+ AbortProg( "removeListElem" );
+ for ( inx++; inx<da->cnt; inx++ )
+ DYNARR_N(void*,*da,inx-1) = DYNARR_N(void*,*da,inx);
+ da->cnt--;
+}
+
+/*
+ * Draw Car Parts
+ */
+
+
+#define BW (8)
+#define TW (45)
+#define SI (30)
+#define SO (37)
+static coOrd truckOutline[] = {
+ { -TW, -SO },
+ { TW, -SO },
+ { TW, -SI },
+ { BW, -SI },
+ { BW, SI },
+ { TW, SI },
+ { TW, SO },
+ { -TW, SO },
+ { -TW, SI },
+ { -BW, SI },
+ { -BW, -SI },
+ { -TW, -SI } };
+#define WO ((56.6-2)/2)
+#define WI ((56.6-12)/2)
+#define Wd (36/2)
+#define AW (8/2)
+static coOrd wheelOutline[] = {
+ { -Wd, -WO },
+
+ { -AW, -WO },
+ { -AW, -SI },
+ { AW, -SI },
+ { AW, -WO },
+
+ { Wd, -WO },
+ { Wd, -WI },
+ { AW, -WI },
+ { AW, WI },
+ { Wd, WI },
+ { Wd, WO },
+
+ { AW, WO },
+ { AW, SI },
+ { -AW, SI },
+ { -AW, WO },
+
+ { -Wd, WO },
+ { -Wd, WI },
+ { -AW, WI },
+ { -AW, -WI },
+
+ { -Wd, -WI } };
+
+static void MovePts(
+ int cnt,
+ coOrd * pts,
+ coOrd orig )
+{
+ int inx;
+ for ( inx=0; inx<cnt; inx++ ) {
+ pts[inx].x += orig.x;
+ pts[inx].y += orig.y;
+ }
+}
+
+
+static void CarProtoDrawTruck(
+ drawCmd_t * d,
+ DIST_T width,
+ FLOAT_T ratio,
+ coOrd pos,
+ ANGLE_T angle )
+{
+ coOrd p[24], pp;
+ wDrawColor color = wDrawColorBlack;
+
+ memcpy( p, truckOutline, sizeof truckOutline );
+ RescalePts( sizeof truckOutline/sizeof truckOutline[0], p, 1.0, width/56.5 );
+ RescalePts( sizeof wheelOutline/sizeof wheelOutline[0], p, ratio, ratio );
+ RotatePts( sizeof wheelOutline/sizeof wheelOutline[0], p, zero, angle );
+ MovePts( sizeof truckOutline/sizeof truckOutline[0], p, pos );
+ DrawFillPoly( d, sizeof truckOutline/sizeof truckOutline[0], p, color );
+ pp.x = -70/2;
+ pp.y = 0;
+ memcpy( p, wheelOutline, sizeof wheelOutline );
+ RescalePts( sizeof wheelOutline/sizeof wheelOutline[0], p, 1.0, width/56.5 );
+ MovePts( sizeof wheelOutline/sizeof wheelOutline[0], p, pp );
+ RescalePts( sizeof wheelOutline/sizeof wheelOutline[0], p, ratio, ratio );
+ RotatePts( sizeof wheelOutline/sizeof wheelOutline[0], p, zero, angle );
+ MovePts( sizeof wheelOutline/sizeof wheelOutline[0], p, pos );
+ DrawFillPoly( d, sizeof wheelOutline/sizeof wheelOutline[0], p, color );
+ pp.x = 70/2;
+ memcpy( p, wheelOutline, sizeof wheelOutline );
+ RescalePts( sizeof wheelOutline/sizeof wheelOutline[0], p, 1.0, width/56.5 );
+ MovePts( sizeof wheelOutline/sizeof wheelOutline[0], p, pp );
+ RescalePts( sizeof wheelOutline/sizeof wheelOutline[0], p, ratio, ratio );
+ RotatePts( sizeof wheelOutline/sizeof wheelOutline[0], p, zero, angle );
+ MovePts( sizeof wheelOutline/sizeof wheelOutline[0], p, pos );
+ DrawFillPoly( d, sizeof wheelOutline/sizeof wheelOutline[0], p, color );
+}
+
+
+static coOrd couplerOutline[] = {
+ { 0, 2.5 },
+ { 0, -2.5 },
+ { 0, -2.5 },
+ { 3, -7 },
+ { 14, -5 },
+ { 14, 2 },
+ { 12, 2 },
+ { 12, -2 },
+ { 9, -2 },
+ { 9, 3 },
+ { 13, 6 },
+ { 13, 7 },
+ { 6, 7 },
+ { 0, 2.5 } };
+static void CarProtoDrawCoupler(
+ drawCmd_t * d,
+ DIST_T length,
+ FLOAT_T ratio,
+ coOrd pos,
+ ANGLE_T angle )
+{
+ coOrd p[24], pp;
+ wDrawColor color = wDrawColorBlack;
+
+ length /= ratio;
+ if ( length < 12.0 )
+ return;
+ memcpy( p, couplerOutline, sizeof couplerOutline );
+ p[0].x = p[1].x = -(length-12.0);
+ pp.x = length-12.0;
+ pp.y = 0;
+/* TODO - if length > 6 then draw Sills */
+#ifdef FUTURE
+ if ( angle == 270.0 ) {
+ pos.x -= (length-12.0);
+ for ( inx=0; inx<sizeof couplerOutline/sizeof couplerOutline[0]; inx++ ) {
+ p[inx].x = -p[inx].x;
+ p[inx].y = -p[inx].y;
+ }
+ } else {
+ pos.x += (length-12.0);
+ }
+#endif
+ MovePts( sizeof couplerOutline/sizeof couplerOutline[0], p, pp );
+ RescalePts( sizeof couplerOutline/sizeof couplerOutline[0], p, ratio, ratio );
+ RotatePts( sizeof couplerOutline/sizeof couplerOutline[0], p, zero, angle-90.0 );
+ MovePts( sizeof couplerOutline/sizeof couplerOutline[0], p, pos );
+ DrawFillPoly( d, sizeof couplerOutline/sizeof couplerOutline[0], p, color );
+}
+
+
+
+/*
+ * Car Proto
+ */
+
+
+struct carProto_t;
+typedef struct carProto_t carProto_t;
+
+struct carProto_t {
+ char * contentsLabel;
+ wIndex_t paramFileIndex;
+ char * desc;
+ long options;
+ long type;
+ carDim_t dim;
+ int segCnt;
+ trkSeg_p segPtr;
+ coOrd size;
+ coOrd orig;
+ };
+
+static dynArr_t carProto_da;
+#define carProto(N) DYNARR_N( carProto_t*, carProto_da, N )
+
+#define N_TYPELISTMAP (7)
+static nameLongMap_t typeListMap[N_TYPELISTMAP] = {
+ { N_("Diesel Loco"), 10101 },
+ { N_("Steam Loco"), 10201 },
+ { N_("Elect Loco"), 10301 },
+ { N_("Freight Car"), 30100 },
+ { N_("Psngr Car"), 50100 },
+ { N_("M-O-W"), 70100 },
+ { N_("Other"), 90100 } };
+
+static trkSeg_p carProtoSegPtr;
+static int carProtoSegCnt;
+
+
+static coOrd dummyOutlineSegPts[5];
+static trkSeg_t dummyOutlineSegs;
+static void CarProtoDlgCreateDummyOutline(
+ int * segCntP,
+ trkSeg_p * segPtrP,
+ BOOL_T isLoco,
+ DIST_T length,
+ DIST_T width,
+ wDrawColor color )
+{
+ trkSeg_p segPtr;
+ coOrd * pts;
+ DIST_T length2;
+
+ *segCntP = 1;
+ segPtr = *segPtrP = &dummyOutlineSegs;
+
+ segPtr->type = SEG_FILPOLY;
+ segPtr->color = color;
+ segPtr->width = 0;
+ segPtr->u.p.cnt = isLoco?5:4;
+ segPtr->u.p.pts = pts = dummyOutlineSegPts;
+ segPtr->u.p.orig.x = 0;
+ segPtr->u.p.orig.y = 0;
+ segPtr->u.p.angle = 0;
+ length2 = length;
+ if ( isLoco ) {
+ pts->x = length;
+ pts->y = width/2.0;
+ pts++;
+ length2 -= width/2.0;
+ }
+ pts->x = length2;
+ pts->y = 0.0;
+ pts++;
+ pts->x = 0.0;
+ pts->y = 0.0;
+ pts++;
+ pts->x = 0.0;
+ pts->y = width;
+ pts++;
+ pts->x = length2;
+ pts->y = width;
+}
+
+
+static int CarProtoFindTypeCode(
+ long code )
+{
+ int inx;
+ for ( inx=0; inx<N_TYPELISTMAP; inx++ ) {
+ if ( typeListMap[inx].value > code ) {
+ if ( inx == 0 )
+ return N_TYPELISTMAP-1;
+ else
+ return inx-1;
+ }
+ }
+ return N_TYPELISTMAP-1;
+}
+
+
+static int CmpCarProto(
+ void * key,
+ void * elem )
+{
+ char * key_val=key;
+ carProto_p elem_val=elem;
+ return strcasecmp( key_val, elem_val->desc );
+}
+
+
+static carProto_p CarProtoFind(
+ char * desc )
+{
+ return LookupListElem( &carProto_da, desc, CmpCarProto, 0 );
+}
+
+
+static carProto_p CarProtoLookup(
+ char * desc,
+ BOOL_T createMissing,
+ BOOL_T isLoco,
+ DIST_T length,
+ DIST_T width )
+{
+ carProto_p proto;
+ trkSeg_p segPtr;
+ proto = LookupListElem( &carProto_da, desc, CmpCarProto, createMissing?sizeof *proto:0 );
+ if ( proto == NULL )
+ return NULL;
+ if ( proto->desc == NULL ) {
+ proto->desc = MyStrdup(desc);
+ proto->contentsLabel = "Car Prototype";
+ proto->paramFileIndex = PARAM_LAYOUT;
+ proto->options = (isLoco?CAR_DESC_IS_LOCO:0);
+ proto->dim.carLength = length;
+ proto->dim.carWidth = width;
+ proto->dim.truckCenter = length - 2.0*59.0;
+ proto->dim.coupledLength = length + 2.0*16.0;
+ CarProtoDlgCreateDummyOutline( &proto->segCnt, &segPtr, isLoco, length, width, drawColorBlue );
+ proto->segPtr = (trkSeg_p)memdup( segPtr, (sizeof *(trkSeg_p)0) * proto->segCnt );
+ CloneFilledDraw( proto->segCnt, proto->segPtr, FALSE );
+ GetSegBounds( zero, 0.0, proto->segCnt, proto->segPtr, &proto->orig, &proto->size );
+ carProtoListChanged = TRUE;
+ }
+ return proto;
+}
+
+
+static carProto_p CarProtoNew(
+ carProto_p proto,
+ int paramFileIndex,
+ char * desc,
+ long options,
+ long type,
+ carDim_t * dim,
+ wIndex_t segCnt,
+ trkSeg_p segPtr )
+{
+ if ( proto == NULL ) {
+ proto = LookupListElem( &carProto_da, desc, CmpCarProto, sizeof *(carProto_p)0 );
+ if ( proto->desc != NULL ) {
+ if ( proto->paramFileIndex == PARAM_CUSTOM &&
+ paramFileIndex != PARAM_CUSTOM )
+ return proto;
+ }
+ }
+ if ( proto->desc != NULL ) {
+ MyFree( proto->desc );
+ }
+ proto->desc = MyStrdup(desc);
+ proto->contentsLabel = "Car Prototype";
+ proto->paramFileIndex = paramFileIndex;
+ proto->options = options;
+ proto->type = type;
+ proto->dim = *dim;
+ proto->segCnt = segCnt;
+ proto->segPtr = (trkSeg_p)memdup( segPtr, (sizeof *(trkSeg_p)0) * proto->segCnt );
+ CloneFilledDraw( proto->segCnt, proto->segPtr, FALSE );
+ GetSegBounds( zero, 0.0, proto->segCnt, proto->segPtr, &proto->orig, &proto->size );
+ carProtoListChanged = TRUE;
+ return proto;
+}
+
+
+static void CarProtoDelete(
+ carProto_p protoP )
+{
+ if ( protoP == NULL )
+ return;
+ RemoveListElem( &carProto_da, protoP );
+ if ( protoP->desc )
+ MyFree( protoP->desc );
+ MyFree( protoP );
+}
+
+
+static BOOL_T CarProtoRead(
+ char * line )
+{
+ char * desc;
+ long options;
+ long type;
+ carDim_t dim;
+
+ if ( !GetArgs( line+9, "qllff00ff",
+ &desc, &options, &type, &dim.carLength, &dim.carWidth, &dim.truckCenter, &dim.coupledLength ) )
+ return FALSE;
+ if ( !ReadSegs() )
+ return FALSE;
+ CarProtoNew( NULL, curParamFileIndex, desc, options, type, &dim, tempSegs_da.cnt, &tempSegs(0) );
+ return TRUE;
+}
+
+
+static BOOL_T CarProtoWrite(
+ FILE * f,
+ carProto_t * proto )
+{
+ BOOL_T rc = TRUE;
+ char *oldLocale = NULL;
+
+ oldLocale = SaveLocale("C");
+
+ rc &= fprintf( f, "CARPROTO \"%s\" %ld %ld %0.3f %0.3f 0 0 %0.3f %0.3f\n",
+ PutTitle(proto->desc), proto->options, proto->type, proto->dim.carLength, proto->dim.carWidth, proto->dim.truckCenter, proto->dim.coupledLength )>0;
+ rc &= WriteSegs( f, proto->segCnt, proto->segPtr );
+
+ RestoreLocale(oldLocale);
+
+ return rc;
+}
+
+
+
+static BOOL_T CarProtoCustomSave(
+ FILE * f )
+{
+ int inx;
+ carProto_t * proto;
+ BOOL_T rc = TRUE;
+
+ for ( inx=0; inx<carProto_da.cnt; inx++ ) {
+ proto = carProto(inx);
+ if ( proto->paramFileIndex == PARAM_CUSTOM )
+ rc &= CarProtoWrite( f, proto );
+ }
+ return rc;
+}
+
+
+/*
+ * Car Desc
+ */
+
+struct carPart_t;
+typedef struct carPart_t carPart_t;
+typedef carPart_t * carPart_p;
+struct carPartParent_t;
+typedef struct carPartParent_t carPartParent_t;
+typedef carPartParent_t * carPartParent_p;
+
+typedef struct {
+ char * name;
+ int len;
+ } cmp_key_t;
+
+typedef struct {
+ tabString_t manuf;
+ tabString_t proto;
+ SCALEINX_T scale;
+ } cmp_partparent_t;
+struct carPartParent_t {
+ char * manuf;
+ char * proto;
+ SCALEINX_T scale;
+ dynArr_t parts_da;
+ };
+struct carPart_t {
+ carPartParent_p parent;
+ wIndex_t paramFileIndex;
+ char * title;
+ long options;
+ long type;
+ carDim_t dim;
+ wDrawColor color;
+ char * partnoP;
+ int partnoL;
+ };
+static dynArr_t carPartParent_da;
+#define carPartParent(N) DYNARR_N(carPartParent_p, carPartParent_da, N)
+#define carPart(P,N) DYNARR_N(carPart_p, (P)->parts_da, N)
+struct roadnameMap_t;
+typedef struct roadnameMap_t roadnameMap_t;
+typedef roadnameMap_t * roadnameMap_p;
+struct roadnameMap_t {
+ char * roadname;
+ char * repmark;
+ };
+static dynArr_t roadnameMap_da;
+#define roadnameMap(N) DYNARR_N(roadnameMap_p, roadnameMap_da, N)
+static BOOL_T roadnameMapChanged;
+static long carPartChangeLevel = 0;
+
+
+
+static int Cmp_part(
+ void * key,
+ void * elem )
+{
+ carPart_p cmp_key=key;
+ carPart_p part_elem=elem;
+ int rc;
+ int len;
+
+ len = min( cmp_key->partnoL, part_elem->partnoL );
+ rc = strncasecmp( cmp_key->partnoP, part_elem->partnoP, len+1 );
+ if ( rc != 0 )
+ return rc;
+ if ( cmp_key->paramFileIndex == part_elem->paramFileIndex )
+ return 0;
+ if ( cmp_key->paramFileIndex == PARAM_DEMO )
+ return -1;
+ if ( part_elem->paramFileIndex == PARAM_DEMO )
+ return 1;
+ if ( cmp_key->paramFileIndex == PARAM_CUSTOM )
+ return -1;
+ if ( part_elem->paramFileIndex == PARAM_CUSTOM )
+ return 1;
+ if ( cmp_key->paramFileIndex == PARAM_LAYOUT )
+ return 1;
+ if ( part_elem->paramFileIndex == PARAM_LAYOUT )
+ return -1;
+ if ( cmp_key->paramFileIndex > part_elem->paramFileIndex )
+ return -1;
+ else
+ return 1;
+}
+
+
+static int Cmp_partparent(
+ void * key,
+ void * elem )
+{
+ cmp_partparent_t * cmp_key=key;
+ carPartParent_p part_elem=elem;
+ int rc;
+
+ rc = - TabStringCmp( part_elem->manuf, &cmp_key->manuf );
+ if ( rc != 0 )
+ return rc;
+ rc = cmp_key->scale - part_elem->scale;
+ if ( rc != 0 )
+ return rc;
+ rc = - TabStringCmp( part_elem->proto, &cmp_key->proto );
+ return rc;
+}
+
+
+static int Cmp_roadnameMap(
+ void * key,
+ void * elem )
+{
+ cmp_key_t * cmp_key=key;
+ roadnameMap_p roadname_elem=elem;
+ int rc;
+
+ rc = strncasecmp( cmp_key->name, roadname_elem->roadname, cmp_key->len );
+ if ( rc == 0 && roadname_elem->roadname[cmp_key->len] )
+ return -1;
+ return rc;
+}
+
+
+static roadnameMap_p LoadRoadnameList(
+ tabString_p roadnameTab,
+ tabString_p repmarkTab )
+{
+ cmp_key_t cmp_key;
+ roadnameMap_p roadnameMapP;
+
+ lookupListIndex = -1;
+ if ( roadnameTab->len<=0 )
+ return NULL;
+ if ( TabStringCmp( "undecorated", roadnameTab ) == 0 )
+ return NULL;
+
+ cmp_key.name = roadnameTab->ptr;
+ cmp_key.len = roadnameTab->len;
+ roadnameMapP = LookupListElem( &roadnameMap_da, &cmp_key, Cmp_roadnameMap, sizeof *(roadnameMap_p)0 );
+ if ( roadnameMapP->roadname == NULL ) {
+ roadnameMapP->roadname = TabStringDup(roadnameTab);
+ roadnameMapP->repmark = TabStringDup(repmarkTab);
+ roadnameMapChanged = TRUE;
+ } else if ( repmarkTab->len > 0 &&
+ ( roadnameMapP->repmark == NULL || roadnameMapP->repmark[0] == '\0' ) ) {
+ roadnameMapP->repmark = TabStringDup(repmarkTab);
+ roadnameMapChanged = TRUE;
+ }
+ return roadnameMapP;
+}
+
+
+static carPart_p CarPartFind(
+ char * manufP,
+ int manufL,
+ char * partnoP,
+ int partnoL,
+ SCALEINX_T scale )
+{
+ wIndex_t inx1, inx2;
+ carPart_p partP;
+ carPartParent_p parentP;
+ for ( inx1=0; inx1<carPartParent_da.cnt; inx1++ ) {
+ parentP = carPartParent(inx1);
+ if ( manufL == (int)strlen(parentP->manuf) &&
+ strncasecmp( manufP, parentP->manuf, manufL ) == 0 &&
+ scale == parentP->scale ) {
+ for ( inx2=0; inx2<parentP->parts_da.cnt; inx2++ ) {
+ partP = carPart( parentP, inx2 );
+ if ( partnoL == partP->partnoL &&
+ strncasecmp( partnoP, partP->partnoP, partnoL ) == 0 ) {
+ return partP;
+ }
+ }
+ }
+ }
+ return NULL;
+}
+
+
+
+
+static void CarPartParentDelete(
+ carPartParent_p parentP )
+{
+ RemoveListElem( &carPartParent_da, parentP );
+ MyFree( parentP->manuf );
+ MyFree( parentP->proto );
+ MyFree( parentP );
+}
+
+
+static void CarPartUnlink(
+ carPart_p partP )
+{
+ carPartParent_p parentP = partP->parent;
+ RemoveListElem( &parentP->parts_da, partP );
+ if ( parentP->parts_da.cnt <= 0 ) {
+ CarPartParentDelete( parentP );
+ }
+}
+
+
+static carPartParent_p CarPartParentNew(
+ char * manufP,
+ int manufL,
+ char *protoP,
+ int protoL,
+ SCALEINX_T scale )
+{
+ carPartParent_p parentP;
+ cmp_partparent_t cmp_key;
+ cmp_key.manuf.ptr = manufP;
+ cmp_key.manuf.len = manufL;
+ cmp_key.proto.ptr = protoP;
+ cmp_key.proto.len = protoL;
+ cmp_key.scale = scale;
+ parentP = (carPartParent_p)LookupListElem( &carPartParent_da, &cmp_key, Cmp_partparent, sizeof * parentP);
+ if ( parentP->manuf == NULL ) {
+ parentP->manuf = (char*)MyMalloc( manufL+1 );
+ memcpy( parentP->manuf, manufP, manufL );
+ parentP->manuf[manufL] = '\0';
+ parentP->proto = (char*)MyMalloc( protoL+1 );
+ memcpy( parentP->proto, protoP, protoL );
+ parentP->proto[protoL] = '\0';
+ parentP->scale = scale;
+ }
+ return parentP;
+}
+
+
+static carPart_p CarPartNew(
+ carPart_p partP,
+ int paramFileIndex,
+ SCALEINX_T scaleInx,
+ char * title,
+ long options,
+ long type,
+ carDim_t *dim,
+ wDrawColor color)
+{
+ carPartParent_p parentP;
+ carPart_t cmp_key;
+ tabString_t tabs[7];
+
+ TabStringExtract( title, 7, tabs );
+ if ( TabStringCmp( "Undecorated", &tabs[T_MANUF] ) == 0 ||
+ TabStringCmp( "Custom", &tabs[T_MANUF] ) == 0 ||
+ tabs[T_PART].len == 0 )
+ return NULL;
+ if ( tabs[T_PROTO].len == 0 )
+ return NULL;
+ if ( partP == NULL ) {
+ partP = CarPartFind( tabs[T_MANUF].ptr, tabs[T_MANUF].len, tabs[T_PART].ptr, tabs[T_PART].len, scaleInx );
+ if ( partP != NULL &&
+ partP->paramFileIndex == PARAM_CUSTOM &&
+ paramFileIndex != PARAM_CUSTOM )
+ return partP;
+LOG( log_carList, 2, ( "new car part: %s (%d) at %d\n", title, paramFileIndex, lookupListIndex ) )
+ }
+ if ( partP != NULL ) {
+ CarPartUnlink( partP );
+ if ( partP->title != NULL )
+ MyFree( partP->title );
+LOG( log_carList, 2, ( "upd car part: %s (%d)\n", title, paramFileIndex ) )
+ }
+ LoadRoadnameList( &tabs[T_ROADNAME], &tabs[T_REPMARK] );
+ parentP = CarPartParentNew( tabs[T_MANUF].ptr, tabs[T_MANUF].len, tabs[T_PROTO].ptr, tabs[T_PROTO].len, scaleInx );
+ cmp_key.title = title;
+ cmp_key.parent = parentP;
+ cmp_key.paramFileIndex = paramFileIndex;
+ cmp_key.options = options;
+ cmp_key.type = type;
+ cmp_key.dim = *dim;
+ cmp_key.color = color;
+ cmp_key.partnoP = tabs[T_PART].ptr;
+ cmp_key.partnoL = tabs[T_PART].len;
+ partP = (carPart_p)LookupListElem( &parentP->parts_da, &cmp_key, Cmp_part, sizeof * partP );
+ if ( partP->title != NULL )
+ MyFree( partP->title );
+ *partP = cmp_key;
+ sprintf( message, "\t\t%s", tabs[2].ptr );
+ partP->title = MyStrdup( message );
+ partP->partnoP = partP->title + 2+tabs[2].len+1;;
+ partP->partnoL = tabs[T_PART].len;
+ return partP;
+}
+
+
+static void CarPartDelete(
+ carPart_p partP )
+{
+ if ( partP == NULL )
+ return;
+ CarPartUnlink( partP );
+ if ( partP->title )
+ MyFree( partP->title );
+ MyFree( partP );
+}
+
+
+static BOOL_T CarPartRead(
+ char * line )
+{
+ char scale[10];
+ long options;
+ long type;
+ char * title;
+ carDim_t dim;
+ long rgb;
+
+ if ( !GetArgs( line+8, "sqllff00ffl",
+ scale, &title, &options, &type, &dim.carLength, &dim.carWidth, &dim.truckCenter, &dim.coupledLength, &rgb ) )
+ return FALSE;
+ CarPartNew( NULL, curParamFileIndex, LookupScale(scale), title, options, type, &dim, wDrawFindColor(rgb) );
+ MyFree( title );
+ return TRUE;
+}
+
+
+static BOOL_T CarPartWrite(
+ FILE * f,
+ carPart_p partP )
+{
+ BOOL_T rc = TRUE;
+ char *oldLocale = NULL;
+ carPartParent_p parentP=partP->parent;
+ tabString_t tabs[7];
+
+ oldLocale = SaveLocale("C");
+
+ TabStringExtract( partP->title, 7, tabs );
+ sprintf( message, "%s\t%s\t%.*s\t%.*s\t%.*s\t%.*s\t%.*s",
+ parentP->manuf, parentP->proto,
+ tabs[T_DESC].len, tabs[T_DESC].ptr,
+ tabs[T_PART].len, tabs[T_PART].ptr,
+ tabs[T_ROADNAME].len, tabs[T_ROADNAME].ptr,
+ tabs[T_REPMARK].len, tabs[T_REPMARK].ptr,
+ tabs[T_NUMBER].len, tabs[T_NUMBER].ptr );
+ rc &= fprintf( f, "CARPART %s \"%s\"", GetScaleName(partP->parent->scale), PutTitle(message) )>0;
+ rc &= fprintf( f, " %ld %ld %0.3f %0.3f 0 0 %0.3f %0.3f %ld\n",
+ partP->options, partP->type, partP->dim.carLength, partP->dim.carWidth, partP->dim.truckCenter, partP->dim.coupledLength, wDrawGetRGB(partP->color) )>0;
+
+ RestoreLocale(oldLocale);
+
+ return rc;
+}
+
+
+
+static BOOL_T CarDescCustomSave(
+ FILE * f )
+{
+ int parentX;
+ carPartParent_p parentP;
+ int partX;
+ carPart_p partP;
+ BOOL_T rc = TRUE;
+
+ for ( parentX=0; parentX<carPartParent_da.cnt; parentX++ ) {
+ parentP = carPartParent(parentX);
+ for ( partX=0; partX<parentP->parts_da.cnt; partX++ ) {
+ partP = carPart(parentP,partX);
+ if ( partP->paramFileIndex == PARAM_CUSTOM )
+ rc &= CarPartWrite(f, partP );
+ }
+ }
+ return rc;
+}
+
+
+
+/*
+ * Car Item
+ */
+
+static dynArr_t carItemInfo_da;
+#define carItemInfo(N) DYNARR_N( carItem_t*, carItemInfo_da, N )
+
+#define N_CONDLISTMAP (6)
+static nameLongMap_t condListMap[N_CONDLISTMAP] = {
+ { N_("N/A"), 0 },
+ { N_("Mint"), 100 },
+ { N_("Excellent"), 80 },
+ { N_("Good"), 60 },
+ { N_("Fair"), 40 },
+ { N_("Poor"), 20 } };
+
+
+static wIndex_t MapCondition(
+ long conditionValue )
+{
+ if ( conditionValue < 10 )
+ return 0;
+ else if ( conditionValue < 30 )
+ return 5;
+ else if ( conditionValue < 50 )
+ return 4;
+ else if ( conditionValue < 70 )
+ return 3;
+ else if ( conditionValue < 90 )
+ return 2;
+ else
+ return 1;
+}
+
+
+static carItem_p CarItemNew(
+ carItem_p item,
+ int paramFileIndex,
+ long itemIndex,
+ SCALEINX_T scale,
+ char * title,
+ long options,
+ long type,
+ carDim_t *dim,
+ wDrawColor color,
+ FLOAT_T purchPrice,
+ FLOAT_T currPrice,
+ long condition,
+ long purchDate,
+ long serviceDate )
+{
+ carPart_p partP;
+ tabString_t tabs[7];
+
+ TabStringExtract( title, 7, tabs );
+ if ( paramFileIndex != PARAM_CUSTOM ) {
+ partP = CarPartFind( tabs[T_MANUF].ptr, tabs[T_MANUF].len, tabs[T_PART].ptr, tabs[T_PART].len, scale );
+ if ( partP == NULL ) {
+ CarPartNew( NULL, PARAM_LAYOUT, scale, title, options, type, dim, color );
+ }
+ }
+
+ if ( item == NULL ) {
+ DYNARR_APPEND( carItem_t*, carItemInfo_da, 10 );
+ item = (carItem_t*)MyMalloc( sizeof * item );
+ carItemInfo(carItemInfo_da.cnt-1) = item;
+ } else {
+ if ( item->title ) MyFree( item->title );
+ if ( item->data.number ) MyFree( item->data.number );
+ }
+ item->index = itemIndex;
+ item->scaleInx = scale;
+ item->title = MyStrdup(title);
+ item->contentsLabel = "Car Item";
+ item->barScale = curBarScale>0?curBarScale:(60.0*12.0/curScaleRatio);
+ item->options = options;
+ item->type = type;
+ item->dim = *dim;
+ item->color = color;
+ if ( tabs[T_REPMARK].len>0 || tabs[T_NUMBER].len>0 ) {
+ sprintf( message, "%.*s%s%.*s", tabs[T_REPMARK].len, tabs[T_REPMARK].ptr, (tabs[T_REPMARK].len>0&&tabs[T_NUMBER].len>0)?" ":"", tabs[T_NUMBER].len, tabs[T_NUMBER].ptr );
+ } else {
+ sprintf( message, "#%ld", item->index );
+ }
+ item->data.number = MyStrdup( message );
+ item->data.purchPrice = purchPrice;
+ item->data.currPrice = currPrice;
+ item->data.condition = condition;
+ item->data.purchDate = purchDate;
+ item->data.serviceDate = serviceDate;
+ item->data.notes = NULL;
+ item->segCnt = 0;
+ item->segPtr = NULL;
+ LoadRoadnameList( &tabs[T_ROADNAME], &tabs[T_REPMARK] );
+ return item;
+}
+
+
+EXPORT BOOL_T CarItemRead(
+ char * line )
+{
+ long itemIndex;
+ char scale[10];
+ char * title;
+ long options;
+ long type;
+ carDim_t dim;
+ long rgb;
+ FLOAT_T purchPrice = 0;
+ FLOAT_T currPrice = 0;
+ long condition = 0;
+ long purchDate = 0;
+ long serviceDate = 0;
+ int len, siz;
+ static dynArr_t buffer_da;
+ carItem_p item;
+ char * cp;
+ wIndex_t layer;
+ coOrd pos;
+ ANGLE_T angle;
+ wIndex_t index;
+
+ if ( !GetArgs( line+4, "lsqll" "ff00ffl" "fflll000000c",
+ &itemIndex, scale, &title, &options, &type,
+ &dim.carLength, &dim.carWidth, &dim.truckCenter, &dim.coupledLength, &rgb,
+ &purchPrice, &currPrice, &condition, &purchDate, &serviceDate, &cp ) )
+ return FALSE;
+ if ( (options&CAR_ITEM_HASNOTES) ) {
+ DYNARR_SET( char, buffer_da, 0 );
+ while ( (line=GetNextLine()) && strncmp( line, " END", 7 ) != 0 ) {
+ siz = buffer_da.cnt;
+ len = strlen( line );
+ DYNARR_SET( char, buffer_da, siz+len+1 );
+ memcpy( &((char*)buffer_da.ptr)[siz], line, len );
+ ((char*)buffer_da.ptr)[siz+len] = '\n';
+ }
+ DYNARR_APPEND( char, buffer_da, 1 );
+ ((char*)buffer_da.ptr)[buffer_da.cnt-1] = 0;
+ }
+ item = CarItemNew( NULL, curParamFileIndex, itemIndex, LookupScale(scale), title,
+ options&(CAR_DESC_BITS|CAR_ITEM_BITS), type, &dim, wDrawFindColor(rgb),
+ purchPrice, currPrice, condition, purchDate, serviceDate );
+ if ( (options&CAR_ITEM_HASNOTES) )
+ item->data.notes = MyStrdup( (char*)buffer_da.ptr );
+ MyFree(title);
+ if ( (options&CAR_ITEM_ONLAYOUT) ) {
+ if ( !GetArgs( cp, "dLpf",
+ &index, &layer, &pos, &angle ) )
+ return FALSE;
+ item->car = NewCar( index, item, pos, angle );
+ SetTrkLayer( item->car, layer );
+ ReadSegs();
+ SetEndPts( item->car, 2 );
+ ComputeBoundingBox( item->car );
+ }
+ return TRUE;
+}
+
+
+static BOOL_T CarItemWrite(
+ FILE * f,
+ carItem_t * item,
+ BOOL_T layout )
+{
+ long options = (item->options&CAR_DESC_BITS);
+ coOrd pos;
+ ANGLE_T angle;
+ BOOL_T rc = TRUE;
+ char *oldLocale = NULL;
+
+ oldLocale = SaveLocale("C");
+
+ if ( item->data.notes && item->data.notes[0] )
+ options |= CAR_ITEM_HASNOTES;
+ if ( layout && item->car && !IsTrackDeleted(item->car) )
+ options |= CAR_ITEM_ONLAYOUT;
+ rc &= fprintf( f, "CAR %ld %s \"%s\" %ld %ld %0.3f %0.3f 0 0 %0.3f %0.3f %ld %0.3f %0.3f %ld %ld %ld 0 0 0 0 0 0",
+ item->index, GetScaleName(item->scaleInx), PutTitle(item->title),
+ options, item->type,
+ item->dim.carLength, item->dim.carWidth, item->dim.truckCenter, item->dim.coupledLength, wDrawGetRGB(item->color),
+ item->data.purchPrice, item->data.currPrice, item->data.condition, item->data.purchDate, item->data.serviceDate )>0;
+ if ( ( options&CAR_ITEM_ONLAYOUT) ) {
+ CarGetPos( item->car, &pos, &angle );
+ rc &= fprintf( f, " %d %d %0.3f %0.3f %0.3f",
+ GetTrkIndex(item->car), GetTrkLayer(item->car), pos.x, pos.y, angle )>0;
+ }
+ rc &= fprintf( f, "\n" )>0;
+ if ( (options&CAR_ITEM_HASNOTES) ) {
+ rc &= fprintf( f, "%s\n", item->data.notes )>0;
+ rc &= fprintf( f, " END\n" )>0;
+ }
+ if ( (options&CAR_ITEM_ONLAYOUT) ) {
+ rc &= WriteEndPt( f, item->car, 0 );
+ rc &= WriteEndPt( f, item->car, 1 );
+ rc &= fprintf( f, "\tEND\n" )>0;
+ }
+
+ RestoreLocale(oldLocale);
+
+ return rc;
+}
+
+
+
+EXPORT carItem_p CarItemFind(
+ long itemInx )
+{
+ if ( itemInx >= 0 && itemInx < carItemInfo_da.cnt )
+ return carItemInfo(itemInx);
+ else
+ return NULL;
+}
+
+
+EXPORT long CarItemFindIndex(
+ carItem_p item )
+{
+ long inx;
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ )
+ if ( carItemInfo(inx) == item )
+ return inx;
+ AbortProg( "carItemFindIndex" );
+ return -1;
+}
+
+
+EXPORT void CarItemGetSegs(
+ carItem_p item )
+{
+ coOrd orig;
+ carProto_p protoP;
+ tabString_t tabs[7];
+ trkSeg_t * segPtr;
+ DIST_T ratio = GetScaleRatio(item->scaleInx);
+
+ TabStringExtract( item->title, 7, tabs );
+ TabStringCpy( message, &tabs[T_PROTO] );
+ protoP = CarProtoLookup( message, FALSE, FALSE, 0.0, 0.0 );
+ if ( protoP != NULL ) {
+ item->segCnt = protoP->segCnt;
+ segPtr = protoP->segPtr;
+ orig = protoP->orig;
+ } else {
+ CarProtoDlgCreateDummyOutline( &item->segCnt, &segPtr, (item->options&CAR_DESC_IS_LOCO)!=0, item->dim.carLength, item->dim.carWidth, item->color );
+ orig = zero;
+ }
+ item->segPtr = (trkSeg_p)MyMalloc( item->segCnt * sizeof *(segPtr) );
+ memcpy( item->segPtr, segPtr, item->segCnt * sizeof *(segPtr) );
+ CloneFilledDraw( item->segCnt, item->segPtr, FALSE );
+ if ( protoP ) {
+ orig.x = -orig.x;
+ orig.y = -orig.y;
+ MoveSegs( item->segCnt, item->segPtr, orig );
+ RescaleSegs( item->segCnt, item->segPtr, item->dim.carLength/protoP->size.x, item->dim.carWidth/protoP->size.y, 1/ratio );
+ RecolorSegs( item->segCnt, item->segPtr, item->color );
+ }
+}
+
+
+EXPORT BOOL_T WriteCars(
+ FILE * f )
+{
+ int inx;
+ BOOL_T rc = TRUE;
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ )
+ rc &= CarItemWrite( f, carItemInfo(inx), TRUE );
+ return rc;
+}
+
+
+EXPORT BOOL_T CarCustomSave(
+ FILE * f )
+{
+ BOOL_T rc = TRUE;
+ rc &= CarProtoCustomSave( f );
+ rc &= CarDescCustomSave( f );
+ return rc;
+}
+
+
+/*
+ * Car Item Select
+ */
+
+EXPORT carItem_p currCarItemPtr;
+EXPORT long carHotbarModeInx = 1;
+static long carHotbarModes[] = { 0x0002, 0x0012, 0x0312, 0x4312, 0x0021, 0x0321, 0x4321 };
+static long carHotbarContents[] = { 0x0005, 0x0002, 0x0012, 0x0012, 0x0001, 0x0021, 0x0021 };
+static long newCarInx;
+static paramData_t newCarPLs[] = {
+ { PD_DROPLIST, &newCarInx, "index", PDO_DLGWIDE, (void*)400, N_("Item") } };
+static paramGroup_t newCarPG = { "train-newcar", 0, newCarPLs, sizeof newCarPLs/sizeof newCarPLs[0] };
+EXPORT wControl_p newCarControls[2];
+static char newCarLabel1[STR_SIZE];
+static char * newCarLabels[2] = { newCarLabel1, NULL };
+
+static dynArr_t carItemHotbar_da;
+#define carItemHotbar(N) DYNARR_N( carItem_p, carItemHotbar_da, N )
+
+
+static int Cmp_carHotbar(
+ const void * ptr1,
+ const void * ptr2 )
+{
+ carItem_p item1 = *(carItem_p*)ptr1;
+ carItem_p item2 = *(carItem_p*)ptr2;
+ tabString_t tabs1[7], tabs2[7];
+ int rc;
+ long mode;
+
+ TabStringExtract( item1->title, 7, tabs1 );
+ TabStringExtract( item2->title, 7, tabs2 );
+ for ( mode=carHotbarModes[carHotbarModeInx],rc=0; mode!=0&&rc==0; mode>>=4 ) {
+ switch ( mode&0x000F ) {
+ case 4:
+ rc = (int)(item1->index-item2->index);
+ break;
+ case 1:
+ rc = strncasecmp( tabs1[T_MANUF].ptr, tabs2[T_MANUF].ptr, max(tabs1[T_MANUF].len,tabs2[T_MANUF].len) );
+ break;
+ case 3:
+ rc = strncasecmp( tabs1[T_PART].ptr, tabs2[T_PART].ptr, max(tabs1[T_PART].len,tabs2[T_PART].len) );
+ break;
+ case 2:
+ if ( item1->type < item2->type )
+ rc = -1;
+ else if ( item1->type > item2->type )
+ rc = 1;
+ else
+ rc = strncasecmp( tabs1[T_PROTO].ptr, tabs2[T_PROTO].ptr, max(tabs1[T_PROTO].len,tabs2[T_PROTO].len) );
+ break;
+ }
+ }
+ return rc;
+}
+
+
+static void CarItemHotbarUpdate(
+ paramGroup_p pg,
+ int inx,
+ void * data )
+{
+ wIndex_t carItemInx;
+ carItem_p item;
+ if ( inx == 0 ) {
+ carItemInx = (wIndex_t)*(long*)data;
+ if ( carItemInx < 0 )
+ return;
+ carItemInx = (wIndex_t)(long)wListGetItemContext( (wList_p)pg->paramPtr[inx].control, carItemInx );
+ item = carItemHotbar(carItemInx);
+ if ( item != NULL )
+ currCarItemPtr = item;
+ }
+}
+
+
+static char * FormatCarTitle(
+ carItem_p item,
+ long mode )
+{
+ tabString_t tabs[7];
+ char * cp;
+ TabStringExtract( item->title, 7, tabs );
+ cp = message;
+ for ( ; mode!=0; mode>>=4 ) {
+ switch ( mode&0x000F ) {
+ case 1:
+ cp = TabStringCpy( cp, &tabs[T_MANUF] );
+ break;
+ case 2:
+ cp = TabStringCpy( cp, &tabs[T_PROTO] );
+ break;
+ case 3:
+ cp = TabStringCpy( cp, &tabs[T_PART] );
+ break;
+ case 4:
+ sprintf( cp, "%ld ", item->index );
+ cp += strlen(cp);
+ break;
+ case 5:
+ strcpy( cp, typeListMap[CarProtoFindTypeCode(item->type)].name );
+ cp += strlen(cp);
+ break;
+ }
+ *cp++ = '/';
+ }
+ *--cp = '\0';
+ return message;
+}
+
+
+EXPORT char * CarItemDescribe(
+ carItem_p item,
+ long mode,
+ long * index )
+{
+ tabString_t tabs[7];
+ char * cp;
+ static char desc[STR_LONG_SIZE];
+
+ TabStringExtract( item->title, 7, tabs );
+ cp = desc;
+ if ( mode != -1 ) {
+ sprintf( cp, "%ld ", item->index );
+ cp = desc+strlen(cp);
+ }
+ if ( (mode&0xF)!=1 && ((mode>>4)&0xF)!=1 && ((mode>>8)&0xF)!=1 && ((mode>>12)&0xF)!=1 ) {
+ cp = TabStringCpy( cp, &tabs[T_MANUF] );
+ *cp++ = ' ';
+ }
+ if ( (mode&0xF)!=3 && ((mode>>4)&0xF)!=3 && ((mode>>8)&0xF)!=3 && ((mode>>12)&0xF)!=3 ) {
+ cp = TabStringCpy( cp, &tabs[T_PART] );
+ *cp++ = ' ';
+ }
+ if ( (mode&0xF)!=2 && ((mode>>4)&0xF)!=2 && ((mode>>8)&0xF)!=2 && ((mode>>12)&0xF)!=2 ) {
+ cp = TabStringCpy( cp, &tabs[T_PROTO] );
+ *cp++ = ' ';
+ }
+ if ( tabs[T_DESC].len > 0 ) {
+ cp = TabStringCpy( cp, &tabs[T_DESC] );
+ *cp++ = ' ';
+ }
+ if ( mode != -1 ) {
+ if ( tabs[T_REPMARK].len > 0 ) {
+ cp = TabStringCpy( cp, &tabs[T_REPMARK] );
+ *cp++ = ' ';
+ } else if ( tabs[T_ROADNAME].len > 0 ) {
+ cp = TabStringCpy( cp, &tabs[T_ROADNAME] );
+ *cp++ = ' ';
+ }
+ if ( tabs[T_NUMBER].len > 0 ) {
+ cp = TabStringCpy( cp, &tabs[T_NUMBER] );
+ *cp++ = ' ';
+ }
+ }
+ *--cp = '\0';
+ if ( index != NULL )
+ *index = item->index;
+ return desc;
+}
+
+
+EXPORT void CarItemLoadList( void * junk )
+{
+ wIndex_t inx;
+ carItem_p item;
+ char * cp;
+ wPos_t w, h;
+
+ DYNARR_SET( carItem_t*, carItemHotbar_da, carItemInfo_da.cnt );
+ memcpy( carItemHotbar_da.ptr, carItemInfo_da.ptr, carItemInfo_da.cnt * sizeof item );
+ wListClear( (wList_p)newCarPLs[0].control );
+ for ( inx=0; inx<carItemHotbar_da.cnt; inx++ ) {
+ item = carItemHotbar(inx);
+ if ( item->car && !IsTrackDeleted(item->car) )
+ continue;
+ cp = CarItemDescribe( item, 0, NULL );
+ wListAddValue( (wList_p)newCarPLs[0].control, cp, NULL, (void*)(intptr_t)inx );
+ }
+ /*wListSetValue( (wList_p)newCarPLs[0].control, "Select a car" );*/
+ wListSetIndex( (wList_p)newCarPLs[0].control, 0 );
+ strcpy( newCarLabel1, _("Select") );
+ ParamLoadControl( &newCarPG, 0 );
+ InfoSubstituteControls( newCarControls, newCarLabels );
+ wWinGetSize( mainW, &w, &h );
+ w -= wControlGetPosX( newCarControls[0] ) + 4;
+ if ( w > 20 )
+ wListSetSize( (wList_p)newCarControls[0], w, wControlGetHeight( newCarControls[0] ) );
+}
+
+
+static char * CarItemHotbarProc(
+ hotBarProc_e op,
+ void * data,
+ drawCmd_p d,
+ coOrd * origP )
+{
+ wIndex_t carItemInx = (wIndex_t)(long)data;
+ carItem_p item;
+ wIndex_t inx;
+ long mode;
+ char * cp;
+ wPos_t w, h;
+
+ item = carItemHotbar(carItemInx);
+ if ( item == NULL )
+ return NULL;
+ switch ( op ) {
+ case HB_SELECT:
+ currCarItemPtr = item;
+ mode = carHotbarModes[carHotbarModeInx];
+ if ( (mode&0xF000) == 0 ) {
+ wListClear( (wList_p)newCarPLs[0].control );
+ for ( inx=carItemInx;
+ inx<carItemHotbar_da.cnt && ( inx==carItemInx || Cmp_carHotbar(&carItemHotbar(carItemInx),&carItemHotbar(inx))==0 );
+ inx++ ) {
+ item = carItemHotbar(inx);
+ if ( item->car && !IsTrackDeleted(item->car) )
+ continue;
+ cp = CarItemDescribe( item, mode, NULL );
+ wListAddValue( (wList_p)newCarPLs[0].control, cp, NULL, (void*)(intptr_t)inx );
+ }
+ /*wListSetValue( (wList_p)newCarPLs[0].control, "Select a car" );*/
+ wListSetIndex( (wList_p)newCarPLs[0].control, 0 );
+ cp = CarItemHotbarProc( HB_BARTITLE, (void*)(intptr_t)carItemInx, NULL, NULL );
+ strncpy( newCarLabel1, cp, sizeof newCarLabel1 );
+ ParamLoadControls( &newCarPG );
+ ParamGroupRecord( &newCarPG );
+
+ InfoSubstituteControls( newCarControls, newCarLabels );
+ wWinGetSize( mainW, &w, &h );
+ w -= wControlGetPosX( newCarControls[0] ) + 4;
+ if ( w > 20 )
+ wListSetSize( (wList_p)newCarControls[0], w, wControlGetHeight( newCarControls[0] ) );
+ } else {
+ InfoSubstituteControls( NULL, NULL );
+ cp = CarItemDescribe( item, 0, NULL );
+ InfoMessage( cp );
+ }
+ break;
+ case HB_LISTTITLE:
+ case HB_BARTITLE:
+ return FormatCarTitle( item, carHotbarModes[carHotbarModeInx] );
+ case HB_FULLTITLE:
+ return item->title;
+ case HB_DRAW:
+ if ( item->segCnt == 0 )
+ CarItemGetSegs( item );
+ DrawSegs( d, *origP, 0.0, item->segPtr, item->segCnt, trackGauge, wDrawColorBlack );
+ return NULL;
+ }
+ return NULL;
+}
+
+
+EXPORT int CarAvailableCount( void )
+{
+ wIndex_t inx;
+ int cnt = 0;
+ carItem_t * item;
+ for ( inx=0; inx < carItemHotbar_da.cnt; inx ++ ) {
+ item = carItemHotbar(inx);
+ if ( item->scaleInx != curScaleInx )
+ continue;
+ cnt++;
+ }
+ return cnt;
+}
+
+
+EXPORT void AddHotBarCarDesc( void )
+{
+ wIndex_t inx;
+ carItem_t * item0, * item1;
+ coOrd orig;
+ coOrd size;
+
+ DYNARR_SET( carItem_t*, carItemHotbar_da, carItemInfo_da.cnt );
+ memcpy( carItemHotbar_da.ptr, carItemInfo_da.ptr, carItemInfo_da.cnt * sizeof item0 );
+ qsort( carItemHotbar_da.ptr, carItemHotbar_da.cnt, sizeof item0, Cmp_carHotbar );
+ for ( inx=0,item0=NULL; inx < carItemHotbar_da.cnt; inx ++ ) {
+ item1 = carItemHotbar(inx);
+ if ( item1->car && !IsTrackDeleted(item1->car) )
+ continue;
+ if ( item1->scaleInx != curScaleInx )
+ continue;
+ if ( (carHotbarModes[carHotbarModeInx]&0xF000)!=0 || ( item0 == NULL || Cmp_carHotbar( &item0, &item1 ) != 0 ) ) {
+#ifdef DESCFIX
+ orig.x = - item->orig.x;
+ orig.y = - item->orig.y;
+#endif
+ orig = zero;
+ size.x = item1->dim.carLength;
+ size.y = item1->dim.carWidth;
+ AddHotBarElement( FormatCarTitle( item1, carHotbarContents[carHotbarModeInx] ), size, orig, FALSE, (60.0*12.0/curScaleRatio), (void*)(intptr_t)inx, CarItemHotbarProc );
+ }
+ item0 = item1;
+ }
+}
+
+
+EXPORT coOrd CarItemFindCouplerMountPoint(
+ carItem_p item,
+ traverseTrack_t trvTrk,
+ int dir )
+{
+ DIST_T couplerOffset;
+ coOrd pos;
+
+ if ( dir )
+ FlipTraverseTrack( &trvTrk );
+ if ( trvTrk.trk == NULL || (item->options&CAR_DESC_COUPLER_MODE_BODY)!=0 ) {
+ couplerOffset = (item->dim.carLength-(item->dim.coupledLength-item->dim.carLength))/2.0;
+ Translate( &pos, trvTrk.pos, trvTrk.angle, couplerOffset );
+ } else {
+ TraverseTrack2( &trvTrk, item->dim.truckCenter/2.0 );
+ /*Translate( &pos1, trvTrk.pos, trvTrk.angle, item->dim.truckCenter/2.0 );*/
+ couplerOffset = item->dim.carLength - (item->dim.truckCenter+item->dim.coupledLength)/2.0;
+ Translate( &pos, trvTrk.pos, trvTrk.angle, couplerOffset );
+ }
+ return pos;
+}
+
+
+EXPORT void CarItemSize(
+ carItem_p item,
+ coOrd * size )
+{
+ size->x = item->dim.carLength;
+ size->y = item->dim.carWidth;
+}
+
+
+EXPORT char * CarItemNumber(
+ carItem_p item )
+{
+ return item->data.number;
+}
+
+
+static DIST_T CarItemTruckCenter(
+ carItem_p item )
+{
+ return item->dim.truckCenter;
+}
+
+
+EXPORT DIST_T CarItemCoupledLength(
+ carItem_p item )
+{
+ return item->dim.coupledLength;
+}
+
+
+EXPORT BOOL_T CarItemIsLoco(
+ carItem_p item )
+{
+ return (item->options&CAR_DESC_IS_LOCO) == (CAR_DESC_IS_LOCO);
+}
+
+
+EXPORT BOOL_T CarItemIsLocoMaster(
+ carItem_p item )
+{
+ return (item->options&(CAR_DESC_IS_LOCO|CAR_DESC_IS_LOCO_MASTER)) == (CAR_DESC_IS_LOCO|CAR_DESC_IS_LOCO_MASTER);
+}
+
+
+EXPORT void CarItemSetLocoMaster(
+ carItem_p item,
+ BOOL_T locoIsMaster )
+{
+ if ( locoIsMaster )
+ item->options |= CAR_DESC_IS_LOCO_MASTER;
+ else
+ item->options &= ~CAR_DESC_IS_LOCO_MASTER;
+}
+
+
+EXPORT void CarItemSetTrack(
+ carItem_p item,
+ track_p trk )
+{
+ item->car = trk;
+ if ( trk != NULL )
+ SetTrkScale( trk, item->scaleInx );
+}
+
+static DIST_T CarItemCouplerLength(
+ carItem_p item,
+ int dir )
+{
+ return item->dim.coupledLength-item->dim.carLength;
+}
+
+
+EXPORT void CarItemPlace(
+ carItem_p item,
+ traverseTrack_p trvTrk,
+ DIST_T * dists )
+{
+ DIST_T dist;
+ traverseTrack_t trks[2];
+
+ dist = CarItemTruckCenter(item)/2.0;
+ trks[0] = trks[1] = *trvTrk;
+ TraverseTrack2( &trks[0], dist );
+ TraverseTrack2( &trks[1], -dist );
+ item->pos.x = (trks[0].pos.x+trks[1].pos.x)/2.0;
+ item->pos.y = (trks[0].pos.y+trks[1].pos.y)/2.0;
+ item->angle = FindAngle( trks[1].pos, trks[0].pos );
+ dists[0] = dists[1] = CarItemCoupledLength(item)/2.0;
+}
+
+
+
+static int drawCarTrucks = 0;
+EXPORT void CarItemDraw(
+ drawCmd_p d,
+ carItem_p item,
+ wDrawColor color,
+ int direction,
+ BOOL_T locoIsMaster,
+ vector_t *coupler )
+{
+ coOrd size, pos, pos2;
+ DIST_T length;
+ wFont_p fp;
+ wDrawWidth width;
+ trkSeg_t simpleSegs[1];
+ coOrd simplePts[4];
+ int dir;
+ DIST_T rad;
+ static int couplerLineWidth = 3;
+ DIST_T scale2rail;
+
+ CarItemSize( item, &size );
+ if ( d->scale >= ((d->options&DC_PRINT)?(twoRailScale*2+1):twoRailScale) ) {
+ simplePts[0].x = simplePts[3].x = -size.x/2.0;
+ simplePts[1].x = simplePts[2].x = size.x/2.0;
+ simplePts[0].y = simplePts[1].y = -size.y/2.0;
+ simplePts[2].y = simplePts[3].y = size.y/2.0;
+ simpleSegs[0].type = SEG_FILPOLY;
+ simpleSegs[0].color = item->color;
+ simpleSegs[0].width = 0;
+ simpleSegs[0].u.p.cnt = 4;
+ simpleSegs[0].u.p.pts = simplePts;
+ simpleSegs[0].u.p.orig = zero;
+ simpleSegs[0].u.p.angle = 0.0;
+ DrawSegs( d, item->pos, item->angle-90.0, simpleSegs, 1, 0.0, color );
+ } else {
+ if ( item->segCnt == 0 )
+ CarItemGetSegs( item );
+ Translate( &pos, item->pos, item->angle, -size.x/2.0 );
+ Translate( &pos, pos, item->angle-90, -size.y/2.0 );
+ DrawSegs( d, pos, item->angle-90.0, item->segPtr, item->segCnt, 0.0, color );
+ }
+
+ if ( drawCarTrucks ) {
+ length = item->dim.truckCenter/2.0;
+ Translate( &pos, item->pos, item->angle, length );
+ DrawArc( d, pos, trackGauge/2.0, 0.0, 360.0, FALSE, 0, color );
+ Translate( &pos, item->pos, item->angle+180, length );
+ DrawArc( d, pos, trackGauge/2.0, 0.0, 360.0, FALSE, 0, color );
+ }
+
+ if ( (labelEnable&LABELENABLE_CARS) ) {
+ fp = wStandardFont( F_HELV, FALSE, FALSE );
+ DrawBoxedString( BOX_BACKGROUND, d, item->pos, item->data.number, fp, (wFontSize_t)descriptionFontSize, color, 0.0 );
+ }
+
+ /* draw loco head light */
+ if ( (item->options&CAR_DESC_IS_LOCO)!=0 ) {
+ Translate( &pos, item->pos, item->angle+(direction?180.0:0.0), size.x/2.0-trackGauge/2.0 );
+ if ( locoIsMaster ) {
+ DrawFillCircle( d, pos, trackGauge/2.0, (color==wDrawColorBlack?drawColorGold:color) );
+ } else {
+ width = (wDrawWidth)floor( trackGauge/8.0 * d->dpi / d->scale );
+ DrawArc( d, pos, trackGauge/2.0, 0.0, 360.0, FALSE, width, (color==wDrawColorBlack?drawColorGold:color) );
+ }
+ }
+
+ /* draw coupler */
+ scale2rail = ((d->options&DC_PRINT)?(twoRailScale*2+1):twoRailScale);
+ if ( d->scale >= scale2rail )
+ return;
+ scale2rail /= 2;
+ rad = trackGauge/8.0;
+ for ( dir=0; dir<2; dir++ ) {
+ Translate( &pos, coupler[dir].pos, coupler[dir].angle, CarItemCouplerLength(item,dir) );
+ DrawLine( d, coupler[dir].pos, pos, couplerLineWidth, color );
+ if ( d->scale < scale2rail ) {
+ /*DrawFillCircle( d, p0, rad, dir==0?color:selectedColor );*/
+ Translate( &pos2, pos, coupler[dir].angle+90.0, trackGauge/3 );
+ DrawLine( d, pos2, pos, couplerLineWidth, color );
+ }
+ }
+}
+
+
+EXPORT void CarItemUpdate(
+ carItem_p item )
+{
+ DoChangeNotification( CHANGE_SCALE );
+}
+
+/*
+ * Car Item/Part Dlg
+ */
+
+static int carDlgChanged;
+
+static SCALEINX_T carDlgScaleInx;
+static carItem_p carDlgUpdateItemPtr;
+static carPart_p carDlgUpdatePartPtr;
+static carProto_p carDlgUpdateProtoPtr;
+static carPart_p carDlgNewPartPtr;
+static carProto_p carDlgNewProtoPtr;
+
+static BOOL_T carDlgFlipToggle;
+
+static wIndex_t carDlgManufInx;
+static char carDlgManufStr[STR_SIZE];
+static wIndex_t carDlgKindInx;
+static wIndex_t carDlgProtoInx;
+static char carDlgProtoStr[STR_SIZE];
+static wIndex_t carDlgPartnoInx;
+static char carDlgPartnoStr[STR_SIZE];
+static char carDlgDescStr[STR_SIZE];
+
+static long carDlgDispMode;
+static wIndex_t carDlgRoadnameInx;
+static char carDlgRoadnameStr[STR_SIZE];
+static char carDlgRepmarkStr[STR_SIZE];
+static char carDlgNumberStr[STR_SIZE];
+static wDrawColor carDlgBodyColor;
+static long carDlgIsLoco;
+static wIndex_t carDlgTypeInx;
+
+static carDim_t carDlgDim;
+static DIST_T carDlgCouplerLength;
+static long carDlgCouplerMount;
+
+static long carDlgItemIndex = 1;
+static FLOAT_T carDlgPurchPrice;
+static char carDlgPurchPriceStr[STR_SIZE];
+static FLOAT_T carDlgCurrPrice;
+static char carDlgCurrPriceStr[STR_SIZE];
+static wIndex_t carDlgConditionInx;
+static long carDlgCondition;
+static long carDlgPurchDate;
+static char carDlgPurchDateStr[STR_SIZE];
+static long carDlgServiceDate;
+static char carDlgServiceDateStr[STR_SIZE];
+static long carDlgQuantity = 1;
+static long carDlgMultiNum;
+
+static char *dispmodeLabels[] = { N_("Information"), N_("Customize"), NULL };
+static drawCmd_t carDlgD = {
+ NULL,
+ &screenDrawFuncs,
+ DC_NOCLIP,
+ 1.0,
+ 0.0,
+ { 0, 0 }, { 0, 0 },
+ Pix2CoOrd, CoOrd2Pix };
+static void CarDlgRedraw(void);
+static paramDrawData_t carDlgDrawData = { 455, 100, (wDrawRedrawCallBack_p)CarDlgRedraw, NULL, &carDlgD };
+static paramTextData_t notesData = { 440, 100 };
+static char *multinumLabels[] = { N_("Sequential"), N_("Repeated"), NULL };
+static void CarDlgNewProto( void );
+static void CarDlgUpdate( paramGroup_p, int, void * );
+static void CarDlgNewDesc( void );
+static void CarDlgNewProto( void );
+
+static paramData_t carDlgPLs[] = {
+#define A (0)
+#define I_CD_MANUF_LIST (A+0)
+ { PD_DROPLIST, &carDlgManufInx, "manuf", PDO_NOPREF, (void*)350, N_("Manufacturer"), BL_EDITABLE },
+#define I_CD_PROTOTYPE_STR (A+1)
+ { PD_STRING, &carDlgProtoStr, "prototype", PDO_NOPREF, (void*)350, N_("Prototype") },
+#define I_CD_PROTOKIND_LIST (A+2)
+ { PD_DROPLIST, &carDlgKindInx, "protokind-list", PDO_NOPREF, (void*)125, N_("Prototype"), 0 },
+#define I_CD_PROTOTYPE_LIST (A+3)
+ { PD_DROPLIST, &carDlgProtoInx, "prototype-list", PDO_NOPREF|PDO_DLGHORZ, (void*)(225-3), NULL, 0 },
+#define I_CD_TYPE_LIST (A+4)
+ { PD_DROPLIST, &carDlgTypeInx, "type", PDO_NOPREF, (void*)350, N_("Type"), 0 },
+#define I_CD_PARTNO_LIST (A+5)
+ { PD_DROPLIST, &carDlgPartnoInx, "partno-list", PDO_NOPREF, (void*)350, N_("Part"), BL_EDITABLE },
+#define I_CD_PARTNO_STR (A+6)
+ { PD_STRING, &carDlgPartnoStr, "partno", PDO_NOPREF, (void*)350, N_("Part Number") },
+#define I_CD_ISLOCO (A+7)
+ { PD_TOGGLE, &carDlgIsLoco, "isLoco", PDO_NOPREF|PDO_DLGWIDE, isLocoLabels, N_("Loco?"), BC_HORZ|BC_NOBORDER },
+#define I_CD_DESC_STR (A+8)
+ { PD_STRING, &carDlgDescStr, "desc", PDO_NOPREF, (void*)350, N_("Description"), 0 },
+#define I_CD_IMPORT (A+9)
+ { PD_BUTTON, NULL, "import", 0, 0, N_("Import") },
+#define I_CD_RESET (A+10)
+ { PD_BUTTON, NULL, "reset", PDO_DLGHORZ, 0, N_("Reset") },
+#define I_CD_FLIP (A+11)
+ { PD_BUTTON, NULL, "flip", PDO_DLGHORZ|PDO_DLGWIDE|PDO_DLGBOXEND, 0, N_("Flip") },
+
+#define I_CD_DISPMODE (A+12)
+ { PD_RADIO, &carDlgDispMode, "dispmode", PDO_NOPREF|PDO_DLGWIDE, dispmodeLabels, N_("Mode"), BC_HORZ|BC_NOBORDER },
+
+#define B (A+13)
+#define I_CD_ROADNAME_LIST (B+0)
+ { PD_DROPLIST, &carDlgRoadnameInx, "road", PDO_NOPREF|PDO_DLGWIDE, (void*)350, N_("Road"), BL_EDITABLE },
+#define I_CD_REPMARK (B+1)
+ { PD_STRING, carDlgRepmarkStr, "repmark", PDO_NOPREF, (void*)60, N_("Reporting Mark") },
+#define I_CD_NUMBER (B+2)
+ { PD_STRING, carDlgNumberStr, "number", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, (void*)80, N_("Number") },
+#define I_CD_BODYCOLOR (B+3)
+ { PD_COLORLIST, &carDlgBodyColor, "bodyColor", PDO_DLGWIDE|PDO_DLGHORZ, NULL, N_("Color") },
+#define I_CD_CARLENGTH (B+4)
+ { PD_FLOAT, &carDlgDim.carLength, "carLength", PDO_DIM|PDO_NOPREF|PDO_DLGWIDE, &r0_99999, N_("Car Length") },
+#define I_CD_CARWIDTH (B+5)
+ { PD_FLOAT, &carDlgDim.carWidth, "carWidth", PDO_DIM|PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, &r0_99999, N_("Width") },
+#define I_CD_TRKCENTER (B+6)
+ { PD_FLOAT, &carDlgDim.truckCenter, "trkCenter", PDO_DIM|PDO_NOPREF, &r0_99999, N_("Truck Centers") },
+#define I_CD_CPLRMNT (B+7)
+ { PD_RADIO, &carDlgCouplerMount, "cplrMount", PDO_NOPREF|PDO_DLGHORZ|PDO_DLGWIDE, cplrModeLabels, N_("Coupler Mount"), BC_HORZ|BC_NOBORDER },
+#define I_CD_CPLDLEN (B+8)
+ { PD_FLOAT, &carDlgDim.coupledLength, "cpldLen", PDO_DIM|PDO_NOPREF, &r0_99999, N_("Coupled Length") },
+#define I_CD_CPLRLEN (B+9)
+ { PD_FLOAT, &carDlgCouplerLength, "cplrLen", PDO_DIM|PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, &r0_99999, N_("Coupler Length") },
+#define I_CD_CANVAS (B+10)
+ { PD_DRAW, NULL, "canvas", PDO_NOPSHUPD|PDO_DLGWIDE|PDO_DLGNOLABELALIGN|PDO_DLGRESETMARGIN|PDO_DLGBOXEND|PDO_DLGRESIZE, &carDlgDrawData, NULL, 0 },
+
+#define C (B+11)
+#define I_CD_ITEMINDEX (C+0)
+ { PD_LONG, &carDlgItemIndex, "index", PDO_NOPREF|PDO_DLGWIDE, &i1_999999999, N_("Index"), 0 },
+#define I_CD_PURPRC (C+1)
+ { PD_STRING, &carDlgPurchPriceStr, "purchPrice", PDO_NOPREF|PDO_DLGWIDE, (void*)50, N_("Purchase Price"), 0, &carDlgPurchPrice },
+#define I_CD_CURPRC (C+2)
+ { PD_STRING, &carDlgCurrPriceStr, "currPrice", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, (void*)50, N_("Current Price"), 0, &carDlgCurrPrice },
+#define I_CD_COND (C+3)
+ { PD_DROPLIST, &carDlgConditionInx, "condition", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, (void*)90, N_("Condition") },
+#define I_CD_PURDAT (C+4)
+ { PD_STRING, &carDlgPurchDateStr, "purchDate", PDO_NOPREF|PDO_DLGWIDE, (void*)80, N_("Purchase Date"), 0, &carDlgPurchDate },
+#define I_CD_SRVDAT (C+5)
+ { PD_STRING, &carDlgServiceDateStr, "serviceDate", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, (void*)80, N_("Service Date"), 0, &carDlgServiceDate },
+#define I_CD_QTY (C+6)
+ { PD_LONG, &carDlgQuantity, "quantity", PDO_NOPREF|PDO_DLGWIDE, &i1_9999, N_("Quantity") },
+#define I_CD_MLTNUM (C+7)
+ { PD_RADIO, &carDlgMultiNum, "multinum", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGHORZ, multinumLabels, N_("Numbers"), BC_HORZ|BC_NOBORDER },
+#define I_CD_NOTES (C+8)
+ { PD_TEXT, NULL, "notes", PDO_NOPREF|PDO_DLGWIDE|PDO_DLGNOLABELALIGN|PDO_DLGRESETMARGIN, &notesData, N_("Notes") },
+
+#define D (C+9)
+#define I_CD_MSG (D+0)
+ { PD_MESSAGE, NULL, NULL, PDO_DLGNOLABELALIGN|PDO_DLGRESETMARGIN|PDO_DLGBOXEND, (void*)450 },
+#define I_CD_NEW (D+1)
+ { PD_MENU, NULL, "new-menu", PDO_DLGCMDBUTTON, NULL, N_("New"), 0, (void*)0 },
+ { PD_MENUITEM, (void*)CarDlgNewDesc, "new-part-mi", 0, NULL, N_("Car Part"), 0, (void*)0 },
+ { PD_MENUITEM, (void*)CarDlgNewProto, "new-proto-mi", 0, NULL, N_("Car Prototype"), 0, (void*)0 },
+#define I_CD_NEWPROTO (D+4)
+ { PD_BUTTON, (void*)CarDlgNewProto, "new", PDO_DLGCMDBUTTON, NULL, N_("New"), 0, (void*)0 } };
+
+static paramGroup_t carDlgPG = { "carpart", 0, carDlgPLs, sizeof carDlgPLs/sizeof carDlgPLs[0] };
+
+
+static dynArr_t carDlgSegs_da;
+#define carDlgSegs(N) DYNARR_N( trkSeg_t, carDlgSegs_da, N )
+
+
+typedef enum {
+ T_ItemSel, T_ItemEnter, T_ProtoSel, T_ProtoEnter, T_PartnoSel, T_PartnoEnter } carDlgTransistion_e;
+static char *carDlgTransistion_s[] = {
+ "ItemSel", "ItemEnter", "ProtoSel", "ProtoEnter", "PartnoSel", "PartnoEnter" };
+typedef enum {
+ S_Error,
+ S_ItemSel, S_ItemEnter, S_PartnoSel, S_PartnoEnter, S_ProtoSel } carDlgState_e;
+static char *carDlgState_s[] = {
+ "Error",
+ "ItemSel", "ItemEnter", "PartnoSel", "PartnoEnter", "ProtoSel" };
+typedef enum {
+ A_Return,
+ A_SError,
+ A_Else,
+ A_SItemSel,
+ A_SItemEnter,
+ A_SPartnoSel,
+ A_SPartnoEnter,
+ A_SProtoSel,
+ A_IsCustom,
+ A_IsNewPart,
+ A_IsNewProto,
+ A_LoadDataFromPartList,
+ A_LoadDimsFromStack,
+ A_LoadManufListForScale,
+ A_LoadManufListAll,
+ A_LoadProtoListForManuf,
+ A_LoadProtoListAll,
+ A_LoadPartnoList,
+ A_LoadLists,
+ A_LoadDimsFromProtoList,
+ A_ConvertDimsToProto,
+ A_Redraw,
+ A_ClrManuf,
+ A_ClrPartnoStr,
+ A_ClrNumberStr,
+ A_LoadProtoStrFromList,
+ A_ShowPartnoList,
+ A_HidePartnoList,
+ A_PushDims,
+ A_PopDims,
+ A_PopTitleAndTypeinx,
+ A_PopCouplerLength,
+ A_ShowControls,
+ A_LoadInfoFromUpdateItem,
+ A_LoadDataFromUpdatePart,
+ A_InitProto,
+ A_RecallCouplerLength,
+ A_Last
+ } carDlgAction_e;
+static char *carDlgAction_s[] = {
+ "Return",
+ "SError",
+ "Else",
+ "SItemSel",
+ "SItemEnter",
+ "SPartnoSel",
+ "SPartnoEnter",
+ "SProtoSel",
+ "IsCustom",
+ "IsNewPart",
+ "IsNewProto",
+ "LoadDataFromPartList",
+ "LoadDimsFromStack",
+ "LoadManufListForScale",
+ "LoadManufListAll",
+ "LoadProtoListForManuf",
+ "LoadProtoListAll",
+ "LoadPartnoList",
+ "LoadLists",
+ "LoadDimsFromProtoList",
+ "ConvertDimsToProto",
+ "Redraw",
+ "ClrManuf",
+ "ClrPartnoStr",
+ "ClrNumberStr",
+ "LoadProtoStrFromList",
+ "ShowPartnoList",
+ "HidePartnoList",
+ "PushDims",
+ "PopDims",
+ "PopTitleAndTypeinx",
+ "PopCouplerLength",
+ "ShowControls",
+ "LoadInfoFromUpdateItem",
+ "LoadDataFromUpdatePart",
+ "InitProto",
+ "RecallCouplerLength",
+ "Last"
+ };
+static carDlgAction_e stateMachine[7][7][10] = {
+/* A_SError */{ {A_SError}, {A_SError}, {A_SError}, {A_SError}, {A_SError}, {A_SError}, {A_SError} },
+
+/*A_SItemSel*/{
+/*T_ItemSel*/ { A_LoadProtoListForManuf, A_LoadPartnoList, A_LoadDataFromPartList, A_Redraw },
+/*T_ItemEnter*/ { A_SItemEnter, A_LoadProtoListAll, A_ClrPartnoStr, A_ClrNumberStr, A_LoadDimsFromProtoList, A_Redraw, A_HidePartnoList },
+/*T_ProtoSel*/ { A_LoadPartnoList, A_LoadDataFromPartList, A_Redraw },
+/*T_ProtoEnter*/ { A_SError },
+/*T_PartnoSel*/ { A_LoadDataFromPartList, A_Redraw },
+/*T_PartnoEnter*/{ A_SItemEnter, A_LoadProtoListAll, A_HidePartnoList } },
+
+/*A_SItemEnter*/{
+/*T_ItemSel*/ { A_SItemSel, A_LoadProtoListForManuf, A_LoadPartnoList, A_LoadDataFromPartList, A_Redraw, A_ShowPartnoList },
+/*T_ItemEnter*/ { A_Return },
+/*T_ProtoSel*/ { A_LoadDimsFromProtoList, A_Redraw },
+/*T_ProtoEnter*/ { A_SError },
+/*T_PartnoSel*/ { A_SError },
+/*T_PartnoEnter*/{ A_Return } },
+
+/*A_SPartnoSel*/{
+/*T_ItemSel*/ { A_SPartnoSel },
+/*T_ItemEnter*/ { A_SPartnoSel },
+/*T_ProtoSel*/ { A_SPartnoSel, A_LoadDimsFromProtoList, A_Redraw },
+/*T_ProtoEnter*/ { A_SError },
+/*T_PartnoSel*/ { A_SError } },
+
+/*A_SPartnoEnter*/{
+/*T_ItemSel*/ { A_SPartnoSel },
+/*T_ItemEnter*/ { A_SPartnoEnter },
+/*T_ProtoSel*/ { A_SPartnoEnter, A_LoadDimsFromProtoList, A_Redraw },
+/*T_ProtoEnter*/ { A_SError },
+/*T_PartnoSel*/ { A_SError },
+/*T_PartnoEnter*/{ A_SPartnoEnter } },
+
+/*A_SProtoSel*/{
+/*T_ItemSel*/ { A_SError },
+/*T_ItemEnter*/ { A_SError },
+/*T_ProtoSel*/ { A_SError },
+/*T_ProtoEnter*/ { A_SProtoSel },
+/*T_PartnoSel*/ { A_SError },
+/*T_PartnoEnter*/{ A_SError } } };
+
+static carDlgAction_e itemNewActions[] = {
+ A_RecallCouplerLength,
+ A_LoadLists,
+ A_IsCustom, 2+3,
+ A_LoadDimsFromProtoList, A_ClrPartnoStr, A_ClrNumberStr,
+ A_Else, 1,
+ A_LoadDataFromPartList,
+ A_ShowControls, A_Return };
+static carDlgAction_e itemUpdActions[] = { A_LoadInfoFromUpdateItem, /*A_LoadManufListForScale,
+ A_IsCustom, 5,
+ A_LoadProtoListAll, A_HidePartnoList, A_SItemEnter,
+ A_Else, 5,
+ A_LoadProtoListForManuf, A_LoadPartnoList, A_LoadDataFromPartList, A_ShowPartnoList, A_SItemSel,*/
+ A_ShowControls, A_Return };
+
+static carDlgAction_e partNewActions[] = { A_RecallCouplerLength, A_LoadManufListAll, A_LoadProtoListAll, A_ClrPartnoStr, A_ClrNumberStr, A_SPartnoSel, A_LoadDimsFromProtoList, A_ShowControls, A_Redraw, A_Return };
+static carDlgAction_e partUpdActions[] = { A_LoadDataFromUpdatePart, A_SPartnoSel, A_ShowControls, A_Return };
+
+static carDlgAction_e protoNewActions[] = { A_InitProto, A_SProtoSel, A_ShowControls, A_Return };
+static carDlgAction_e protoUpdActions[] = { A_InitProto, A_SProtoSel, A_ShowControls, A_Return };
+
+static carDlgAction_e item2partActions[] = {
+ A_PushDims, A_LoadManufListAll, A_LoadProtoListAll,
+ A_IsCustom, 0+1,
+ A_ClrManuf,
+ A_SPartnoSel,
+ A_ShowControls, A_Return };
+static carDlgAction_e part2itemActions[] = {
+ A_IsNewPart, 2+0,
+ A_Else, 1,
+ A_PopTitleAndTypeinx,
+ A_LoadLists,
+ A_IsCustom, 2+1,
+ A_LoadDimsFromProtoList,
+ A_Else, 1,
+ A_LoadDataFromPartList,
+#ifdef LATER
+ A_IsNewPart, 2+0,
+ A_Else, 1,
+ A_LoadDimsFromStack,
+#endif
+ A_ShowControls,
+ A_Return };
+
+static carDlgAction_e item2protoActions[] = { A_PushDims, A_ConvertDimsToProto, A_SProtoSel, A_ShowControls, A_Return };
+static carDlgAction_e proto2itemActions[] = {
+ A_IsCustom, 2+2+3,
+ A_IsNewProto, 2+3,
+ A_LoadProtoListAll,
+ A_PopCouplerLength,
+ A_LoadDimsFromProtoList,
+ A_Else, 2,
+ A_LoadDimsFromStack,
+ A_LoadProtoStrFromList,
+ A_ShowControls,
+ A_Return };
+
+static carDlgAction_e part2protoActions[] = { A_PushDims, A_ConvertDimsToProto, A_SProtoSel, A_ShowControls, A_Return };
+static carDlgAction_e proto2partActions[] = {
+ A_IsNewProto, 2+3,
+ A_LoadProtoListAll,
+ A_PopCouplerLength,
+ A_LoadDimsFromProtoList,
+ A_Else, 2,
+ A_LoadDimsFromStack,
+ A_LoadProtoStrFromList,
+ A_ShowControls,
+ A_Return };
+
+
+#define CARDLG_STK_SIZE (2)
+int carDlgStkPtr = 0;
+struct {
+ carDim_t dim;
+ DIST_T couplerLength;
+ carDlgState_e state;
+ int changed;
+ carPart_p partP;
+ wIndex_t typeInx;
+ } carDlgStk[CARDLG_STK_SIZE];
+
+static carDlgState_e currState = S_Error;
+#define S_ITEM (currState==S_ItemSel||currState==S_ItemEnter)
+#define S_PART (currState==S_PartnoSel)
+#define S_PROTO (currState==S_ProtoSel)
+
+
+
+static void CarDlgLoadDimsFromPart( carPart_p partP )
+{
+ tabString_t tabs[7];
+
+ if ( partP == NULL ) return;
+ carDlgDim = partP->dim;
+ carDlgCouplerLength = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ wPrefSetFloat( carDlgPG.nameStr, message, carDlgCouplerLength );
+ carDlgIsLoco = (partP->options&CAR_DESC_IS_LOCO)?1:0;
+ carDlgBodyColor = partP->color;
+ ParamLoadControl( &carDlgPG, I_CD_CARLENGTH );
+ ParamLoadControl( &carDlgPG, I_CD_CARWIDTH );
+ ParamLoadControl( &carDlgPG, I_CD_TRKCENTER );
+ ParamLoadControl( &carDlgPG, I_CD_CPLDLEN );
+ wColorSelectButtonSetColor( (wButton_p)carDlgPLs[I_CD_BODYCOLOR].control, *(wDrawColor*)carDlgPLs[I_CD_BODYCOLOR].valueP );
+ TabStringExtract( partP->title, 7, tabs );
+}
+
+
+static void CarDlgLoadDimsFromProto( carProto_p protoP )
+{
+ DIST_T ratio = GetScaleRatio(carDlgScaleInx);
+ carDlgDim.carLength = protoP->dim.carLength/ratio;
+ carDlgDim.carWidth = protoP->dim.carWidth/ratio;
+ carDlgDim.truckCenter = protoP->dim.truckCenter/ratio;
+ carDlgDim.coupledLength = carDlgDim.carLength + carDlgCouplerLength*2;
+ /*carDlgCouplerLength = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;*/
+ carDlgIsLoco = (protoP->options&CAR_DESC_IS_LOCO)?1:0;
+ ParamLoadControl( &carDlgPG, I_CD_CARLENGTH );
+ ParamLoadControl( &carDlgPG, I_CD_CARWIDTH );
+ ParamLoadControl( &carDlgPG, I_CD_TRKCENTER );
+ ParamLoadControl( &carDlgPG, I_CD_CPLDLEN );
+}
+
+
+static void CarDlgRedraw( void )
+{
+ wPos_t w, h;
+ DIST_T ww, hh;
+ DIST_T scale_w, scale_h;
+ coOrd orig, pos, size;
+ carProto_p protoP;
+ FLOAT_T ratio;
+ int segCnt;
+ trkSeg_p segPtr;
+
+ if ( S_PROTO )
+ ratio = 1;
+ else
+ ratio = 1/GetScaleRatio(carDlgScaleInx);
+ wDrawClear( carDlgD.d );
+ if ( carDlgDim.carLength <= 0 || carDlgDim.carWidth <= 0 )
+ return;
+ FreeFilledDraw( carDlgSegs_da.cnt, &carDlgSegs(0) );
+ if ( !S_PROTO ) {
+ if ( carDlgProtoInx < 0 ||
+ (protoP = CarProtoLookup( carDlgProtoStr, FALSE, FALSE, 0.0, 0.0 )) == NULL ||
+ protoP->segCnt == 0 ) {
+ CarProtoDlgCreateDummyOutline( &segCnt, &segPtr, (BOOL_T)carDlgIsLoco, carDlgDim.carLength, carDlgDim.carWidth, carDlgBodyColor );
+ } else {
+ segCnt = protoP->segCnt;
+ segPtr = protoP->segPtr;
+ }
+ } else {
+ if ( carProtoSegCnt <= 0 ) {
+ CarProtoDlgCreateDummyOutline( &segCnt, &segPtr, (BOOL_T)carDlgIsLoco, carDlgDim.carLength, carDlgDim.carWidth, drawColorBlue );
+ } else {
+ segCnt = carProtoSegCnt;
+ segPtr = carProtoSegPtr;
+ }
+ }
+ DYNARR_SET( trkSeg_t, carDlgSegs_da, segCnt );
+ memcpy( &carDlgSegs(0), segPtr, segCnt * sizeof *(trkSeg_t*)0 );
+ CloneFilledDraw( carDlgSegs_da.cnt, &carDlgSegs(0), TRUE );
+ GetSegBounds( zero, 0.0, carDlgSegs_da.cnt, &carDlgSegs(0), &orig, &size );
+ scale_w = carDlgDim.carLength/size.x;
+ scale_h = carDlgDim.carWidth/size.y;
+ RescaleSegs( carDlgSegs_da.cnt, &carDlgSegs(0), scale_w, scale_h, ratio );
+ if ( !S_PROTO ) {
+ RecolorSegs( carDlgSegs_da.cnt, &carDlgSegs(0), carDlgBodyColor );
+ } else {
+ if ( carDlgFlipToggle ) {
+ pos.x = carDlgDim.carLength/2.0;
+ pos.y = carDlgDim.carWidth/2.0;
+ RotateSegs( carDlgSegs_da.cnt, &carDlgSegs(0), pos, 180.0 );
+ }
+ }
+
+ wDrawGetSize( carDlgD.d, &w, &h );
+ ww = w/carDlgD.dpi-1.0;
+ hh = h/carDlgD.dpi-0.5;
+ scale_w = carDlgDim.carLength/ww;
+ scale_h = carDlgDim.carWidth/hh;
+ if ( scale_w > scale_h )
+ carDlgD.scale = scale_w;
+ else
+ carDlgD.scale = scale_h;
+ orig.x = 0.50*carDlgD.scale;
+ orig.y = 0.25*carDlgD.scale;
+ DrawSegs( &carDlgD, orig, 0.0, &carDlgSegs(0), carDlgSegs_da.cnt, 0.0, wDrawColorBlack );
+ pos.y = orig.y+carDlgDim.carWidth/2.0;
+
+ if ( carDlgDim.truckCenter > 0.0 ) {
+ pos.x = orig.x+(carDlgDim.carLength-carDlgDim.truckCenter)/2.0;
+ CarProtoDrawTruck( &carDlgD, trackGauge*curScaleRatio, ratio, pos, 0.0 );
+ pos.x = orig.x+(carDlgDim.carLength+carDlgDim.truckCenter)/2.0;
+ CarProtoDrawTruck( &carDlgD, trackGauge*curScaleRatio, ratio, pos, 0.0 );
+ }
+ if ( carDlgDim.coupledLength > carDlgDim.carLength ) {
+ pos.x = orig.x;
+ CarProtoDrawCoupler( &carDlgD, (carDlgDim.coupledLength-carDlgDim.carLength)/2.0, ratio, pos, 270.0 );
+ pos.x = orig.x+carDlgDim.carLength;
+ CarProtoDrawCoupler( &carDlgD, (carDlgDim.coupledLength-carDlgDim.carLength)/2.0, ratio, pos, 90.0 );
+ }
+}
+
+
+
+static void CarDlgLoadRoadnameList( void )
+/* Loads RoadnameList.
+ * Set carDlgRoadnameInx to entry matching carDlgRoadnameStr (if found)
+ * Otherwise not set
+ */
+{
+ wIndex_t inx;
+ roadnameMap_p roadnameMapP;
+
+ if ( !roadnameMapChanged ) return;
+ wListClear( (wList_p)carDlgPLs[I_CD_ROADNAME_LIST].control );
+ wListAddValue( (wList_p)carDlgPLs[I_CD_ROADNAME_LIST].control, _("Undecorated"), NULL, NULL );
+ for ( inx=0; inx<roadnameMap_da.cnt; inx++ ) {
+ roadnameMapP = DYNARR_N(roadnameMap_p, roadnameMap_da, inx);
+ wListAddValue( (wList_p)carDlgPLs[I_CD_ROADNAME_LIST].control, roadnameMapP->roadname, NULL, roadnameMapP );
+ if ( strcasecmp( carDlgRoadnameStr, roadnameMapP->roadname )==0 )
+ carDlgRoadnameInx = inx+1;
+ }
+ roadnameMapChanged = FALSE;
+}
+
+
+static BOOL_T CheckAvail(
+ carPartParent_p parentP )
+{
+ wIndex_t inx;
+ carPart_p partP;
+ for ( inx=0; inx<parentP->parts_da.cnt; inx++ ) {
+ partP = carPart(parentP,inx);
+ if ( IsParamValid(partP->paramFileIndex) )
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+static BOOL_T CarDlgLoadManufList(
+ BOOL_T bLoadAll,
+ BOOL_T bInclCustomUnknown,
+ SCALEINX_T scale )
+{
+ carPartParent_p manufP, manufP1;
+ wIndex_t inx, listInx=-1;
+ BOOL_T found = TRUE;
+ char * firstName = NULL;
+
+LOG( log_carDlgList, 3, ( "CarDlgLoadManufList( %s, %s, %d )\n carDlgManufStr=\"%s\"\n", bLoadAll?"TRUE":"FALSE", bInclCustomUnknown?"TRUE":"FALSE", scale, carDlgManufStr ) )
+ carDlgManufInx = -1;
+ manufP1 = NULL;
+ wListClear( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control );
+ for ( inx=0; inx<carPartParent_da.cnt; inx++ ) {
+ manufP = carPartParent(inx);
+ if ( manufP1!=NULL && strcasecmp( manufP1->manuf, manufP->manuf ) == 0 )
+ continue;
+ if ( bLoadAll==FALSE && manufP->scale != scale )
+ continue;
+ if ( !CheckAvail(manufP) )
+ continue;
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, manufP->manuf, NULL, (void*)manufP );
+ if ( carDlgManufInx < 0 && ( carDlgManufStr[0] == '\0' || strcasecmp( carDlgManufStr, manufP->manuf ) == 0 ) ) {
+LOG( log_carDlgList, 4, ( " found manufStr (inx=%d, listInx=%d)\n", inx, listInx ) )
+ carDlgManufInx = listInx;
+ if ( carDlgManufStr[0] == '\0' ) strcpy( carDlgManufStr, manufP->manuf );
+ }
+ if ( firstName == NULL )
+ firstName = manufP->manuf;
+ manufP1 = manufP;
+ }
+ if ( bInclCustomUnknown ) {
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, _("Custom"), NULL, (void*)NULL );
+ if ( carDlgManufInx < 0 && ( carDlgManufStr[0] == '\0' || strcasecmp( carDlgManufStr, "Custom" ) == 0 ) ) {
+LOG( log_carDlgList, 4, ( " found Cus manufStr (inx=%d, listInx=%d)\n", inx, listInx ) )
+ carDlgManufInx = listInx;
+ if ( carDlgManufStr[0] == '\0' ) strcpy( carDlgManufStr, _("Custom") );
+ }
+ if ( firstName == NULL )
+ firstName = "Custom";
+ wListAddValue( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, _("Unknown"), NULL, (void*)NULL );
+ if ( carDlgManufInx < 0 && ( carDlgManufStr[0] == '\0' || strcasecmp( carDlgManufStr, "Unknown" ) == 0 ) ) {
+LOG( log_carDlgList, 4, ( " found Unk manufStr (inx=%d, listInx=%d)\n", inx, listInx ) )
+ carDlgManufInx = listInx;
+ if ( carDlgManufStr[0] == '\0' ) strcpy( carDlgManufStr, _("Unknown") );
+ }
+ }
+ if ( carDlgManufInx < 0 ) {
+ found = FALSE;
+ if ( firstName != NULL ) {
+LOG( log_carDlgList, 4, ( " didn't find manufStr, using [0] = %s\n", firstName ) )
+ carDlgManufInx = 0;
+ strcpy( carDlgManufStr, firstName );
+ }
+ }
+ return found;
+}
+
+
+static BOOL_T CarDlgLoadProtoList(
+ char * manuf,
+ SCALEINX_T scale,
+ BOOL_T loadTypeList )
+{
+ carPartParent_p parentP;
+ wIndex_t inx, listInx, inx1;
+ BOOL_T found;
+ carProto_p protoP;
+ carPart_p partP;
+ char * firstName;
+ int typeCount[N_TYPELISTMAP];
+ int listTypeInx, currTypeInx;
+
+ listTypeInx = -1;
+ carDlgProtoInx = -1;
+ firstName = NULL;
+
+ wListClear( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control );
+ memset( typeCount, 0, N_TYPELISTMAP * sizeof typeCount[0] );
+LOG( log_carDlgList, 3, ( "CarDlgLoadProtoList( %s, %d, %s )\n carDlgProtoStr=\"%s\", carDlgTypeInx=%d\n", manuf?manuf:"NULL", scale, loadTypeList?"TRUE":"FALSE", carDlgProtoStr, carDlgTypeInx ) )
+ if ( manuf==NULL ) {
+ if ( carProto_da.cnt <= 0 ) return FALSE;
+ if ( listTypeInx < 0 && carDlgProtoStr[0] && (protoP=CarProtoFind(carDlgProtoStr)) )
+ listTypeInx = CarProtoFindTypeCode(protoP->type);
+ if ( listTypeInx < 0 )
+ listTypeInx = CarProtoFindTypeCode(carProto(0)->type);
+ for ( inx=0; inx<carProto_da.cnt; inx++ ) {
+ protoP = carProto(inx);
+ currTypeInx = CarProtoFindTypeCode(protoP->type);
+ typeCount[currTypeInx]++;
+ if ( carDlgTypeInx >= 0 &&
+ listTypeInx != carDlgTypeInx &&
+ currTypeInx == carDlgTypeInx ) {
+LOG( log_carDlgList, 4, ( " found typeinx, reset list (old=%d)\n", listTypeInx ) )
+ wListClear( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control );
+ listTypeInx = carDlgTypeInx;
+ carDlgProtoInx = -1;
+ firstName = NULL;
+ }
+ if ( currTypeInx != listTypeInx ) continue;
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, protoP->desc, NULL, (void*)protoP );
+ if ( carDlgProtoInx < 0 && carDlgProtoStr[0] && strcasecmp( carDlgProtoStr, protoP->desc ) == 0 ) {
+LOG( log_carDlgList, 4, ( " found protoStr (inx=%d, listInx=%d)\n", inx, listInx ) )
+ carDlgProtoInx = listInx;
+ if ( carDlgProtoStr[0] == '\0' ) strcpy( carDlgProtoStr, protoP->desc );
+ }
+ if ( firstName == NULL )
+ firstName = protoP->desc;
+ }
+ } else {
+ for ( inx=0; inx<carPartParent_da.cnt; inx++ ) {
+ parentP = carPartParent(inx);
+ if ( strcasecmp( manuf, parentP->manuf ) != 0 ||
+ scale != parentP->scale )
+ continue;
+ if ( !CheckAvail(parentP) )
+ continue;
+ found = FALSE;
+ for ( inx1=0; inx1<parentP->parts_da.cnt; inx1++ ) {
+ partP = carPart( parentP, inx1 );
+ currTypeInx = CarProtoFindTypeCode(partP->type);
+ typeCount[currTypeInx]++;
+ if ( listTypeInx < 0 )
+ listTypeInx = currTypeInx;
+ if ( carDlgTypeInx >= 0 &&
+ listTypeInx != carDlgTypeInx &&
+ currTypeInx == carDlgTypeInx ) {
+LOG( log_carDlgList, 4, ( " found typeinx, reset list (old=%d)\n", listTypeInx ) )
+ wListClear( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control );
+ listTypeInx = carDlgTypeInx;
+ carDlgProtoInx = -1;
+ firstName = NULL;
+ }
+ if ( listTypeInx == currTypeInx )
+ found = TRUE;
+ }
+ if ( !found )
+ continue;
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, parentP->proto, NULL, (void*)parentP );
+ if ( carDlgProtoInx < 0 && ( carDlgProtoStr[0] == '\0' || strcasecmp( carDlgProtoStr, parentP->proto ) == 0 ) ) {
+LOG( log_carDlgList, 4, ( " found protoStr (inx=%d, listInx=%d)\n", inx, listInx ) )
+ carDlgProtoInx = listInx;
+ if ( carDlgProtoStr[0] == '\0' ) {
+ strcpy( carDlgProtoStr, parentP->proto );
+ }
+ }
+ if ( firstName == NULL )
+ firstName = parentP->proto;
+ }
+ }
+
+ found = TRUE;
+ if ( carDlgProtoInx < 0 ) {
+ found = FALSE;
+ if ( firstName != NULL ) {
+LOG( log_carDlgList, 4, ( " didn't find protoStr, using [0] = %s\n", firstName ) )
+ carDlgProtoInx = 0;
+ strcpy( carDlgProtoStr, firstName );
+ }
+ }
+ wListSetIndex( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+
+ if ( loadTypeList ) {
+LOG( log_carDlgList, 4, ( " loading typelist\n" ) )
+ wListClear( (wList_p)carDlgPLs[I_CD_PROTOKIND_LIST].control );
+ for ( currTypeInx=0; currTypeInx<N_TYPELISTMAP; currTypeInx++ ) {
+ if ( typeCount[currTypeInx] > 0 ) {
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_PROTOKIND_LIST].control, _(typeListMap[currTypeInx].name), NULL, (void*)(intptr_t)currTypeInx );
+ if ( currTypeInx == listTypeInx ) {
+LOG( log_carDlgList, 4, ( " current = %d\n", listInx ) )
+ carDlgKindInx = listInx;
+ }
+ }
+ }
+ }
+
+ return found;
+}
+
+
+static void ConstructPartDesc(
+ tabString_t * tabs )
+{
+ char * cp;
+ cp = message;
+ *cp = '\0';
+ if ( tabs[T_PART].len ) {
+ cp = TabStringCpy( cp, &tabs[T_PART] );
+ *cp++ = ' ';
+ }
+ if ( tabs[T_DESC].len ) {
+ cp = TabStringCpy( cp, &tabs[T_DESC] );
+ *cp++ = ' ';
+ }
+ if ( tabs[T_REPMARK].len ) {
+ cp = TabStringCpy( cp, &tabs[T_REPMARK] );
+ *cp++ = ' ';
+ } else if ( tabs[T_ROADNAME].len ) {
+ cp = TabStringCpy( cp, &tabs[T_ROADNAME] );
+ *cp++ = ' ';
+ } else {
+ strcpy( cp, _("Undecorated ") );
+ cp += strlen( cp );
+ }
+ if ( tabs[T_NUMBER].len ) {
+ cp = TabStringCpy( cp, &tabs[T_NUMBER] );
+ *cp++ = ' ';
+ }
+ *cp = '\0';
+}
+
+
+static BOOL_T CarDlgLoadPartList( carPartParent_p parentP )
+/* Loads PartList from parentP
+ * Set carDlgPartnoInx to entry matching carDlgPartnoStr (if set and found)
+ * Otherwise set carDlgPartnoInx and carDlgPartnoStr to 1st entry on list
+ * Set carDlgDescStr to found entry
+ */
+{
+ wIndex_t listInx;
+ wIndex_t inx;
+ carPart_p partP;
+ carPart_t lastPart;
+ tabString_t tabs[7];
+ BOOL_T found;
+ carPart_p selPartP;
+
+ carDlgPartnoInx = -1;
+ wListClear( (wList_p)carDlgPLs[I_CD_PARTNO_LIST].control );
+ if ( parentP==NULL ) {
+ carDlgPartnoStr[0] = '\0';
+ carDlgDescStr[0] = '\0';
+ return FALSE;
+ }
+ found = FALSE;
+ selPartP = NULL;
+ lastPart.title = NULL;
+ for ( inx=0; inx<parentP->parts_da.cnt; inx++ ) {
+ partP = carPart(parentP,inx);
+ TabStringExtract( partP->title, 7, tabs );
+ ConstructPartDesc( tabs );
+ lastPart.paramFileIndex = partP->paramFileIndex;
+ if ( message[0] && IsParamValid(partP->paramFileIndex) &&
+ ( lastPart.title == NULL || Cmp_part( &lastPart, partP ) != 0 ) ) {
+ listInx = wListAddValue( (wList_p)carDlgPLs[I_CD_PARTNO_LIST].control, message, NULL, (void*)partP );
+ if ( carDlgPartnoInx<0 &&
+ (carDlgPartnoStr[0]?TabStringCmp( carDlgPartnoStr, &tabs[T_PART] ) == 0:TRUE) ) {
+ carDlgPartnoInx = listInx;
+ found = TRUE;
+ selPartP = partP;
+ }
+ if ( selPartP == NULL )
+ selPartP = partP;
+ lastPart = *partP;
+ }
+ }
+ if ( selPartP == NULL ) {
+ carDlgPartnoStr[0] = '\0';
+ carDlgDescStr[0] = '\0';
+ } else {
+ if ( carDlgPartnoInx<0 )
+ carDlgPartnoInx = 0;
+ TabStringExtract( selPartP->title, 7, tabs );
+ TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ TabStringCpy( carDlgDescStr, &tabs[T_DESC] );
+ }
+ return found;
+}
+
+
+
+static void CarDlgLoadPart(
+ carPart_p partP )
+{
+ tabString_t tabs[7];
+ roadnameMap_p roadnameMapP;
+ CarDlgLoadDimsFromPart( partP );
+ carDlgBodyColor = partP->color;
+ carDlgTypeInx = CarProtoFindTypeCode( partP->type );
+ carDlgIsLoco = ((partP->type)&1)!=0;
+ TabStringExtract( partP->title, 7, tabs );
+ TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ TabStringCpy( carDlgDescStr, &tabs[T_DESC] );
+ roadnameMapP = LoadRoadnameList( &tabs[T_ROADNAME], &tabs[T_REPMARK] );
+ carDlgRoadnameInx = lookupListIndex+1;
+ if ( roadnameMapP ) {
+ TabStringCpy( carDlgRoadnameStr, &tabs[T_ROADNAME] );
+ CarDlgLoadRoadnameList();
+ TabStringCpy( carDlgRepmarkStr, &tabs[T_REPMARK] );
+ } else {
+ carDlgRoadnameInx = 0;
+ strcpy( carDlgRoadnameStr, _("Undecorated") );
+ carDlgRepmarkStr[0] = '\0';
+ }
+ TabStringCpy( carDlgNumberStr, &tabs[T_NUMBER] );
+ carDlgBodyColor = partP->color;
+}
+
+
+static BOOL_T CarDlgLoadLists(
+ BOOL_T isItem,
+ tabString_t * tabs,
+ SCALEINX_T scale )
+{
+ BOOL_T loadCustomUnknown = isItem;
+ DIST_T ratio;
+ carPartParent_p parentP;
+ static carProto_t protoTmp;
+ static char protoTmpDesc[STR_SIZE];
+
+ if ( tabs ) TabStringCpy( carDlgManufStr, &tabs[T_MANUF] );
+ if ( strcasecmp( carDlgManufStr, "unknown" ) == 0 ||
+ strcasecmp( carDlgManufStr, "custom" ) == 0 ) {
+ loadCustomUnknown = TRUE;
+ /*isItem = FALSE;*/
+ }
+ if ( (!CarDlgLoadManufList( !isItem, loadCustomUnknown, scale )) && tabs ) {
+ TabStringCpy( carDlgManufStr, &tabs[T_MANUF] );
+ carDlgManufInx = wListAddValue( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, carDlgManufStr, NULL, (void*)NULL );
+ isItem = FALSE;
+ }
+ if ( isItem ) {
+ parentP = (carPartParent_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, carDlgManufInx );
+ if ( parentP ) {
+ if ( tabs ) TabStringCpy( carDlgProtoStr, &tabs[T_PROTO] );
+ if ( CarDlgLoadProtoList( carDlgManufStr, scale, TRUE ) || !tabs ) {
+ parentP = (carPartParent_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+ if ( parentP ) {
+ if ( tabs ) TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ if ( CarDlgLoadPartList( parentP ) || ( (!tabs) && carDlgPartnoInx>=0 ) ) {
+ return TRUE;
+ }
+ }
+ }
+ }
+ }
+ if ( tabs ) TabStringCpy( carDlgProtoStr, &tabs[T_PROTO] );
+ if ( !CarDlgLoadProtoList( NULL, 0, TRUE ) && tabs ) {
+ /* create dummy proto */
+ ratio = GetScaleRatio( scale );
+ protoTmp.contentsLabel = "temporary";
+ protoTmp.paramFileIndex = PARAM_LAYOUT;
+ strcpy( protoTmpDesc, carDlgProtoStr );
+ protoTmp.desc = protoTmpDesc;
+ protoTmp.options = (carDlgIsLoco?CAR_DESC_IS_LOCO:0);
+ protoTmp.type = typeListMap[carDlgTypeInx].value;
+ protoTmp.dim.carWidth = carDlgDim.carWidth*ratio;
+ protoTmp.dim.carLength = carDlgDim.carLength*ratio;
+ protoTmp.dim.coupledLength = carDlgDim.coupledLength*ratio;
+ protoTmp.dim.truckCenter = carDlgDim.truckCenter*ratio;
+ CarProtoDlgCreateDummyOutline( &carProtoSegCnt, &carProtoSegPtr, (BOOL_T)carDlgIsLoco, protoTmp.dim.carLength, protoTmp.dim.carWidth, drawColorBlue );
+ protoTmp.segCnt = carProtoSegCnt;
+ protoTmp.segPtr = carProtoSegPtr;
+ GetSegBounds( zero, 0.0, carProtoSegCnt, carProtoSegPtr, &protoTmp.orig, &protoTmp.size );
+ TabStringCpy( carDlgProtoStr, &tabs[T_PROTO] );
+ carDlgProtoInx = wListAddValue( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoStr, NULL, &protoTmp );/*??*/
+ }
+ carDlgPartnoInx = -1;
+ if ( tabs ) {
+ TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ TabStringCpy( carDlgDescStr, &tabs[T_DESC] );
+ }
+ return FALSE;
+}
+
+
+static void CarDlgShowControls( void )
+{
+
+
+ /*ParamControlActive( &carDlgPG, I_CD_MANUF_LIST, S_ITEM||(S_PART&&carDlgUpdatePartPtr) );*/
+
+ ParamControlShow( &carDlgPG, I_CD_NEW, S_ITEM );
+ ParamControlShow( &carDlgPG, I_CD_NEWPROTO, S_PART );
+
+ ParamControlShow( &carDlgPG, I_CD_ITEMINDEX, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_PURPRC, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_CURPRC, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_COND, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_PURDAT, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_SRVDAT, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_NOTES, S_ITEM && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_MLTNUM, S_ITEM && carDlgUpdateItemPtr==NULL && carDlgDispMode==0 );
+ ParamControlShow( &carDlgPG, I_CD_QTY, S_ITEM && carDlgUpdateItemPtr==NULL && carDlgDispMode==0 );
+
+ ParamControlShow( &carDlgPG, I_CD_ROADNAME_LIST, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_REPMARK, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_NUMBER, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_BODYCOLOR, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_CARLENGTH, !( S_ITEM && carDlgDispMode==0 ) );
+ ParamControlShow( &carDlgPG, I_CD_CARWIDTH, !( S_ITEM && carDlgDispMode==0 ) );
+ ParamControlShow( &carDlgPG, I_CD_TRKCENTER, !( S_ITEM && carDlgDispMode==0 ) );
+ ParamControlShow( &carDlgPG, I_CD_CANVAS, !( S_ITEM && carDlgDispMode==0 ) );
+ ParamControlShow( &carDlgPG, I_CD_CPLRLEN, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_CPLDLEN, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+ ParamControlShow( &carDlgPG, I_CD_CPLRMNT, S_PART || ( S_ITEM && carDlgDispMode==1 ) );
+
+ ParamControlShow( &carDlgPG, I_CD_DISPMODE, S_ITEM );
+
+ ParamControlShow( &carDlgPG, I_CD_TYPE_LIST, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_FLIP, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_DESC_STR, S_PART || (currState==S_ItemEnter) );
+ ParamControlShow( &carDlgPG, I_CD_IMPORT, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_RESET, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_STR, S_PART || (currState==S_ItemEnter) );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_LIST, (currState==S_ItemSel) );
+ ParamControlShow( &carDlgPG, I_CD_ISLOCO, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_PROTOKIND_LIST, !S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_PROTOTYPE_LIST, !S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_PROTOTYPE_STR, S_PROTO );
+ ParamControlShow( &carDlgPG, I_CD_MANUF_LIST, !S_PROTO );
+
+ /*ParamControlActive( &carDlgPG, I_CD_PROTOTYPE_STR, S_PROTO && carDlgUpdateProtoPtr==NULL );*/
+ ParamControlActive( &carDlgPG, I_CD_ITEMINDEX, S_ITEM && carDlgUpdateItemPtr==NULL );
+ ParamControlActive( &carDlgPG, I_CD_MLTNUM, S_ITEM && carDlgQuantity>1 );
+ ParamControlActive( &carDlgPG, I_CD_IMPORT, selectedTrackCount > 0 );
+
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, "" );
+
+ if ( S_ITEM ) {
+ if ( carDlgUpdateItemPtr == NULL ) {
+ sprintf( message, _("New %s Scale Car"), GetScaleName( carDlgScaleInx ) );
+ wButtonSetLabel( carDlgPG.okB, _("Add") );
+ } else {
+ sprintf( message, _("Update %s Scale Car"), GetScaleName( carDlgScaleInx ) );
+ wButtonSetLabel( carDlgPG.okB, _("Update") );
+ }
+ wWinSetTitle( carDlgPG.win, message );
+ } else if ( S_PART ) {
+ if ( carDlgUpdatePartPtr == NULL ) {
+ sprintf( message, _("New %s Scale Car Part"), GetScaleName( carDlgScaleInx ) );
+ wButtonSetLabel( carDlgPG.okB, _("Add") );
+ } else {
+ sprintf( message, _("Update %s Scale Car Part"), GetScaleName( carDlgScaleInx ) );
+ wButtonSetLabel( carDlgPG.okB, _("Update") );
+ }
+ wWinSetTitle( carDlgPG.win, message );
+ } else if ( S_PROTO ) {
+ if ( carDlgUpdateProtoPtr == NULL ) {
+ wWinSetTitle( carDlgPG.win, _("New Prototype") );
+ wButtonSetLabel( carDlgPG.okB, _("Add") );
+ } else {
+ wWinSetTitle( carDlgPG.win, _("Update Prototype") );
+ wButtonSetLabel( carDlgPG.okB, _("Update") );
+ }
+ }
+
+ ParamLoadControls( &carDlgPG );
+
+ ParamDialogOkActive( &carDlgPG, S_ITEM );
+ CarDlgUpdate( &carDlgPG, -1, NULL );
+}
+
+
+
+static void CarDlgDoActions(
+ carDlgAction_e * actions )
+{
+ carPart_p partP;
+ carPartParent_p parentP;
+ carProto_p protoP;
+ wIndex_t inx;
+ int offset;
+ DIST_T ratio;
+ tabString_t tabs[7];
+ char * cp;
+ BOOL_T reload[sizeof carDlgPLs/sizeof carDlgPLs[0]];
+#define RELOAD_DIMS \
+ reload[I_CD_CARLENGTH] = reload[I_CD_CARWIDTH] = reload[I_CD_CPLDLEN] = \
+ reload[I_CD_TRKCENTER] = reload[I_CD_CPLRLEN] = TRUE
+#define RELOAD_PARTDATA \
+ RELOAD_DIMS; \
+ reload[I_CD_PARTNO_STR] = reload[I_CD_DESC_STR] = \
+ reload[I_CD_ROADNAME_LIST] = reload[I_CD_REPMARK] = \
+ reload[I_CD_NUMBER] = reload[I_CD_BODYCOLOR] = TRUE
+#define RELOAD_LISTS \
+ reload[I_CD_MANUF_LIST] = \
+ reload[I_CD_PROTOKIND_LIST] = \
+ reload[I_CD_PROTOTYPE_LIST] = \
+ reload[I_CD_PARTNO_LIST] = TRUE
+
+ memset( reload, 0, sizeof reload );
+ while ( 1 ) {
+LOG( log_carDlgState, 2, ( "Action = %s\n", carDlgAction_s[*actions] ) )
+ switch ( *actions++ ) {
+ case A_Return:
+ for ( inx=0; inx<sizeof carDlgPLs/sizeof carDlgPLs[0]; inx++ )
+ if ( reload[inx] )
+ ParamLoadControl( &carDlgPG, inx );
+ return;
+ case A_SError:
+ currState = S_Error;
+ break;
+ case A_Else:
+ offset = (int)*actions++;
+ actions += offset;
+ break;
+ case A_SItemSel:
+ currState = S_ItemSel;
+ break;
+ case A_SItemEnter:
+ currState = S_ItemEnter;
+ break;
+ case A_SPartnoSel:
+ currState = S_PartnoSel;
+ break;
+ case A_SPartnoEnter:
+ currState = S_PartnoEnter;
+ break;
+ case A_SProtoSel:
+ currState = S_ProtoSel;
+ break;
+ case A_IsCustom:
+ offset = (int)*actions++;
+ if ( currState != S_ItemEnter )
+ actions += offset;
+ break;
+ case A_IsNewPart:
+ offset = (int)*actions++;
+ if (carDlgNewPartPtr==NULL) {
+ actions += offset;
+ } else {
+ TabStringExtract( carDlgNewPartPtr->title, 7, tabs );
+ TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ TabStringCpy( carDlgDescStr, &tabs[T_DESC] );
+ reload[I_CD_PARTNO_STR] = reload[I_CD_DESC_STR] = TRUE;
+ }
+ break;
+ case A_IsNewProto:
+ offset = (int)*actions++;
+ if (carDlgNewProtoPtr==NULL) {
+ actions += offset;
+ } else {
+ strcpy( carDlgProtoStr, carDlgNewProtoPtr->desc );
+ }
+ break;
+ case A_LoadDataFromPartList:
+ partP = (carPart_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PARTNO_LIST].control, carDlgPartnoInx );
+ if ( partP != NULL ){
+ CarDlgLoadPart(partP);
+ RELOAD_PARTDATA;
+ RELOAD_PARTDATA;
+ }
+ break;
+ case A_LoadDimsFromStack:
+ carDlgDim = carDlgStk[carDlgStkPtr].dim;
+ carDlgCouplerLength = carDlgStk[carDlgStkPtr].couplerLength;
+ carDlgTypeInx = carDlgStk[carDlgStkPtr].typeInx;
+ carDlgIsLoco = (typeListMap[carDlgTypeInx].value&1) != 0;
+ RELOAD_DIMS;
+ break;
+ case A_LoadManufListForScale:
+ CarDlgLoadManufList( FALSE, TRUE, carDlgScaleInx );
+ reload[I_CD_MANUF_LIST] = TRUE;
+ break;
+ case A_LoadManufListAll:
+ CarDlgLoadManufList( TRUE, FALSE, carDlgScaleInx );
+ reload[I_CD_MANUF_LIST] = TRUE;
+ break;
+ case A_LoadProtoListForManuf:
+ parentP = (carPartParent_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, carDlgManufInx );
+ CarDlgLoadProtoList( parentP->manuf, parentP->scale, TRUE );
+ reload[I_CD_PROTOKIND_LIST] = TRUE;
+ reload[I_CD_PROTOTYPE_LIST] = TRUE;
+ break;
+ case A_LoadProtoListAll:
+ CarDlgLoadProtoList( NULL, 0, TRUE );
+ reload[I_CD_PROTOKIND_LIST] = TRUE;
+ reload[I_CD_PROTOTYPE_LIST] = TRUE;
+ break;
+ case A_LoadPartnoList:
+ parentP = (carPartParent_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+ CarDlgLoadPartList( parentP );
+ reload[I_CD_PARTNO_LIST] = TRUE;
+ break;
+ case A_LoadLists:
+ if ( CarDlgLoadLists( TRUE, NULL, carDlgScaleInx ) )
+ currState = S_ItemSel;
+ else
+ currState = S_ItemEnter;
+ break;
+ case A_LoadDimsFromProtoList:
+ protoP = (carProto_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+ if ( protoP ) {
+ CarDlgLoadDimsFromProto( protoP );
+ carDlgTypeInx = CarProtoFindTypeCode( protoP->type );
+ carDlgIsLoco = (protoP->options&CAR_DESC_IS_LOCO)!=0;
+ } else {
+ ratio = GetScaleRatio( carDlgScaleInx );
+ carDlgDim.carLength = 50*12/ratio;
+ carDlgDim.carWidth = 10*12/ratio;
+ carDlgDim.coupledLength = carDlgDim.carLength+carDlgCouplerLength*2;
+ carDlgDim.truckCenter = carDlgDim.carLength-59.0*2.0/ratio;
+ carDlgTypeInx = 0;
+ carDlgIsLoco = (typeListMap[0].value&1);
+ }
+ RELOAD_DIMS;
+ reload[I_CD_TYPE_LIST] = reload[I_CD_ISLOCO] = TRUE;
+ break;
+ case A_ConvertDimsToProto:
+ ratio = GetScaleRatio( carDlgScaleInx );
+ carDlgDim.carLength *= ratio;
+ carDlgDim.carWidth *= ratio;
+ carDlgCouplerLength = 16.0;
+ carDlgDim.coupledLength = carDlgDim.carLength + 2 * carDlgCouplerLength;
+ carDlgDim.truckCenter *= ratio;
+ RELOAD_DIMS;
+ break;
+ case A_Redraw:
+ CarDlgRedraw();
+ break;
+ case A_ClrManuf:
+ carDlgManufStr[0] = '\0';
+ wListSetValue( (wList_p)carDlgPLs[I_CD_MANUF_LIST].control, "" );
+ carDlgManufInx = -1;
+ break;
+ case A_ClrPartnoStr:
+ carDlgPartnoStr[0] = '\0';
+ carDlgDescStr[0] = '\0';
+ reload[I_CD_PARTNO_STR] = reload[I_CD_DESC_STR] = TRUE;
+ break;
+ case A_ClrNumberStr:
+ carDlgNumberStr[0] = '\0';
+ reload[I_CD_NUMBER] = TRUE;
+ break;
+ case A_LoadProtoStrFromList:
+ wListGetValues( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoStr, sizeof carDlgProtoStr, NULL, NULL );
+#ifdef LATER
+ protoP = (carProto_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+ if ( protoP ) {
+ carDlgTypeInx = CarProtoFindTypeCode( protoP->type );
+ carDlgIsLoco = (protoP->options&CAR_DESC_IS_LOCO)!=0;
+ }
+#endif
+ break;
+ case A_ShowPartnoList:
+ reload[I_CD_PARTNO_LIST] = TRUE;
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_LIST, TRUE );
+ ParamControlShow( &carDlgPG, I_CD_DESC_STR, FALSE );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_STR, FALSE );
+ break;
+ case A_HidePartnoList:
+ reload[I_CD_PARTNO_STR] = reload[I_CD_DESC_STR] = TRUE;
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_LIST, FALSE );
+ ParamControlShow( &carDlgPG, I_CD_DESC_STR, TRUE );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_STR, TRUE );
+ break;
+ case A_PushDims:
+ if ( carDlgStkPtr >= CARDLG_STK_SIZE )
+ AbortProg( "carDlgNewDesc: CARDLG_STK_SIZE" );
+ carDlgStk[carDlgStkPtr].dim = carDlgDim;
+ carDlgStk[carDlgStkPtr].couplerLength = carDlgCouplerLength;
+ carDlgStk[carDlgStkPtr].state = currState;
+ carDlgStk[carDlgStkPtr].changed = carDlgChanged;
+ carDlgStk[carDlgStkPtr].typeInx = carDlgTypeInx;
+ if ( currState == S_ItemSel && carDlgPartnoInx >= 0 )
+ carDlgStk[carDlgStkPtr].partP = (carPart_p)wListGetItemContext( (wList_p)carDlgPLs[I_CD_PARTNO_LIST].control, carDlgPartnoInx );
+ else
+ carDlgStk[carDlgStkPtr].partP = NULL;
+ carDlgStkPtr++;
+ break;
+ case A_PopDims:
+ break;
+ case A_PopTitleAndTypeinx:
+ if ( carDlgStk[carDlgStkPtr].partP ) {
+ TabStringExtract( carDlgStk[carDlgStkPtr].partP->title, 7, tabs );
+ strcpy( carDlgManufStr, carDlgStk[carDlgStkPtr].partP->parent->manuf );
+ strcpy( carDlgProtoStr, carDlgStk[carDlgStkPtr].partP->parent->proto );
+ TabStringCpy( carDlgPartnoStr, &tabs[T_PART] );
+ TabStringCpy( carDlgDescStr, &tabs[T_DESC] );
+ }
+ carDlgTypeInx = carDlgStk[carDlgStkPtr].typeInx;
+ break;
+ case A_PopCouplerLength:
+ carDlgCouplerLength = carDlgStk[carDlgStkPtr].couplerLength;
+ break;
+ case A_ShowControls:
+ CarDlgShowControls();
+ break;
+ case A_LoadInfoFromUpdateItem:
+ carDlgScaleInx = carDlgUpdateItemPtr->scaleInx;
+ carDlgItemIndex = carDlgUpdateItemPtr->index;
+ TabStringExtract( carDlgUpdateItemPtr->title, 7, tabs );
+ TabStringCpy( carDlgManufStr, &tabs[T_MANUF] );
+ TabStringCpy( carDlgProtoStr, &tabs[T_PROTO] );
+ TabStringCpy( carDlgRoadnameStr, &tabs[T_ROADNAME] );
+ TabStringCpy( carDlgRepmarkStr, &tabs[T_REPMARK] );
+ TabStringCpy( carDlgNumberStr, &tabs[T_NUMBER] );
+ carDlgDim = carDlgUpdateItemPtr->dim;
+ carDlgBodyColor = carDlgUpdateItemPtr->color;
+ carDlgTypeInx = CarProtoFindTypeCode( carDlgUpdateItemPtr->type );
+ carDlgIsLoco = (carDlgUpdateItemPtr->type&1)!=0;
+ carDlgCouplerLength = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ wPrefSetFloat( carDlgPG.nameStr, message, carDlgCouplerLength );
+ carDlgCouplerMount = (carDlgUpdateItemPtr->options&CAR_DESC_COUPLER_MODE_BODY)!=0;
+ carDlgIsLoco = (carDlgUpdateItemPtr->options&CAR_DESC_IS_LOCO)!=0;
+ carDlgPurchPrice = carDlgUpdateItemPtr->data.purchPrice;
+ sprintf( carDlgPurchPriceStr, "%0.2f", carDlgPurchPrice );
+ carDlgCurrPrice = carDlgUpdateItemPtr->data.currPrice;
+ sprintf( carDlgCurrPriceStr, "%0.2f", carDlgCurrPrice );
+ carDlgCondition = carDlgUpdateItemPtr->data.condition;
+ carDlgConditionInx = MapCondition( carDlgUpdateItemPtr->data.condition );
+ carDlgPurchDate = carDlgUpdateItemPtr->data.purchDate;
+ if ( carDlgPurchDate )
+ sprintf( carDlgPurchDateStr, "%ld", carDlgPurchDate );
+ else
+ carDlgPurchDateStr[0] = '\0';
+ carDlgServiceDate = carDlgUpdateItemPtr->data.serviceDate;
+ if ( carDlgServiceDate )
+ sprintf( carDlgServiceDateStr, "%ld", carDlgServiceDate );
+ else
+ carDlgServiceDateStr[0] = '\0';
+ wTextClear( (wText_p)carDlgPLs[I_CD_NOTES].control );
+ if ( carDlgUpdateItemPtr->data.notes ) {
+ strncpy( message, carDlgUpdateItemPtr->data.notes, sizeof message );
+ message[sizeof message - 1] = '\0';
+ for ( cp=message; *cp; cp++ )
+ if ( *cp == '\n' ) *cp = ' ';
+ wTextAppend( (wText_p)carDlgPLs[I_CD_NOTES].control, message );
+ }
+ LoadRoadnameList( &tabs[T_ROADNAME], &tabs[T_REPMARK] );
+ CarDlgLoadRoadnameList();
+ carDlgRoadnameInx = lookupListIndex+1;
+ memset( reload, 1, sizeof reload );
+
+ if ( CarDlgLoadLists( TRUE, tabs, carDlgScaleInx ) )
+ currState = S_ItemSel;
+ else
+ currState = S_ItemEnter;
+ break;
+ case A_LoadDataFromUpdatePart:
+ carDlgScaleInx = carDlgUpdatePartPtr->parent->scale;
+ TabStringExtract( carDlgUpdatePartPtr->title, 7, tabs );
+ tabs[T_MANUF].ptr = carDlgUpdatePartPtr->parent->manuf;
+ tabs[T_MANUF].len = strlen(carDlgUpdatePartPtr->parent->manuf);
+ tabs[T_PROTO].ptr = carDlgUpdatePartPtr->parent->proto;
+ tabs[T_PROTO].len = strlen(carDlgUpdatePartPtr->parent->proto);
+ CarDlgLoadLists( FALSE, tabs, carDlgScaleInx );
+ CarDlgLoadPart( carDlgUpdatePartPtr );
+ RELOAD_LISTS;
+ RELOAD_DIMS;
+ RELOAD_PARTDATA;
+ break;
+ case A_InitProto:
+ if ( carDlgUpdateProtoPtr==NULL ) {
+ carDlgProtoStr[0] = 0;
+ carDlgDim.carLength = 50*12;
+ carDlgDim.carWidth = 10*12;
+ carDlgDim.coupledLength = carDlgDim.carLength+16.0*2.0;
+ carDlgCouplerLength = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ carDlgDim.truckCenter = carDlgDim.carLength-59.0*2.0;
+ carDlgIsLoco = (typeListMap[carDlgTypeInx].value&1);
+ } else {
+ strcpy( carDlgProtoStr , carDlgUpdateProtoPtr->desc );
+ carDlgDim = carDlgUpdateProtoPtr->dim;
+ carDlgCouplerLength = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ carDlgIsLoco = (carDlgUpdateProtoPtr->options&CAR_DESC_IS_LOCO)!=0;
+ carDlgTypeInx = CarProtoFindTypeCode( carDlgUpdateProtoPtr->type );
+ carProtoSegCnt = carDlgUpdateProtoPtr->segCnt;
+ carProtoSegPtr = carDlgUpdateProtoPtr->segPtr;
+ currState = S_ProtoSel;
+ }
+ RELOAD_DIMS;
+ break;
+ case A_RecallCouplerLength:
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ carDlgCouplerLength = 16.0/GetScaleRatio(carDlgScaleInx);
+ wPrefGetFloat( carDlgPG.nameStr, message, &carDlgCouplerLength, carDlgCouplerLength );
+ break;
+ default:
+ AbortProg( "carDlgDoActions: bad action" );
+ break;
+ }
+ }
+}
+
+
+static void CarDlgDoStateActions(
+ carDlgAction_e * actions )
+{
+ CarDlgDoActions( actions );
+LOG( log_carDlgState, 1, ( " ==> S_%s\n", carDlgState_s[currState] ) )
+}
+
+static void CarDlgStateMachine(
+ carDlgTransistion_e transistion )
+{
+LOG( log_carDlgState, 1, ( "S_%s[T_%s]\n", carDlgState_s[currState], carDlgTransistion_s[transistion] ) )
+ CarDlgDoStateActions( stateMachine[currState][transistion] );
+}
+
+
+static BOOL_T CheckCarDlgItemIndex( long * index )
+{
+ BOOL_T found = TRUE;
+ BOOL_T updated = FALSE;
+
+ int inx;
+ carItem_p item;
+ while ( found ) {
+ found = FALSE;
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ ) {
+ item = carItemInfo(inx);
+ if ( item->index == *index ) {
+ (*index)++;
+ found = TRUE;
+ updated = TRUE;
+ break;
+ }
+ }
+ }
+ return !updated;
+}
+
+
+static void CarDlgUpdate(
+ paramGroup_p pg,
+ int inx,
+ void * valueP )
+{
+ BOOL_T redraw = FALSE;
+ roadnameMap_p roadnameMapP;
+ char * cp, *cq;
+ long valL, d, m;
+ FLOAT_T ratio;
+ BOOL_T ok;
+ DIST_T len;
+ BOOL_T checkTruckCenter = FALSE;
+ cmp_key_t cmp_key;
+ coOrd orig, size, size2;
+ carPartParent_p parentP;
+ static DIST_T carDlgTruckOffset;
+ static long carDlgClock;
+ static long carDlgCarLengthClock;
+ static long carDlgTruckCenterClock;
+ static long carDlgCoupledLengthClock;
+ static long carDlgCouplerLengthClock;
+
+ ratio = (S_PROTO?1.0:GetScaleRatio(carDlgScaleInx));
+
+LOG( log_carDlgState, 3, ( "CarDlgUpdate( %d )\n", inx ) )
+
+ switch ( inx ) {
+
+ case -1:
+ if ( carDlgDim.truckCenter > 0 && carDlgDim.carLength > carDlgDim.truckCenter )
+ carDlgTruckOffset = carDlgDim.carLength - carDlgDim.truckCenter;
+ else
+ carDlgTruckOffset = 0;
+ carDlgCarLengthClock = carDlgCoupledLengthClock = carDlgTruckCenterClock = carDlgCouplerLengthClock = carDlgClock = 0;
+ redraw = TRUE;
+ break;
+
+ case I_CD_MANUF_LIST:
+ carDlgChanged++;
+ wListGetValues( (wList_p)pg->paramPtr[inx].control, carDlgManufStr, sizeof carDlgManufStr, NULL, NULL );
+ if ( carDlgManufInx < 0 ||
+ wListGetItemContext( (wList_p)pg->paramPtr[inx].control, carDlgManufInx ) == NULL )
+ CarDlgStateMachine( T_ItemEnter );
+#ifdef LATER
+ else if ( strcasecmp( carDlgManufStr, "unknown" ) == 0 ||
+ strcasecmp( carDlgManufStr, "custom" ) == 0 )
+ CarDlgStateMachine( T_ItemEnter );
+#endif
+ else
+ CarDlgStateMachine( T_ItemSel );
+ /*ParamControlShow( &carDlgPG, I_CD_MANUF_LIST, TRUE );*/
+ break;
+
+ case I_CD_PROTOKIND_LIST:
+ carDlgChanged++;
+ carDlgTypeInx = (int)(long)wListGetItemContext( (wList_p)pg->paramPtr[inx].control, carDlgKindInx );
+ if ( S_PART || (currState==S_ItemEnter) ) {
+ CarDlgLoadProtoList( NULL, 0, FALSE );
+ } else {
+ parentP = NULL;
+ if ( carDlgProtoInx >= 0 )
+ parentP = (carPartParent_p)wListGetItemContext( (wList_p)pg->paramPtr[I_CD_PROTOTYPE_LIST].control, carDlgProtoInx );
+ CarDlgLoadProtoList( carDlgManufStr, (parentP?parentP->scale:0), FALSE );
+ }
+ CarDlgStateMachine( T_ProtoSel );
+ break;
+
+ case I_CD_PROTOTYPE_LIST:
+ carDlgChanged++;
+ wListGetValues( (wList_p)pg->paramPtr[inx].control, carDlgProtoStr, sizeof carDlgProtoStr, NULL, NULL );
+ CarDlgStateMachine( T_ProtoSel );
+ break;
+
+ case I_CD_PARTNO_LIST:
+ carDlgChanged++;
+ wListGetValues( (wList_p)pg->paramPtr[inx].control, carDlgPartnoStr, sizeof carDlgPartnoStr, NULL, NULL );
+ if ( carDlgPartnoInx >= 0 ) {
+ CarDlgStateMachine( T_PartnoSel );
+ } else {
+ CarDlgStateMachine( T_PartnoEnter );
+ wControlSetFocus( pg->paramPtr[I_CD_PARTNO_STR].control );
+ }
+ break;
+
+ case I_CD_DISPMODE:
+ for ( inx=B; inx<C; inx++ )
+ ParamControlShow( &carDlgPG, inx, carDlgDispMode==1 );
+ for ( inx=C; inx<D; inx++ )
+ ParamControlShow( &carDlgPG, inx, carDlgDispMode==0 );
+ if ( carDlgDispMode == 0 && carDlgUpdateItemPtr != NULL ) {
+ ParamControlShow( &carDlgPG, I_CD_QTY, FALSE );
+ ParamControlShow( &carDlgPG, I_CD_MLTNUM, FALSE );
+ }
+ redraw = carDlgDispMode==1;
+ break;
+
+ case I_CD_ROADNAME_LIST:
+ carDlgChanged++;
+ roadnameMapP = NULL;
+ if ( *(long*)valueP == 0 ) {
+ roadnameMapP = NULL;
+ carDlgRoadnameStr[0] = '\0';
+ } else if ( *(long*)valueP > 0 ) {
+ roadnameMapP = (roadnameMap_p)wListGetItemContext( (wList_p)pg->paramPtr[I_CD_ROADNAME_LIST].control, (wIndex_t)*(long*)valueP );
+ strcpy( carDlgRoadnameStr, roadnameMapP->roadname );
+ } else {
+ wListGetValues( (wList_p)pg->paramPtr[I_CD_ROADNAME_LIST].control, carDlgRoadnameStr, sizeof carDlgRoadnameStr, NULL, NULL );
+ cmp_key.name = carDlgRoadnameStr;
+ cmp_key.len = strlen(carDlgRoadnameStr);
+ roadnameMapP = LookupListElem( &roadnameMap_da, &cmp_key, Cmp_roadnameMap, 0 );
+ }
+ if ( roadnameMapP ) {
+ strcpy( carDlgRepmarkStr, roadnameMapP->repmark );
+ } else {
+ carDlgRepmarkStr[0] = '\0';
+ }
+ ParamLoadControl( pg, I_CD_REPMARK );
+ break;
+
+ case I_CD_CARLENGTH:
+ carDlgChanged++;
+ if ( carDlgDim.carLength == 0.0 ) {
+ carDlgCarLengthClock = 0;
+ } else if ( carDlgDim.carLength < 100/ratio ) {
+ return;
+ } else if ( carDlgCouplerLength != 0 && ( carDlgDim.coupledLength == 0 || carDlgCouplerLengthClock >= carDlgCoupledLengthClock ) ) {
+ len = carDlgDim.carLength+carDlgCouplerLength*2.0;
+ if ( len > 0 ) {
+ carDlgDim.coupledLength = len;
+ ParamLoadControl( &carDlgPG, I_CD_CPLDLEN );
+ }
+ carDlgCarLengthClock = ++carDlgClock;
+ } else if ( carDlgDim.coupledLength != 0 && ( carDlgCouplerLength == 0 || carDlgCoupledLengthClock > carDlgCouplerLengthClock ) ) {
+ len = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ if ( len > 0 ) {
+ carDlgCouplerLength = len;
+ ParamLoadControl( &carDlgPG, I_CD_CPLRLEN );
+ if ( !S_PROTO ) {
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ wPrefSetFloat( carDlgPG.nameStr, message, carDlgCouplerLength );
+ }
+ }
+ carDlgCarLengthClock = ++carDlgClock;
+ }
+ checkTruckCenter = TRUE;
+ redraw = TRUE;
+ break;
+
+ case I_CD_CPLDLEN:
+ carDlgChanged++;
+ if ( carDlgDim.coupledLength == 0 ) {
+ carDlgCoupledLengthClock = 0;
+ } else if ( carDlgDim.coupledLength < 100/ratio ) {
+ return;
+ } else if ( carDlgDim.carLength != 0 && ( carDlgCouplerLength == 0 || carDlgCarLengthClock > carDlgCouplerLengthClock ) ) {
+ len = (carDlgDim.coupledLength-carDlgDim.carLength)/2.0;
+ if ( len > 0 ) {
+ carDlgCouplerLength = len;
+ ParamLoadControl( &carDlgPG, I_CD_CPLRLEN );
+ if ( !S_PROTO ) {
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ wPrefSetFloat( carDlgPG.nameStr, message, carDlgCouplerLength );
+ }
+ }
+ carDlgCoupledLengthClock = ++carDlgClock;
+ } else if ( carDlgCouplerLength != 0 && ( carDlgDim.carLength == 0 || carDlgCouplerLengthClock >= carDlgCarLengthClock ) ) {
+ len = carDlgDim.coupledLength-carDlgCouplerLength*2.0;
+ if ( len > 0 ) {
+ carDlgDim.carLength = len;
+ ParamLoadControl( &carDlgPG, I_CD_CARLENGTH );
+ checkTruckCenter = TRUE;
+ }
+ carDlgCoupledLengthClock = ++carDlgClock;
+ }
+ redraw = TRUE;
+ break;
+
+ case I_CD_CPLRLEN:
+ carDlgChanged++;
+ if ( carDlgCouplerLength == 0 ) {
+ carDlgCouplerLengthClock = 0;
+ redraw = TRUE;
+ break;
+ } else if ( carDlgCouplerLength < 1/ratio ) {
+ return;
+ } else if ( carDlgDim.carLength != 0 && ( carDlgDim.coupledLength == 0 || carDlgCarLengthClock >= carDlgCoupledLengthClock ) ) {
+ len = carDlgDim.carLength+carDlgCouplerLength*2.0;
+ if ( len > 0 ) {
+ carDlgDim.coupledLength = carDlgDim.carLength+carDlgCouplerLength*2.0;
+ ParamLoadControl( &carDlgPG, I_CD_CPLDLEN );
+ }
+ carDlgCouplerLengthClock = ++carDlgClock;
+ } else if ( carDlgDim.coupledLength != 0 && ( carDlgDim.carLength == 0 || carDlgCoupledLengthClock > carDlgCarLengthClock ) ) {
+ len = carDlgCouplerLength-carDlgDim.coupledLength*2.0;
+ if ( len > 0 ) {
+ carDlgDim.carLength = carDlgCouplerLength-carDlgDim.coupledLength*2.0;
+ ParamLoadControl( &carDlgPG, I_CD_CARLENGTH );
+ checkTruckCenter = TRUE;
+ }
+ carDlgCouplerLengthClock = ++carDlgClock;
+ }
+ if ( !S_PROTO ) {
+ sprintf( message, "%s-%s", carDlgPLs[I_CD_CPLRLEN].nameStr, GetScaleName(carDlgScaleInx) );
+ wPrefSetFloat( carDlgPG.nameStr, message, carDlgCouplerLength );
+ }
+ redraw = TRUE;
+ break;
+
+ case I_CD_CARWIDTH:
+ carDlgChanged++;
+ if ( carDlgDim.carLength < 30/ratio ) return;
+ redraw = TRUE;
+ break;
+
+ case I_CD_BODYCOLOR:
+ carDlgChanged++;
+ RecolorSegs( carDlgSegs_da.cnt, &carDlgSegs(0), carDlgBodyColor );
+ redraw = TRUE;
+ break;
+
+ case I_CD_ISLOCO:
+ carDlgChanged++;
+ redraw = TRUE;
+ break;
+
+ case I_CD_TRKCENTER:
+ carDlgChanged++;
+ if ( carDlgDim.truckCenter == 0 ) {
+ carDlgTruckOffset = 0;
+ } else if ( carDlgDim.truckCenter < 100/ratio /*&& carDlgDim.carLength == 0.0*/ ) {
+ return;
+ } else if ( carDlgDim.carLength > carDlgDim.truckCenter ) {
+ carDlgTruckOffset = carDlgDim.carLength - carDlgDim.truckCenter;
+ } else {
+ carDlgTruckOffset = 0;
+ }
+ redraw = TRUE;
+ break;
+
+ case I_CD_QTY:
+ wControlActive( carDlgPLs[I_CD_MLTNUM].control, carDlgQuantity>1 );
+ break;
+
+ case I_CD_PURPRC:
+ case I_CD_CURPRC:
+ carDlgChanged++;
+ *(FLOAT_T*)(pg->paramPtr[inx].context) = strtod( (char*)pg->paramPtr[inx].valueP, &cp );
+ if ( cp==NULL || *cp!='\0' )
+ *(FLOAT_T*)(pg->paramPtr[inx].context) = -1;
+ break;
+
+ case I_CD_COND:
+ carDlgChanged++;
+ carDlgCondition =
+ (carDlgConditionInx==0)?0:
+ (carDlgConditionInx==1)?100:
+ (carDlgConditionInx==2)?80:
+ (carDlgConditionInx==3)?60:
+ (carDlgConditionInx==4)?40:20;
+ break;
+
+ case I_CD_PURDAT:
+ case I_CD_SRVDAT:
+ carDlgChanged++;
+ cp = (char*)pg->paramPtr[inx].valueP;
+ if ( *cp ) {
+ valL = strtol( cp, &cq, 10 );
+ if ( cq==NULL || *cq!='\0' ) {
+ cp = N_("Enter a 8 digit numeric date");
+ } else if ( valL != 0 ) {
+ if ( strlen(cp) != 8 ) {
+ cp = N_("Enter a 8 digit date");
+ } else if ( valL < 19000101 || valL > 21991231 ) {
+ cp = N_("Enter a date between 19000101 and 21991231");
+ } else {
+ d = valL % 100;
+ m = (valL / 100) % 100;
+ if ( m < 1 || m > 12 ) {
+ cp = N_("Invalid month");
+ } else if ( d < 1 || d > 31 ) {
+ cp = N_("Invalid day");
+ } else {
+ cp = NULL;
+ }
+ }
+ }
+ if ( cp ) {
+ valL = 0;
+ }
+ } else {
+ cp = NULL;
+ valL = 0;
+ }
+ wControlSetBalloon( pg->paramPtr[inx].control, 0, -5, _(cp) );
+ *(long*)(pg->paramPtr[inx].context) = valL;
+ break;
+
+ case I_CD_TYPE_LIST:
+ carDlgChanged++;
+ carDlgIsLoco = (typeListMap[carDlgTypeInx].value&1);
+ ParamLoadControl( &carDlgPG, I_CD_ISLOCO );
+ redraw = TRUE;
+ break;
+
+ case I_CD_IMPORT:
+ carDlgChanged++;
+ WriteSelectedTracksToTempSegs();
+ carProtoSegCnt = tempSegs_da.cnt;
+ carProtoSegPtr = (trkSeg_t*)tempSegs_da.ptr;
+ CloneFilledDraw( carProtoSegCnt, carProtoSegPtr, TRUE );
+ GetSegBounds( zero, 0.0, carProtoSegCnt, carProtoSegPtr, &orig, &size );
+ if ( size.x <= 0.0 ||
+ size.y <= 0.0 ||
+ size.x < size.y ) {
+ NoticeMessage( MSG_CARPROTO_BADSEGS, _("Ok"), NULL );
+ return;
+ }
+ orig.x = -orig.x;
+ orig.y = -orig.y;
+ MoveSegs( carProtoSegCnt, carProtoSegPtr, orig );
+ size2.x = floor(size.x*curScaleRatio+0.5);
+ size2.y = floor(size.y*curScaleRatio+0.5);
+ RescaleSegs( carProtoSegCnt, carProtoSegPtr, size2.x/size.x, size2.y/size.y, curScaleRatio );
+ carDlgDim.carLength = size2.x;
+ carDlgDim.carWidth = size2.y;
+ carDlgDim.coupledLength = carDlgDim.carLength + 32;
+ if ( carDlgDim.carLength > 120 ) {
+ carDlgDim.truckCenter = carDlgDim.carLength - 120;
+ carDlgTruckOffset = carDlgDim.carLength - carDlgDim.truckCenter;
+ } else {
+ carDlgDim.truckCenter = 0;
+ carDlgTruckOffset = 0;
+ }
+ carDlgFlipToggle = FALSE;
+ ParamLoadControl( &carDlgPG, I_CD_CARLENGTH );
+ ParamLoadControl( &carDlgPG, I_CD_CARWIDTH );
+ ParamLoadControl( &carDlgPG, I_CD_CPLRLEN );
+ ParamLoadControl( &carDlgPG, I_CD_TRKCENTER );
+ redraw = TRUE;
+ break;
+
+ case I_CD_RESET:
+ carDlgChanged++;
+ carProtoSegCnt = 0;
+ redraw = TRUE;
+ break;
+
+ case I_CD_FLIP:
+ carDlgChanged++;
+ carDlgFlipToggle = ! carDlgFlipToggle;
+ redraw = TRUE;
+ break;
+
+ }
+
+ if ( checkTruckCenter && carDlgDim.carLength > 0 ) {
+ if ( carDlgTruckOffset > 0 ) {
+ carDlgDim.truckCenter = carDlgDim.carLength - carDlgTruckOffset;
+ } else {
+ carDlgDim.truckCenter = carDlgDim.carLength * 0.75;
+ }
+ ParamLoadControl( &carDlgPG, I_CD_TRKCENTER );
+ }
+
+ ok = FALSE;
+ if ( S_PROTO && carDlgProtoStr[0] == '\0' )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter a Prototype name") );
+ else if ( S_PART && carDlgManufStr[0] == '\0' )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Select or Enter a Manufacturer") );
+ else if ( S_PART && carDlgPartnoStr[0] == '\0' )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter a Part Number") );
+ else if ( carDlgDim.carLength <= 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter the Car Length") );
+ else if ( carDlgDim.carWidth <= 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter the Car Width") );
+ else if ( carDlgDim.truckCenter <= 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter the Truck Centers") );
+ else if ( carDlgDim.truckCenter >= carDlgDim.carLength )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Truck Centers must be less than Car Length") );
+ else if ( (!S_PROTO) && ( carDlgDim.coupledLength <= 0 || carDlgCouplerLength <= 0 ) )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter the Coupled Length or Coupler Length") );
+ else if ( S_PROTO && carDlgDim.coupledLength <= 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter the Coupled Length") );
+ else if ( S_ITEM && carDlgItemIndex <= 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Enter a item Index") );
+ else if ( S_ITEM && carDlgPurchPrice < 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Purchase Price is not valid") );
+ else if ( S_ITEM && carDlgCurrPrice < 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Current Price is not valid") );
+ else if ( S_ITEM && carDlgPurchDate < 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Purchase Date is not valid") );
+ else if ( S_ITEM && carDlgServiceDate < 0 )
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, _("Service Date is not valid") );
+ else if ( S_ITEM && carDlgUpdateItemPtr==NULL &&
+ ( valL = carDlgItemIndex , !CheckCarDlgItemIndex(&carDlgItemIndex) ) ) {
+ sprintf( message, _("Item Index %ld duplicated an existing item: updated to new value"), valL );
+ ParamLoadControl( &carDlgPG, I_CD_ITEMINDEX );
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, message );
+ ok = TRUE;
+ } else {
+ ParamLoadMessage( pg, I_CD_MSG, "" );
+ ok = TRUE;
+ }
+
+ if ( redraw )
+ CarDlgRedraw();
+
+ ParamDialogOkActive( pg, ok );
+}
+
+
+
+static void CarDlgNewDesc( void )
+{
+ carDlgNewPartPtr = NULL;
+ carDlgNewProtoPtr = NULL;
+ carDlgUpdatePartPtr = NULL;
+ carDlgNumberStr[0] = '\0';
+ ParamLoadControl( &carDlgPG, I_CD_NUMBER );
+ CarDlgDoStateActions( item2partActions );
+ carDlgChanged = 0;
+}
+
+
+static void CarDlgNewProto( void )
+{
+ carProto_p protoP = CarProtoFind( carDlgProtoStr );
+ if ( protoP != NULL ) {
+ carProtoSegCnt = protoP->segCnt;;
+ carProtoSegPtr = protoP->segPtr;;
+ } else {
+ carProtoSegCnt = 0;
+ carProtoSegPtr = NULL;
+ }
+ carDlgUpdateProtoPtr = NULL;
+ carDlgNewProtoPtr = NULL;
+ if ( S_ITEM )
+ CarDlgDoStateActions( item2protoActions );
+ else
+ CarDlgDoStateActions( part2protoActions );
+ carDlgChanged = 0;
+}
+
+
+static void CarDlgClose( wWin_p win )
+{
+ carDlgState_e oldState;
+
+ if ( carDlgChanged ) {
+ if ( !inPlayback ) {
+ if ( NoticeMessage( MSG_CARDESC_CHANGED, _("Yes"), _("No") ) <= 0 )
+ return;
+ } else {
+ PlaybackMessage( "Car Desc Changed\n" );
+ }
+ }
+ if ( carDlgStkPtr > 0 ) {
+ carDlgStkPtr--;
+ oldState = currState;
+ currState = carDlgStk[carDlgStkPtr].state;
+ carDlgChanged = carDlgStk[carDlgStkPtr].changed;
+ if ( oldState == S_ProtoSel )
+ if ( S_PART )
+ CarDlgDoStateActions( proto2partActions );
+ else
+ CarDlgDoStateActions( proto2itemActions );
+ else
+ CarDlgDoStateActions( part2itemActions );
+ } else {
+ wTextClear( (wText_p)carDlgPLs[I_CD_NOTES].control );
+ wHide( carDlgPG.win );
+ }
+}
+
+
+static void CarDlgOk( void * junk )
+{
+ long options = 0;
+ int len;
+ FILE * f;
+ long number;
+ char * cp;
+ long count;
+ tabString_t tabs[7];
+ char title[STR_LONG_SIZE];
+ carItem_p itemP=NULL;
+ carPart_p partP=NULL;
+ carProto_p protoP;
+ BOOL_T reloadRoadnameList = FALSE;
+ char *oldLocale = NULL;
+
+LOG( log_carDlgState, 3, ( "CarDlgOk()\n" ) )
+
+ /*ParamUpdate( &carDlgPG );*/
+ if ( carDlgDim.carLength <= 0.0 ||
+ carDlgDim.carWidth <= 0.0 ||
+ carDlgDim.truckCenter <= 0.0 ||
+ carDlgDim.coupledLength <= 0.0 ) {
+ NoticeMessage( MSG_CARDESC_VALUE_ZERO, _("Ok"), NULL );
+ return;
+ }
+ if ( carDlgDim.carLength <= carDlgDim.carWidth ) {
+ NoticeMessage( MSG_CARDESC_BAD_DIM_VALUE, _("Ok"), NULL );
+ return;
+ }
+ if ( carDlgDim.coupledLength <= carDlgDim.carLength ) {
+ NoticeMessage( MSG_CARDESC_BAD_COUPLER_LENGTH_VALUE, _("Ok"), NULL );
+ return;
+ }
+
+ if ( S_ITEM && carDlgUpdateItemPtr==NULL && !CheckCarDlgItemIndex(&carDlgItemIndex) ) {
+ NoticeMessage( MSG_CARITEM_BAD_INDEX, _("Ok"), NULL );
+ ParamLoadControl( &carDlgPG, I_CD_ITEMINDEX );
+ return;
+ }
+
+ if ( (!S_PROTO) && carDlgCouplerMount != 0 )
+ options |= CAR_DESC_COUPLER_MODE_BODY;
+ if ( carDlgIsLoco == 1 )
+ options |= CAR_DESC_IS_LOCO;
+
+ if ( S_ITEM ) {
+ len = wTextGetSize( (wText_p)carDlgPLs[I_CD_NOTES].control );
+ sprintf( title, "%s\t%s\t%s\t%s\t%s\t%s\t%s", carDlgManufStr, carDlgProtoStr, carDlgDescStr, carDlgPartnoStr, carDlgRoadnameStr, carDlgRepmarkStr, carDlgNumberStr );
+ partP = NULL;
+ if ( ( carDlgManufInx < 0 || carDlgPartnoInx < 0 ) && carDlgPartnoStr[0] ) {
+ partP = CarPartFind( carDlgManufStr, strlen(carDlgManufStr), carDlgPartnoStr, strlen(carDlgPartnoStr), carDlgScaleInx );
+ if ( partP != NULL &&
+ NoticeMessage( MSG_CARPART_DUPNAME, _("Yes"), _("No") ) <= 0 )
+ return;
+ partP = CarPartNew( NULL, PARAM_CUSTOM, carDlgScaleInx, title, options, typeListMap[carDlgTypeInx].value, &carDlgDim, carDlgBodyColor );
+ if ( partP != NULL ) {
+ if ( ( f = OpenCustom("a") ) ) {
+ oldLocale = SaveLocale("C");
+ CarPartWrite( f, partP );
+ fclose(f);
+ RestoreLocale(oldLocale);
+ }
+ }
+ }
+ if ( carDlgUpdateItemPtr!=NULL ) {
+ carDlgQuantity = 1;
+ }
+ for ( count=0; count<carDlgQuantity; count++ ) {
+ itemP = CarItemNew( carDlgUpdateItemPtr,
+ PARAM_CUSTOM, carDlgItemIndex,
+ carDlgScaleInx, title, options, typeListMap[carDlgTypeInx].value,
+ &carDlgDim, carDlgBodyColor,
+ carDlgPurchPrice, carDlgCurrPrice, carDlgCondition,
+ carDlgPurchDate, carDlgServiceDate );
+ if ( carDlgUpdateItemPtr==NULL ) {
+ wPrefSetInteger( "misc", "last-car-item-index", carDlgItemIndex );
+ carDlgItemIndex++;
+ CheckCarDlgItemIndex(&carDlgItemIndex);
+ ParamLoadControl( &carDlgPG, I_CD_ITEMINDEX );
+ if ( carDlgQuantity>1 && carDlgMultiNum==0 ) {
+ number = strtol( carDlgNumberStr, &cp, 10 );
+ if ( cp && *cp == 0 && number > 0 ) {
+ sprintf( carDlgNumberStr, "%ld", number+1 );
+ sprintf( title, "%s\t%s\t%s\t%s\t%s\t%s\t%s", carDlgManufStr, carDlgProtoStr, carDlgDescStr, carDlgPartnoStr, carDlgRoadnameStr, carDlgRepmarkStr, carDlgNumberStr );
+ }
+ }
+ }
+ if ( len > 0 ) {
+ if ( itemP->data.notes )
+ itemP->data.notes = MyRealloc( itemP->data.notes, len+2 );
+ else
+ itemP->data.notes = MyMalloc( len+2 );
+ itemP->data.notes = (char*)MyMalloc( len+2 );
+ wTextGetText( (wText_p)carDlgPLs[I_CD_NOTES].control, itemP->data.notes, len );
+ if ( itemP->data.notes[len-1] != '\n' ) {
+ itemP->data.notes[len] = '\n';
+ itemP->data.notes[len+1] = '\0';
+ } else {
+ itemP->data.notes[len] = '\0';
+ }
+ } else if ( itemP->data.notes ) {
+ MyFree( itemP->data.notes );
+ itemP->data.notes = NULL;
+ }
+ }
+ if ( carDlgUpdateItemPtr==NULL )
+ CarInvListAdd( itemP );
+ else
+ CarInvListUpdate( itemP );
+ changed++;
+ SetWindowTitle();
+ reloadRoadnameList = TRUE;
+ if ( carDlgUpdateItemPtr==NULL ) {
+ if ( carDlgQuantity > 1 ) {
+ sprintf( message, _("Added %ld new Cars"), carDlgQuantity );
+ } else {
+ strcpy( message, _("Added new Car") );
+ }
+ } else {
+ strcpy( message, _("Updated Car") );
+ }
+ sprintf( message+strlen(message), "%s: %s %s %s %s %s %s",
+ (partP?_(" and Part"):""),
+ carDlgManufStr, carDlgPartnoStr, carDlgProtoStr, carDlgDescStr,
+ (carDlgRepmarkStr?carDlgRepmarkStr:carDlgRoadnameStr), carDlgNumberStr );
+ carDlgQuantity = 1;
+ ParamLoadControl( &carDlgPG, I_CD_QTY );
+
+ } else if ( S_PART ) {
+ if ( strcasecmp( carDlgRoadnameStr, "undecorated" ) == 0 ) {
+ carDlgRoadnameStr[0] = '\0';
+ carDlgRepmarkStr[0] = '\0';
+ }
+ if ( carDlgUpdatePartPtr==NULL ) {
+ partP = CarPartFind( carDlgManufStr, strlen(carDlgManufStr), carDlgPartnoStr, strlen(carDlgPartnoStr), carDlgScaleInx );
+ if ( partP != NULL &&
+ NoticeMessage( MSG_CARPART_DUPNAME, _("Yes"), _("No") ) <= 0 )
+ return;
+ }
+ sprintf( message, "%s\t%s\t%s\t%s\t%s\t%s\t%s", carDlgManufStr, carDlgProtoStr, carDlgDescStr, carDlgPartnoStr, carDlgRoadnameStr, carDlgRepmarkStr, carDlgNumberStr );
+ carDlgNewPartPtr = CarPartNew( carDlgUpdatePartPtr, PARAM_CUSTOM, carDlgScaleInx, message, options, typeListMap[carDlgTypeInx].value,
+ &carDlgDim, carDlgBodyColor );
+ if ( carDlgNewPartPtr != NULL && ( f = OpenCustom("a") ) ) {
+ oldLocale = SaveLocale("C");
+ CarPartWrite( f, carDlgNewPartPtr );
+ fclose(f);
+ RestoreLocale(oldLocale);
+ }
+ reloadRoadnameList = TRUE;
+ sprintf( message, _("%s Part: %s %s %s %s %s %s"), carDlgUpdatePartPtr==NULL?_("Added new"):_("Updated"), carDlgManufStr, carDlgPartnoStr, carDlgProtoStr, carDlgDescStr, carDlgRepmarkStr?carDlgRepmarkStr:carDlgRoadnameStr, carDlgNumberStr );
+
+ } else if ( S_PROTO ) {
+ if ( carDlgUpdateProtoPtr==NULL ) {
+ protoP = CarProtoFind( carDlgProtoStr );
+ if ( protoP != NULL &&
+ NoticeMessage( MSG_CARPROTO_DUPNAME, _("Yes"), _("No") ) <= 0 )
+ return;
+ }
+ carDlgNewProtoPtr = CarProtoNew( carDlgUpdateProtoPtr, PARAM_CUSTOM, carDlgProtoStr, options, typeListMap[carDlgTypeInx].value, &carDlgDim, carDlgSegs_da.cnt, &carDlgSegs(0) );
+ if ( (f = OpenCustom("a") ) ) {
+ oldLocale = SaveLocale("C");
+ CarProtoWrite( f, carDlgNewProtoPtr );
+ fclose(f);
+ RestoreLocale(oldLocale);
+ }
+ sprintf( message, _("%s Prototype: %s%s."),
+ carDlgUpdateProtoPtr==NULL?_("Added new"):_("Updated"), carDlgProtoStr,
+ carDlgUpdateProtoPtr==NULL?_(". Enter new values or press Close"):"" );
+ }
+
+ if ( reloadRoadnameList ) {
+ tabs[0].ptr = carDlgRoadnameStr;
+ tabs[0].len = strlen(carDlgRoadnameStr);
+ tabs[1].ptr = carDlgRepmarkStr;
+ tabs[1].len = strlen(carDlgRepmarkStr);
+ LoadRoadnameList( &tabs[0], &tabs[1] );
+ CarDlgLoadRoadnameList();
+ ParamLoadControl( &carDlgPG, I_CD_ROADNAME_LIST );
+ }
+
+ ParamLoadMessage( &carDlgPG, I_CD_MSG, message );
+
+ DoChangeNotification( CHANGE_PARAMS );
+
+ carDlgChanged = 0;
+ if ( S_ITEM ) {
+ if ( carDlgUpdateItemPtr==NULL ) {
+ if ( partP ) {
+ TabStringExtract( title, 7, tabs );
+ if ( CarDlgLoadLists( TRUE, tabs, curScaleInx ) )
+ currState = S_ItemSel;
+ else
+ currState = S_ItemEnter;
+ ParamLoadControl( &carDlgPG, I_CD_MANUF_LIST );
+ ParamLoadControl( &carDlgPG, I_CD_PROTOKIND_LIST );
+ ParamLoadControl( &carDlgPG, I_CD_PROTOTYPE_LIST );
+ ParamLoadControl( &carDlgPG, I_CD_PARTNO_LIST );
+ ParamLoadControl( &carDlgPG, I_CD_PARTNO_STR );
+ ParamLoadControl( &carDlgPG, I_CD_DESC_STR );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_LIST, carDlgPartnoInx>=0 );
+ ParamControlShow( &carDlgPG, I_CD_PARTNO_STR, carDlgPartnoInx<0 );
+ ParamControlShow( &carDlgPG, I_CD_DESC_STR, carDlgPartnoInx<0 );
+ } else if ( carDlgManufInx == -1 ) {
+ carDlgManufStr[0] = '\0';
+ }
+ return;
+ }
+ } else if ( S_PART ) {
+ if ( carDlgUpdatePartPtr==NULL ) {
+ number = strtol( carDlgPartnoStr, &cp, 10 );
+ if ( cp && *cp == 0 && number > 0 )
+ sprintf( carDlgPartnoStr, "%ld", number+1 );
+ else
+ carDlgPartnoStr[0] = '\0';
+ carDlgNumberStr[0] = '\0';
+ ParamLoadControl( &carDlgPG, I_CD_PARTNO_STR );
+ ParamLoadControl( &carDlgPG, I_CD_NUMBER );
+ return;
+ }
+ } else if ( S_PROTO ) {
+ if ( carDlgUpdateProtoPtr==NULL ) {
+ carDlgProtoStr[0] = '\0';
+ ParamLoadControl( &carDlgPG, I_CD_PROTOTYPE_STR );
+ return;
+ }
+ }
+ CarDlgClose( carDlgPG.win );
+}
+
+
+
+static void CarDlgLayout(
+ paramData_t * pd,
+ int inx,
+ wPos_t currX,
+ wPos_t *xx,
+ wPos_t *yy )
+{
+ static wPos_t col2pos = 0;
+ wPos_t y0, y1;
+
+ switch (inx) {
+ case I_CD_PROTOTYPE_STR:
+ case I_CD_PARTNO_STR:
+ case I_CD_ISLOCO:
+ case I_CD_IMPORT:
+ case I_CD_TYPE_LIST:
+ *yy = wControlGetPosY(carDlgPLs[inx-1].control);
+ break;
+ case I_CD_NEWPROTO:
+ *yy = wControlGetPosY(carDlgPLs[I_CD_NEW].control);
+ break;
+ case I_CD_CPLRMNT:
+ case I_CD_CPLRLEN:
+ case I_CD_CARWIDTH:
+ if ( col2pos == 0 )
+ col2pos = wLabelWidth( _("Coupler Length") )+20;
+ *xx = wControlBeside(carDlgPLs[inx-1].control) + col2pos;
+ break;
+ case I_CD_DESC_STR:
+ *yy = wControlBelow(carDlgPLs[I_CD_PARTNO_STR].control) + 3;
+ break;
+ case I_CD_CPLDLEN:
+ *yy = wControlBelow(carDlgPLs[I_CD_TRKCENTER].control) + 3;
+ break;
+ case I_CD_CANVAS:
+ *yy = wControlBelow(carDlgPLs[I_CD_CPLDLEN].control)+5;
+ break;
+ case C:
+ *yy = wControlGetPosY(carDlgPLs[B].control);
+ break;
+ case I_CD_MSG:
+ y0 = wControlBelow(carDlgPLs[C-1].control);
+ y1 = wControlBelow(carDlgPLs[D-1].control);
+ *yy = ((y0>y1)?y0:y1) + 10;
+ break;
+ }
+}
+
+
+static void DoCarPartDlg( carDlgAction_e *actions )
+{
+ paramData_t * pd;
+ int inx;
+
+ if ( carDlgPG.win == NULL ) {
+ ParamCreateDialog( &carDlgPG, MakeWindowTitle(_("New Car Part")), _("Add"), CarDlgOk, CarDlgClose, TRUE, CarDlgLayout, F_BLOCK|PD_F_ALT_CANCELLABEL, CarDlgUpdate );
+
+ if ( carDlgDim.carWidth==0 )
+ carDlgDim.carWidth = 12.0*10.0/curScaleRatio;
+
+ for ( pd=carDlgPG.paramPtr; pd<&carDlgPG.paramPtr[carDlgPG.paramCnt]; pd++ ) {
+ if ( pd->type == PD_FLOAT && pd->valueP ) {
+ sprintf( message, "%s-%s", pd->nameStr, curScaleName );
+ wPrefGetFloat( carDlgPG.nameStr, message, (FLOAT_T*)pd->valueP, *(FLOAT_T*)pd->valueP );
+ }
+ }
+ roadnameMapChanged = TRUE;
+
+ for ( inx=0; inx<N_CONDLISTMAP; inx++ )
+ wListAddValue( (wList_p)carDlgPLs[I_CD_COND].control, _(condListMap[inx].name), NULL, (void*)condListMap[inx].value );
+
+ for ( inx=0; inx<N_TYPELISTMAP; inx++ )
+ wListAddValue( (wList_p)carDlgPLs[I_CD_TYPE_LIST].control, _(typeListMap[inx].name), NULL, (void*)typeListMap[inx].value );
+
+ for ( inx=0; inx<N_TYPELISTMAP; inx++ )
+ wListAddValue( (wList_p)carDlgPLs[I_CD_PROTOKIND_LIST].control, _(typeListMap[inx].name), NULL, (void*)typeListMap[inx].value );
+
+ wTextSetReadonly( (wText_p)carDlgPLs[I_CD_NOTES].control, FALSE );
+ }
+
+ wPrefGetInteger( "misc", "last-car-item-index", &carDlgItemIndex, 1 );
+ CheckCarDlgItemIndex(&carDlgItemIndex);
+ CarDlgLoadRoadnameList();
+ carProtoSegCnt = 0;
+ carProtoSegPtr = NULL;
+ carDlgScaleInx = curScaleInx;
+ carDlgFlipToggle = FALSE;
+ carDlgChanged = 0;
+
+ CarDlgDoStateActions( actions );
+
+ /*CarDlgShowControls();*/
+
+#ifdef LATER
+if ( logTable(log_carList).level >= 1 ) {
+ int inx;
+ carPart_p partP;
+ for ( inx=0; inx<carPart_da.cnt; inx++ ) {
+ partP = carPart(inx);
+ LogPrintf( "%d %s %d\n", inx, partP->title, partP->paramFileIndex );
+ }
+}
+#endif
+ wShow( carDlgPG.win );
+}
+
+
+EXPORT void CarDlgAddProto( void )
+{
+ /*carDlgPrototypeStr[0] = 0; */
+ carDlgTypeInx = 0;
+ carDlgUpdateProtoPtr = NULL;
+ DoCarPartDlg( protoNewActions );
+}
+
+EXPORT void CarDlgAddDesc( void )
+{
+ if ( carProto_da.cnt <= 0 ) {
+ NoticeMessage( MSG_NO_CARPROTO, _("Ok"), NULL );
+ return;
+ }
+ carDlgIsLoco = FALSE;
+ carDlgUpdatePartPtr = NULL;
+ carDlgNumberStr[0] = '\0';
+ ParamLoadControl( &carDlgPG, I_CD_NUMBER );
+ DoCarPartDlg( partNewActions );
+}
+
+/*
+ * Car Inventory List
+ */
+
+static wIndex_t carInvInx;
+
+static wIndex_t carInvSort[] = { 0, 1, 2, 3 };
+#define N_SORT (sizeof carInvSort/sizeof carInvSort[0])
+
+static void CarInvDlgAdd( void );
+static void CarInvDlgEdit( void );
+static void CarInvDlgDelete( void );
+static void CarInvDlgImportCsv( void );
+static void CarInvDlgExportCsv( void );
+static void CarInvDlgSaveText( void );
+static void CarInvListLoad( void );
+
+static wPos_t carInvColumnWidths[] = {
+ -40, 30, 100, -50, 50, 130, 120, 100,
+ -50, -50, 60, 55, 55, 40, 200 };
+static const char * carInvColumnTitles[] = {
+ N_("Index"), N_("Scale"), N_("Manufacturer"), N_("Part No"), N_("Type"),
+ N_("Description"), N_("Roadname"), N_("Rep Marks"), N_("Purc Price"),
+ N_("Curr Price"), N_("Condition"), N_("Purc Date"), N_("Srvc Date"),
+ N_("Locat'n"), N_("Notes") };
+static char * sortOrders[] = {
+ N_("Index"), N_("Scale"), N_("Manufacturer"), N_("Part No"), N_("Type"),
+ N_("Description"), N_("Roadname"), N_("RepMarks"), N_("Purch Price"),
+ N_("Curr Price"), N_("Condition"), N_("Purch Date"), N_("Service Date") };
+#define S_INDEX (0)
+#define S_SCALE (1)
+#define S_MANUF (2)
+#define S_PARTNO (3)
+#define S_TYPE (4)
+#define S_DESC (5)
+#define S_ROADNAME (6)
+#define S_REPMARKS (7)
+#define S_PURCHPRICE (8)
+#define S_CURRPRICE (9)
+#define S_CONDITION (10)
+#define S_PURCHDATE (11)
+#define S_SRVDATE (12)
+static paramListData_t carInvListData = { 30, 600, sizeof carInvColumnTitles/sizeof carInvColumnTitles[0], carInvColumnWidths, carInvColumnTitles };
+static paramData_t carInvPLs[] = {
+#define I_CI_SORT (0)
+ { PD_DROPLIST, &carInvSort[0], "sort1", PDO_LISTINDEX|0, (void*)110, N_("Sort By") },
+ { PD_DROPLIST, &carInvSort[1], "sort2", PDO_LISTINDEX|PDO_DLGHORZ, (void*)110, "" },
+ { PD_DROPLIST, &carInvSort[2], "sort3", PDO_LISTINDEX|PDO_DLGHORZ, (void*)110, "" },
+ { PD_DROPLIST, &carInvSort[3], "sort4", PDO_LISTINDEX|PDO_DLGHORZ, (void*)110, "" },
+#define S (4)
+#define I_CI_LIST (S+0)
+ { PD_LIST, &carInvInx, "list", PDO_LISTINDEX|PDO_DLGRESIZE|PDO_DLGNOLABELALIGN|PDO_DLGRESETMARGIN, &carInvListData, NULL, BO_READONLY|BL_MANY },
+#define I_CI_EDIT (S+1)
+ { PD_BUTTON, (void*)CarInvDlgEdit, "edit", PDO_DLGCMDBUTTON, NULL, N_("Edit") },
+#define I_CI_ADD (S+2)
+ { PD_BUTTON, (void*)CarInvDlgAdd, "add", 0, NULL, N_("Add"), 0, 0 },
+#define I_CI_DELETE (S+3)
+ { PD_BUTTON, (void*)CarInvDlgDelete, "delete", PDO_DLGWIDE, NULL, N_("Delete") },
+#define I_CI_IMPORT_CSV (S+4)
+ { PD_BUTTON, (void*)CarInvDlgImportCsv, "import", PDO_DLGWIDE, NULL, N_("Import") },
+#define I_CI_EXPORT_CSV (S+5)
+ { PD_BUTTON, (void*)CarInvDlgExportCsv, "export", 0, NULL, N_("Export") },
+#define I_CI_PRINT (S+6)
+ { PD_BUTTON, (void*)CarInvDlgSaveText, "savetext", 0, NULL, N_("List") } };
+static paramGroup_t carInvPG = { "carinv", 0, carInvPLs, sizeof carInvPLs/sizeof carInvPLs[0] };
+
+static carItem_p CarInvDlgFindCurrentItem( void )
+{
+ wIndex_t selcnt = wListGetSelectedCount( (wList_p)carInvPLs[I_CI_LIST].control );
+ wIndex_t inx, cnt;
+
+ if ( selcnt != 1 ) return NULL;
+ cnt = wListGetCount( (wList_p)carInvPLs[I_CI_LIST].control );
+ for ( inx=0; inx<cnt; inx++ )
+ if ( wListGetItemSelected( (wList_p)carInvPLs[I_CI_LIST].control, inx ) )
+ break;
+ if ( inx>=cnt ) return NULL;
+ return (carItem_p)wListGetItemContext( (wList_p)carInvPLs[I_CI_LIST].control, inx );
+}
+
+
+static void CarInvDlgFind( void * junk )
+{
+ carItem_p item = CarInvDlgFindCurrentItem();
+ coOrd pos;
+ ANGLE_T angle;
+ if ( item == NULL || item->car == NULL || IsTrackDeleted(item->car) ) return;
+ CarGetPos( item->car, &pos, &angle );
+ CarSetVisible( item->car );
+ DrawMapBoundingBox( FALSE );
+ mainCenter = pos;
+ mainD.orig.x = pos.x-mainD.size.x/2;;
+ mainD.orig.y = pos.y-mainD.size.y/2;;
+ MainRedraw();
+ DrawMapBoundingBox( TRUE );
+}
+
+
+static void CarInvDlgAdd( void )
+{
+ if ( carProto_da.cnt <= 0 ) {
+ NoticeMessage( MSG_NO_CARPROTO, _("Ok"), NULL );
+ return;
+ }
+ carDlgUpdateItemPtr = NULL;
+ DoCarPartDlg( itemNewActions );
+}
+
+
+static void CarInvDlgEdit( void )
+{
+ carDlgUpdateItemPtr = CarInvDlgFindCurrentItem();
+ if ( carDlgUpdateItemPtr == NULL )
+ return;
+ DoCarPartDlg( itemUpdActions );
+}
+
+
+static void CarInvDlgDelete( void )
+{
+ carItem_p item;
+ wIndex_t inx, inx1, cnt, selcnt;
+
+ selcnt = wListGetSelectedCount( (wList_p)carInvPLs[I_CI_LIST].control );
+ if ( selcnt == 0 )
+ return;
+ if ( NoticeMessage( MSG_CARINV_DELETE_CONFIRM, _("Yes"), _("No"), selcnt ) <= 0 )
+ return;
+ cnt = wListGetCount( (wList_p)carInvPLs[I_CI_LIST].control );
+ for ( inx=0; inx<cnt; inx++ ) {
+ if ( !wListGetItemSelected( (wList_p)carInvPLs[I_CI_LIST].control, inx ) )
+ continue;
+ item = (carItem_p)wListGetItemContext( (wList_p)carInvPLs[I_CI_LIST].control, inx );
+ if ( item == NULL )
+ continue;
+ if ( item->car && !IsTrackDeleted(item->car) )
+ continue;
+ wListDelete( (wList_p)carInvPLs[I_CI_LIST].control, inx );
+ if ( item->title ) MyFree( item->title );
+ if ( item->data.number ) MyFree( item->data.number );
+ MyFree( item );
+ for ( inx1=inx; inx1<carItemInfo_da.cnt-1; inx1++ )
+ carItemInfo(inx1) = carItemInfo(inx1+1);
+ carItemInfo_da.cnt -= 1;
+ inx--;
+ cnt--;
+ }
+ changed++;
+ SetWindowTitle();
+ carInvInx = -1;
+ ParamLoadControl( &carInvPG, I_CI_LIST );
+ ParamControlActive( &carInvPG, I_CI_EDIT, FALSE );
+ ParamControlActive( &carInvPG, I_CI_DELETE, FALSE );
+ ParamControlActive( &carInvPG, I_CI_EXPORT_CSV, carItemInfo_da.cnt > 0 );
+ ParamDialogOkActive( &carInvPG, FALSE );
+}
+
+
+static int CarInvSaveText(
+ const char * pathName,
+ const char * fileName,
+ void * data )
+{
+ FILE * f;
+ carItem_p item;
+ int inx;
+ int widths[9], width;
+ tabString_t tabs[7];
+ char * cp0, * cp1;
+ int len;
+
+ if ( pathName == NULL )
+ return TRUE;
+ SetCurDir( pathName, fileName );
+ f = fopen( pathName, "w" );
+ if ( f == NULL ) {
+ NoticeMessage( MSG_OPEN_FAIL, _("Continue"), NULL, _("Car Inventory"), fileName, strerror(errno) );
+ return FALSE;
+ }
+
+ memset( widths, 0, sizeof widths );
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ ) {
+ item = carItemInfo(inx);
+ TabStringExtract( item->title, 7, tabs );
+ sprintf( message, "%ld", item->index );
+ width = strlen( message );
+ if ( width > widths[0] ) widths[0] = width;
+ width = strlen(GetScaleName(item->scaleInx)) + 1 + tabs[T_MANUF].len + 1 + tabs[T_PART].len;
+ if ( width > widths[1] ) widths[1] = width;
+ if ( tabs[T_PROTO].len > widths[2] ) widths[2] = tabs[T_PROTO].len;
+ width = tabs[T_REPMARK].len + tabs[T_NUMBER].len;
+ if ( tabs[T_REPMARK].len > 0 && tabs[T_NUMBER].len > 0 )
+ width += 1;
+ if ( width > widths[3] ) widths[3] = width;
+ if ( item->data.purchDate > 0 ) widths[4] = 8;
+ if ( item->data.purchPrice > 0 ) {
+ sprintf( message, "%0.2f", item->data.purchPrice );
+ width = strlen(message);
+ if ( width > widths[5] ) widths[5] = width;
+ }
+ if ( item->data.condition != 0 )
+ widths[6] = 5;
+ if ( item->data.currPrice > 0 ) {
+ sprintf( message, "%0.2f", item->data.currPrice );
+ width = strlen(message);
+ if ( width > widths[7] ) widths[7] = width;
+ }
+ if ( item->data.serviceDate > 0 ) widths[8] = 8;
+ }
+ fprintf( f, "%-*.*s %-*.*s %-*.*s %-*.*s", widths[0], widths[0], "#", widths[1], widths[1], "Part", widths[2], widths[2], "Description", widths[3], widths[3], "Rep Mark" );
+ if ( widths[4] ) fprintf( f, " %-*.*s", widths[4], widths[4], "PurDate" );
+ if ( widths[5] ) fprintf( f, " %-*.*s", widths[5], widths[5], "PurPrice" );
+ if ( widths[6] ) fprintf( f, " %-*.*s", widths[6], widths[6], "Cond" );
+ if ( widths[7] ) fprintf( f, " %-*.*s", widths[7], widths[7], "CurPrice" );
+ if ( widths[8] ) fprintf( f, " %-*.*s", widths[8], widths[8], "SrvDate" );
+ fprintf( f, "\n" );
+
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ ) {
+ item = carItemInfo(inx);
+ TabStringExtract( item->title, 7, tabs );
+ sprintf( message, "%ld", item->index );
+ fprintf( f, "%.*s", widths[0], message );
+ width = tabs[T_MANUF].len + 1 + tabs[T_PART].len;
+ sprintf( message, "%s %.*s %.*s", GetScaleName(item->scaleInx), tabs[T_MANUF].len, tabs[T_MANUF].ptr, tabs[T_PART].len, tabs[T_PART].ptr );
+ fprintf( f, " %-*s", widths[1], message );
+ fprintf( f, " %-*.*s", widths[2], tabs[T_PROTO].len, tabs[T_PROTO].ptr );
+ width = tabs[T_REPMARK].len + tabs[T_NUMBER].len;
+ sprintf( message, "%.*s%s%.*s", tabs[T_REPMARK].len, tabs[T_REPMARK].ptr, (tabs[T_REPMARK].len > 0 && tabs[T_NUMBER].len > 0)?" ":"", tabs[T_NUMBER].len, tabs[T_NUMBER].ptr );
+ fprintf( f, " %-*s", widths[3], message );
+ if ( widths[4] > 0 ) {
+ if ( item->data.purchDate > 0 ) {
+ sprintf( message, "%ld", item->data.purchDate );
+ fprintf( f, " %*.*s", widths[4], widths[4], message );
+ } else {
+ fprintf( f, " %*s", widths[4], " " );
+ }
+ }
+ if ( widths[5] > 0 ) {
+ if ( item->data.purchPrice > 0 ) {
+ sprintf( message, "%0.2f", item->data.purchPrice );
+ fprintf( f, " %*.*s", widths[5], widths[5], message );
+ } else {
+ fprintf( f, " %*s", widths[5], " " );
+ }
+ }
+ if ( widths[6] > 0 ) {
+ if ( item->data.condition != 0 ) {
+ fprintf( f, " %-*.*s", widths[6], widths[6], condListMap[MapCondition(item->data.condition)].name );
+ } else {
+ fprintf( f, " %*s", widths[6], " " );
+ }
+ }
+ if ( widths[7] > 0 ) {
+ if ( item->data.purchPrice > 0 ) {
+ sprintf( message, "%0.2f", item->data.purchPrice );
+ fprintf( f, " %*.*s", widths[7], widths[7], message );
+ } else {
+ fprintf( f, " %*s", widths[7], " " );
+ }
+ }
+ if ( widths[8] > 0 ) {
+ if ( item->data.serviceDate > 0 ) {
+ sprintf( message, "%ld", item->data.serviceDate );
+ fprintf( f, " %*.*s", widths[8], widths[8], message );
+ } else {
+ fprintf( f, " %*s", widths[8], " " );
+ }
+ }
+ fprintf( f, "\n" );
+ if ( item->data.notes ) {
+ cp0 = item->data.notes;
+ while ( 1 ) {
+ cp1 = strchr( cp0, '\n' );
+ if ( cp1 ) {
+ len = cp1-cp0;
+ } else {
+ len = strlen( cp0 );
+ if ( len == 0 )
+ break;
+ }
+ fprintf( f, "%*.*s %*.*s\n", widths[0], widths[0], " ", len, len, cp0 );
+ if ( cp1 == NULL )
+ break;
+ cp0 = cp1+1;
+ }
+ }
+ }
+ fclose( f );
+ return TRUE;
+}
+
+
+static struct wFilSel_t * carInvSaveText_fs;
+static void CarInvDlgSaveText( void )
+{
+ if ( carInvSaveText_fs == NULL )
+ carInvSaveText_fs = wFilSelCreate( mainW, FS_SAVE, 0, _("List Cars"),
+ "Text|*.txt", CarInvSaveText, NULL );
+ wFilSelect( carInvSaveText_fs, curDirName );
+}
+
+
+static char *carCsvColumnTitles[] = {
+ "Index", "Scale", "Manufacturer", "Type", "Partno", "Prototype",
+ "Description", "Roadname", "Repmark", "Number", "Options", "CarLength",
+ "CarWidth", "CoupledLength", "TruckCenter", "Color", "PurchPrice",
+ "CurrPrice", "Condition", "PurchDate", "ServiceDate", "Notes" };
+#define M_INDEX (0)
+#define M_SCALE (1)
+#define M_MANUF (2)
+#define M_TYPE (3)
+#define M_PARTNO (4)
+#define M_PROTO (5)
+#define M_DESC (6)
+#define M_ROADNAME (7)
+#define M_REPMARK (8)
+#define M_NUMBER (9)
+#define M_OPTIONS (10)
+#define M_CARLENGTH (11)
+#define M_CARWIDTH (12)
+#define M_CPLDLENGTH (13)
+#define M_TRKCENTER (14)
+#define M_COLOR (15)
+#define M_PURCHPRICE (16)
+#define M_CURRPRICE (17)
+#define M_CONDITION (18)
+#define M_PURCHDATE (19)
+#define M_SRVDATE (20)
+#define M_NOTES (21)
+
+
+static int ParseCsvLine(
+ char * line,
+ int max_elem,
+ tabString_t * tabs,
+ int * map )
+{
+ int elem = 0;
+ char * cp, * cq, * ptr;
+ int rc, len;
+
+ cp = line;
+ for ( cq=cp+strlen(cp)-1; cq>cp&&isspace(*cq); cq-- );
+ cq[1] = '\0';
+ for ( elem=0; elem<max_elem; elem++ ) {
+ tabs[elem].ptr = "";
+ tabs[elem].len = 0;
+ }
+ elem = 0;
+ while ( *cp && elem < max_elem ) {
+ while ( *cp == ' ' ) cp++;
+ if ( *cp == ',' ) {
+ ptr = "";
+ len = 0;
+ } else if ( *cp == '"' ) {
+ cp++;
+ ptr = cq = cp;
+ while (1) {
+ while ( *cp!='"' ) {
+ if ( *cp == '\0' ) {
+ rc = NoticeMessage( MSG_CARIMP_EOL, _("Continue"), _("Stop"), ptr );
+ return (rc<1)?-1:elem;
+ }
+ *cq++ = *cp++;
+ }
+ cp++;
+ if ( *cp!='"' ) break;
+ *cq++ = *cp++;
+ }
+ if ( *cp && *cp != ',' ) {
+ rc = NoticeMessage( MSG_CARIMP_MISSING_COMMA, _("Continue"), _("Stop"), ptr );
+ return (rc<1)?-1:elem;
+ }
+ len = cq-ptr;
+ } else {
+ ptr = cp;
+ while ( *cp && *cp != ',' ) { cp++; }
+ len = cp-ptr;
+ }
+ if ( map[elem] >= 0 ) {
+ tabs[map[elem]].ptr = ptr;
+ tabs[map[elem]].len = len;
+ }
+ if ( *cp ) cp++;
+ elem++;
+ }
+ return elem;
+}
+
+
+static int CarInvImportCsv(
+ const char * pathName,
+ const char * fileName,
+ void * data )
+{
+ FILE * f;
+ carItem_p item;
+ tabString_t tabs[40], partTabs[7];
+ int map[40];
+ int i, j, cnt, numCol, len, rc;
+ char * cp, * cq;
+ long type = 0;
+ char title[STR_LONG_SIZE];
+ long index, options, color, condition, purchDate, srvcDate;
+ carDim_t dim;
+ FLOAT_T purchPrice, currPrice;
+ int duplicateIndexError = 0;
+ SCALEINX_T scale;
+ carPart_p partP;
+ int requiredCols;
+ char *oldLocale = NULL;
+
+ if ( pathName == NULL )
+ return TRUE;
+ SetCurDir( pathName, fileName );
+ f = fopen( pathName, "r" );
+ if ( f == NULL ) {
+ NoticeMessage( MSG_OPEN_FAIL, _("Continue"), NULL, _("Import Cars"), fileName, strerror(errno) );
+ return FALSE;
+ }
+
+ oldLocale = SaveLocale("C");
+
+ if ( fgets( message, sizeof message, f ) == NULL ) {
+ NoticeMessage( MSG_CARIMP_NO_DATA, _("Continue"), NULL );
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ for ( j=0; j<40; j++ ) map[j] = j;
+ numCol = ParseCsvLine( message, 40, tabs, map );
+ if ( numCol <= 0 ) {
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ for ( j=0; j<40; j++ ) map[j] = -1;
+ requiredCols = 0;
+ for ( i=0; i<numCol; i++ ) {
+ for ( j=0; j<sizeof carCsvColumnTitles/sizeof carCsvColumnTitles[0]; j++ ) {
+ if ( TabStringCmp( carCsvColumnTitles[j], &tabs[i] ) == 0 ) {
+ if ( map[i] >= 0 ) {
+ NoticeMessage( MSG_CARIMP_DUP_COLUMNS, _("Continue"), NULL, carCsvColumnTitles[j] );
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ map[i] = j;
+ /*j = sizeof carCsvColumnTitles/sizeof carCsvColumnTitles[0];*/
+ if ( j == M_SCALE || j == M_PROTO || j == M_MANUF || j == M_PARTNO )
+ requiredCols++;
+ }
+ }
+ if ( map[i] == -1 ) {
+ tabs[i].ptr[tabs[i].len] = '\0';
+ NoticeMessage( MSG_CARIMP_IGNORED_COLUMN, _("Continue"), NULL, tabs[i].ptr );
+ tabs[i].ptr[tabs[i].len] = ',';
+ }
+ }
+ if ( requiredCols != 4 ) {
+ NoticeMessage( MSG_CARIMP_MISSING_COLUMNS, _("Continue"), NULL );
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ while ( fgets( message, sizeof message, f ) != NULL ) {
+ cnt = ParseCsvLine( message, 40, tabs, map );
+ if ( cnt > numCol ) cnt = numCol;
+ tabs[M_SCALE].ptr[tabs[M_SCALE].len] = '\0';
+ scale = LookupScale( tabs[M_SCALE].ptr );
+ tabs[M_SCALE].ptr[tabs[M_SCALE].len] = ',';
+ index = TabGetLong( &tabs[M_INDEX] );
+ if ( index == 0 ) {
+ CheckCarDlgItemIndex( &carDlgItemIndex );
+ index = carDlgItemIndex;
+ } else {
+ carDlgItemIndex = index;
+ if ( !CheckCarDlgItemIndex(&index) ) {
+ if ( !duplicateIndexError ) {
+ NoticeMessage( MSG_CARIMP_DUP_INDEX, _("Ok"), NULL );
+ duplicateIndexError++;
+ }
+ carDlgItemIndex = index;
+ }
+ }
+#ifdef OBSOLETE
+ if ( TabStringCmp( "Unknown", &tabs[M_MANUF] ) != 0 &&
+ TabStringCmp( "Custom", &tabs[M_MANUF] ) != 0 ) {
+ if ( tabs[M_PARTNO].len == 0 ) {
+ rc = NoticeMessage( MSG_CARIMP_MISSING_PARTNO, _("Continue"), _("Stop"), tabs[M_MANUF].ptr );
+ if ( rc <= 0 ) {
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ continue;
+ }
+ }
+#endif
+ dim.carLength = TabGetFloat( &tabs[M_CARLENGTH] );
+ dim.carWidth = TabGetFloat( &tabs[M_CARWIDTH] );
+ dim.coupledLength = TabGetFloat( &tabs[M_CPLDLENGTH] );
+ dim.truckCenter = TabGetFloat( &tabs[M_TRKCENTER] );
+ partP = NULL;
+ if ( tabs[M_MANUF].len > 0 && tabs[M_PARTNO].len > 0 )
+ partP = CarPartFind( tabs[M_MANUF].ptr, tabs[M_MANUF].len, tabs[M_PARTNO].ptr, tabs[M_PARTNO].len, scale );
+ if ( partP ) {
+ TabStringExtract( partP->title, 7, partTabs );
+ if ( tabs[M_PROTO].len == 0 && partTabs[T_PROTO].len > 0 ) { tabs[M_PROTO].ptr = partTabs[T_PROTO].ptr; tabs[M_PROTO].len = partTabs[T_PROTO].len; }
+ if ( tabs[M_DESC].len == 0 && partTabs[T_DESC].len > 0 ) { tabs[M_DESC].ptr = partTabs[T_DESC].ptr; tabs[M_DESC].len = partTabs[T_DESC].len; }
+ if ( tabs[M_ROADNAME].len == 0 && partTabs[T_ROADNAME].len > 0 ) { tabs[M_ROADNAME].ptr = partTabs[T_ROADNAME].ptr; tabs[M_ROADNAME].len = partTabs[T_ROADNAME].len; }
+ if ( tabs[M_REPMARK].len == 0 && partTabs[T_REPMARK].len > 0 ) { tabs[M_REPMARK].ptr = partTabs[T_REPMARK].ptr; tabs[M_REPMARK].len = partTabs[T_REPMARK].len; }
+ if ( tabs[M_NUMBER].len == 0 && partTabs[T_NUMBER].len > 0 ) { tabs[M_NUMBER].ptr = partTabs[T_NUMBER].ptr; tabs[M_NUMBER].len = partTabs[T_NUMBER].len; }
+ if ( dim.carLength <= 0 ) dim.carLength = partP->dim.carLength;
+ if ( dim.carWidth <= 0 ) dim.carWidth = partP->dim.carWidth;
+ if ( dim.coupledLength <= 0 ) dim.coupledLength = partP->dim.coupledLength;
+ if ( dim.truckCenter <= 0 ) dim.truckCenter = partP->dim.truckCenter;
+ }
+ cp = TabStringCpy( title, &tabs[M_MANUF] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_PROTO] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_DESC] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_PARTNO] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_ROADNAME] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_REPMARK] );
+ *cp++ = '\t';
+ cp = TabStringCpy( cp, &tabs[M_NUMBER] );
+ *cp = '\0';
+ options = TabGetLong( &tabs[M_OPTIONS] );
+ type = TabGetLong( &tabs[M_TYPE] );
+ color = TabGetLong( &tabs[M_COLOR] );
+ purchPrice = TabGetFloat( &tabs[M_PURCHPRICE] );
+ currPrice = TabGetFloat( &tabs[M_CURRPRICE] );
+ condition = TabGetLong( &tabs[M_CONDITION] );
+ purchDate = TabGetLong( &tabs[M_PURCHDATE] );
+ srvcDate = TabGetLong( &tabs[M_SRVDATE] );
+ if ( dim.carLength <= 0 || dim.carWidth <= 0 || dim.coupledLength <= 0 || dim.truckCenter <= 0 ) {
+ rc = NoticeMessage( MSG_CARIMP_MISSING_DIMS, _("Yes"), _("No"), message );
+ if ( rc <= 0 ) {
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return FALSE;
+ }
+ continue;
+ }
+ item = CarItemNew( NULL, PARAM_CUSTOM, index, scale, title, options, type,
+ &dim, wDrawFindColor(color),
+ purchPrice, currPrice, condition, purchDate, srvcDate );
+ if ( tabs[M_NOTES].len > 0 ) {
+ item->data.notes = cp = MyMalloc( tabs[M_NOTES].len+1 );
+ for ( cq=tabs[M_NOTES].ptr,len=tabs[M_NOTES].len; *cq&&len; ) {
+ if ( strncmp( cq, "<NL>", 4 ) == 0 ) {
+ *cp++ = '\n';
+ cq += 4;
+ len -= 4;
+ } else {
+ *cp++ = *cq++;
+ len -= 1;
+ }
+ }
+ }
+ changed++;
+ SetWindowTitle();
+ }
+ fclose( f );
+ RestoreLocale(oldLocale);
+ CarInvListLoad();
+ return TRUE;
+}
+
+
+
+static struct wFilSel_t * carInvImportCsv_fs;
+static void CarInvDlgImportCsv( void )
+{
+ if ( carInvImportCsv_fs == NULL )
+ carInvImportCsv_fs = wFilSelCreate( mainW, FS_LOAD, 0, _("Import Cars"),
+ _("Comma-Separated-Values|*.csv"), CarInvImportCsv, NULL );
+ wFilSelect( carInvImportCsv_fs, curDirName );
+}
+
+
+static void CsvFormatString(
+ FILE * f,
+ char * str,
+ int len,
+ char * sep )
+{
+ while ( str && len>0 && str[len-1]=='\n' ) len--;
+ if ( *str && len ) {
+ fputc( '"', f );
+ for ( ; *str && len; str++,len-- ) {
+ if ( !iscntrl( *str ) ) {
+ if ( *str == '"' )
+ fputc( '"', f );
+ fputc( *str, f );
+ } else if ( *str == '\n' && str[1] && len > 1 ) {
+ fprintf( f, "<NL>" );
+ }
+ }
+ fputc( '"', f );
+ }
+ fprintf( f, "%s", sep );
+}
+
+
+static void CsvFormatLong(
+ FILE * f,
+ long val,
+ char * sep )
+{
+ if ( val != 0 )
+ fprintf( f, "%ld", val );
+ fprintf( f, "%s", sep );
+}
+
+
+static void CsvFormatFloat(
+ FILE * f,
+ FLOAT_T val,
+ int digits,
+ char * sep )
+{
+ if ( val != 0.0 )
+ fprintf( f, "%0.*f", digits, val );
+ fprintf( f, "%s", sep );
+}
+
+
+static int CarInvExportCsv(
+ const char * pathName,
+ const char * fileName,
+ void * data )
+{
+ FILE * f;
+ carItem_p item;
+ long inx;
+ tabString_t tabs[7];
+ char * sp;
+ char *oldLocale = NULL;
+
+ if ( pathName == NULL )
+ return TRUE;
+ SetCurDir( pathName, fileName );
+ f = fopen( pathName, "w" );
+ if ( f == NULL ) {
+ NoticeMessage( MSG_OPEN_FAIL, _("Continue"), NULL, _("Export Cars"), fileName, strerror(errno) );
+ return FALSE;
+ }
+
+ oldLocale = SaveLocale("C");
+
+ for ( inx=0; inx<sizeof carCsvColumnTitles/sizeof carCsvColumnTitles[0]; inx++ ) {
+ CsvFormatString( f, carCsvColumnTitles[inx], strlen(carCsvColumnTitles[inx]), inx<(sizeof carCsvColumnTitles/sizeof carCsvColumnTitles[0])-1?",":"\n" );
+ }
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ ) {
+ item = carItemInfo( inx );
+ TabStringExtract( item->title, 7, tabs );
+ CsvFormatLong( f, item->index, "," );
+ sp = GetScaleName(item->scaleInx);
+ CsvFormatString( f, sp, strlen(sp), "," );
+ CsvFormatString( f, tabs[T_MANUF].ptr, tabs[T_MANUF].len, "," );
+ CsvFormatLong( f, item->type, "," );
+ CsvFormatString( f, tabs[T_PART].ptr, tabs[T_PART].len, "," );
+ CsvFormatString( f, tabs[T_PROTO].ptr, tabs[T_PROTO].len, "," );
+ CsvFormatString( f, tabs[T_DESC].ptr, tabs[T_DESC].len, "," );
+ CsvFormatString( f, tabs[T_ROADNAME].ptr, tabs[T_ROADNAME].len, "," );
+ CsvFormatString( f, tabs[T_REPMARK].ptr, tabs[T_REPMARK].len, "," );
+ CsvFormatString( f, tabs[T_NUMBER].ptr, tabs[T_NUMBER].len, "," );
+ CsvFormatLong( f, item->options, "," );
+ CsvFormatFloat( f, item->dim.carLength, 3, "," );
+ CsvFormatFloat( f, item->dim.carWidth, 3, "," );
+ CsvFormatFloat( f, item->dim.coupledLength, 3, "," );
+ CsvFormatFloat( f, item->dim.truckCenter, 3, "," );
+ CsvFormatLong( f, wDrawGetRGB(item->color), "," );
+ CsvFormatFloat( f, item->data.purchPrice, 2, "," );
+ CsvFormatFloat( f, item->data.currPrice, 2, "," );
+ CsvFormatLong( f, item->data.condition, "," );
+ CsvFormatLong( f, item->data.purchDate, "," );
+ CsvFormatLong( f, item->data.serviceDate, "," );
+ if ( item->data.notes )
+ CsvFormatString( f, item->data.notes, strlen(item->data.notes), "\n" );
+ else
+ CsvFormatString( f, "", strlen(""), "\n" );
+ }
+ fclose( f );
+ RestoreLocale(oldLocale);
+ return TRUE;
+}
+
+
+static struct wFilSel_t * carInvExportCsv_fs;
+static void CarInvDlgExportCsv( void )
+{
+ if ( carItemInfo_da.cnt <= 0 )
+ return;
+ if ( carInvExportCsv_fs == NULL )
+ carInvExportCsv_fs = wFilSelCreate( mainW, FS_SAVE, 0, _("Export Cars"),
+ _("Comma-Separated-Values|*.csv"), CarInvExportCsv, NULL );
+ wFilSelect( carInvExportCsv_fs, curDirName );
+}
+
+
+static void CarInvLoadItem(
+ carItem_p item )
+{
+/* "Index", "Scale", "Manufacturer", "Type", "Part No", "Description", "Roadname", "RepMarks",
+ "Purch Price", "Curr Price", "Condition", "Purch Date", "Service Date", "Location", "Notes" */
+ char *condition;
+ char *location;
+ char *manuf;
+ char *road;
+ char notes[100];
+ tabString_t tabs[7];
+
+ TabStringExtract( item->title, 7, tabs );
+ if ( item->data.notes ) {
+ strncpy( notes, item->data.notes, sizeof notes - 1 );
+ notes[sizeof notes - 1] = '\0';
+ } else {
+ notes[0] = '\0';
+ }
+ condition =
+ (item->data.condition < 10) ? N_("N/A"):
+ (item->data.condition < 30) ? N_("Poor"):
+ (item->data.condition < 50) ? N_("Fair"):
+ (item->data.condition < 70) ? N_("Good"):
+ (item->data.condition < 90) ? N_("Excellent"):
+ N_("Mint");
+
+ if ( item->car && !IsTrackDeleted(item->car) )
+ location = N_("Layout");
+ else
+ location = N_("Shelf");
+
+ manuf = TabStringDup(&tabs[T_MANUF]);
+ road = TabStringDup(&tabs[T_ROADNAME]);
+ sprintf( message, "%ld\t%s\t%s\t%.*s\t%s\t%.*s%s%.*s\t%s\t%.*s%s%.*s\t%0.2f\t%0.2f\t%s\t%ld\t%ld\t%s\t%s",
+ item->index, GetScaleName(item->scaleInx),
+ _(manuf),
+ tabs[T_PART].len, tabs[T_PART].ptr,
+ _(typeListMap[CarProtoFindTypeCode(item->type)].name),
+ tabs[T_PROTO].len, tabs[T_PROTO].ptr,
+ (tabs[T_PROTO].len>0 && tabs[T_DESC].len)?"/":"",
+ tabs[T_DESC].len, tabs[T_DESC].ptr,
+ _(road),
+ tabs[T_REPMARK].len, tabs[T_REPMARK].ptr,
+ (tabs[T_REPMARK].len>0&&tabs[T_NUMBER].len>0)?" ":"",
+ tabs[T_NUMBER].len, tabs[T_NUMBER].ptr,
+ item->data.purchPrice, item->data.currPrice, _(condition), item->data.purchDate, item->data.serviceDate, _(location), notes );
+ if (manuf) MyFree(manuf);
+ if (road) MyFree(road);
+ wListAddValue( (wList_p)carInvPLs[I_CI_LIST].control, message, NULL, item );
+}
+
+
+static int Cmp_carInvItem(
+ const void * ptr1,
+ const void * ptr2 )
+{
+ carItem_p item1 = *(carItem_p*)ptr1;
+ carItem_p item2 = *(carItem_p*)ptr2;
+ tabString_t tabs1[7], tabs2[7];
+ int inx;
+ int rc;
+
+ TabStringExtract( item1->title, 7, tabs1 );
+ TabStringExtract( item2->title, 7, tabs2 );
+ for ( inx=0,rc=0; inx<N_SORT&&rc==0; inx++ ) {
+ switch ( carInvSort[inx] ) {
+ case S_INDEX:
+ rc = (int)(item1->index-item2->index);
+ break;
+ case S_SCALE:
+ rc = (int)(item1->scaleInx-item2->scaleInx);
+ case S_MANUF:
+ rc = strncasecmp( tabs1[T_MANUF].ptr, tabs2[T_MANUF].ptr, max(tabs1[T_MANUF].len,tabs2[T_MANUF].len) );
+ break;
+ case S_TYPE:
+ rc = (int)(item1->type-item2->type);
+ break;
+ case S_PARTNO:
+ rc = strncasecmp( tabs1[T_PART].ptr, tabs2[T_PART].ptr, max(tabs1[T_PART].len,tabs2[T_PART].len) );
+ break;
+ case S_DESC:
+ rc = strncasecmp( tabs1[T_PROTO].ptr, tabs2[T_PROTO].ptr, max(tabs1[T_PROTO].len,tabs2[T_PROTO].len) );
+ if ( rc != 0 )
+ break;
+ rc = strncasecmp( tabs1[T_DESC].ptr, tabs2[T_DESC].ptr, max(tabs1[T_DESC].len,tabs2[T_DESC].len) );
+ break;
+ case S_ROADNAME:
+ rc = strncasecmp( tabs1[T_ROADNAME].ptr, tabs2[T_ROADNAME].ptr, max(tabs1[T_ROADNAME].len,tabs2[T_ROADNAME].len) );
+ break;
+ case S_REPMARKS:
+ rc = strncasecmp( tabs1[T_REPMARK].ptr, tabs2[T_REPMARK].ptr, max(tabs1[T_REPMARK].len,tabs2[T_REPMARK].len) );
+ break;
+ case S_PURCHPRICE:
+ rc = (int)(item1->data.purchPrice-item2->data.purchPrice);
+ break;
+ case S_CURRPRICE:
+ rc = (int)(item1->data.currPrice-item2->data.currPrice);
+ break;
+ case S_CONDITION:
+ rc = (int)(item1->data.condition-item2->data.condition);
+ break;
+ case S_PURCHDATE:
+ rc = (int)(item1->data.purchDate-item2->data.purchDate);
+ break;
+ case S_SRVDATE:
+ rc = (int)(item1->data.serviceDate-item2->data.serviceDate);
+ break;
+ default:
+ break;
+ }
+ }
+ return rc;
+}
+
+static void CarInvListLoad( void )
+{
+ int inx;
+ carItem_p item;
+
+ qsort( carItemInfo_da.ptr, carItemInfo_da.cnt, sizeof item, Cmp_carInvItem );
+ ParamControlShow( &carInvPG, I_CI_LIST, FALSE );
+ wListClear( (wList_p)carInvPLs[I_CI_LIST].control );
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ ) {
+ item = carItemInfo(inx);
+ CarInvLoadItem( item );
+ }
+ ParamControlShow( &carInvPG, I_CI_LIST, TRUE );
+ ParamControlActive( &carInvPG, I_CI_EDIT, FALSE );
+ ParamControlActive( &carInvPG, I_CI_DELETE, FALSE );
+ ParamControlActive( &carInvPG, I_CI_EXPORT_CSV, carItemInfo_da.cnt > 0 );
+ ParamDialogOkActive( &carInvPG, FALSE );
+}
+
+
+static void CarInvDlgUpdate(
+ paramGroup_p pg,
+ int inx,
+ void * valueP )
+{
+ carItem_p item = NULL;
+ wIndex_t cnt, selinx, selcnt;
+ wBool_t enableDelete;
+
+ if ( inx >= I_CI_SORT && inx < I_CI_SORT+N_SORT ) {
+ item = CarInvDlgFindCurrentItem();
+ CarInvListLoad();
+ if ( item ) {
+ carInvInx = (wIndex_t)CarItemFindIndex( item );
+ if ( carInvInx >= 0 )
+ ParamLoadControl( &carInvPG, I_CI_LIST );
+ }
+ } else if ( inx == I_CI_LIST ) {
+ cnt = wListGetCount( (wList_p)carInvPLs[I_CI_LIST].control );
+ enableDelete = TRUE;
+ for ( selinx=selcnt=0; selinx<cnt; selinx++ ) {
+ if ( wListGetItemSelected( (wList_p)carInvPLs[I_CI_LIST].control, selinx ) ) {
+ selcnt++;
+ item = (carItem_p)wListGetItemContext( (wList_p)carInvPLs[I_CI_LIST].control, selinx );
+ if ( item && item->car && !IsTrackDeleted( item->car ) ) {
+ enableDelete = FALSE;
+ break;
+ }
+ }
+ }
+ item = CarInvDlgFindCurrentItem();
+ ParamDialogOkActive( pg, selcnt==1 && item && item->car && !IsTrackDeleted(item->car) );
+ ParamControlActive( &carInvPG, I_CI_EDIT, selcnt==1 && item && (item->car==NULL || IsTrackDeleted(item->car)) );
+ ParamControlActive( &carInvPG, I_CI_DELETE, selcnt>0 && enableDelete );
+ }
+}
+
+
+static void CarInvListAdd(
+ carItem_p item )
+{
+ CarInvListLoad();
+ carInvInx = (wIndex_t)CarItemFindIndex( item );
+ if ( carInvInx >= 0 ) {
+ ParamLoadControl( &carInvPG, I_CI_LIST );
+ }
+}
+
+
+static void CarInvListUpdate(
+ carItem_p item )
+{
+ CarInvListLoad();
+ carInvInx = (wIndex_t)CarItemFindIndex( item );
+ if ( carInvInx >= 0 ) {
+ ParamLoadControl( &carInvPG, I_CI_LIST );
+ }
+}
+
+
+EXPORT void DoCarDlg( void )
+{
+ int inx, inx2;
+ if ( carInvPG.win == NULL ) {
+ ParamCreateDialog( &carInvPG, MakeWindowTitle(_("Car Inventory")), _("Find"), CarInvDlgFind, wHide, TRUE, NULL, F_BLOCK|F_RESIZE|F_RECALLSIZE|PD_F_ALT_CANCELLABEL, CarInvDlgUpdate );
+ for ( inx=I_CI_SORT; inx<I_CI_SORT+N_SORT; inx++ ) {
+ for ( inx2=0; inx2<sizeof sortOrders/sizeof sortOrders[0]; inx2++ ) {
+ wListAddValue( (wList_p)carInvPLs[inx].control, _(sortOrders[inx2]), NULL, NULL );
+ ParamLoadControl( &carInvPG, inx );
+ }
+ }
+ ParamDialogOkActive( &carInvPG, FALSE );
+ }
+ CarInvListLoad();
+ wShow( carInvPG.win );
+}
+
+
+static void CarDlgChange( long changes )
+{
+ if ( (changes&CHANGE_SCALE) ) {
+ carPartChangeLevel = 0;
+ carDlgCouplerLength = 0.0;
+ }
+}
+
+
+EXPORT void ClearCars( void )
+{
+ int inx;
+ for ( inx=0; inx<carItemInfo_da.cnt; inx++ )
+ MyFree( carItemInfo(inx) );
+ carItemInfo_da.cnt = 0;
+ carItemInfo_da.max = 0;
+ if ( carItemInfo_da.ptr )
+ MyFree( carItemInfo_da.ptr );
+ carItemInfo_da.ptr = NULL;
+}
+
+
+static struct {
+ dynArr_t carProto_da;
+ dynArr_t carPartParent_da;
+ dynArr_t carItemInfo_da;
+ } savedCarState;
+
+EXPORT void SaveCarState( void )
+{
+ savedCarState.carProto_da = carProto_da;
+ savedCarState.carPartParent_da = carPartParent_da;
+ savedCarState.carItemInfo_da = carItemInfo_da;
+ carItemInfo_da.cnt = carItemInfo_da.max = 0;
+ carItemInfo_da.ptr = NULL;
+}
+
+
+EXPORT void RestoreCarState( void )
+{
+#ifdef LATER
+ carProto_da = savedCarState.carProto_da;
+ carPartParent_da = savedCarState.carPartParent_da;
+#endif
+ carItemInfo_da = savedCarState.carItemInfo_da;
+}
+
+
+
+EXPORT void InitCarDlg( void )
+{
+ log_carList = LogFindIndex( "carList" );
+ log_carInvList = LogFindIndex( "carInvList" );
+ log_carDlgState = LogFindIndex( "carDlgState" );
+ log_carDlgList = LogFindIndex( "carDlgList" );
+ carDlgBodyColor = wDrawFindColor( wRGB(255,128,0) );
+ ParamRegister( &carDlgPG );
+ ParamRegister( &carInvPG );
+ RegisterChangeNotification( CarDlgChange );
+ AddParam( "CARPROTO ", CarProtoRead );
+ AddParam( "CARPART ", CarPartRead );
+ ParamRegister( &newCarPG );
+ ParamCreateControls( &newCarPG, CarItemHotbarUpdate );
+ newCarControls[0] = newCarPLs[0].control;
+}
+
+/*****************************************************************************
+ *
+ * Custom Management Support
+ *
+ */
+
+static int CarPartCustMgmProc(
+ int cmd,
+ void * data )
+{
+ tabString_t tabs[7];
+ int rd_inx;
+
+ carPart_p partP = (carPart_p)data;
+ switch ( cmd ) {
+ case CUSTMGM_DO_COPYTO:
+ return CarPartWrite( customMgmF, partP );
+ case CUSTMGM_CAN_EDIT:
+ return TRUE;
+ case CUSTMGM_DO_EDIT:
+ if ( partP == NULL )
+ return FALSE;
+ carDlgUpdatePartPtr = partP;
+ DoCarPartDlg( partUpdActions );
+ return TRUE;
+ case CUSTMGM_CAN_DELETE:
+ return TRUE;
+ case CUSTMGM_DO_DELETE:
+ CarPartDelete( partP );
+ return TRUE;
+ case CUSTMGM_GET_TITLE:
+ TabStringExtract( partP->title, 7, tabs );
+ rd_inx = T_REPMARK;
+ if ( tabs[T_REPMARK].len == 0 )
+ rd_inx = T_ROADNAME;
+ sprintf( message, "\t%s\t%s\t%.*s\t%s%s%.*s%s%.*s%s%.*s",
+ partP->parent->manuf,
+ GetScaleName(partP->parent->scale),
+ tabs[T_PART].len, tabs[T_PART].ptr,
+ partP->parent->proto,
+ tabs[T_DESC].len?", ":"", tabs[T_DESC].len, tabs[T_DESC].ptr,
+ tabs[rd_inx].len?", ":"", tabs[rd_inx].len, tabs[rd_inx].ptr,
+ tabs[T_NUMBER].len?" ":"", tabs[T_NUMBER].len, tabs[T_NUMBER].ptr );
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+static int CarProtoCustMgmProc(
+ int cmd,
+ void * data )
+{
+ carProto_p protoP = (carProto_p)data;
+ switch ( cmd ) {
+ case CUSTMGM_DO_COPYTO:
+ return CarProtoWrite( customMgmF, protoP );
+ case CUSTMGM_CAN_EDIT:
+ return TRUE;
+ case CUSTMGM_DO_EDIT:
+ if ( protoP == NULL )
+ return FALSE;
+ carDlgUpdateProtoPtr = protoP;
+ DoCarPartDlg( protoUpdActions );
+ return TRUE;
+ case CUSTMGM_CAN_DELETE:
+ return TRUE;
+ case CUSTMGM_DO_DELETE:
+ CarProtoDelete( protoP );
+ return TRUE;
+ case CUSTMGM_GET_TITLE:
+ sprintf( message, "\t%s\t\t%s\t%s", _("Prototype"), _(typeListMap[CarProtoFindTypeCode(protoP->type)].name), protoP->desc );
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+#include "bitmaps/carpart.xpm"
+#include "bitmaps/carproto.xpm"
+
+EXPORT void CarCustMgmLoad( void )
+{
+ long parentX, partX, protoX;
+ carPartParent_p parentP;
+ carPart_p partP;
+ carProto_p carProtoP;
+ static wIcon_p carpartI = NULL;
+ static wIcon_p carprotoI = NULL;
+
+ if ( carpartI == NULL )
+ carpartI = wIconCreatePixMap( carpart_xpm );
+ if ( carprotoI == NULL )
+ carprotoI = wIconCreatePixMap( carproto_xpm );
+
+ for ( parentX=0; parentX<carPartParent_da.cnt; parentX++ ) {
+ parentP = carPartParent(parentX);
+ for ( partX=0; partX<parentP->parts_da.cnt; partX++ ) {
+ partP = carPart(parentP,partX);
+ if ( partP->paramFileIndex != PARAM_CUSTOM )
+ continue;
+ CustMgmLoad( carpartI, CarPartCustMgmProc, (void*)partP );
+ }
+ }
+
+ for ( protoX=0; protoX<carProto_da.cnt; protoX++ ) {
+ carProtoP = carProto(protoX);
+ if ( carProtoP->paramFileIndex != PARAM_CUSTOM )
+ continue;
+ if (carProtoP->paramFileIndex == PARAM_CUSTOM) {
+ CustMgmLoad( carprotoI, CarProtoCustMgmProc, (void*)carProtoP );
+ }
+ }
+}