Initial import of xtrkcad version 1:4.0.2-2

1 files changed, 2626 insertions, 0 deletions

diff --git a/app/bin/cturnout.c b/app/bin/cturnout.c
new file mode 100644
index 0000000..55b7a4d
--- /dev/null
+++ b/app/bin/cturnout.c
@@ -0,0 +1,2626 @@
+/*
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/cturnout.c,v 1.8 2009-08-16 13:07:14 m_fischer Exp $
+ *
+ * T_TURNOUT
+ *
+ */
+
+/*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2005 Dave Bullis
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <ctype.h>
+#include "track.h"
+#include "ccurve.h"
+#include "cstraigh.h"
+#include "compound.h"
+#include "cjoin.h"
+#include "i18n.h"
+
+#include <stdint.h>
+
+EXPORT TRKTYP_T T_TURNOUT = -1;
+
+#define TURNOUTCMD
+
+#define MIN_TURNOUT_SEG_CONNECT_DIST		(0.1)
+
+EXPORT dynArr_t turnoutInfo_da;
+
+EXPORT turnoutInfo_t * curTurnout = NULL;
+EXPORT long curTurnoutEp = 0;
+
+static int log_turnout = 0;
+static int log_traverseTurnout = 0;
+
+static wMenu_p turnoutPopupM;
+
+#ifdef TURNOUTCMD
+static drawCmd_t turnoutD = {
+		NULL,
+		&screenDrawFuncs,
+		0,
+		1.0,
+		0.0,
+		{0.0,0.0}, {0.0,0.0},
+		Pix2CoOrd, CoOrd2Pix };
+
+static wIndex_t turnoutHotBarCmdInx;
+static wIndex_t turnoutInx;
+static long hideTurnoutWindow;
+static void RedrawTurnout(void);
+static void SelTurnoutEndPt( wIndex_t, coOrd );
+
+static wPos_t turnoutListWidths[] = { 80, 80, 220 };
+static const char * turnoutListTitles[] = { N_("Manufacturer"), N_("Part No"), N_("Description") };
+static paramListData_t listData = { 13, 400, 3, turnoutListWidths, turnoutListTitles };
+static const char * hideLabels[] = { N_("Hide"), NULL };
+static paramDrawData_t turnoutDrawData = { 490, 200, (wDrawRedrawCallBack_p)RedrawTurnout, SelTurnoutEndPt, &turnoutD };
+static paramData_t turnoutPLs[] = {
+#define I_LIST		(0)
+#define turnoutListL    ((wList_p)turnoutPLs[I_LIST].control)
+	{   PD_LIST, &turnoutInx, "list", PDO_NOPREF|PDO_DLGRESIZEW, &listData, NULL, BL_DUP },
+#define I_DRAW		(1)
+#define turnoutDrawD    ((wDraw_p)turnoutPLs[I_DRAW].control)
+	{   PD_DRAW, NULL, "canvas", PDO_NOPSHUPD|PDO_DLGUNDERCMDBUTT|PDO_DLGRESIZE, &turnoutDrawData, NULL, 0 },
+#define I_NEW		(2)
+#define turnoutNewM     ((wMenu_p)turnoutPLs[I_NEW].control)
+	{   PD_MENU, NULL, "new", PDO_DLGCMDBUTTON, NULL, N_("New") },
+#define I_HIDE		(3)
+#define turnoutHideT    ((wChoice_p)turnoutPLs[I_HIDE].control)
+	{   PD_TOGGLE, &hideTurnoutWindow, "hide", PDO_DLGCMDBUTTON, /*CAST_AWAY_CONST*/(void*)hideLabels, NULL, BC_NOBORDER } };
+static paramGroup_t turnoutPG = { "turnout", 0, turnoutPLs, sizeof turnoutPLs/sizeof turnoutPLs[0] };
+#endif
+
+
+
+/****************************************
+ *
+ * TURNOUT LIST MANAGEMENT
+ *
+ */
+
+
+EXPORT turnoutInfo_t * CreateNewTurnout(
+		char * scale,
+		char * title,
+		wIndex_t segCnt,
+		trkSeg_p segData,
+		wIndex_t pathLen,
+		PATHPTR_T paths,
+		EPINX_T endPtCnt,
+		trkEndPt_t * endPts,
+		wBool_t updateList )
+{
+	turnoutInfo_t * to;
+	long changes=0;
+
+	to = FindCompound( FIND_TURNOUT, scale, title );
+	if (to == NULL) {
+		DYNARR_APPEND( turnoutInfo_t *, turnoutInfo_da, 10 );
+		to = (turnoutInfo_t*)MyMalloc( sizeof *to );
+		turnoutInfo(turnoutInfo_da.cnt-1) = to;
+		to->title = MyStrdup( title );
+		to->scaleInx = LookupScale( scale );
+		changes = CHANGE_PARAMS;
+	}
+	to->segCnt = segCnt;
+	to->segs = (trkSeg_p)memdup( segData, (sizeof *segData) * segCnt );
+	GetSegBounds( zero, 0.0, segCnt, to->segs, &to->orig, &to->size );
+	to->endCnt = endPtCnt;
+	to->endPt = (trkEndPt_t*)memdup( endPts, (sizeof *endPts) * to->endCnt );
+
+	to->pathLen = pathLen;
+	to->paths = (PATHPTR_T)memdup( paths, (sizeof *to->paths) * to->pathLen );
+	to->paramFileIndex = curParamFileIndex;
+	if (curParamFileIndex == PARAM_CUSTOM)
+		to->contentsLabel = "Custom Turnouts";
+	else
+		to->contentsLabel = curSubContents;
+#ifdef TURNOUTCMD
+	if (updateList && turnoutListL != NULL) {
+		FormatCompoundTitle( LABEL_TABBED|LABEL_MANUF|LABEL_PARTNO|LABEL_DESCR, title );
+		if (message[0] != '\0')
+			wListAddValue( turnoutListL, message, NULL, to );
+	}
+#endif
+
+	to->barScale = curBarScale>0?curBarScale:-1;
+	to->special = TOnormal;
+	if (updateList && changes)
+		DoChangeNotification( changes );
+	return to;
+}
+
+
+
+EXPORT wIndex_t CheckPaths(
+		wIndex_t segCnt,
+		trkSeg_p segs,
+		PATHPTR_T paths )
+{
+	int pc, ps;
+	PATHPTR_T pp;
+	int inx, inx1;
+	static dynArr_t segMap_da;
+	int segInx[2], segEp[2];
+	int segTrkLast = -1;
+	trkSeg_t tempSeg;
+	
+#define segMap(N) DYNARR_N( trkSeg_p, segMap_da, N )
+
+	DYNARR_RESET( trkSeg_p, segMap_da );
+	for ( inx=0; inx<segCnt; inx++ ) {
+		if ( IsSegTrack(&segs[inx]) ) {
+			if ( segTrkLast != inx-1 ) {
+				tempSeg = segs[inx];
+				segTrkLast++;
+				for ( inx1=inx; inx1>segTrkLast; inx1-- ) {
+					 segs[inx1] = segs[inx1-1];
+				}
+				segs[segTrkLast] = tempSeg;
+			} else {
+				segTrkLast = inx;
+			}
+			DYNARR_APPEND( trkSeg_p, segMap_da, 10 );
+			segMap(segMap_da.cnt-1) = &segs[inx];
+		}
+	}
+
+	for ( pc=0,pp=paths; *pp; pp+=2,pc++ ) {
+		for ( ps=0,pp+=strlen((char *)pp)+1; pp[0]!=0 || pp[1]!=0; pp++,ps++ ) {
+#ifdef LATER
+			if (*pp >= '0' && *pp <= '9')
+				*pp -= '0';
+			else if (*pp >= 'A' && *pp <= 'Z')
+				*pp -= 'A' - 10;
+			if (*pp < 0 || *pp > segCnt) {
+				InputError( _("Turnout path[%d:%d] out of bounds: %d"),
+						FALSE, pc, ps, *pp);
+				return -1;
+			}
+#endif
+
+			if (pp[0]!=0 && pp[1]!=0 ) {
+				/* check connectivity */
+				DIST_T d;
+				GetSegInxEP( pp[0], &segInx[0], &segEp[0] );
+				GetSegInxEP( pp[1], &segInx[1], &segEp[1] );
+				if ( !IsSegTrack( &segs[segInx[0]] ) ) {
+					InputError( _("Turnout path[%d] %d is not a track segment"),
+						FALSE, pc, pp[0] );
+					return -1;
+				}
+				if ( !IsSegTrack( &segs[segInx[1]] ) ) {
+					InputError( _("Turnout path[%d] %d is not a track segment"),
+						FALSE, pc, pp[1] );
+					return -1;
+				}
+				d = FindDistance(
+						GetSegEndPt( &segs[segInx[0]], 1-segEp[0], FALSE, NULL ),
+						GetSegEndPt( &segs[segInx[1]], segEp[1], FALSE, NULL ) );
+				if (d > MIN_TURNOUT_SEG_CONNECT_DIST) {
+					InputError( _("Turnout path[%d] %d-%d not connected: %0.3f"),
+						FALSE, pc, pp[0], pp[1], d );
+					return -1;
+				}
+			}
+
+		}
+	}
+	return pp-paths+1;
+}
+
+
+static BOOL_T ReadTurnoutParam(
+		char * firstLine )
+{
+	char scale[10];
+	char *title;
+	turnoutInfo_t * to;
+
+	if ( !GetArgs( firstLine+8, "sq", scale, &title ) )
+		return FALSE;
+	DYNARR_RESET( trkEndPt_t, tempEndPts_da );
+	pathCnt = 0;
+	if (ReadSegs()) {
+		CheckPaths( tempSegs_da.cnt, &tempSegs(0), pathPtr );
+		to = CreateNewTurnout( scale, title, tempSegs_da.cnt, &tempSegs(0),
+						pathCnt, pathPtr, tempEndPts_da.cnt, &tempEndPts(0), FALSE );
+		if (to == NULL)
+			return FALSE;
+		if (tempSpecial[0] != '\0') {
+			if (strncmp( tempSpecial, ADJUSTABLE, strlen(ADJUSTABLE) ) == 0) {
+				to->special = TOadjustable;
+				GetArgs( tempSpecial+strlen(ADJUSTABLE), "ff",
+						&to->u.adjustable.minD, &to->u.adjustable.maxD );
+				
+			} else {
+				InputError(_("Unknown special case"), TRUE);
+			}
+		}
+		if (tempCustom[0] != '\0') {
+			to->customInfo = MyStrdup( tempCustom );
+		}
+	}
+	MyFree( title );
+	return TRUE;
+}
+
+
+EXPORT turnoutInfo_t * TurnoutAdd( long mode, SCALEINX_T scale, wList_p list, coOrd * maxDim, EPINX_T epCnt )
+{
+	wIndex_t inx;
+	turnoutInfo_t * to, * to1 = NULL;
+	for ( inx = 0; inx < turnoutInfo_da.cnt; inx++ ) {
+		to = turnoutInfo(inx);
+		if ( IsParamValid(to->paramFileIndex) &&
+			 to->segCnt > 0 &&
+			 CompatibleScale( TRUE, to->scaleInx, scale ) &&
+			 /*strcasecmp( to->scale, scaleName ) == 0 && */
+			 ( epCnt <= 0 || epCnt == to->endCnt ) ) {
+			if (to1==NULL)
+				to1 = to;
+			FormatCompoundTitle( mode, to->title );
+			if (message[0] != '\0') {
+				wListAddValue( list, message, NULL, to );
+				if (maxDim) {
+					if (to->size.x > maxDim->x) 
+						maxDim->x = to->size.x;
+					if (to->size.y > maxDim->y) 
+						maxDim->y = to->size.y;
+				}
+			}
+		}
+	}
+	return to1;
+}
+
+/****************************************
+ *
+ * Adjustable Track Support
+ *
+ */
+
+
+static void ChangeAdjustableEndPt(
+		track_p trk,
+		EPINX_T ep,
+		DIST_T d )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	coOrd pos;
+	trkSeg_p segPtr;
+	ANGLE_T angle = GetTrkEndAngle( trk, ep );
+	Translate( &pos, GetTrkEndPos( trk, 1-ep ), angle, d );
+	UndoModify(trk);
+	SetTrkEndPoint( trk, ep, pos, angle );
+	if ( ep == 0 )
+		xx->orig = pos;
+	for ( segPtr=xx->segs; segPtr<&xx->segs[xx->segCnt]; segPtr++ ) {
+		switch (segPtr->type) {
+		case SEG_STRLIN:
+		case SEG_STRTRK:
+			segPtr->u.l.pos[1].x = d;
+			break;
+		default:
+			;
+		}
+	}
+	ComputeBoundingBox( trk );
+	DrawNewTrack( trk );
+}
+
+
+EXPORT BOOL_T ConnectAdjustableTracks(
+		track_p trk1,
+		EPINX_T ep1,
+		track_p trk2,
+		EPINX_T ep2 )
+{
+	struct extraData * xx1;
+	struct extraData * xx2;
+	BOOL_T adj1, adj2;
+	coOrd p1, p2;
+	ANGLE_T a, a1, a2;
+	DIST_T d, maxD, d1, d2;
+	BOOL_T rc;
+	coOrd off;
+	DIST_T beyond;
+
+	xx1 = GetTrkExtraData(trk1);
+	xx2 = GetTrkExtraData(trk2);
+	adj1 = adj2 = FALSE;
+	if (GetTrkType(trk1) == T_TURNOUT && xx1->special == TOadjustable)
+		adj1 = TRUE;
+	if (GetTrkType(trk2) == T_TURNOUT && xx2->special == TOadjustable)
+		adj2 = TRUE;
+	if (adj1 == FALSE && adj2 == FALSE)
+		return FALSE;
+	a1 = GetTrkEndAngle( trk1, ep1 );
+	a2 = GetTrkEndAngle( trk2, ep2 );
+	a = NormalizeAngle( a1 - a2 + 180.0 + connectAngle/2.0);
+	if (a>connectAngle)
+		return FALSE;
+	UndoStart( _("Connect Adjustable Tracks"), "changeAdjustableEndPt" );
+	maxD = 0.0;
+	if (adj1) {
+		p1 = GetTrkEndPos( trk1, 1-ep1 );
+		Translate( &p1, p1, a1, xx1->u.adjustable.minD );
+		maxD += xx1->u.adjustable.maxD-xx1->u.adjustable.minD;
+	} else {
+		p1 = GetTrkEndPos( trk1, ep1 );
+	}
+	if (adj2) {
+		p2 = GetTrkEndPos( trk2, 1-ep2 );
+		Translate( &p2, p2, a2, xx2->u.adjustable.minD );
+		maxD += xx2->u.adjustable.maxD-xx2->u.adjustable.minD;
+	} else {
+		p2 = GetTrkEndPos( trk2, ep2 );
+	}
+	d = FindDistance( p1, p2 );
+	rc = TRUE;
+	if (d > maxD) {
+		d = maxD;
+		rc = FALSE;
+	}
+	FindPos( &off, &beyond, p1, p2, a1, 10000.0 );
+	if (fabs(off.y) > connectDistance)
+		rc = FALSE;
+	if (adj1) {
+		UndrawNewTrack( trk1 );
+		d1 = d * (xx1->u.adjustable.maxD-xx1->u.adjustable.minD)/maxD + xx1->u.adjustable.minD;
+		ChangeAdjustableEndPt( trk1, ep1, d1 );
+	}
+	if (adj2) {
+		UndrawNewTrack( trk2 );
+		d2 = d * (xx2->u.adjustable.maxD-xx2->u.adjustable.minD)/maxD + xx2->u.adjustable.minD;
+		ChangeAdjustableEndPt( trk2, ep2, d2 );
+	}
+	if (rc) {
+		DrawEndPt( &mainD, trk1, ep1, wDrawColorWhite );
+		DrawEndPt( &mainD, trk2, ep2, wDrawColorWhite );
+		ConnectTracks( trk1, ep1, trk2, ep2 );
+		DrawEndPt( &mainD, trk1, ep1, wDrawColorBlack );
+		DrawEndPt( &mainD, trk2, ep2, wDrawColorBlack );
+	}
+	return rc;
+}
+
+/****************************************
+ *
+ * Draw Turnout Roadbed
+ *
+ */
+
+int roadbedOnScreen = 0;
+
+
+void DrawTurnoutRoadbedSide( drawCmd_p d, wDrawColor color, coOrd orig, ANGLE_T angle, trkSeg_p sp, ANGLE_T side, int first, int last )
+{
+	segProcData_t data;
+	if (last<=first)
+		return;
+	data.drawRoadbedSide.first = first;
+	data.drawRoadbedSide.last = last;
+	data.drawRoadbedSide.side = side;
+	data.drawRoadbedSide.roadbedWidth = roadbedWidth;
+	data.drawRoadbedSide.rbw = (wDrawWidth)floor(roadbedLineWidth*(d->dpi/d->scale)+0.5);
+	data.drawRoadbedSide.orig = orig;
+	data.drawRoadbedSide.angle = angle;
+	data.drawRoadbedSide.color = color;
+	data.drawRoadbedSide.d = d;
+	SegProc( SEGPROC_DRAWROADBEDSIDE, sp, &data );
+}
+
+
+static void ComputeAndDrawTurnoutRoadbedSide(
+		drawCmd_p d,
+		wDrawColor color,
+		coOrd orig,
+		ANGLE_T angle,
+		trkSeg_p segPtr,
+		int segCnt,
+		int segInx,
+		ANGLE_T side )
+{
+	unsigned long res, res1;
+	int b0, b1;
+	res = ComputeTurnoutRoadbedSide( segPtr, segCnt, segInx, side, roadbedWidth );
+	if (res == 0L) {
+	} else if (res == 0xFFFFFFFF) {
+		DrawTurnoutRoadbedSide( d, color, orig, angle, &segPtr[segInx], side, 0, 32 );
+	} else {
+		for ( b0=0, res1=0x00000001; res1&&(res1&res); b0++,res1<<=1 );
+		for ( b1=32,res1=0x80000000; res1&&(res1&res); b1--,res1>>=1 );
+		DrawTurnoutRoadbedSide( d, color, orig, angle, &segPtr[segInx], side, 0, b0 );
+		DrawTurnoutRoadbedSide( d, color, orig, angle, &segPtr[segInx], side, b1, 32 );
+	}
+}
+
+
+static void DrawTurnoutRoadbed(
+		drawCmd_p d,
+		wDrawColor color,
+		coOrd orig,
+		ANGLE_T angle,
+		trkSeg_p segPtr,
+		int segCnt )
+{
+	int inx, trkCnt=0, segInx=0;
+	for (inx=0;inx<segCnt;inx++) {
+		if ( IsSegTrack(&segPtr[inx]) ) {
+			segInx = inx;
+			trkCnt++;
+			if (trkCnt>1)
+				break;
+		}
+	}
+	if (trkCnt==0)
+		return;
+	if (trkCnt == 1) {
+		DrawTurnoutRoadbedSide( d, color, orig, angle, &segPtr[segInx], +90, 0, 32 );
+		DrawTurnoutRoadbedSide( d, color, orig, angle, &segPtr[segInx], -90, 0, 32 );
+	} else {
+		for (inx=0;inx<segCnt;inx++) {
+			if ( IsSegTrack(&segPtr[inx]) ) {
+				ComputeAndDrawTurnoutRoadbedSide( d, color, orig, angle, segPtr, segCnt, inx, +90 );
+				ComputeAndDrawTurnoutRoadbedSide( d, color, orig, angle, segPtr, segCnt, inx, -90 );
+			}
+		}
+	}
+}
+
+/****************************************
+ *
+ * HAND LAID TURNOUTS
+ *
+ */
+
+track_p NewHandLaidTurnout(
+		coOrd p0,
+		ANGLE_T a0,
+		coOrd p1,
+		ANGLE_T a1,
+		coOrd p2,
+		ANGLE_T a2,
+		ANGLE_T frogA )
+{
+	track_p trk;
+	struct extraData * xx;
+	trkSeg_t segs[2];
+	sprintf( message, "\tHand Laid Turnout, Angle=%0.1f\t", frogA );
+	DYNARR_SET( trkEndPt_t, tempEndPts_da, 2 );
+	memset( &tempEndPts(0), 0, tempEndPts_da.cnt * sizeof tempEndPts(0) );
+	tempEndPts(0).pos = p0;
+	tempEndPts(0).angle = a0;
+	tempEndPts(1).pos = p1;
+	tempEndPts(1).angle = a1;
+	tempEndPts(2).pos = p2;
+	tempEndPts(2).angle = a2;
+	Rotate( &p1, p0, -a0 );
+	p1.x -= p0.x;
+	p1.y -= p0.y;
+	segs[0].type = SEG_STRTRK;
+	segs[0].color = wDrawColorBlack;
+	segs[0].u.l.pos[0] = zero;
+	segs[0].u.l.pos[1] = p1;
+	Rotate( &p2, p0, -a0 );
+	p2.x -= p0.x;
+	p2.y -= p0.y;
+	segs[1].type = SEG_STRTRK;
+	segs[1].color = wDrawColorBlack;
+	segs[1].u.l.pos[0] = zero;
+	segs[1].u.l.pos[1] = p2;
+	trk = NewCompound( T_TURNOUT, 0, p0, a0, message, 3, &tempEndPts(0), 22, "Normal\0\1\0\0Reverse\0\2\0\0\0", 2, segs );
+	xx = GetTrkExtraData(trk);
+	xx->handlaid = TRUE;
+
+#ifdef LATER
+	trk = NewTrack( 0, T_TURNOUT, 3,
+			sizeof (*xx) + (3-1)*sizeof curTurnout->segs[0] + 1);
+	xx = GetTrkExtraData(trk);
+	xx->orig = p0;
+	xx->angle = a0;
+	xx->handlaid = TRUE;
+	xx->descriptionOff = zero;
+	xx->descriptionSize = zero;
+	sprintf( message, "\tHand Laid Turnout, Angle=%0.1f\t", frogA );
+	xx->title = MyStrdup( message );
+	xx->paths = xx->pathCurr = (PATHPTR_T)"Normal\0\1\0\0Reverse\0\2\0\0\0";
+	xx->pathLen = 21;
+	SetTrkEndPoint( trk, 0, p0, a0 );
+	SetTrkEndPoint( trk, 1, p1, a1 );
+	SetTrkEndPoint( trk, 2, p2, a2 );
+	xx->segCnt = 2;
+	Rotate( &p1, p0, -a0 );
+	p1.x -= p0.x;
+	p1.y -= p0.y;
+	xx->segs[0].type = SEG_STRTRK;
+	xx->segs[0].color = wDrawColorBlack;
+	xx->segs[0].u.l.pos[0] = zero;
+	xx->segs[0].u.l.pos[1] = p1;
+	Rotate( &p2, p0, -a0 );
+	p2.x -= p0.x;
+	p2.y -= p0.y;
+	xx->segs[1].type = SEG_STRTRK;
+	xx->segs[1].color = wDrawColorBlack;
+	xx->segs[1].u.l.pos[0] = zero;
+	xx->segs[1].u.l.pos[1] = p2;
+	ComputeBoundingBox( trk );
+	SetDescriptionOrig( trk );
+#endif
+	return trk;
+}
+
+/****************************************
+ *
+ * GENERIC FUNCTIONS
+ *
+ */
+
+static coOrd MapPathPos(
+		struct extraData * xx,
+		signed char segInx,
+		EPINX_T ep )
+{
+	trkSeg_p segPtr;
+	wIndex_t inx;
+	coOrd pos;
+
+	if ( segInx < 0 ) {
+		segInx = - segInx;
+		ep = 1-ep;
+	}
+
+	for ( inx=0,segPtr=xx->segs; inx<xx->segCnt; inx++,segPtr++ ) {
+		if ( !IsSegTrack(segPtr) ) continue;
+		if ( --segInx > 0 ) continue;
+		pos = GetSegEndPt( segPtr, ep, FALSE, NULL );
+		REORIGIN1( pos, xx->angle, xx->orig );
+		return pos;
+	}
+	fprintf( stderr, "mapPathPos: bad segInx: %d\n", segInx );
+	return zero;
+}
+
+
+static void DrawTurnout(
+		track_p trk,
+		drawCmd_p d,
+		wDrawColor color )
+{
+	struct extraData *xx = GetTrkExtraData(trk);
+	wIndex_t i;
+	long widthOptions = 0;
+	DIST_T scale2rail;
+
+	if (GetTrkWidth(trk) == 2)
+		widthOptions = DTS_THICK2;
+	if (GetTrkWidth(trk) == 3)
+		widthOptions = DTS_THICK3;
+	scale2rail = (d->options&DC_PRINT)?(twoRailScale*2+1):twoRailScale;
+	if ( tieDrawMode!=TIEDRAWMODE_NONE &&
+		 d!=&mapD &&
+		 (d->options&DC_TIES)!=0 &&
+		 d->scale<scale2rail/2 )
+		DrawSegsO( d, trk, xx->orig, xx->angle, xx->segs, xx->segCnt, GetTrkGauge(trk), color, widthOptions|DTS_TIES );
+	DrawSegsO( d, trk, xx->orig, xx->angle, xx->segs, xx->segCnt, GetTrkGauge(trk), color, widthOptions | DTS_NOCENTER );  // no curve center for turnouts
+	for (i=0; i<GetTrkEndPtCnt(trk); i++) {
+		DrawEndPt( d, trk, i, color );
+	}
+	if ( ((d->funcs->options&wDrawOptTemp)==0) &&
+		 (labelWhen == 2 || (labelWhen == 1 && (d->options&DC_PRINT))) &&
+		 labelScale >= d->scale &&
+		 ( GetTrkBits( trk ) & TB_HIDEDESC ) == 0 ) {
+		DrawCompoundDescription( trk, d, color );
+		if (!xx->handlaid)
+			LabelLengths( d, trk, color );
+	}
+	if ( roadbedWidth > GetTrkGauge(trk) &&
+		( ((d->options&DC_PRINT) && d->scale <= (twoRailScale*2+1)/2.0) ||
+		  (roadbedOnScreen && d->scale <= twoRailScale) ) )
+		DrawTurnoutRoadbed( d, color, xx->orig, xx->angle, xx->segs, xx->segCnt );
+
+}
+
+
+static void ReadTurnout(
+		char * line )
+{
+	ReadCompound( line+8, T_TURNOUT );
+	CheckPaths( tempSegs_da.cnt, &tempSegs(0), pathPtr );
+}
+
+
+static ANGLE_T GetAngleTurnout(
+		track_p trk,
+		coOrd pos,
+		EPINX_T *ep0,
+		EPINX_T *ep1 )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	wIndex_t segCnt, segInx;
+	ANGLE_T angle;
+
+	if ( ep0 && ep1 )
+		*ep0 = *ep1 = PickEndPoint( pos, trk );
+	for ( segCnt=0; segCnt<xx->segCnt && IsSegTrack(&xx->segs[segCnt]); segCnt++ );
+	pos.x -= xx->orig.x;
+	pos.y -= xx->orig.y;
+	Rotate( &pos, zero, -xx->angle );
+	angle = GetAngleSegs( segCnt, xx->segs, pos, &segInx );
+	return NormalizeAngle( angle+xx->angle );
+}
+
+
+static BOOL_T SplitTurnoutCheckPath(
+		wIndex_t segInxEnd,
+		PATHPTR_T pp1,
+		int dir1,
+		PATHPTR_T pp2,
+		int dir2,
+		trkSeg_p segs,
+		coOrd epPos )
+{
+	wIndex_t segInx1, segInx2;
+	EPINX_T segEP;
+	coOrd pos;
+	DIST_T dist;
+
+	GetSegInxEP( pp2[0], &segInx2, &segEP );
+	if ( dir2 < 0 ) segEP = 1-segEP;
+	pos = GetSegEndPt( &segs[segInx2], segEP, FALSE, NULL );
+	dist = FindDistance( pos, epPos );
+	if ( dist>connectDistance )
+		return TRUE;
+	while ( pp2[0] ) {
+		GetSegInxEP( pp1[0], &segInx1, &segEP );
+		GetSegInxEP( pp2[0], &segInx2, &segEP );
+		if ( segInx1 != segInx2 )
+			break;
+		if ( segInxEnd == segInx2 )
+			return TRUE;
+		pp1 += dir1;
+		pp2 += dir2;
+	}
+	return FALSE;
+}
+
+
+static BOOL_T SplitTurnoutCheckEP(
+		wIndex_t segInx0,
+		coOrd epPos,
+		PATHPTR_T pp1,
+		int dir1,
+		PATHPTR_T pp,
+		trkSeg_p segs )
+{
+	while ( pp[0] ) {
+		pp += strlen((char *)pp)+1;
+		while ( pp[0] ) {
+			if (!SplitTurnoutCheckPath( segInx0, pp1, dir1, pp, 1, segs, epPos ))
+				return FALSE;
+			while ( pp[0] )
+				pp++;
+			if (!SplitTurnoutCheckPath( segInx0, pp1, dir1, pp-1, -1, segs, epPos ))
+				return FALSE;
+			pp++;
+		}
+		pp++;
+	}
+	return TRUE;
+}
+
+
+EXPORT EPINX_T TurnoutPickEndPt(
+		coOrd epPos,
+		track_p trk )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	wIndex_t segCnt, segInx, segInx0;
+	EPINX_T segEP;
+	PATHPTR_T cp, cq, pps[2];
+	coOrd pos;
+	DIST_T dist, dists[2];
+	int dir;
+	EPINX_T ep, epCnt, eps[2];
+	BOOL_T unique_eps[2];
+
+	for ( segCnt=0; segCnt<xx->segCnt && IsSegTrack(&xx->segs[segCnt]); segCnt++ );
+	DistanceSegs( xx->orig, xx->angle, segCnt, xx->segs, &epPos, &segInx0 );
+	Rotate( &epPos, xx->orig, xx->angle );
+	epPos.x -= xx->orig.x;
+	epPos.y -= xx->orig.y;
+	epCnt = GetTrkEndPtCnt(trk);
+	cp = xx->paths;
+	eps[0] = eps[1] = -1;
+	unique_eps[0] = unique_eps[1] = TRUE;
+	while ( cp[0] ) {
+		cp += strlen((char *)cp)+1;
+		while ( cp[0] ) {
+			while ( cp[0] ) {
+				GetSegInxEP( cp[0], &segInx, &segEP );
+				if ( segInx == segInx0 ) {
+					for ( dir=0; dir<2; dir++ ) {
+						for ( cq=cp; cq[dir?-1:1]; cq += (dir?-1:1) );
+						GetSegInxEP( cq[0], &segInx, &segEP );
+						if ( dir==0 ) segEP = 1-segEP;
+						pos = GetSegEndPt( &xx->segs[segInx], segEP, FALSE, NULL );
+						dist = FindDistance( pos, epPos );
+						if ( eps[dir] < 0 || dist < dists[dir] ) {
+							dists[dir] = dist;
+							pos.x += xx->orig.x;
+							pos.y += xx->orig.y;
+							Rotate( &pos, xx->orig, xx->angle );
+							for ( ep=0; ep<epCnt; ep++ ) {
+								if ( FindDistance( pos, GetTrkEndPos(trk,ep) ) < connectDistance )
+									break;
+							}
+							if ( ep<epCnt ) {
+								if ( eps[dir] >= 0 && eps[dir] != ep )
+									unique_eps[dir] = FALSE;
+								eps[dir] = ep;
+								dists[dir] = dist;
+								pps[dir] = cq;
+							}
+						}
+					}
+				}
+				cp++;
+			}
+			cp++;
+		}
+		cp++;
+	}
+
+	for ( dir=0; dir<2; dir++ ) {
+		if ( unique_eps[dir] && eps[dir] >= 0 ) {
+			GetSegInxEP( pps[dir][0], &segInx, &segEP );
+			if ( dir == 0 ) segEP = 1-segEP;
+			epPos = GetSegEndPt( &xx->segs[segInx], segEP, FALSE, NULL );
+			if ( ! SplitTurnoutCheckEP( segInx0, epPos, pps[dir], dir?1:-1, xx->paths, xx->segs ) )
+				unique_eps[dir] = FALSE; 
+		}
+	}
+
+	if ( unique_eps[0] == unique_eps[1] ) {
+		if ( eps[0] >= 0 && eps[1] >= 0 )
+			return ( dists[0] < dists[1] ) ? eps[0] : eps[1] ;
+	}
+	if ( unique_eps[0] && eps[0] >= 0 )
+		return eps[0];
+	if ( unique_eps[1] && eps[1] >= 0 )
+		return eps[1];
+	if ( eps[0] >= 0 && eps[1] >= 0 )
+		return ( dists[0] < dists[1] ) ? eps[0] : eps[1] ;
+	return eps[0] >= 0 ? eps[0] : eps[1] ;
+}
+
+
+static PATHPTR_T splitTurnoutPath;
+static PATHPTR_T splitTurnoutRoot;
+static int splitTurnoutDir;
+
+static void SplitTurnoutCheckEndPt(
+		PATHPTR_T path,
+		int dir,
+		trkSeg_p segs,
+		coOrd epPos,
+		coOrd splitPos )
+{
+	PATHPTR_T path0;
+	wIndex_t segInx;
+	EPINX_T segEP;
+	coOrd pos;
+	DIST_T dist, minDist;
+
+	path0 = path;
+	GetSegInxEP( path[0], &segInx, &segEP );
+	if ( dir < 0 ) segEP = 1-segEP;
+	pos = GetSegEndPt( &segs[segInx], segEP, FALSE, NULL );
+	dist = FindDistance( pos, epPos );
+	if ( dist>connectDistance )
+		return;
+	minDist = trackGauge;
+	while ( path[0] ) {
+		GetSegInxEP( path[0], &segInx, &segEP );
+		if ( dir < 0 ) segEP = 1-segEP;
+		pos = splitPos;
+		dist = DistanceSegs( zero, 0.0, 1, &segs[segInx], &pos, NULL );
+		if ( dist < minDist ) {
+			minDist = dist;
+			splitTurnoutPath = path;
+			splitTurnoutDir = -dir;
+			splitTurnoutRoot = path0;
+		}
+		path += dir;
+	}
+}
+
+
+static BOOL_T SplitTurnout(
+		track_p trk,
+		coOrd pos,
+		EPINX_T ep,
+		track_p *leftover,
+		EPINX_T * ep0,
+		EPINX_T * ep1 )
+{
+	struct extraData * xx = GetTrkExtraData( trk );
+	wIndex_t segInx0, segInx, segCnt;
+	EPINX_T segEP, epCnt, ep2=0, epN;
+	PATHPTR_T pp, pp1, pp2;
+	unsigned char c;
+	char * cp;
+	int negCnt, posCnt, pathCnt, dir;
+	segProcData_t segProcDataSplit;
+	segProcData_t segProcDataNewTrack;
+	track_p trk2=NULL;
+	static dynArr_t segIndexMap_da;
+#define segIndexMap(N) DYNARR_N( int, segIndexMap_da, N )
+	static dynArr_t newPath_da;
+#define newPath(N) DYNARR_N( char, newPath_da, N )
+	coOrd orig, size, epPos;
+	ANGLE_T epAngle;
+	PATHPTR_T path;
+	int s0, s1;
+	trkSeg_t newSeg;
+
+	if ( (MyGetKeyState()&WKEY_SHIFT) == 0 ) {
+		ErrorMessage( MSG_CANT_SPLIT_TRK, _("Turnout") );
+		return FALSE;
+	}
+
+	/*
+	 * 1. Find segment on path that ends at 'ep'
+	 */
+	epCnt = GetTrkEndPtCnt(trk);
+	epPos = GetTrkEndPos( trk, ep );
+	for ( segCnt=0; segCnt<xx->segCnt && IsSegTrack(&xx->segs[segCnt]); segCnt++ );
+	Rotate( &pos, xx->orig, -xx->angle );
+	pos.x -= xx->orig.x;
+	pos.y -= xx->orig.y;
+	Rotate( &epPos, xx->orig, -xx->angle );
+	epPos.x -= xx->orig.x;
+	epPos.y -= xx->orig.y;
+	splitTurnoutPath = NULL;
+	pp = xx->paths;
+	while ( pp[0] ) {
+		pp += strlen((char *)pp)+1;
+		while ( pp[0] ) {
+			SplitTurnoutCheckEndPt( pp, 1, xx->segs, epPos, pos );
+			if ( splitTurnoutPath != NULL )
+				goto foundSeg;
+			while ( pp[0] )
+				pp++;
+			SplitTurnoutCheckEndPt( pp-1, -1, xx->segs, epPos, pos );
+			if ( splitTurnoutPath != NULL )
+				goto foundSeg;
+			pp++;
+		}
+		pp++;
+	}
+	ErrorMessage( _("splitTurnout: can't find segment") );
+	return FALSE;
+foundSeg:
+
+	/*
+	 * 2a. Check that all other paths thru found segment are the same
+	 */
+	GetSegInxEP( splitTurnoutPath[0], &segInx0, &segEP );
+	pp = xx->paths;
+	pathCnt = 0;
+	while ( pp[0] ) {
+		pp += strlen((char *)pp)+1;
+		while ( pp[0] ) {
+			while ( pp[0] ) {
+				GetSegInxEP( pp[0], &segInx, &segEP );
+				if ( segInx == segInx0 ) {
+					pp1 = splitTurnoutPath;
+					pp2 = pp;
+					dir = (pp2[0]>0?1:-1) * splitTurnoutDir;
+					while ( pp1[0] && pp2[0] ) {
+						if ( splitTurnoutDir * pp1[0] != dir * pp2[0] )
+							break;
+						pp1 += splitTurnoutDir;
+						pp2 += dir;
+					}
+					if ( pp1[0]!='\0' || pp2[0]!='\0' ) {
+						ErrorMessage( MSG_SPLIT_POS_BTW_MERGEPTS );
+						return FALSE;
+					}
+				}
+				pp++;
+			}
+			pp++;
+		}
+		pp++;
+	}
+
+	/*
+	 * 2b. Check that all paths from ep pass thru segInx0
+	 */
+	if ( !SplitTurnoutCheckEP( segInx0, epPos, splitTurnoutRoot, -splitTurnoutDir, xx->paths, xx->segs ) ) {
+		ErrorMessage( MSG_SPLIT_PATH_NOT_UNIQUE );
+		return FALSE;
+	}
+
+
+	/*
+	 * 3. Split the found segment.
+	 */
+	segProcDataSplit.split.pos = pos;
+	s0 = (splitTurnoutPath[0] > 0) != (splitTurnoutDir > 0);
+	s1 = 1-s0;
+	SegProc( SEGPROC_SPLIT, xx->segs+segInx0, &segProcDataSplit );
+	if ( segProcDataSplit.split.length[s1] <= minLength ) {
+		if ( splitTurnoutPath[splitTurnoutDir] == '\0' )
+			return FALSE;
+		segProcDataSplit.split.length[s0] += segProcDataSplit.split.length[s1];
+		segProcDataSplit.split.length[s1] = 0;
+		segProcDataSplit.split.newSeg[s0] = xx->segs[segInx0];
+		epPos = GetSegEndPt( &segProcDataSplit.split.newSeg[s0], s1, FALSE, &epAngle );
+	} else if ( segProcDataSplit.split.length[s0] <= minLength ) {
+		segProcDataSplit.split.length[s1] += segProcDataSplit.split.length[s0];
+		segProcDataSplit.split.length[s0] = 0;
+		segProcDataSplit.split.newSeg[s1] = xx->segs[segInx0];
+		epPos = GetSegEndPt( &segProcDataSplit.split.newSeg[s1], s0, FALSE, &epAngle );
+		epAngle += 180.0;
+	} else {
+		epPos = GetSegEndPt( &segProcDataSplit.split.newSeg[s1], s0, FALSE, &epAngle );
+		epAngle += 180.0;
+	}
+#ifdef LATER
+	if ( segProcDataSplit.split.length[s1] <= minLength && splitTurnoutPath[1] == '\0' )
+		return FALSE;
+#endif
+
+	/*
+	 * 4. Map the old segments to new
+	 */
+	DYNARR_SET( int, segIndexMap_da, xx->segCnt );
+	for ( segInx=0; segInx<xx->segCnt; segInx++ )
+		segIndexMap(segInx) = segInx+1;
+	pp = splitTurnoutPath;
+	if ( segProcDataSplit.split.length[s0] > minLength )
+		pp += splitTurnoutDir;
+	negCnt = 0;
+	while ( *pp ) {
+		GetSegInxEP( *pp, &segInx, &segEP );
+		segIndexMap(segInx) = - segIndexMap(segInx);
+		negCnt++;
+		pp += splitTurnoutDir;
+	}
+	for ( segInx=posCnt=0; segInx<xx->segCnt; segInx++ ) {
+		if ( segIndexMap(segInx) > 0 )
+			segIndexMap(segInx) = ++posCnt;
+	}
+	DYNARR_SET( trkSeg_t, tempSegs_da, posCnt );
+	for ( segInx=posCnt=0; segInx<xx->segCnt; segInx++ ) {
+		if ( segIndexMap(segInx) > 0 ) {
+			if ( segInx == segInx0 ) {
+				tempSegs(segIndexMap(segInx)-1) = segProcDataSplit.split.newSeg[s0];
+			} else {
+				tempSegs(segIndexMap(segInx)-1) = xx->segs[segInx];
+			}
+		}
+	}
+
+	/*
+	 * 5. Remap paths by removing trailing segments
+	 */
+	DYNARR_SET( char, newPath_da, xx->pathLen );
+	pp = xx->paths;
+	pp1 = (PATHPTR_T)&newPath(0);
+	while ( *pp ) {
+		strcpy( (char *)pp1, (char *)pp );
+		pp += strlen( (char *)pp )+1;
+		pp1 += strlen( (char *)pp1 )+1;
+		while ( *pp ) {
+			while ( *pp ) {
+				GetSegInxEP( *pp, &segInx, &segEP );
+				if ( segIndexMap(segInx) > 0 ) {
+					c = segIndexMap(segInx);
+					if ( *pp<0 )
+						c = -c;
+					*pp1++ = c;
+				}
+				pp++;
+			}
+			*pp1++ = '\0';
+			pp++;
+		}
+		*pp1++ = '\0';
+		pp++;
+	}
+	*pp1++ = '\0';
+
+	/*
+	 * 6. Reorigin segments
+	 */
+	GetSegBounds( zero, 0, tempSegs_da.cnt, &tempSegs(0), &orig, &size );
+	orig.x = -orig.x;
+	orig.y = -orig.y;
+	MoveSegs( tempSegs_da.cnt, &tempSegs(0), orig );
+	epPos.x += orig.x;
+	epPos.y += orig.y;
+	cp = strchr( xx->title, '\t' );
+	if ( cp ) {
+		if ( strncmp( cp+1, "Split ", 6 ) != 0 ) {
+			memcpy( message, xx->title, cp-xx->title+1 );
+			strcpy( message+(cp-xx->title+1), "Split " );
+			strcat( message, cp+1 );
+		} else {
+			strcpy( message, xx->title );
+		}
+	} else {
+		sprintf( message, "Split %s", xx->title );
+	}
+
+	/*
+	 * 7. Convert trailing segments to new tracks
+	 */
+	path = splitTurnoutPath;
+	if ( segProcDataSplit.split.length[s1] < minLength )
+		path += splitTurnoutDir;
+	while ( path[0] ) {
+		GetSegInxEP( path[0], &segInx, &segEP );
+		s0 = (path[0] > 0) != (splitTurnoutDir > 0);
+		if ( segInx0 != segInx ) {
+			newSeg = xx->segs[segInx];
+		} else {
+			newSeg = segProcDataSplit.split.newSeg[s1];
+		}
+		MoveSegs( 1, &newSeg, xx->orig );
+		RotateSegs( 1, &newSeg, xx->orig, xx->angle );
+		SegProc( SEGPROC_NEWTRACK, &newSeg, &segProcDataNewTrack );
+		if ( *leftover == NULL ) {
+			*ep0 = segProcDataNewTrack.newTrack.ep[s0];
+			*leftover = trk2 = segProcDataNewTrack.newTrack.trk;
+			ep2 = 1-*ep0;
+		} else {
+			epN = segProcDataNewTrack.newTrack.ep[s0];
+			ConnectTracks( trk2, ep2, segProcDataNewTrack.newTrack.trk, epN );
+			trk2 = segProcDataNewTrack.newTrack.trk;
+			ep2 = 1-epN;
+		}
+		path += splitTurnoutDir;
+	}
+
+	/*
+	 * 8. Replace segments, paths, and endPt in original turnout
+	 */
+	xx->split = TRUE;
+	Rotate( &orig, zero, xx->angle );
+	xx->orig.x -= orig.x;
+	xx->orig.y -= orig.y;
+	xx->segCnt = tempSegs_da.cnt;
+	xx->segs = (trkSeg_p)memdup( &tempSegs(0), tempSegs_da.cnt * sizeof tempSegs(0) );
+	CloneFilledDraw( xx->segCnt, xx->segs, TRUE );
+	xx->pathLen = pp1-(PATHPTR_T)&newPath(0);
+	xx->pathCurr = xx->paths = memdup( &newPath(0), xx->pathLen );
+	epAngle = NormalizeAngle( xx->angle+epAngle );
+	epPos.x += xx->orig.x;
+	epPos.y += xx->orig.y;
+	Rotate( &epPos, xx->orig, xx->angle );
+	SetTrkEndPoint( trk, ep, epPos, epAngle );
+	ComputeCompoundBoundingBox( trk );
+
+	return TRUE;
+}
+
+
+static BOOL_T CheckTraverseTurnout(
+		track_p trk,
+		coOrd pos )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	coOrd pos1;
+#ifdef LATER
+	int inx, foundInx = 0;
+	DIST_T d, foundD;
+#endif
+	DIST_T d;
+	PATHPTR_T pathCurr;
+	int segInx;
+	EPINX_T segEP;
+
+LOG( log_traverseTurnout, 1, ( "CheckTraverseTurnout( T%d, [%0.3f %0.3f])\n", GetTrkIndex(trk), pos.x, pos.y ) )
+	Rotate( &pos, xx->orig, -xx->angle );
+	pos.x -= xx->orig.x;
+	pos.y -= xx->orig.y;
+LOG( log_traverseTurnout, 1, ( "After rotation = [%0.3f %0.3f])\n", pos.x, pos.y ) )
+	
+#ifdef LATER
+	for ( inx=0; inx<xx->segCnt; inx++ ) {
+		switch ( xx->segs[inx].type ) {
+		case SEG_STRTRK:
+		case SEG_CRVTRK:
+			pos1 = GetSegEndPt( &xx->segs[inx], 0, FALSE, NULL );
+			d = FindDistance( pos, pos1 );
+			if ( foundInx == 0 || d < foundD ) {
+				foundInx = inx+1;
+				foundD = d;
+			}
+			pos1 = GetSegEndPt( &xx->segs[inx], 1, FALSE, NULL );
+			d = FindDistance( pos, pos1 );
+			if ( foundInx == 0 || d < foundD ) {
+				foundInx = -(inx+1);
+				foundD = d;
+			}
+			break;
+		}
+	}
+	if ( foundInx == 0 )
+		return FALSE;
+#endif
+	for ( pathCurr = xx->pathCurr+strlen((char*)xx->pathCurr)+1; pathCurr[0] || pathCurr[1]; pathCurr++ ) {
+LOG( log_traverseTurnout, 1, ( "P[%d] = %d ", pathCurr-xx->paths, pathCurr[0] ) )
+		if ( pathCurr[-1] == 0 ) {
+			GetSegInxEP( pathCurr[0], &segInx, &segEP );
+			pos1 = GetSegEndPt( &xx->segs[segInx], segEP, FALSE, NULL );
+			d = FindDistance( pos, pos1 );
+LOG( log_traverseTurnout, 1, ( "d=%0.3f\n", d ) )
+			if ( d < connectDistance )
+				return TRUE;
+		}
+		if ( pathCurr[1] == 0 ) {
+			GetSegInxEP( pathCurr[0], &segInx, &segEP );
+			pos1 = GetSegEndPt( &xx->segs[segInx], 1-segEP, FALSE, NULL );
+			d = FindDistance( pos, pos1 );
+LOG( log_traverseTurnout, 1, ( "d=%0.3f\n", d ) )
+			if ( d < connectDistance )
+				return TRUE;
+		}
+	}
+LOG( log_traverseTurnout, 1, ( " not found\n" ) )
+	return FALSE;
+}
+
+
+static BOOL_T TraverseTurnout(
+		traverseTrack_p trvTrk,
+		DIST_T * distR )
+{
+	track_p trk = trvTrk->trk;
+	struct extraData * xx = GetTrkExtraData(trk);
+	coOrd pos0, pos1, pos2;
+	DIST_T d, dist;
+	PATHPTR_T path, pathCurr;
+	BOOL_T backwards=FALSE;
+	trkSeg_p segPtr;
+	EPINX_T ep, epCnt, ep2;
+	int segInx;
+	EPINX_T segEP;
+	segProcData_t segProcData;
+
+	d = 10000;
+	pos0 = trvTrk->pos;
+	Rotate( &pos0, xx->orig, -xx->angle );
+	pos0.x -= xx->orig.x;
+	pos0.y -= xx->orig.y;
+	dist = *distR;
+LOG( log_traverseTurnout, 1, ( "TraverseTurnout( T%d, [%0.3f %0.3f] [%0.3f %0.3f], A%0.3f, D%0.3f\n", GetTrkIndex(trk), trvTrk->pos.x, trvTrk->pos.y, pos0.x, pos0.y, trvTrk->angle, *distR ) )
+	pathCurr = 0;
+	for ( path = xx->pathCurr+strlen((char*)xx->pathCurr)+1; path[0] || path[1]; path++ ) {
+		if ( path[0] == 0 )
+			continue;
+		GetSegInxEP( path[0], &segInx, &segEP );
+		segPtr = xx->segs+segInx;
+#ifdef LATER
+	for ( inx = 0; inx<xx->segCnt; inx++ ) {
+		segPtr = xx->segs+inx;
+#endif
+		segProcData.distance.pos1 = pos0;
+		SegProc( SEGPROC_DISTANCE, segPtr, &segProcData );
+		if ( segProcData.distance.dd < d ) {
+			d = segProcData.distance.dd;
+			pos2 = segProcData.distance.pos1;
+			pathCurr = path;
+		}
+	}
+	if ( d > 10 || pathCurr == 0 ) {
+		ErrorMessage( "traverseTurnout: Not near: %0.3f", d );
+		return FALSE;
+	}
+LOG( log_traverseTurnout, 1, ( "  PC=%d ", pathCurr[0] ) )
+	GetSegInxEP( pathCurr[0], &segInx, &segEP );
+	segPtr = xx->segs+segInx;
+#ifdef LATER
+	for ( pathCurr = xx->pathCurr+strlen((char*)xx->pathCurr)+1; pathCurr[0] || pathCurr[1]; pathCurr++ ) {
+		if ( pathCurr[0] == 0 )
+			continue;
+		if ( Abs(pathCurr[0])-1 == currInx )
+			break;
+	}
+	if ( pathCurr[0] == 0 ) {
+		fprintf( stderr, "Open turnout [%d]\n", currInx );
+		return FALSE;
+	}
+	segPtr = xx->segs+currInx;
+#endif
+	segProcData.traverse1.pos = pos2;
+	segProcData.traverse1.angle = xx->angle-trvTrk->angle;
+	SegProc( SEGPROC_TRAVERSE1, segPtr, &segProcData );
+	dist += segProcData.traverse1.dist;
+	backwards = segProcData.traverse1.backwards;
+	if ( segEP ) backwards = !backwards;
+LOG( log_traverseTurnout, 2, ( " B%d D%0.3f\n", backwards, dist ) )
+
+	while ( *pathCurr ) {
+		GetSegInxEP( pathCurr[0], &segInx, &segEP );
+		segPtr = xx->segs+segInx;
+		segProcData.traverse2.segDir = (backwards?1-segEP:segEP);
+		segProcData.traverse2.dist = dist;
+		SegProc( SEGPROC_TRAVERSE2, segPtr, &segProcData );
+		if ( segProcData.traverse2.dist <= 0 ) {
+			*distR = 0;
+			REORIGIN( trvTrk->pos, segProcData.traverse2.pos, xx->angle, xx->orig );
+			trvTrk->angle = NormalizeAngle( xx->angle+segProcData.traverse2.angle );
+			return TRUE;
+		}
+		dist = segProcData.traverse2.dist;
+		pathCurr += (backwards?-1:1);
+LOG( log_traverseTurnout, 1, ( " D%0.3f\n", dist ) )
+	}
+
+	pathCurr += (backwards?1:-1);
+	pos1 = MapPathPos( xx, pathCurr[0], (backwards?0:1) );
+	*distR = dist;
+	epCnt = GetTrkEndPtCnt(trk);
+	ep = 0;
+	dist = FindDistance( pos1, GetTrkEndPos(trk,0) );
+	for ( ep2=1; ep2<epCnt; ep2++ ) {
+		d = FindDistance( pos1, GetTrkEndPos(trk,ep2) );
+		if ( d < dist ) {
+			dist = d;
+			ep = ep2;
+		}
+	}
+	if ( dist > connectDistance ) {
+		trk = NULL;
+		trvTrk->pos = pos1;
+	} else {
+		trvTrk->pos = GetTrkEndPos( trk, ep );
+		trvTrk->angle = GetTrkEndAngle( trk, ep );
+		trk = GetTrkEndTrk( trk, ep );
+	}
+	dist = FindDistance( trvTrk->pos, pos1 );
+LOG( log_traverseTurnout, 1, ( "  -> [%0.3f %0.3f] A%0.3f D%0.3f\n", trvTrk->pos.x, trvTrk->pos.y, trvTrk->angle, *distR ) )
+	trvTrk->trk = trk;
+	return TRUE;
+}
+
+
+static STATUS_T ModifyTurnout( track_p trk, wAction_t action, coOrd pos )
+{
+	struct extraData *xx;
+	static EPINX_T ep;
+	DIST_T d;
+
+	xx = GetTrkExtraData(trk);
+	if ( xx->special == TOadjustable ) {
+		switch ( action ) {
+		case C_DOWN:
+			ep = PickUnconnectedEndPoint( pos, trk );
+			if (ep == -1)
+				return C_ERROR;
+			UndrawNewTrack( trk );
+			tempSegs(0).type = SEG_STRTRK;
+			tempSegs(0).width = 0;
+			tempSegs(0).u.l.pos[0] = GetTrkEndPos( trk, 1-ep );
+			tempSegs_da.cnt = 1;
+			InfoMessage( _("Drag to change track length") );
+
+		case C_MOVE:
+			d = FindDistance( tempSegs(0).u.l.pos[0], pos );
+			if ( d < xx->u.adjustable.minD )
+				d = xx->u.adjustable.minD;
+			else if ( d > xx->u.adjustable.maxD )
+				d = xx->u.adjustable.maxD;
+			Translate( &tempSegs(0).u.l.pos[1], tempSegs(0).u.l.pos[0], GetTrkEndAngle( trk, ep ), d );
+			tempSegs_da.cnt = 1;
+			if (action == C_MOVE)
+				InfoMessage( _("Length=%s"), FormatDistance( d ) );
+			return C_CONTINUE;
+	
+		case C_UP:
+			d = FindDistance( tempSegs(0).u.l.pos[0],tempSegs(0).u.l.pos[1] );
+			ChangeAdjustableEndPt( trk, ep, d );
+			return C_TERMINATE;
+
+		default:
+			;
+		}
+	}
+	return ExtendStraightFromOrig( trk, action, pos );
+}
+
+
+static BOOL_T GetParamsTurnout( int inx, track_p trk, coOrd pos, trackParams_t * params )
+{
+	params->type = curveTypeStraight;
+	params->ep = PickUnconnectedEndPoint( pos, trk );
+	if (params->ep == -1)
+		 return FALSE;
+	params->lineOrig = GetTrkEndPos(trk,params->ep);
+	params->lineEnd = params->lineOrig;
+	params->len = 0.0;
+	params->angle = GetTrkEndAngle(trk,params->ep);
+	params->arcR = 0.0;
+	return TRUE;
+}
+
+
+static BOOL_T MoveEndPtTurnout( track_p *trk, EPINX_T *ep, coOrd pos, DIST_T d0 )
+{
+	ANGLE_T angle0;
+	DIST_T d;
+	track_p trk1;
+
+	angle0 = GetTrkEndAngle(*trk,*ep);
+	d = FindDistance( GetTrkEndPos(*trk,*ep), pos);
+	if (d0 > 0.0) {
+		d -= d0;
+		if (d < 0.0) {
+			ErrorMessage( MSG_MOVED_BEFORE_END_TURNOUT );
+			return FALSE;
+		}
+		Translate( &pos, pos, angle0+180, d0 );
+	}
+	if (d > minLength) {
+		trk1 = NewStraightTrack( GetTrkEndPos(*trk,*ep), pos );
+		CopyAttributes( *trk, trk1 );
+		ConnectTracks( *trk, *ep, trk1, 0 );
+		*trk = trk1;
+		*ep = 1;
+		DrawNewTrack( *trk );
+	}
+	return TRUE;
+}
+
+
+static BOOL_T QueryTurnout( track_p trk, int query )
+{
+	switch ( query ) {
+	case Q_IGNORE_EASEMENT_ON_EXTEND:
+	case Q_DRAWENDPTV_1:
+	case Q_CAN_GROUP:
+	case Q_ISTRACK:
+	case Q_NOT_PLACE_FROGPOINTS:
+	case Q_HAS_DESC:
+	case Q_MODIFY_REDRAW_DONT_UNDRAW_TRACK:
+		return TRUE;
+	case Q_CAN_PARALLEL:
+		if( GetTrkEndPtCnt( trk ) == 2 && fabs( GetTrkEndAngle( trk, 0 ) - GetTrkEndAngle( trk, 1 )) == 180.0 )
+			return TRUE;
+		else
+			return FALSE;
+	case Q_CAN_NEXT_POSITION:
+		return ( GetTrkEndPtCnt(trk) > 2 );
+	default:
+		return FALSE;
+	}
+}
+
+
+EXPORT int doDrawTurnoutPosition = 1;
+static wIndex_t drawTurnoutPositionWidth=3;
+static void DrawTurnoutPositionIndicator(
+		track_p trk,
+		wDrawColor color )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	PATHPTR_T path = xx->pathCurr;
+	coOrd pos0, pos1;
+
+	if ( xx->pathCurr == xx->paths ) {
+		for ( path=xx->pathCurr+strlen((char *)xx->pathCurr); path[0] || path[1]; path++ );
+		if ( path[2] == 0 )
+			return;
+	}
+	for ( path=xx->pathCurr+strlen((char *)xx->pathCurr); path[0] || path[1]; path++ ) {
+		if ( path[0] == 0 ) {
+			pos0 = MapPathPos( xx, path[1], 0 );
+		} else if ( path[1] == 0 ) {
+			pos1 = MapPathPos( xx, path[0], 1 );
+			DrawLine( &mainD, pos0, pos1, drawTurnoutPositionWidth, color );
+		}
+	}
+}
+
+
+EXPORT void AdvanceTurnoutPositionIndicator(
+		track_p trk,
+		coOrd pos,
+		coOrd *posR,
+		ANGLE_T *angleR )
+{
+	struct extraData * xx = GetTrkExtraData(trk);
+	PATHPTR_T path;
+	traverseTrack_t trvtrk;
+	DIST_T dist;
+
+	if ( GetTrkType(trk) != T_TURNOUT )
+		AbortProg( "nextTurnoutPosition" );
+
+	DrawTurnoutPositionIndicator( trk, wDrawColorWhite );
+	path = xx->pathCurr;
+	path += strlen((char *)path)+1;
+	while ( path[0] || path[1] )
+		path++;
+	path += 2;
+	if ( *path == 0 )
+		path = xx->paths;
+	xx->pathCurr = path;
+	DrawTurnoutPositionIndicator( trk, selectedColor );
+	if ( angleR == NULL || posR == NULL )
+		return;
+	trvtrk.trk = trk;
+	trvtrk.length = 0;
+	trvtrk.dist = 0;
+	trvtrk.pos = *posR;
+	trvtrk.angle = *angleR;
+	dist = 0;
+	if ( !TraverseTurnout( &trvtrk, &dist ) )
+		return;
+	if ( NormalizeAngle( trvtrk.angle-*angleR+90.0 ) > 180 )
+		trvtrk.angle = NormalizeAngle( trvtrk.angle+180.0 );
+	*posR = trvtrk.pos;
+	*angleR = trvtrk.angle;
+}
+
+/**
+ * Create a parallel track for a turnout.
+ * 
+ *
+ * \param trk IN existing track
+ * \param pos IN ??
+ * \param sep IN distance between existing and new track
+ * \param newTrk OUT new track piece
+ * \param p0R OUT starting point of new piece
+ * \param p1R OUT ending point of new piece
+ * \return    always TRUE
+ */
+
+static BOOL_T MakeParallelTurnout(
+		track_p trk,
+		coOrd pos,
+		DIST_T sep,
+		track_p * newTrk,
+		coOrd * p0R,
+		coOrd * p1R )
+{
+	ANGLE_T angle = GetTrkEndAngle(trk,1);
+	struct extraData *xx, *yy;
+	coOrd *endPts;
+	trkEndPt_p endPt;
+	int i;
+	int option;
+	DIST_T d;
+
+	if ( NormalizeAngle( FindAngle( GetTrkEndPos(trk,0), pos ) - GetTrkEndAngle(trk,1) ) < 180.0 )
+		angle += 90;
+	else
+		angle -= 90; 
+
+	/*
+	 * get all endpoints of current piece and translate them for the new piece
+	 */
+	endPts = MyMalloc( GetTrkEndPtCnt( trk ) * sizeof( coOrd ));
+	for( i = 0; i < GetTrkEndPtCnt( trk ); i++) {
+		Translate( &(endPts[ i ]), GetTrkEndPos( trk, i ), angle, sep );
+	}
+
+	/*
+	 * get information about the current piece and copy data 
+	 */
+
+	if( newTrk ) {
+		endPt = MyMalloc( GetTrkEndPtCnt( trk ) * sizeof( trkEndPt_t ));
+		endPt[ 0 ].pos = endPts[ 0 ];
+		endPt[ 0 ].angle = GetTrkEndAngle( trk, 0 );
+		endPt[ 1 ].pos = endPts[ 1 ];
+		endPt[ 1 ].angle = GetTrkEndAngle( trk, 1 ); 
+
+		yy = GetTrkExtraData(trk);
+
+		*newTrk = NewCompound( T_TURNOUT, 0, endPt[ 0 ].pos, endPt[ 0 ].angle + 90.0, yy->title, 2, endPt, yy->pathLen, (char *)yy->paths, yy->segCnt, yy->segs );
+		xx = GetTrkExtraData(*newTrk);
+		xx->customInfo = yy->customInfo;
+
+		/*	if (connection((int)curTurnoutEp).trk) {
+			CopyAttributes( connection((int)curTurnoutEp).trk, newTrk );
+			SetTrkScale( newTrk, curScaleInx );
+		} */
+		xx->special = yy->special;
+		xx->u = yy->u;
+
+		SetDescriptionOrig( *newTrk );
+		xx->descriptionOff = zero;
+		xx->descriptionSize = zero;
+
+		SetTrkElev(*newTrk, GetTrkElevMode(trk), GetTrkElev(trk));
+		GetTrkEndElev( trk, 0, &option, &d );
+		SetTrkEndElev( *newTrk, 0, option, d, NULL );
+		GetTrkEndElev( trk, 1, &option, &d );
+		SetTrkEndElev( *newTrk, 1, option, d, NULL );
+
+		MyFree( endPt );
+	} else { 
+		/* draw some temporary track while command is in process */
+		tempSegs(0).color = wDrawColorBlack;
+		tempSegs(0).width = 0;
+		tempSegs_da.cnt = 1;
+		tempSegs(0).type = SEG_STRTRK;
+		tempSegs(0).u.l.pos[0] = endPts[ 0 ];
+		tempSegs(0).u.l.pos[1] = endPts[ 1 ];
+	}
+
+	if ( p0R ) *p0R = endPts[ 0 ];
+	if ( p1R ) *p1R = endPts[ 1 ];
+
+	MyFree( endPts );
+	return TRUE;
+}
+
+static trackCmd_t turnoutCmds = {
+		N_("TURNOUT "),
+		DrawTurnout,
+		DistanceCompound,
+		DescribeCompound,
+		DeleteCompound,
+		WriteCompound,
+		ReadTurnout,
+		MoveCompound,
+		RotateCompound,
+		RescaleCompound,
+		NULL,
+		GetAngleTurnout,
+		SplitTurnout,
+		TraverseTurnout,
+		EnumerateCompound,
+		NULL, /*redraw*/
+		NULL, /*trim*/
+		NULL, /*merge*/
+		ModifyTurnout,
+		NULL, /* getLength */
+		GetParamsTurnout,
+		MoveEndPtTurnout,
+		QueryTurnout,
+		UngroupCompound,
+		FlipCompound,
+		DrawTurnoutPositionIndicator,
+		AdvanceTurnoutPositionIndicator,
+		CheckTraverseTurnout,
+		MakeParallelTurnout };
+
+
+#ifdef TURNOUTCMD
+/*****************************************
+ *
+ *   Turnout Dialog
+ *
+ */
+
+static coOrd maxTurnoutDim;
+
+static void AddTurnout( void );
+
+
+static wWin_p turnoutW;
+
+
+static void RescaleTurnout( void )
+{
+	DIST_T xscale, yscale;
+	wPos_t ww, hh;
+	DIST_T w, h;
+	wDrawGetSize( turnoutD.d, &ww, &hh );
+	w = ww/turnoutD.dpi;
+	h = hh/turnoutD.dpi;
+	xscale = maxTurnoutDim.x/w;
+	yscale = maxTurnoutDim.y/h;
+	turnoutD.scale = max(xscale,yscale);
+	if (turnoutD.scale == 0.0)
+		turnoutD.scale = 1.0;
+	turnoutD.size.x = w*turnoutD.scale;
+	turnoutD.size.y = h*turnoutD.scale;
+	return;
+}
+
+
+static void TurnoutChange( long changes )
+{
+	static char * lastScaleName = NULL;
+	if (turnoutW == NULL)
+		return;
+	wListSetIndex( turnoutListL, 0 );
+	if ( (!wWinIsVisible(turnoutW)) ||
+	   ( ((changes&CHANGE_SCALE) == 0 || lastScaleName == curScaleName) &&
+		  (changes&CHANGE_PARAMS) == 0 ) )
+		return;
+	lastScaleName = curScaleName;
+	curTurnout = NULL;
+	curTurnoutEp = 0;
+	wControlShow( (wControl_p)turnoutListL, FALSE );
+	wListClear( turnoutListL );
+	maxTurnoutDim.x = maxTurnoutDim.y = 0.0;
+	if (turnoutInfo_da.cnt <= 0)
+		return;
+	curTurnout = TurnoutAdd( LABEL_TABBED|LABEL_MANUF|LABEL_PARTNO|LABEL_DESCR, curScaleInx, turnoutListL, &maxTurnoutDim, -1 );
+	wListSetIndex( turnoutListL, 0 );
+	wControlShow( (wControl_p)turnoutListL, TRUE );
+	if (curTurnout == NULL) {
+		wDrawClear( turnoutD.d );
+		return;
+	}
+	turnoutD.orig.x = -trackGauge;
+	turnoutD.orig.y = -trackGauge;
+	maxTurnoutDim.x += 2*trackGauge;
+	maxTurnoutDim.y += 2*trackGauge;
+	/*RescaleTurnout();*/
+	RedrawTurnout();
+	return;
+}
+
+static void RedrawTurnout()
+{
+	coOrd p, s;
+	RescaleTurnout();
+LOG( log_turnout, 2, ( "SelTurnout(%s)\n", (curTurnout?curTurnout->title:"<NULL>") ) )
+
+	wDrawClear( turnoutD.d );
+	if (curTurnout == NULL) {
+		return;
+	}
+	turnoutD.orig.x = curTurnout->orig.x - trackGauge;
+	turnoutD.orig.y = (curTurnout->size.y + curTurnout->orig.y) - turnoutD.size.y + trackGauge;
+	DrawSegs( &turnoutD, zero, 0.0, curTurnout->segs, curTurnout->segCnt,
+					 trackGauge, wDrawColorBlack );
+	curTurnoutEp = 0;
+	p.x = curTurnout->endPt[0].pos.x - trackGauge;
+	p.y = curTurnout->endPt[0].pos.y - trackGauge;
+	s.x = s.y = trackGauge*2.0 /*+ turnoutD.minSize*/;
+	DrawHilight( &turnoutD, p, s );
+}
+
+
+static void TurnoutOk( void )
+{
+	AddTurnout();
+	Reset();
+}
+
+
+static void TurnoutDlgUpdate(
+		paramGroup_p pg,
+		int inx,
+		void * valueP )
+{
+	turnoutInfo_t * to;
+	if ( inx != I_LIST ) return;
+	to = (turnoutInfo_t*)wListGetItemContext( (wList_p)pg->paramPtr[inx].control, (wIndex_t)*(long*)valueP );
+	AddTurnout();
+	curTurnout = to;
+	RedrawTurnout();
+/*	ParamDialogOkActive( &turnoutPG, FALSE ); */
+}
+
+
+static wIndex_t TOpickEndPoint(
+		coOrd p,
+		turnoutInfo_t *to )
+{
+	wIndex_t inx, i;
+	DIST_T d, dd;
+	coOrd posI;
+
+	d = FindDistance( p, to->endPt[0].pos );
+	inx = 0;
+	for ( i=1; i<to->endCnt; i++ ) {
+		posI = to->endPt[i].pos;
+		if ((dd=FindDistance(p, posI)) < d) {
+			d = dd;
+			inx = i;
+		}
+	}
+	return inx;
+}
+
+
+static void HilightEndPt( void )
+{
+	coOrd p, s;
+	p.x = curTurnout->endPt[(int)curTurnoutEp].pos.x - trackGauge;
+	p.y = curTurnout->endPt[(int)curTurnoutEp].pos.y - trackGauge;
+	s.x = s.y = trackGauge*2.0 /*+ turnoutD.minSize*/;
+	DrawHilight( &turnoutD, p, s );
+}
+
+
+static void SelTurnoutEndPt(
+		wIndex_t action,
+		coOrd pos )
+{
+	if (action != C_DOWN) return;
+
+	HilightEndPt();
+	curTurnoutEp = TOpickEndPoint( pos, curTurnout );
+	HilightEndPt();
+LOG( log_turnout, 3, (" selected (action=%d) %ld\n", action, curTurnoutEp ) )
+}
+#endif
+
+/****************************************
+ *
+ * GRAPHICS COMMANDS
+ *
+ */
+
+/*
+ * STATE INFO
+ */
+static struct {
+		int state;
+		coOrd pos;
+		coOrd place;
+		track_p trk;
+		ANGLE_T angle;
+		coOrd rot0, rot1;
+		} Dto;
+
+
+typedef struct {
+		DIST_T off;
+		ANGLE_T angle;
+		EPINX_T ep;
+		} vector_t;
+
+static void PlaceTurnoutTrial(
+		track_p *trkR,
+		coOrd *posR,
+		ANGLE_T *angle1R,
+		ANGLE_T *angle2R,
+		int *connCntR,
+		DIST_T *maxDR,
+		vector_t *v )
+{
+	coOrd pos = *posR;
+	ANGLE_T aa;
+	ANGLE_T angle;
+	EPINX_T ep0, ep1;
+	track_p trk, trk1;
+	coOrd epPos, conPos, posI;
+	ANGLE_T epAngle;
+	int i, connCnt = 0;
+	DIST_T d, maxD = 0;
+
+	if ( (*trkR = trk = OnTrack( &pos, FALSE, TRUE )) != NULL &&
+		 !QueryTrack(trk,Q_CANNOT_PLACE_TURNOUT) &&
+		 (ep0 = PickEndPoint( pos, trk )) >= 0 &&
+		 ! ( GetTrkType(trk) == T_TURNOUT &&
+			 (trk1=GetTrkEndTrk(trk,ep0)) &&
+			 GetTrkType(trk1) == T_TURNOUT) &&
+		 ! GetLayerFrozen(GetTrkLayer(trk)) ) {
+		epPos = GetTrkEndPos( trk, ep0 );
+		d = FindDistance( pos, epPos );
+		if (d <= minLength)
+			pos = epPos;
+		if ( GetTrkType(trk) == T_TURNOUT ) {
+			ep0 = ep1 = PickEndPoint( pos, trk );
+			angle = GetTrkEndAngle( trk, ep0 );
+		} else {
+			angle = GetAngleAtPoint( trk, pos, &ep0, &ep1 );
+		}
+		angle = NormalizeAngle( angle + 180.0 );
+		if ( NormalizeAngle( FindAngle( pos, *posR ) - angle ) < 180.0 && ep0 != ep1 )
+			angle = NormalizeAngle( angle + 180 );
+		*angle2R = angle;
+		epPos = curTurnout->endPt[(int)curTurnoutEp].pos;
+		*angle1R = angle = NormalizeAngle( angle - curTurnout->endPt[(int)curTurnoutEp].angle );
+		Rotate( &epPos, zero, angle );
+		pos.x -= epPos.x;
+		pos.y -= epPos.y;
+		*posR = pos;
+LOG( log_turnout, 3, ( "placeTurnout T%d (%0.3f %0.3f) A%0.3f\n",
+				GetTrkIndex(trk), pos.x, pos.y, angle ) )
+		/*InfoMessage( "Turnout(%d): Angle=%0.3f", GetTrkIndex(trk), angle );*/
+
+		for (i=0;i<curTurnout->endCnt;i++) {
+			posI = curTurnout->endPt[i].pos;
+			epPos = AddCoOrd( pos, posI, angle );
+			epAngle = NormalizeAngle( curTurnout->endPt[i].angle + angle );
+			conPos = epPos;
+			if ((trk = OnTrack(&conPos, FALSE, TRUE)) != NULL &&
+				!GetLayerFrozen(GetTrkLayer(trk))) {
+				v->off = FindDistance( epPos, conPos );
+				v->angle = FindAngle( epPos, conPos );
+				if ( GetTrkType(trk) == T_TURNOUT ) {
+					ep0 = ep1 = PickEndPoint( conPos, trk );
+					aa = GetTrkEndAngle( trk, ep0 );
+				} else {
+					aa = GetAngleAtPoint( trk, conPos, &ep0, &ep1 );
+				}
+				v->ep = i;
+				aa = NormalizeAngle( aa - epAngle + connectAngle/2.0 );
+				if ( IsClose(v->off) &&
+					 ( aa<connectAngle || ( aa>180.0 && aa<180.0+connectAngle ) ) &&
+					 ! ( GetTrkType(trk) == T_TURNOUT &&
+						 (trk1=GetTrkEndTrk(trk,ep0)) &&
+						 GetTrkType(trk1) == T_TURNOUT ) ) {
+					if (v->off > maxD)
+						maxD = v->off;
+					connCnt++;
+					v++;
+				}
+			}
+		}
+	}
+	*connCntR = connCnt;
+	*maxDR = maxD;
+}
+
+
+static void PlaceTurnout(
+		coOrd pos )
+{
+	coOrd p, pos1, pos2;
+	track_p trk1, trk2;
+	ANGLE_T a, a1, a2, a3;
+	int i, connCnt1, connCnt2;
+	DIST_T d, maxD1, maxD2, sina;
+	vector_t *V, * maxV;
+
+	static dynArr_t vector_da;
+#define vector(N) DYNARR_N( vector_t, vector_da, N )
+	
+	pos1 = Dto.place = Dto.pos = pos;
+	if (curTurnoutEp >= (long)curTurnout->endCnt)
+		curTurnoutEp = 0;
+	DYNARR_SET( vector_t, vector_da, curTurnout->endCnt );
+	PlaceTurnoutTrial( &trk1, &pos1, &a1, &a2, &connCnt1, &maxD1, &vector(0) );
+	if (connCnt1 > 0) {
+		Dto.pos = pos1;
+		Dto.trk = trk1;
+		Dto.angle = a1;
+		if ( (MyGetKeyState()&WKEY_SHIFT)==0 && connCnt1 > 1 && maxD1 >= 0.001 ) {
+			maxV = &vector(0);
+			for ( i=1; i<connCnt1; i++ ) {
+				V = &vector(i);
+				if ( V->off > maxV->off ) {
+					maxV = V;
+				}
+			}
+			a3 = NormalizeAngle( Dto.angle + curTurnout->endPt[maxV->ep].angle );
+			a = NormalizeAngle( a2 - a3 );
+			sina = sin(D2R(a));
+			if (fabs(sina) > 0.01) {
+				d = maxV->off/sina;
+				if (NormalizeAngle( maxV->angle - a3) > 180)
+					d = -d;
+				Translate( &pos2, pos, a2, d );
+				PlaceTurnoutTrial( &trk2, &pos2, &a2, &a, &connCnt2, &maxD2, &vector(0) );
+				if ( connCnt2 >= connCnt1 && maxD2 < maxD1 ) {
+					Dto.pos = pos2;
+					Dto.trk = trk2;
+					Dto.angle = a2;
+					maxD1 = maxD2;
+					connCnt1 = connCnt2;
+				}
+			}
+		}
+	}
+	if ( connCnt1 > 0 ) {
+		FormatCompoundTitle( listLabels, curTurnout->title );
+		InfoMessage( _("%d connections, max distance %0.3f (%s)"),
+				connCnt1, PutDim(maxD1), message );
+	} else {
+		Dto.trk = NULL;
+		FormatCompoundTitle( listLabels, curTurnout->title );
+		InfoMessage( _("0 connections (%s)"), message );
+		p = curTurnout->endPt[(int)curTurnoutEp].pos;
+		Rotate( &p, zero, Dto.angle );
+		Dto.pos.x = pos.x - p.x;
+		Dto.pos.y = pos.y - p.y;
+	}
+}
+
+static void AddTurnout( void )
+{
+	track_p newTrk;
+	track_p trk, trk1;
+	struct extraData *xx;
+	coOrd epPos;
+	DIST_T d;
+	ANGLE_T a, aa;
+	EPINX_T ep0, ep1, epx, epy;
+	wIndex_t i,j;
+	wIndex_t titleLen;
+	typedef struct {
+		track_p trk;
+		EPINX_T ep;
+		} junk_t;
+	static dynArr_t connection_da;
+	static dynArr_t leftover_da;
+#define connection(N) DYNARR_N( junk_t, connection_da, N )
+#define leftover(N) DYNARR_N( junk_t, leftover_da, N )
+	BOOL_T visible;
+	BOOL_T noConnections;
+	coOrd p0, p1;
+
+	if (Dto.state == 0)
+		return;
+
+	if (curTurnout->segCnt < 1 || curTurnout->endCnt < 1) {
+		AbortProg( "addTurnout: bad cnt" );
+	}
+
+	DrawSegs( &tempD, Dto.pos, Dto.angle,
+		curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlack );
+	UndoStart( _("Place New Turnout"), "addTurnout" );
+	titleLen = strlen( curTurnout->title );
+#ifdef LATER
+	newTrk = NewTrack( 0, T_TURNOUT, curTurnout->endCnt, sizeof (*xx) + 1 );
+	xx = GetTrkExtraData(newTrk);
+	xx->orig = Dto.pos;
+	xx->angle = Dto.angle;
+	xx->customInfo = curTurnout->customInfo;
+	xx->segs = MyMalloc( (curTurnout->segCnt)*sizeof curTurnout->segs[0] );
+#endif
+
+	DYNARR_SET( trkEndPt_t, tempEndPts_da, curTurnout->endCnt );
+	DYNARR_SET( junk_t, connection_da, curTurnout->endCnt );
+	DYNARR_SET( junk_t, leftover_da, curTurnout->endCnt );
+
+	for (i=0; i<curTurnout->endCnt; i++ ) {
+		coOrd posI;
+		posI = curTurnout->endPt[i].pos;
+		tempEndPts(i).pos = AddCoOrd( Dto.pos, posI, Dto.angle );
+		tempEndPts(i).angle = NormalizeAngle( curTurnout->endPt[i].angle + Dto.angle );
+	}
+
+	AuditTracks( "addTurnout begin" );
+
+	for (i=0;i<curTurnout->endCnt;i++) {
+		AuditTracks( "addTurnout [%d]", i );
+		connection(i).trk = leftover(i).trk = NULL;
+		/* connect each endPt ... */
+		epPos = tempEndPts(i).pos;
+		if ((trk = OnTrack(&epPos, FALSE, TRUE)) != NULL &&
+			(!GetLayerFrozen(GetTrkLayer(trk))) &&
+			(!QueryTrack(trk,Q_CANNOT_PLACE_TURNOUT)) ) {
+LOG( log_turnout, 1, ( "ep[%d] on T%d @(%0.3f %0.3f)\n",
+					i, GetTrkIndex(trk), epPos.x, epPos.y ) )
+			d = FindDistance( tempEndPts(i).pos, epPos );
+			if ( GetTrkType(trk) == T_TURNOUT ) {
+				ep0 = ep1 = PickEndPoint( epPos, trk );
+				a = GetTrkEndAngle( trk, ep0 );
+			} else {
+				a = GetAngleAtPoint( trk, epPos, &ep0, &ep1 );
+			}
+			aa = NormalizeAngle( a - tempEndPts(i).angle + connectAngle/2.0 );
+			if ( IsClose(d) && 
+				 ( (ep0!=ep1 && aa<connectAngle) ||
+				   ( aa>180.0 && aa<180.0+connectAngle ) ) &&
+				   ! ( GetTrkType(trk) == T_TURNOUT &&
+				       (trk1=GetTrkEndTrk(trk,ep0)) &&
+					   GetTrkType(trk1) == T_TURNOUT ) ) {
+				/* ... if they are close to a track and line up */
+				if (aa<connectAngle) {
+				   epx = ep1;
+				   epy = ep0;
+				} else {
+				   epx = ep0;
+				   epy = ep1;
+				}
+LOG( log_turnout, 1, ( "   Attach! epx=%d\n", epx ) )
+				if ( epx != epy &&
+					(d=FindDistance(GetTrkEndPos(trk,epy), epPos)) < minLength &&
+					(trk1=GetTrkEndTrk(trk,epy)) != NULL ) {
+					epx = GetEndPtConnectedToMe( trk1, trk );
+					trk = trk1;
+				}
+				/* split the track at the intersection point */
+		AuditTracks( "addTurnout [%d] before splitTrack", i );
+				if (SplitTrack( trk, epPos, epx, &leftover(i).trk, TRUE )) {
+		AuditTracks( "addTurnout [%d], after splitTrack", i );
+					/* remember so we can fix up connection later */
+					connection(i).trk = trk;
+					connection(i).ep = epx;
+					if (leftover(i).trk != NULL) {
+						leftover(i).ep = PickEndPoint( epPos, leftover(i).trk );
+						/* did we already split this track? */
+						for (j=0;j<i;j++) {
+							if ( leftover(j).trk == leftover(i).trk ) {
+								leftover(i).trk = NULL;
+								break;
+							}
+							if ( leftover(j).trk == connection(i).trk ) {
+								/* yes.  Remove the leftover piece */
+LOG( log_turnout, 1, ( "   deleting leftover T%d\n",
+										GetTrkIndex(leftover(i).trk) ) )
+								leftover(j).trk = NULL;
+		AuditTracks( "addTurnout [%d] before delete", i );
+								DeleteTrack( leftover(i).trk, FALSE );
+		AuditTracks( "addTurnout [%d] before delete", i );
+								leftover(i).trk = NULL;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	AuditTracks( "addTurnout after loop" );
+
+	/*
+	 * copy data */
+	newTrk = NewCompound( T_TURNOUT, 0, Dto.pos, Dto.angle, curTurnout->title, tempEndPts_da.cnt, &tempEndPts(0), curTurnout->pathLen, (char *)curTurnout->paths, curTurnout->segCnt, curTurnout->segs );
+	xx = GetTrkExtraData(newTrk);
+	xx->customInfo = curTurnout->customInfo;
+	if (connection((int)curTurnoutEp).trk) {
+		CopyAttributes( connection((int)curTurnoutEp).trk, newTrk );
+		SetTrkScale( newTrk, curScaleInx );
+	}
+	xx->special = curTurnout->special;
+	xx->u = curTurnout->u;
+#ifdef LATER
+	xx->segCnt = curTurnout->segCnt;
+	memcpy( xx->segs, curTurnout->segs, xx->segCnt * sizeof *(trkSeg_p)0 );
+	xx->title = curTurnout->title;
+	xx->paths = xx->pathCurr = curTurnout->paths;
+	xx->pathLen = curTurnout->pathLen;
+#endif
+
+	/* Make the connections */
+#ifdef LATER
+	for (i=0; i<curTurnout->endCnt; i++)
+		SetTrkEndPoint( newTrk, i, tempEndPts(i).pos, tempEndPts(i).angle );
+#endif
+	visible = FALSE;
+	noConnections = TRUE;
+	AuditTracks( "addTurnout T%d before connection", GetTrkIndex(newTrk) );
+	for (i=0;i<curTurnout->endCnt;i++) {
+		if ( connection(i).trk != NULL ) {
+			p0 = GetTrkEndPos( newTrk, i );
+			p1 = GetTrkEndPos( connection(i).trk, connection(i).ep );
+			d = FindDistance( p0, p1 );
+			if ( d < connectDistance ) {
+				noConnections = FALSE;
+				trk1 = connection(i).trk;
+				ep0 = connection(i).ep;
+				DrawEndPt( &mainD, trk1, ep0, wDrawColorWhite );
+				ConnectTracks( newTrk, i, trk1, ep0 );
+				visible |= GetTrkVisible(trk1);
+				DrawEndPt( &mainD, trk1, ep0, wDrawColorBlack );
+			}
+		}
+	}
+	if (noConnections)
+		visible = TRUE;
+	SetTrkVisible( newTrk, visible);
+#ifdef LATER
+	SetTrkScale( newTrk, curScaleInx );
+	ComputeCompoundBoundingBox( newTrk );
+#endif
+
+	AuditTracks( "addTurnout T%d before dealing with leftovers", GetTrkIndex(newTrk) );
+	/* deal with the leftovers */
+	for (i=0;i<curTurnout->endCnt;i++) {
+		if ( (trk=leftover(i).trk) != NULL && !IsTrackDeleted(trk) ) {
+			/* move endPt beyond the turnout */
+			/* it it is short then delete it */
+			coOrd off;
+			DIST_T maxX;
+			track_p lt = leftover(i).trk;
+			EPINX_T ep, le = leftover(i).ep;
+			coOrd pos;
+			maxX = 0.0;
+			a = NormalizeAngle( GetTrkEndAngle(lt,le) + 180.0 );
+			for (ep=0; ep<curTurnout->endCnt; ep++) {
+				FindPos( &off, NULL, GetTrkEndPos(newTrk,ep), GetTrkEndPos(lt,le), a, 100000.0 );
+				if (off.x > maxX)
+					maxX = off.x;
+			}
+			maxX += trackGauge;
+			pos = Dto.pos;
+	AuditTracks( "addTurnout T%d[%d] before trimming L%d[%d]", GetTrkIndex(newTrk), i, GetTrkIndex(lt), le );
+			TrimTrack( lt, le, maxX );
+	AuditTracks( "addTurnout T%d[%d] after trimming L%d[%d]", GetTrkIndex(newTrk), i, GetTrkIndex(lt), le );
+		}
+	}
+
+	SetDescriptionOrig( newTrk );
+	xx->descriptionOff = zero;
+	xx->descriptionSize = zero;
+
+	DrawNewTrack( newTrk );
+
+	AuditTracks( "addTurnout T%d returns", GetTrkIndex(newTrk) );
+	UndoEnd();
+	Dto.state = 0;
+	Dto.trk = NULL;
+	Dto.angle = 0.0;
+}
+
+
+static void TurnoutRotate( void * pangle )
+{
+	ANGLE_T angle = (ANGLE_T)(long)pangle;
+	if (Dto.state == 1)
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+			curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlack );
+	else
+		Dto.pos = cmdMenuPos;
+	Rotate( &Dto.pos, cmdMenuPos, angle );
+	Dto.angle += angle;
+	DrawSegs( &tempD, Dto.pos, Dto.angle,
+		curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlack );
+	Dto.state = 1;
+}
+	
+/**
+ * Process the mouse events for laying track.
+ *
+ * \param action IN event type
+ * \param pos    IN mouse position 
+ * \return    		next state
+ */
+
+EXPORT STATUS_T CmdTurnoutAction(
+		wAction_t action,
+		coOrd pos )
+{
+	ANGLE_T angle;
+	static BOOL_T validAngle;
+	static ANGLE_T baseAngle;
+	static coOrd origPos;
+#ifdef NEWROTATE
+	static ANGLE_T origAngle;
+#endif
+	switch (action & 0xFF) {
+
+	case C_START:
+		Dto.state = 0;
+		Dto.trk = NULL;
+		Dto.angle = 0.0;
+		return C_CONTINUE;
+
+	case C_DOWN:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		if (Dto.state == 1) {
+			DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		}
+		PlaceTurnout( pos );
+		Dto.state = 1;
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		return C_CONTINUE;
+
+	case C_MOVE:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		if ( curTurnoutEp >= (long)curTurnout->endCnt )
+			curTurnoutEp = 0;
+		if (Dto.state == 1) {
+			DrawSegs( &tempD, Dto.pos, Dto.angle,
+					curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		} else {
+			Dto.state = 1;
+		}
+		PlaceTurnout( pos );
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		return C_CONTINUE;
+
+	case C_UP:
+		InfoMessage( _("Left drag to move, right drag to rotate, press Space or Return to fix track in place or Esc to cancel") );
+		return C_CONTINUE;
+
+	case C_RDOWN:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		if (Dto.state == 1)
+			DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		else
+			Dto.pos = pos;
+		Dto.rot0 = Dto.rot1 = pos;
+		DrawLine( &tempD, Dto.rot0, Dto.rot1, 0, wDrawColorBlack );
+		Dto.state = 1;
+		origPos = Dto.pos;
+#ifdef NEWROTATE
+		origAngle = Dto.angle;
+#else
+		Rotate( &origPos, Dto.rot0, -(Dto.angle + curTurnout->endPt[(int)curTurnoutEp].angle) );
+#endif
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		validAngle = FALSE;
+		return C_CONTINUE;
+
+	case C_RMOVE:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		DrawLine( &tempD, Dto.rot0, Dto.rot1, 0, wDrawColorBlack );
+		Dto.rot1 = pos;
+		if ( FindDistance(Dto.rot0, Dto.rot1) > 0.1*mainD.scale ) {
+			angle = FindAngle( Dto.rot0, Dto.rot1 );
+			if (!validAngle) {
+				baseAngle = angle/* - Dto.angle*/;
+				validAngle = TRUE;
+			}
+			Dto.pos = origPos;
+#ifdef NEWROTATE
+			angle -= baseAngle;
+			Dto.angle = NormalizeAngle( origAngle + angle );
+#else
+			angle += 180.0;
+			Dto.angle = angle - curTurnout->endPt[(int)curTurnoutEp].angle;
+#endif
+			Rotate( &Dto.pos, Dto.rot0, angle );
+		}
+		FormatCompoundTitle( listLabels, curTurnout->title );
+		InfoMessage( _("Angle = %0.3f (%s)"), PutAngle( NormalizeAngle(Dto.angle + 90.0) ), message );
+		DrawLine( &tempD, Dto.rot0, Dto.rot1, 0, wDrawColorBlack );
+		DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		return C_CONTINUE;
+
+	case C_RUP:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		DrawLine( &tempD, Dto.rot0, Dto.rot1, 0, wDrawColorBlack );
+		InfoMessage( _("Left drag to move, right drag to rotate, press Space or Return to fix track in place or Esc to cancel") );
+		return C_CONTINUE;
+
+	case C_LCLICK:
+		if ( curTurnout == NULL ) return C_CONTINUE;
+		if ( MyGetKeyState() & WKEY_SHIFT ) {
+			if (Dto.state == 1)
+				DrawSegs( &tempD, Dto.pos, Dto.angle,
+					curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+			angle = curTurnout->endPt[(int)curTurnoutEp].angle;
+			curTurnoutEp++;
+			if (curTurnoutEp >= (long)curTurnout->endCnt)
+				curTurnoutEp = 0;
+			if (Dto.trk == NULL)
+				Dto.angle = NormalizeAngle( Dto.angle + (angle - curTurnout->endPt[(int)curTurnoutEp].angle ) );
+			PlaceTurnout( Dto.place );
+			if (Dto.state == 1)
+				DrawSegs( &tempD, Dto.pos, Dto.angle,
+					curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		} else {
+			CmdTurnoutAction( C_DOWN, pos );
+			CmdTurnoutAction( C_UP, pos );
+		}
+		return C_CONTINUE;
+
+	case C_REDRAW:
+		if (Dto.state)
+			DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		return C_CONTINUE;
+
+	case C_CANCEL:
+		if (Dto.state)
+			DrawSegs( &tempD, Dto.pos, Dto.angle,
+				curTurnout->segs, curTurnout->segCnt, trackGauge, wDrawColorBlue );
+		Dto.state = 0;
+		Dto.trk = NULL;
+		/*wHide( newTurn.reg.win );*/
+		return C_TERMINATE;
+
+	case C_TEXT:
+		if ((action>>8) != ' ') 
+			return C_CONTINUE;
+	case C_OK:
+		AddTurnout();
+		return C_TERMINATE;
+
+	case C_FINISH:
+		if (Dto.state != 0 && Dto.trk != NULL)
+			CmdTurnoutAction( C_OK, pos );
+		else
+			CmdTurnoutAction( C_CANCEL, pos );
+		return C_TERMINATE;
+
+	case C_CMDMENU:
+		if ( turnoutPopupM == NULL ) {
+			turnoutPopupM = MenuRegister( "Turnout Rotate" );
+			AddRotateMenu( turnoutPopupM, TurnoutRotate );
+		}
+		wMenuPopupShow( turnoutPopupM );
+		return C_CONTINUE;
+
+	default:
+		return C_CONTINUE;
+	}
+}
+
+
+#ifdef TURNOUTCMD
+static STATUS_T CmdTurnout(
+		wAction_t action,
+		coOrd pos )
+{
+	wIndex_t turnoutIndex;
+	turnoutInfo_t * turnoutPtr;
+
+	switch (action & 0xFF) {
+
+	case C_START:
+		if (turnoutW == NULL) {
+/*			turnoutW = ParamCreateDialog( &turnoutPG, MakeWindowTitle("Turnout"), "Ok", , (paramActionCancelProc)Reset, TRUE, NULL, F_RESIZE|F_RECALLSIZE, TurnoutDlgUpdate ); */
+			turnoutW = ParamCreateDialog( &turnoutPG, MakeWindowTitle(_("Turnout")), _("Close"), (paramActionOkProc)TurnoutOk, NULL, TRUE, NULL, F_RESIZE|F_RECALLSIZE|PD_F_ALT_CANCELLABEL, TurnoutDlgUpdate ); 
+			InitNewTurn( turnoutNewM );
+		}
+/*		ParamDialogOkActive( &turnoutPG, FALSE ); */
+		turnoutIndex = wListGetIndex( turnoutListL );
+		turnoutPtr = curTurnout;
+		wShow( turnoutW );
+		TurnoutChange( CHANGE_PARAMS|CHANGE_SCALE );
+		if (curTurnout == NULL) {
+			NoticeMessage2( 0, MSG_TURNOUT_NO_TURNOUT, _("Ok"), NULL );
+			return C_TERMINATE;
+		}
+		if (turnoutIndex > 0 && turnoutPtr) {
+			curTurnout = turnoutPtr;
+			wListSetIndex( turnoutListL, turnoutIndex );
+			RedrawTurnout();
+		}
+		InfoMessage( _("Pick turnout and active End Point, then place on the layout"));
+		ParamLoadControls( &turnoutPG );
+		ParamGroupRecord( &turnoutPG );
+		return CmdTurnoutAction( action, pos );
+
+	case C_DOWN:
+	case C_RDOWN:
+		ParamDialogOkActive( &turnoutPG, TRUE );
+		if (hideTurnoutWindow)
+			wHide( turnoutW );
+	case C_MOVE:
+	case C_RMOVE:
+		return CmdTurnoutAction( action, pos );
+
+	case C_UP:
+	case C_RUP:
+		if (hideTurnoutWindow)
+			wShow( turnoutW );
+		InfoMessage( _("Left drag to move, right drag to rotate, press Space or Return to fix track in place or Esc to cancel") );
+		return CmdTurnoutAction( action, pos );
+
+	case C_LCLICK:
+		HilightEndPt();
+		CmdTurnoutAction( action, pos );
+		HilightEndPt();
+		return C_CONTINUE;
+
+	case C_CANCEL:
+		wHide( turnoutW );
+		return CmdTurnoutAction( action, pos );
+	case C_TEXT:
+		CmdTurnoutAction( action, pos );
+		return C_CONTINUE;
+	case C_OK:
+	case C_FINISH:
+	case C_CMDMENU:
+	case C_REDRAW:
+		return CmdTurnoutAction( action, pos );
+
+	default:
+		return C_CONTINUE;
+	}
+}
+
+#endif
+
+/**
+ * Event procedure for the hotbar.
+ *
+ * \param op   IN requested function
+ * \param data IN	pointer to info on selected element	
+ * \param d    IN
+ * \param origP IN
+ * \return   
+ */
+
+static char * CmdTurnoutHotBarProc(
+		hotBarProc_e op,
+		void * data,
+		drawCmd_p d,
+		coOrd * origP )
+{
+	turnoutInfo_t * to = (turnoutInfo_t*)data;
+	switch ( op ) {
+	case HB_SELECT:		/* new element is selected */
+		CmdTurnoutAction( C_FINISH, zero ); 		/* finish current operation */
+		curTurnout = to;
+		DoCommandB( (void*)(intptr_t)turnoutHotBarCmdInx ); /* continue with new turnut / structure */
+		return NULL;
+	case HB_LISTTITLE:
+		FormatCompoundTitle( listLabels, to->title );
+		if (message[0] == '\0')
+			FormatCompoundTitle( listLabels|LABEL_DESCR, to->title );
+		return message;
+	case HB_BARTITLE:
+		FormatCompoundTitle( hotBarLabels<<1, to->title );
+		return message;
+	case HB_FULLTITLE:
+		return to->title;
+	case HB_DRAW:
+		DrawSegs( d, *origP, 0.0, to->segs, to->segCnt, trackGauge, wDrawColorBlack );
+		return NULL;
+	}
+	return NULL;
+}
+
+
+EXPORT void AddHotBarTurnouts( void )
+{
+	wIndex_t inx;
+	turnoutInfo_t * to;
+	for ( inx=0; inx < turnoutInfo_da.cnt; inx ++ ) {
+		to = turnoutInfo(inx);
+		if ( !( IsParamValid(to->paramFileIndex) &&
+				to->segCnt > 0 &&
+				CompatibleScale( TRUE, to->scaleInx, curScaleInx ) ) )
+				continue;
+		AddHotBarElement( to->contentsLabel, to->size, to->orig, TRUE, to->barScale, to, CmdTurnoutHotBarProc );
+	}
+}
+
+/**
+ * Handle mouse events for laying track when initiated from hotbar.
+ *
+ * \param action IN mouse event type
+ * \param pos IN mouse position
+ * \return    next state of operation
+ */
+
+static STATUS_T CmdTurnoutHotBar(
+		wAction_t action,
+		coOrd pos )
+{
+
+	switch (action & 0xFF) {
+
+	case C_START:
+		TurnoutChange( CHANGE_PARAMS|CHANGE_SCALE );
+		if (curTurnout == NULL) {
+			NoticeMessage2( 0, MSG_TURNOUT_NO_TURNOUT, _("Ok"), NULL );
+			return C_TERMINATE;
+		}
+		FormatCompoundTitle( listLabels|LABEL_DESCR, curTurnout->title );
+		InfoMessage( _("Place %s and draw into position"), message );
+		ParamLoadControls( &turnoutPG );
+		ParamGroupRecord( &turnoutPG );
+		return CmdTurnoutAction( action, pos );
+
+	case C_UP:
+	case C_RUP:
+		InfoMessage( _("Left drag to move, right drag to rotate, press Space or Return to fix track in place or Esc to cancel") );
+		return CmdTurnoutAction( action, pos );
+
+	case C_TEXT:
+		if ((action>>8) != ' ')
+			return C_CONTINUE;
+	case C_OK:
+		CmdTurnoutAction( action, pos );
+		return C_CONTINUE;
+
+	case C_CANCEL:
+		HotBarCancel();
+	default:
+		return CmdTurnoutAction( action, pos );
+	}
+}
+
+#ifdef TURNOUTCMD
+#include "bitmaps/turnout.xpm"
+
+
+EXPORT void InitCmdTurnout( wMenu_p menu )
+{
+	AddMenuButton( menu, CmdTurnout, "cmdTurnout", _("Turnout"), wIconCreatePixMap(turnout_xpm), LEVEL0_50, IC_STICKY|IC_LCLICK|IC_CMDMENU|IC_POPUP2, ACCL_TURNOUT, NULL );
+	turnoutHotBarCmdInx = AddMenuButton( menu, CmdTurnoutHotBar, "cmdTurnoutHotBar", "", NULL, LEVEL0_50, IC_STICKY|IC_LCLICK|IC_CMDMENU|IC_POPUP2, 0, NULL );
+	RegisterChangeNotification( TurnoutChange );
+	ParamRegister( &turnoutPG );
+	log_turnout = LogFindIndex( "turnout" );
+	log_traverseTurnout = LogFindIndex( "traverseTurnout" );
+}
+#endif
+
+EXPORT void InitTrkTurnout( void )
+{
+	T_TURNOUT = InitObject( &turnoutCmds );
+
+	/*InitDebug( "Turnout", &debugTurnout );*/
+	AddParam( N_("TURNOUT "), ReadTurnoutParam );
+}
+
+#ifdef TEST
+
+wDrawable_t turnoutD;
+
+void wListAddValue( wList_p bl, char * val, wIcon_p, void * listData, void * itemData )
+{
+}
+
+void wListClear( wList_p bl )
+{
+}
+
+void wDrawSetScale( wDrawable_p d )
+{
+	d->scale = 1.0;
+}
+
+void wDrawClear( wDrawable_p d )
+{
+}
+
+void GetTrkCurveCenter( track_p t, coOrd *pos, DIST_T *radius )
+{
+}
+
+#ifdef NOTRACK_C
+
+track_p NewTrack( wIndex_t index, TRKTYP_T type, EPINX_T endCnt, SIZE_T extraSize )
+{
+	return NULL;
+}
+
+track_p OnTrack( coOrd *pos )
+{
+	return NULL;
+}
+
+void ErrorMessage( char * msg, ... )
+{
+	lprintf( "ERROR : %s\n", msg );
+}
+
+void DeleteTrack( track_p t )
+{
+}
+
+void ConnectTracks( track_p t0, EPINX_T ep0, track_p t1, EPINX_T ep1 )
+{
+}
+#endif
+
+main( INT_T argc, char * argv[] )
+{
+	FILE * f;
+	char line[STR_SIZE];
+	wIndex_t lineCnt = 0;
+
+	/*debugTurnout = 3;*/
+	if ((f = fopen("turnout.params", "r" )) == NULL ) {
+		Perror( "turnout.params" );
+		Exit(1);
+	}
+	while ( fgets( line, sizeof line, f ) != NULL ) {
+		lineCnt++;
+		ReadTurnoutParam( &lineCnt );
+	}
+}
+#endif