Initial import of xtrkcad version 1:4.0.2-2

1 files changed, 1301 insertions, 0 deletions

diff --git a/app/bin/cprint.c b/app/bin/cprint.c
new file mode 100644
index 0000000..d89d1e2
--- /dev/null
+++ b/app/bin/cprint.c
@@ -0,0 +1,1301 @@
+/** \file cprint.c
+ * Printing functions. 
+ *
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/cprint.c,v 1.6 2009-08-16 13:26:41 m_fischer Exp $
+ */
+
+/*  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 <sys/types.h>
+#include <time.h>
+#include <string.h>
+#include <ctype.h>
+#include "track.h"
+#include "i18n.h"
+
+
+#define PRINT_GAUDY		(0)
+#define PRINT_PLAIN		(1)
+#define PRINT_BARE		(2)
+#define PORTRAIT		(0)
+#define LANDSCAPE		(1)
+
+#define PRINTOPTION_SNAP		(1<<0)
+
+typedef struct {
+		int x0, x1, y0, y1;
+		char * bm;
+		int memsize;
+		coOrd orig;
+		coOrd size;
+		ANGLE_T angle;
+		} bitmap_t;
+static bitmap_t bm, bm0;
+#define BITMAP( BM, X, Y ) \
+		(BM).bm[ (X)-(BM).x0 + ((Y)-(BM).y0) * ((BM).x1-(BM).x0) ]
+
+struct {
+		coOrd size;
+		coOrd orig;
+		ANGLE_T angle;
+		} currPrintGrid, newPrintGrid;
+
+
+/*
+ * GUI VARS
+ */
+
+
+static long printGaudy = 1;
+static long printRegistrationMarks = 1;
+static long printPhysSize = FALSE;
+static long printFormat = PORTRAIT;
+static long printOrder = 0;
+static long printGrid = 0;
+static long printRuler = 0;
+static long printRoadbed = 0;
+static DIST_T printRoadbedWidth = 0.0;
+static BOOL_T printRotate = FALSE;
+static BOOL_T rotateCW = FALSE;
+
+static double printScale = 16;
+static long iPrintScale = 16;
+static coOrd maxPageSize;
+static coOrd realPageSize;
+
+static wWin_p printWin;
+
+static wMenu_p printGridPopupM;
+
+static wIndex_t pageCount = 0;
+
+static int log_print = 0;
+
+static void PrintSnapShot( void );
+static void DoResetGrid( void );
+static void DoPrintSetup( void );
+static void PrintClear( void );
+static void PrintMaxPageSize( void );
+
+static char * printFormatLabels[] = { N_("Portrait"), N_("Landscape"), NULL };
+static char * printOrderLabels[] = { N_("Normal"), N_("Reverse"), NULL };
+static char * printGaudyLabels[] = { N_("Engineering Data"), NULL };
+static char * printRegistrationMarksLabels[] = { N_("Print Registration Marks"), NULL };
+static char * printPhysSizeLabels[] = { N_("Ignore Page Margins"), NULL };
+static char * printGridLabels[] = { N_("Print Snap Grid"), NULL };
+static char * printRulerLabels[] = { N_("Print Rulers"), NULL };
+static char * printRoadbedLabels[] = { N_("Print Roadbed Outline"), NULL };
+static paramIntegerRange_t rminScale_999 = { 1, 999, 0, PDO_NORANGECHECK_HIGH };
+static paramFloatRange_t r0_ = { 0, 0, 0, PDO_NORANGECHECK_HIGH };
+static paramFloatRange_t r1_ = { 1, 0, 0, PDO_NORANGECHECK_HIGH };
+static paramFloatRange_t r_10_99999 = { -10, 99999, 0, PDO_NORANGECHECK_HIGH };
+static paramFloatRange_t r0_360 = { 0, 360 };
+
+static paramData_t printPLs[] = {
+/*0*/ { PD_LONG, &iPrintScale, "scale", 0, &rminScale_999, N_("Print Scale"), 0, (void*)1 },
+/*1*/ { PD_FLOAT, &newPrintGrid.size.x, "pagew", PDO_DIM|PDO_SMALLDIM|PDO_NORECORD|PDO_NOPREF, &r1_, N_("Page Width"), 0, (void*)2 },
+/*2*/ { PD_BUTTON, (void*)PrintMaxPageSize, "max", PDO_DLGHORZ, NULL, N_("Max") },
+/*3*/ { PD_FLOAT, &newPrintGrid.size.y, "pageh", PDO_DIM|PDO_SMALLDIM|PDO_NORECORD|PDO_NOPREF, &r1_, N_("Height"), 0, (void*)2 },
+/*4*/ { PD_BUTTON, (void*)PrintSnapShot, "snapshot", PDO_DLGHORZ, NULL, N_("Snap Shot") },
+/*5*/ { PD_RADIO, &printFormat, "format", 0, printFormatLabels, N_("Page Format"), BC_HORZ|BC_NOBORDER, (void*)1 },
+/*6*/ { PD_RADIO, &printOrder, "order", PDO_DLGBOXEND, printOrderLabels, N_("Print Order"), BC_HORZ|BC_NOBORDER },
+
+/*7*/ { PD_TOGGLE, &printGaudy, "style", PDO_DLGNOLABELALIGN, printGaudyLabels, NULL, BC_HORZ|BC_NOBORDER, (void*)1 },
+/*8*/ { PD_TOGGLE, &printPhysSize, "physsize", PDO_DLGNOLABELALIGN, printPhysSizeLabels, NULL, BC_HORZ|BC_NOBORDER, (void*)1 },
+#define I_REGMARKS		(9)
+/*9*/ { PD_TOGGLE, &printRegistrationMarks, "registrationMarks", PDO_DLGNOLABELALIGN, printRegistrationMarksLabels, NULL, BC_HORZ|BC_NOBORDER },
+#define I_GRID			(10)
+/*10*/ { PD_TOGGLE, &printGrid, "grid", PDO_DLGNOLABELALIGN, printGridLabels, NULL, BC_HORZ|BC_NOBORDER },
+#define I_RULER			(11)
+/*11*/ { PD_TOGGLE, &printRuler, "ruler", PDO_DLGNOLABELALIGN, printRulerLabels, NULL, BC_HORZ|BC_NOBORDER },
+#define I_ROADBED		(12)
+/*12*/{ PD_TOGGLE, &printRoadbed, "roadbed", PDO_DLGNOLABELALIGN, printRoadbedLabels, NULL, BC_HORZ|BC_NOBORDER },
+#define I_ROADBEDWIDTH	(13)
+/*13*/{ PD_FLOAT, &printRoadbedWidth, "roadbedWidth", PDO_DIM|PDO_DLGBOXEND, &r0_, N_("Width") },
+/*14*/{ PD_FLOAT, &newPrintGrid.orig.x, "origx", PDO_DIM|PDO_DLGRESETMARGIN, &r_10_99999, N_("Origin: X"), 0, (void*)2 },
+/*15*/ { PD_FLOAT, &newPrintGrid.orig.y, "origy", PDO_DIM, &r_10_99999, N_("Y"), 0, (void*)2 },
+/*16*/ { PD_BUTTON, (void*)DoResetGrid, "reset", PDO_DLGHORZ, NULL, N_("Reset") },
+/*17*/ { PD_FLOAT, &newPrintGrid.angle, "origa", PDO_ANGLE|PDO_DLGBOXEND, &r0_360, N_("Angle"), 0, (void*)2 },
+/*18*/ { PD_BUTTON, (void*)DoPrintSetup, "setup", PDO_DLGCMDBUTTON, NULL, N_("Setup") },
+/*19*/ { PD_BUTTON, (void*)PrintClear, "clear", 0, NULL, N_("Clear") },
+#define I_PAGECNT		(20)
+/*20*/ { PD_MESSAGE, N_("0 pages"), NULL, 0, (void*)80 },
+/*21*/ { PD_MESSAGE, N_("selected"), NULL, 0, (void*)80 } };
+
+static paramGroup_t printPG = { "print", PGO_PREFMISCGROUP, printPLs, sizeof printPLs/sizeof printPLs[0] };
+
+
+/*****************************************************************************
+ *
+ * TEMP DRAW
+ *
+ */
+
+
+static void ChangeDim( void )
+{
+	int x, y, x0, x1, y0, y1;
+	coOrd p0;
+	int size;
+	bitmap_t tmpBm;
+	BOOL_T selected;
+
+	MapGrid( zero, mapD.size, 0.0, currPrintGrid.orig, currPrintGrid.angle, currPrintGrid.size.x, currPrintGrid.size.y,
+		&x0, &x1, &y0, &y1 );
+#ifdef LATER
+	d0 = sqrt( mapD.size.x * mapD.size.x + mapD.size.y * mapD.size.y );
+
+	Translate( &p1, currPrintGrid.orig, currPrintGrid.angle, d0 );
+	p0 = currPrintGrid.orig;
+	ClipLine( &p0, &p1, zero, 0.0, mapD.size );
+	d1 = FindDistance( currPrintGrid.orig, p1 );
+	y1 = (int)ceil(d1/currPrintGrid.size.y);
+
+	Translate( &p1, currPrintGrid.orig, currPrintGrid.angle+180, d0 );
+	p0 = currPrintGrid.orig;
+	ClipLine( &p0, &p1, zero, 0.0, mapD.size );
+	d1 = FindDistance( currPrintGrid.orig, p1 );
+	y0 = -(int)floor(d1/currPrintGrid.size.y);
+
+	Translate( &p1, currPrintGrid.orig, currPrintGrid.angle+90, d0 );
+	p0 = currPrintGrid.orig;
+	ClipLine( &p0, &p1, zero, 0.0, mapD.size );
+	d1 = FindDistance( currPrintGrid.orig, p1 );
+	x1 = (int)ceil(d1/currPrintGrid.size.x);
+
+	Translate( &p1, currPrintGrid.orig, currPrintGrid.angle+270, d0 );
+	p0 = currPrintGrid.orig;
+	ClipLine( &p0, &p1, zero, 0.0, mapD.size );
+	d1 = FindDistance( currPrintGrid.orig, p1 );
+	x0 = -(int)floor(d1/currPrintGrid.size.x);
+#endif
+
+	if ( x0==bm.x0 && x1==bm.x1 && y0==bm.y0 && y1==bm.y1 )
+		return;
+	size = (x1-x0) * (y1-y0);
+	if (size > bm0.memsize) {
+		bm0.bm = MyRealloc( bm0.bm, size );
+		bm0.memsize = size;
+	}
+	bm0.x0 = x0; bm0.x1 = x1; bm0.y0 = y0; bm0.y1 = y1;
+	memset( bm0.bm, 0, bm0.memsize );
+	pageCount = 0;
+	if (bm.bm) {
+		for ( x=bm.x0; x<bm.x1; x++ ) {
+			for ( y=bm.y0; y<bm.y1; y++ ) {
+				selected = BITMAP( bm, x, y );
+				if (selected) {
+					p0.x = bm.orig.x + x * bm.size.x + bm.size.x/2.0;
+					p0.y = bm.orig.y + y * bm.size.y + bm.size.y/2.0;
+					Rotate( &p0, bm.orig, bm.angle );
+					p0.x -= currPrintGrid.orig.x;
+					p0.y -= currPrintGrid.orig.y;
+					Rotate( &p0, zero, -currPrintGrid.angle );
+					x0 = (int)floor(p0.x/currPrintGrid.size.x);
+					y0 = (int)floor(p0.y/currPrintGrid.size.y);
+					if ( x0>=bm0.x0 && x0<bm0.x1 && y0>=bm0.y0 && y0<bm0.y1 ) {
+						if ( BITMAP( bm0, x0, y0 ) == FALSE ) {
+							pageCount++;
+							BITMAP( bm0, x0, y0 ) = TRUE;
+						}
+					}
+				}
+			}
+		}
+	}
+	tmpBm = bm0;
+	bm0 = bm;
+	bm = tmpBm;
+	bm.orig = currPrintGrid.orig;
+	bm.size = currPrintGrid.size;
+	bm.angle = currPrintGrid.angle;
+	sprintf( message, _("%d pages"), pageCount );
+	ParamLoadMessage( &printPG, I_PAGECNT, message );
+	ParamDialogOkActive( &printPG, pageCount!=0 );
+}
+
+
+static void MarkPage(
+		wIndex_t x,
+		wIndex_t y )
+/*
+ * Hilite a area
+ */
+{
+	coOrd p[4];
+		
+LOG1( log_print, ( "MarkPage( %d, %d )\n", x, y) )
+	if ( x<bm.x0 || x>=bm.x1 || y<bm.y0 || y>=bm.y1) {
+		ErrorMessage( MSG_OUT_OF_BOUNDS );
+		return;
+	}
+	p[0].x = p[3].x = currPrintGrid.orig.x + x * currPrintGrid.size.x;
+	p[0].y = p[1].y = currPrintGrid.orig.y + y * currPrintGrid.size.y;
+	p[2].x = p[1].x = p[0].x + currPrintGrid.size.x;
+	p[2].y = p[3].y = p[0].y + currPrintGrid.size.y;
+	Rotate( &p[0], currPrintGrid.orig, currPrintGrid.angle );
+	Rotate( &p[1], currPrintGrid.orig, currPrintGrid.angle );
+	Rotate( &p[2], currPrintGrid.orig, currPrintGrid.angle );
+	Rotate( &p[3], currPrintGrid.orig, currPrintGrid.angle );
+LOG( log_print, 2, ( "MP(%d,%d) [%0.3f %0.3f] x [%0.3f %0.3f]\n", x, y, p[0].x, p[0].y, p[2].x, p[2].y ) )
+	DrawHilightPolygon( &mainD, p, 4 );
+}
+
+
+static void SelectPage( coOrd pos )
+{
+	int x, y;
+	BOOL_T selected;
+	/*PrintUpdate();*/
+	pos.x -= currPrintGrid.orig.x;
+	pos.y -= currPrintGrid.orig.y;
+	Rotate( &pos, zero, -currPrintGrid.angle );
+	x = (int)floor(pos.x/currPrintGrid.size.x);
+	y = (int)floor(pos.y/currPrintGrid.size.y);
+	if ( x<bm.x0 || x>=bm.x1 || y<bm.y0 || y>=bm.y1)
+		return;
+	selected = BITMAP( bm, x, y );
+	pageCount += (selected?-1:1);
+	BITMAP( bm, x, y ) = !selected;
+	MarkPage( x, y );
+	sprintf( message, _("%d pages"), pageCount );
+	ParamLoadMessage( &printPG, I_PAGECNT, message );
+	ParamDialogOkActive( &printPG, pageCount!=0 );
+}
+
+
+static void DrawPrintGrid( void )
+/*
+ * Draw a grid using currPrintGrid.orig, currPrintGrid.angle, currPrintGrid.size.
+ * Drawing it twice erases the grid.
+ * Also hilite any marked pages.
+ */
+{
+	wIndex_t x, y;
+
+	DrawGrid( &tempD, &mapD.size, currPrintGrid.size.x, currPrintGrid.size.y, 0, 0, currPrintGrid.orig, currPrintGrid.angle, wDrawColorBlack, TRUE );
+
+	for (y=bm.y0; y<bm.y1; y++)
+		for (x=bm.x0; x<bm.x1; x++)
+			if (BITMAP(bm,x,y)) {
+				MarkPage( x, y );
+			}
+}
+
+/*****************************************************************************
+ *
+ * PRINTING FUNCTIONS
+ *
+ */
+
+
+static drawCmd_t print_d = {
+		NULL,
+		&printDrawFuncs,
+		DC_PRINT,
+		16.0,
+		0.0,
+		{0.0, 0.0}, {1.0, 1.0},
+		Pix2CoOrd, CoOrd2Pix };
+
+static drawCmd_t page_d = {
+		NULL,
+		&printDrawFuncs,
+		DC_PRINT,
+		1.0,
+		0.0,
+		{0.0, 0.0}, {1.0, 1.0},
+		Pix2CoOrd, CoOrd2Pix };
+
+
+/**
+ * Print the basic layout for a trackplan. This includes the frame and some
+ * information like room size, print scale etc..
+ *
+ * \param roomSize IN size of the layout  
+ */
+
+static void PrintGaudyBox(
+		coOrd roomSize )
+{
+	coOrd p00, p01, p10, p11;
+	struct tm *tm;
+	time_t clock;
+	char dat[STR_SIZE];
+	wFont_p fp;
+	DIST_T pageW, pageH;
+	DIST_T smiggin;
+	coOrd textsize;
+
+	/*GetTitle();*/
+	time(&clock);
+	tm = localtime(&clock);
+	strftime( dat, STR_SIZE, "%x", tm );
+
+	smiggin = wDrawGetDPI( print_d.d );
+	if (smiggin>4.0)
+		smiggin = 4.0/smiggin;
+	pageW = currPrintGrid.size.x/print_d.scale;
+	pageH = currPrintGrid.size.y/print_d.scale;
+	/* Draw some lines */
+	p00.x = p01.x = 0.0;
+	p00.y = p10.y = 0.0;
+	p10.x = p11.x = pageW-smiggin;
+	p01.y = p11.y = pageH+1.0-smiggin;
+
+	DrawLine( &page_d, p00, p10, 0, wDrawColorBlack );
+	DrawLine( &page_d, p10, p11, 0, wDrawColorBlack );
+	DrawLine( &page_d, p11, p01, 0, wDrawColorBlack );
+	DrawLine( &page_d, p01, p00, 0, wDrawColorBlack );
+
+	p00.y = p10.y = 1.0;
+	DrawLine( &page_d, p00, p10, 0, wDrawColorBlack );
+	p00.y = p10.y = 0.5;
+	DrawLine( &page_d, p00, p10, 0, wDrawColorBlack );
+	p00.y = 0.5;
+	p01.y = 1.0;
+	p00.x = 0.05; p00.y = 0.5+0.05;
+	fp = wStandardFont( F_TIMES, TRUE, TRUE );
+	DrawString( &page_d, p00, 0.0, sProdName, fp, 30.0, wDrawColorBlack );
+
+	p00.y = 0.5; p01.y = 1.0;
+	p00.x = p01.x = (157.0/72.0)+0.1;
+	DrawLine( &page_d, p00, p01, 0, wDrawColorBlack );
+	p00.x = p01.x = pageW-((157.0/72.0)+0.1);
+	DrawLine( &page_d, p00, p01, 0, wDrawColorBlack );
+
+	fp = wStandardFont( F_TIMES, FALSE, FALSE );
+	p00.x = pageW-((157.0/72.0)+0.05); p00.y = 0.5+0.25+0.05;
+	DrawString( &page_d, p00, 0.0, dat, fp, 16.0, wDrawColorBlack );
+	p00.y = 0.5+0.05;
+
+	DrawTextSize( &mainD, Title1, fp, 16.0, FALSE, &textsize );
+	p00.x = (pageW/2.0)-(textsize.x/2.0);
+	p00.y = 0.75+0.05;
+	DrawString( &page_d, p00, 0.0, Title1, fp, 16.0, wDrawColorBlack );
+	DrawTextSize( &mainD, Title2, fp, 16.0, FALSE, &textsize );
+	p00.x = (pageW/2.0)-(textsize.x/2.0);
+	p00.y = 0.50+0.05;
+	DrawString( &page_d, p00, 0.0, Title2, fp, 16.0, wDrawColorBlack );
+
+	sprintf( dat, _("PrintScale 1:%ld   Room %s x %s   Model Scale %s   File %s"),
+		(long)printScale, 
+		FormatDistance( roomSize.x ),
+		FormatDistance( roomSize.y ),
+		curScaleName, curFileName );
+	p00.x = 0.05; p00.y = 0.25+0.05;
+	DrawString( &page_d, p00, 0.0, dat, fp, 16.0, wDrawColorBlack );
+}
+
+
+static void PrintPlainBox(
+		wPos_t x,
+		wPos_t y,
+		coOrd *corners )
+{
+	coOrd p00, p01, p10, p11;
+	char tmp[30];
+	wFont_p fp;
+	DIST_T pageW, pageH;
+	DIST_T smiggin;
+
+	smiggin = wDrawGetDPI( print_d.d );
+	if (smiggin>4.0)
+		smiggin = 4.0/smiggin;
+
+	pageW = currPrintGrid.size.x/print_d.scale;
+	pageH = currPrintGrid.size.y/print_d.scale;
+
+	p00.x = p01.x = 0.0;
+	p00.y = p10.y = 0.0;
+	p10.x = p11.x = pageW-smiggin;
+	p01.y = p11.y = pageH-smiggin;
+	DrawLine( &page_d, p00, p10, 0, wDrawColorBlack );
+	DrawLine( &page_d, p10, p11, 0, wDrawColorBlack );
+	DrawLine( &page_d, p11, p01, 0, wDrawColorBlack );
+	DrawLine( &page_d, p01, p00, 0, wDrawColorBlack );
+
+	fp = wStandardFont( F_HELV, FALSE, FALSE );
+	sprintf( tmp, "[%d,%d]", x, y );
+	p00.x = pageW/2.0 - 20.0/72.0;
+	p00.y = pageH - 10.0/72.0;
+	DrawString( &page_d, p00, 0.0, tmp, fp, 4.0, wDrawColorBlack );
+
+	sprintf( tmp, "[%0.2f,%0.2f]", corners[0].x, corners[0].y );
+	p00.x = 4.0/72.0;
+	p00.y = 4.0/72.0;
+	DrawString( &page_d, p00, 0.0, tmp, fp, 4.0, wDrawColorBlack );
+
+	sprintf( tmp, "[%0.2f,%0.2f]", corners[1].x, corners[1].y );
+	p00.x = pageW - 40.0/72.0;
+	p00.y = 4.0/72.0;
+	DrawString( &page_d, p00, 0.0, tmp, fp, 4.0, wDrawColorBlack );
+
+	sprintf( tmp, "[%0.2f,%0.2f]", corners[2].x, corners[2].y );
+	p00.x = pageW - 40.0/72.0;
+	p00.y = pageH - 10.0/72.0;
+	DrawString( &page_d, p00, 0.0, tmp, fp, 4.0, wDrawColorBlack );
+
+	sprintf( tmp, "[%0.2f,%0.2f]", corners[3].x, corners[3].y );
+	p00.x = 4.0/72.0;
+	p00.y = pageH - 10.0/72.0;
+	DrawString( &page_d, p00, 0.0, tmp, fp, 4.0, wDrawColorBlack );
+
+}
+
+/*****************************************************************************
+ *
+ * BUTTON HANDLERS
+ *
+ */
+
+
+static void PrintEnableControls( void )
+{
+	if (printScale <= 1) {
+		ParamLoadControl( &printPG, I_REGMARKS );
+		ParamControlActive( &printPG, I_REGMARKS, TRUE );
+	} else {
+		ParamLoadControl( &printPG, I_REGMARKS );
+		printRegistrationMarks = 0;
+		ParamControlActive( &printPG, I_REGMARKS, FALSE );
+	}
+	if (printScale <= (twoRailScale*2+1)/2.0) {
+		ParamLoadControl( &printPG, I_ROADBED );
+		ParamControlActive( &printPG, I_ROADBED, TRUE );
+		ParamControlActive( &printPG, I_ROADBEDWIDTH, TRUE );
+	} else {
+		printRoadbed = 0;
+		ParamLoadControl( &printPG, I_ROADBED );
+		ParamControlActive( &printPG, I_ROADBED, FALSE );
+		ParamControlActive( &printPG, I_ROADBEDWIDTH, FALSE );
+	}
+}
+
+
+#ifdef LATER
+static void PrintSetOrient( void )
+/*
+ * Called when print landscape/portrait toggled
+ */
+{
+	DrawPrintGrid();
+	ParamLoadData( &printPG );
+	currPrintGrid = newPrintGrid;
+	ChangeDim();
+	DrawPrintGrid();
+}
+#endif
+
+
+static void PrintUpdate( int inx0 )
+/*
+ * Called when print page size (x or y) is changed.
+ * Checks for valid values
+ */
+{
+	int inx;
+
+	DrawPrintGrid();
+	ParamLoadData( &printPG );
+
+	if (newPrintGrid.size.x > maxPageSize.x+0.01 ||
+		newPrintGrid.size.y > maxPageSize.y+0.01) {
+		NoticeMessage( MSG_PRINT_MAX_SIZE, _("Ok"), NULL,
+				FormatSmallDistance(maxPageSize.x), FormatSmallDistance(maxPageSize.y) );
+	}
+	if (newPrintGrid.size.x > maxPageSize.x) {
+		newPrintGrid.size.x = maxPageSize.x;
+		ParamLoadControl( &printPG, 1 );
+	}
+	if (newPrintGrid.size.y > maxPageSize.y) {
+		newPrintGrid.size.y = maxPageSize.y;
+		ParamLoadControl( &printPG, 3 );
+	}
+	currPrintGrid = newPrintGrid;
+	for ( inx = 0; inx < sizeof printPLs/sizeof printPLs[0]; inx++ ) {
+		if ( inx != inx0 && printPLs[inx].context == (void*)2 )
+			ParamLoadControl( &printPG, inx );
+	}
+	ChangeDim();
+	DrawPrintGrid();
+}
+
+
+static void SetPageSize( BOOL_T doScale )
+{
+	WDOUBLE_T temp, x, y;
+	if (printPhysSize)
+		wPrintGetPhysSize( &x, &y );
+	else
+		wPrintGetPageSize( &x, &y );
+	maxPageSize.x = x;
+	maxPageSize.y = y;
+	realPageSize = maxPageSize;
+	if ( (printFormat == PORTRAIT) == (maxPageSize.x > maxPageSize.y) ) {
+		temp = maxPageSize.x;
+		maxPageSize.x = maxPageSize.y;
+		maxPageSize.y = temp;
+		printRotate = TRUE;
+	} else {
+		printRotate = FALSE;
+	}
+	if (doScale) {
+		if (printGaudy)
+			maxPageSize.y -= 1.0;
+		maxPageSize.x *= printScale;
+		maxPageSize.y *= printScale;
+	}
+}
+
+
+static void PrintMaxPageSize( void )
+/*
+ * Called when print:maxPageSize button is clicked.
+ * Set print page size to maximum
+ * (depending on paper size, scale and orientation)
+ */
+{
+	DrawPrintGrid();
+	SetPageSize( TRUE );
+	currPrintGrid.size = maxPageSize;
+	newPrintGrid = currPrintGrid;
+	ParamLoadControls( &printPG );
+	ChangeDim();
+	DrawPrintGrid();
+	wShow( printWin);
+}
+
+
+static void DoPrintScale( void )
+/*
+ * Called whenever print scale or orientation changes.
+ */
+{
+	printScale = iPrintScale;
+	PrintMaxPageSize();
+	PrintEnableControls();
+}
+
+
+static void DoPrintSetup( void )
+{
+	wPrintSetup( (wPrintSetupCallBack_p)DoPrintScale );
+}
+
+
+static void PrintClear( void )
+/*
+ * Called when print:clear button is clicked.
+ * Flip the status of all printable pages
+ * (Thus making them non-print)
+ */
+{
+	wIndex_t x, y;
+	for (y=bm.y0; y<bm.y1; y++)
+		for (x=bm.x0; x<bm.x1; x++)
+			if (BITMAP(bm,x,y)) {
+				BITMAP(bm,x,y) = 0;
+				MarkPage( x, y );
+			}
+	pageCount = 0;
+	ParamLoadMessage( &printPG, I_PAGECNT, _("0 pages") );
+	ParamDialogOkActive( &printPG, FALSE );
+}
+
+
+static void PrintSnapShot( void )
+/*
+ * Called when print:SnapShot button is clicked.
+ * Set scale and orientation so the whole layout is printed on one page.
+ */
+{
+	coOrd size;
+	ANGLE_T scaleX, scaleY;
+	long scaleH, scaleV;
+	int i;
+	coOrd pageSize;
+	POS_T t;
+
+	PrintClear();
+	DrawPrintGrid();
+	SetPageSize( FALSE );
+	pageSize = realPageSize;
+	if (pageSize.x > pageSize.y) {
+		t = pageSize.x;
+		pageSize.x = pageSize.y;
+		pageSize.y = t;
+	}
+	size = mapD.size;
+
+	scaleH = 1;
+	for (i=0;i<3;i++) {
+		size = mapD.size;
+		size.x += 0.75*scaleH;
+		size.y += 0.75*scaleH;
+		if (printGaudy)
+			size.y += 1.0*scaleH;
+		scaleX = size.x/pageSize.x;
+		scaleY = size.y/pageSize.y;
+		scaleH = (long)ceil(max( scaleX, scaleY ));
+	}
+
+	scaleV = 1;
+	for (i=0;i<3;i++) {
+		size = mapD.size;
+		size.x += 0.75*scaleV;
+		size.y += 0.75*scaleV;
+		if (printGaudy)
+			size.y += 1.0*scaleV;
+		scaleX = size.x/pageSize.y;
+		scaleY = size.y/pageSize.x;
+		scaleV = (long)ceil(max( scaleX, scaleY ));
+	}
+
+	if ( scaleH <= scaleV ) {
+		printScale = scaleH;
+		printFormat = PORTRAIT;
+	} else {
+		printScale = scaleV;
+		printFormat = LANDSCAPE;
+	}
+
+	SetPageSize( TRUE );
+/*
+	if (printFormat == LANDSCAPE) {
+		currPrintGrid.orig.x = -0.5*printScale;
+		currPrintGrid.orig.y = maxPageSize.x-0.5*printScale;
+		currPrintGrid.angle = 90.0;
+	} else {*/
+		currPrintGrid.orig.x = -0.5*printScale;
+		currPrintGrid.orig.y = -0.5*printScale;
+		currPrintGrid.angle = 0.0;
+/*    }*/
+	currPrintGrid.size = maxPageSize;
+	newPrintGrid = currPrintGrid;
+	iPrintScale = (long)printScale;
+	ParamLoadControls( &printPG );
+	ParamGroupRecord( &printPG );
+	ChangeDim();
+	pageCount = 1;
+	BITMAP(bm,0,0) = TRUE;
+	DrawPrintGrid();
+	ParamLoadMessage( &printPG, I_PAGECNT, _("1 page") );
+	ParamDialogOkActive( &printPG, TRUE );
+	PrintEnableControls();
+	wShow( printWin );
+}
+
+
+static void DrawRegistrationMarks( drawCmd_p d )
+{
+	long x, y, delta, divisor;
+	coOrd p0, p1, qq, q0, q1;
+	POS_T len;
+	char msg[10];
+	wFont_p fp;
+	wFontSize_t fs;
+	fp = wStandardFont( F_TIMES, FALSE, FALSE );
+	if ( units==UNITS_METRIC ) {
+		delta = 10;
+		divisor = 100;
+	} else {
+		delta = 3;
+		divisor = 12;
+	}
+	for ( x=delta; (POS_T)x<PutDim(mapD.size.x); x+=delta ) {
+		qq.x = p0.x = p1.x = (POS_T)GetDim(x);
+		p0.y = 0.0;
+		p1.y = mapD.size.y;
+		if (!ClipLine( &p0, &p1, d->orig, d->angle, d->size ))
+			continue;
+		for ( y=(long)(ceil(PutDim(p0.y)/delta)*delta); (POS_T)y<PutDim(p1.y); y+=delta ) {
+			qq.y = (POS_T)GetDim(y);
+			q0.x = q1.x = qq.x;
+			if ( x%divisor == 0 && y%divisor == 0 ) {
+				len = 0.25;
+				fs = 12.0;
+			} else {
+				len = 0.125;
+				fs = 8.0;
+			}
+			q0.y = qq.y-len;
+			q1.y = qq.y+len;
+			DrawLine( d, q0, q1, 0, wDrawColorBlack );
+			q0.y = q1.y = qq.y;
+			q0.x = qq.x-len;
+			q1.x = qq.x+len;
+			DrawLine( d, q0, q1, 0, wDrawColorBlack );
+			q0.x = qq.x + len/4;;
+			q0.y = qq.y + len/4;;
+			if (units == UNITS_METRIC)
+				sprintf( msg, "%0.1fm", (DOUBLE_T)x/100.0 );
+			else
+				sprintf( msg, "%ld\' %ld\"", x/12, x%12 );
+			DrawString( d, q0, 0.0, msg, fp, fs, wDrawColorBlack );
+			q0.y = qq.y - len*3/4;
+			if (units == UNITS_METRIC)
+				sprintf( msg, "%0.1fm", (DOUBLE_T)y/100.0 );
+			else
+				sprintf( msg, "%ld\' %ld\"", y/12, y%12 );
+			DrawString( d, q0, 0.0, msg, fp, fs, wDrawColorBlack );
+		}
+	}
+}
+
+
+static BOOL_T PrintPage(
+		int x,
+		int y )
+{
+	coOrd orig, p[4], minP, maxP;
+	int i;
+	coOrd clipOrig, clipSize;
+	wFont_p fp;
+	coOrd roomSize;
+
+			if (BITMAP(bm,x,y)) {
+				orig.x = currPrintGrid.orig.x + x*currPrintGrid.size.x;
+				orig.y = currPrintGrid.orig.y + y*currPrintGrid.size.y;
+				Rotate( &orig, currPrintGrid.orig, currPrintGrid.angle );
+				p[0] = p[1] = p[2] = p[3] = orig;
+				p[1].x = p[2].x = orig.x + currPrintGrid.size.x;
+				p[2].y = p[3].y = orig.y + currPrintGrid.size.y + 
+						( printGaudy ? printScale : 0.0 );
+				Rotate( &p[0], orig, currPrintGrid.angle );
+				Rotate( &p[1], orig, currPrintGrid.angle );
+				Rotate( &p[2], orig, currPrintGrid.angle );
+				Rotate( &p[3], orig, currPrintGrid.angle );
+				minP = maxP = p[0];
+				for (i=1; i<4; i++) {
+					if (maxP.x < p[i].x) maxP.x = p[i].x;
+					if (maxP.y < p[i].y) maxP.y = p[i].y;
+					if (minP.x > p[i].x) minP.x = p[i].x;
+					if (minP.y > p[i].y) minP.y = p[i].y;
+				} 
+				maxP.x -= minP.x;
+				maxP.y -= minP.y;
+				print_d.d = page_d.d = wPrintPageStart();
+				if (page_d.d == NULL)
+					return FALSE;
+				print_d.dpi = page_d.dpi = wDrawGetDPI( print_d.d );
+				print_d.angle = currPrintGrid.angle;
+				print_d.orig = orig;
+				print_d.size = /*maxP*/ currPrintGrid.size;
+				page_d.orig = zero;
+				page_d.angle = 0.0;
+				if ( printGaudy ) {
+					Translate( &print_d.orig, orig, currPrintGrid.angle+180.0, printScale );
+					print_d.size.y += printScale;
+				}
+				if (printRotate) {
+					rotateCW = (printFormat != PORTRAIT);
+					if (rotateCW) {
+						page_d.orig.x = realPageSize.y;
+						page_d.orig.y = 0.0;
+						page_d.angle = -90.0;
+						print_d.angle += -90.0;
+						Translate( &print_d.orig, print_d.orig, currPrintGrid.angle+90, maxPageSize.x );
+					} else {
+						page_d.orig.x = 0.0;
+						page_d.orig.y = realPageSize.x;
+						page_d.angle = 90.0;
+						print_d.angle += 90.0;
+						Translate( &print_d.orig, print_d.orig, currPrintGrid.angle,
+								maxPageSize.y+(printGaudy?printScale:0) );
+					}
+					page_d.size.x = print_d.size.y/printScale;
+					page_d.size.y = print_d.size.x/printScale;
+					print_d.size.x = currPrintGrid.size.y;
+					print_d.size.y = currPrintGrid.size.x;
+				} else {
+					page_d.size.x = print_d.size.x/printScale;
+					page_d.size.y = print_d.size.y/printScale;
+				}
+				wSetCursor( wCursorWait );
+				print_d.scale = printScale;
+				if (print_d.d == NULL)
+					 AbortProg( "wPrintPageStart" );
+				clipOrig.x = clipOrig.y = 0;
+				clipSize.x = maxPageSize.x/printScale;
+				clipSize.y = maxPageSize.y/printScale;
+				GetRoomSize( &roomSize );
+				if (printGaudy) {
+					PrintGaudyBox( roomSize );
+					if ((!printRotate) || rotateCW) {
+						clipOrig.y = 1.0;
+					}
+					if (printRotate && rotateCW) {
+						print_d.size.x += printScale;
+					}
+				} else if (printRegistrationMarks)
+					PrintPlainBox( x, y, p );
+				if (printRotate) {
+					wPrintClip( (wPos_t)(clipOrig.y*print_d.dpi), (wPos_t)(clipOrig.x*print_d.dpi),
+							(wPos_t)(clipSize.y*print_d.dpi), (wPos_t)(clipSize.x*print_d.dpi) );
+				} else {
+					wPrintClip( (wPos_t)(clipOrig.x*print_d.dpi), (wPos_t)(clipOrig.y*print_d.dpi),
+							(wPos_t)(clipSize.x*print_d.dpi), (wPos_t)(clipSize.y*print_d.dpi) );
+				}
+				p[0].x = p[3].x = 0.0;
+				p[1].x = p[2].x = roomSize.x;
+				p[0].y = p[1].y = 0.0;
+				p[2].y = p[3].y = roomSize.y;
+				fp = wStandardFont( F_TIMES, FALSE, FALSE );
+				DrawRuler( &print_d, p[0], p[1], 0.0, TRUE, FALSE, wDrawColorBlack );
+				DrawRuler( &print_d, p[0], p[3], 0.0, TRUE, TRUE, wDrawColorBlack );
+				DrawRuler( &print_d, p[1], p[2], 0.0, FALSE, FALSE, wDrawColorBlack );
+				DrawRuler( &print_d, p[3], p[2], 0.0, FALSE, TRUE, wDrawColorBlack );
+				if ( printRuler && currPrintGrid.angle == 0 ) {
+					if ( !printRotate ) {
+						p[2] = p[3] = print_d.orig;
+						p[3].x += print_d.size.x;
+						p[3].y += print_d.size.y;
+					} else if ( rotateCW ) {
+						p[2].x = print_d.orig.x - print_d.size.y;
+						p[2].y = print_d.orig.y; 
+						p[3].x = print_d.orig.x;
+						p[3].y = print_d.orig.y + print_d.size.x;
+					} else {
+						p[2].x = print_d.orig.x;
+						p[2].y = print_d.orig.y - print_d.size.x;
+						p[3].x = print_d.orig.x + print_d.size.y;
+						p[3].y = print_d.orig.y;
+					}
+					if ( p[2].x > 0 )
+						minP.x = p[2].x + 0.4 * print_d.scale;
+					else
+						minP.x = 0.0;
+					if ( p[3].x < roomSize.x )
+						maxP.x = p[3].x - 0.2 * print_d.scale;
+					else
+						maxP.x = roomSize.x;
+					if ( p[2].y > 0 )
+						minP.y = p[2].y + 0.4 * print_d.scale;
+					else
+						minP.y = 0.0;
+					if ( p[3].y < roomSize.y )
+						maxP.y = p[3].y - 0.2 * print_d.scale;
+					else
+						maxP.y = roomSize.y;
+					p[0].y = 0.0;
+					p[1].y = maxP.y - minP.y;
+					if ( p[2].x > 0 ) {
+						p[0].x = p[1].x = p[2].x + 0.4 * print_d.scale;
+						DrawRuler( &print_d, p[0], p[1], minP.y, TRUE, TRUE, wDrawColorBlack );
+					}
+					if ( p[3].x < roomSize.x ) {
+						p[0].x = p[1].x = p[3].x - 0.2 * print_d.scale;
+						DrawRuler( &print_d, p[0], p[1], minP.y, FALSE, FALSE, wDrawColorBlack );
+					}
+					p[0].x = 0;
+					p[1].x = maxP.x - minP.x;
+					if ( p[2].y > 0 ) {
+						p[0].y = p[1].y = p[2].y + 0.4 * print_d.scale;
+						DrawRuler( &print_d, p[0], p[1], minP.x, TRUE, FALSE, wDrawColorBlack );
+					}
+					if ( p[3].y < roomSize.y ) {
+						p[0].y = p[1].y = p[3].y - 0.2 * print_d.scale;
+						DrawRuler( &print_d, p[0], p[1], minP.x, FALSE, TRUE, wDrawColorBlack );
+					}
+				}
+				if (printGrid)
+					DrawSnapGrid( &print_d, mapD.size, FALSE );
+				roadbedWidth = printRoadbed?printRoadbedWidth:0.0;
+				DrawTracks( &print_d, print_d.scale, minP, maxP );
+				if (printRegistrationMarks && printScale == 1)
+					DrawRegistrationMarks( &print_d );
+				if ( !wPrintPageEnd( print_d.d ) )
+					return FALSE;
+				/*BITMAP(bm,x,y) = 0;*/
+				MarkPage( x, y );
+	}
+	return TRUE;
+}
+
+
+static void DoPrintPrint( void * junk )
+/*
+ * Called when print:print button is clicked.
+ * Print all the printable pages and mark them
+ * non-print.
+ */
+{
+	wIndex_t x, y;
+	int copy, copies;
+	long noDecoration;
+
+	if (pageCount == 0) {
+		NoticeMessage( MSG_PRINT_NO_PAGES, _("Ok"), NULL );
+		return;
+	}
+
+	wPrefGetInteger( "print", "nodecoration", &noDecoration, 0 );
+
+	print_d.CoOrd2Pix = page_d.CoOrd2Pix = mainD.CoOrd2Pix;
+	wSetCursor( wCursorWait );
+	if (!wPrintDocStart( Title1, pageCount, &copies )) {
+		wSetCursor( wCursorNormal );
+		return;
+	}
+	if (copies <= 0)
+		copies = 1;
+	for ( copy=1; copy<=copies; copy++) {
+		if ( printOrder == 0 ) {
+			for (x=bm.x0; x<bm.x1; x++)
+				for (y=bm.y1-1; y>=bm.y0; y--)
+					if (!PrintPage( x, y )) goto quitPrinting;
+		} else {
+			for (y=bm.y0; y<bm.y1; y++)
+				for (x=bm.x0; x<bm.x1; x++)
+					if (!PrintPage( x, y )) goto quitPrinting;
+		}
+		for (y=bm.y0; y<bm.y1; y++)
+			for (x=bm.x0; x<bm.x1; x++)
+				if (BITMAP(bm,x,y)) {
+					if (copy < copies)
+						MarkPage( x, y );
+					else
+						BITMAP(bm,x,y) = 0;
+				}
+	}
+
+quitPrinting:
+	wPrintDocEnd();
+	wSetCursor( wCursorNormal );
+	Reset();		/* undraws grid, resets pagecount, etc */
+}
+
+
+static void DoResetGrid( void )
+{
+	DrawPrintGrid();
+	currPrintGrid.orig = zero;
+	currPrintGrid.angle = 0.0;
+	ChangeDim();
+	newPrintGrid = currPrintGrid;
+	ParamLoadControls( &printPG );
+	DrawPrintGrid();
+}
+
+
+static void PrintGridRotate( void * pangle )
+{
+	ANGLE_T angle = (ANGLE_T)(long)pangle;
+	DrawPrintGrid();
+	currPrintGrid.orig = cmdMenuPos;
+	currPrintGrid.angle += angle;
+	newPrintGrid = currPrintGrid;
+	ParamLoadControls( &printPG );
+	ChangeDim();
+	DrawPrintGrid();
+}
+
+/*****************************************************************************
+ *
+ * PAGE PRINT COMMAND
+ *
+ */
+
+static void PrintChange( long changes )
+{
+	if ( (changes&(CHANGE_MAP|CHANGE_UNITS|CHANGE_GRID))==0 || printWin==NULL || !wWinIsVisible(printWin) )
+		return;
+	newPrintGrid = currPrintGrid;
+	if (!GridIsVisible())
+		printGrid = 0;
+	ParamLoadControls( &printPG );
+	ParamControlActive( &printPG, I_GRID, GridIsVisible() );
+	PrintEnableControls();
+}
+
+
+static void PrintDlgUpdate(
+		paramGroup_p pg,
+		int inx,
+		void * valueP )
+{
+	if ( inx < 0 ) return;
+	if ( pg->paramPtr[inx].context == (void*)1 )
+		DoPrintScale();
+	else if ( pg->paramPtr[inx].context == (void*)2 )
+		PrintUpdate( inx );
+	ParamControlActive( &printPG, I_RULER, currPrintGrid.angle == 0 );
+}
+
+static STATUS_T CmdPrint(
+		wAction_t action,
+		coOrd pos )
+/*
+ * Print command:
+ *
+ * 3 Sub-states:
+ *		Select - grid coordinates are computed and the selected page is marked.
+ *		Move - grid base (currPrintGrid.orig) is moved.
+ *		Rotate - grid base and angle is rotated about selected point.
+ */
+{
+	STATUS_T rc = C_CONTINUE;
+	static BOOL_T downShift;
+
+	switch (action) {
+
+	case C_START:
+		if (!wPrintInit())
+			return C_TERMINATE;
+		printScale = iPrintScale;
+		if (printWin == NULL) {
+			rminScale_999.low = 1;
+			if (printScale < rminScale_999.low)
+				printScale = rminScale_999.low;
+			print_d.scale = printScale;
+			printWin = ParamCreateDialog( &printPG, MakeWindowTitle(_("Print")), _("Print"), DoPrintPrint, (paramActionCancelProc)Reset, TRUE, NULL, 0, PrintDlgUpdate );
+		}
+		wShow( printWin );
+		SetPageSize( TRUE );
+		if (currPrintGrid.size.x == 0.0) {
+			currPrintGrid.size.x = maxPageSize.x;
+			currPrintGrid.size.y = maxPageSize.y;
+		}
+		if (currPrintGrid.size.x >= maxPageSize.x)
+			currPrintGrid.size.x = maxPageSize.x;
+		if (currPrintGrid.size.y >= maxPageSize.y)
+			currPrintGrid.size.y = maxPageSize.y;
+		newPrintGrid = currPrintGrid;
+		ParamLoadControls( &printPG );
+		DrawPrintGrid();
+		pageCount = 0;
+LOG( log_print, 2, ( "Page size = %0.3f %0.3f\n", currPrintGrid.size.x, currPrintGrid.size.y ) )
+		PrintChange( CHANGE_MAP|CHANGE_UNITS );
+		ParamGroupRecord( &printPG );
+		ParamLoadMessage( &printPG, I_PAGECNT, "0 pages" );
+		ParamDialogOkActive( &printPG, FALSE );
+		ChangeDim();
+		InfoMessage( _("Select pages to print, or drag to move print grid") );
+		downShift = FALSE;
+		ParamControlActive( &printPG, I_RULER, currPrintGrid.angle == 0 );
+		return C_CONTINUE;
+
+	case C_DOWN:
+		downShift = FALSE;
+		if (MyGetKeyState()&WKEY_SHIFT) {
+			newPrintGrid = currPrintGrid;
+			rc = GridAction( C_DOWN, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			downShift = TRUE;
+		}
+		return C_CONTINUE;
+
+	case C_MOVE:
+		if (downShift) {
+			rc = GridAction( action, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			ParamLoadControls( &printPG );
+		}
+		return C_CONTINUE;
+
+	case C_UP:
+		if (downShift) {
+			rc = GridAction( action, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			ParamLoadControls( &printPG );
+			DrawPrintGrid();
+			currPrintGrid = newPrintGrid;
+			ChangeDim();
+			DrawPrintGrid();
+			downShift = FALSE;
+		}
+		return C_CONTINUE;
+
+	case C_LCLICK:
+		SelectPage( pos );
+		return C_CONTINUE;
+
+	case C_RDOWN:
+		downShift = FALSE;
+		if (MyGetKeyState()&WKEY_SHIFT) {
+			newPrintGrid = currPrintGrid;
+			rc = GridAction( action, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			downShift = TRUE;
+		}
+		return rc;
+
+	case C_RMOVE:
+		if (downShift) {
+			rc = GridAction( action, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			ParamLoadControls( &printPG );
+		}
+		return rc;
+
+	case C_RUP:
+		if (downShift) {
+			rc = GridAction( action, pos, &newPrintGrid.orig, &newPrintGrid.angle );
+			ParamLoadControls( &printPG );
+			DrawPrintGrid();
+			currPrintGrid = newPrintGrid;
+			ChangeDim();
+			DrawPrintGrid();
+			downShift = FALSE;
+			ParamControlActive( &printPG, I_RULER, currPrintGrid.angle == 0 );
+		}
+		return rc;
+
+	case C_REDRAW:
+		DrawPrintGrid();
+		return C_TERMINATE;
+
+	case C_CANCEL:
+		if (printWin == NULL)
+			return C_TERMINATE;
+		PrintClear();
+		DrawPrintGrid();
+		wHide( printWin );
+		return C_TERMINATE;
+
+	case C_OK:
+		DoPrintPrint( NULL );
+		return C_TERMINATE;
+
+	case C_CMDMENU:
+		wMenuPopupShow( printGridPopupM );
+		return C_CONTINUE;
+
+	default:
+		return C_CONTINUE;
+	}
+}
+
+EXPORT wIndex_t InitCmdPrint( wMenu_p menu )
+{
+	ParamRegister( &printPG );
+	currPrintGrid = newPrintGrid;
+	log_print = LogFindIndex( "print" );
+	RegisterChangeNotification( PrintChange );
+	printGridPopupM = MenuRegister( "Print Grid Rotate" );
+	AddRotateMenu( printGridPopupM, PrintGridRotate );
+	return InitCommand( menu, CmdPrint, N_("Print..."), NULL, LEVEL0, IC_LCLICK|IC_POPUP2|IC_CMDMENU, ACCL_PRINT );
+}
+
+/*****************************************************************************
+ *
+ * TEST
+ *
+ */
+#ifdef TEST
+
+wDrawable_t printD, mainD;
+
+void wDrawHilight( void * d, coOrd orig, coOrd size )
+{
+	lprintf( "wDrawHilight (%0.3f %0.3f) (%0.3f %0.3f)\n", orig.x, orig.y, size.x, size.y );
+}
+void PrintPage( void * d, wIndex_t mode , wIndex_t x, wIndex_t y )
+{
+	lprintf( "printPage %dx%d at (%0.3f %0.3f)\n", x, y, orig.x, orig.y );
+}
+void PrintStart( wDrawable_t *d, wIndex_t mode )
+{
+}
+void PrintEnd( wDrawable *d )
+{
+}
+void wPrintGetPageSize( int style, int format, int scale )
+{
+	printD.size.x = 11.5-(48.0/72.0);
+	printD.size.y = 8.0-(48.0/72.0);
+}
+
+void DumpMap( char * f, ANGLE_T a, ANGLE_T b )
+{
+	wIndex_t x, y;
+	lprintf( f, a, b );
+	for (y=bm.y1-1; y>=bm.y1; y--) {
+		for (x=bm.x0; x<bm.x1; x++)
+			if (BITMAP(bm,x,y)) {
+				lprintf( "X");
+			} else {
+				lprintf( " ");
+			}
+	lprintf( "\n");
+	}
+}
+
+#define C_PRINT (C_UP+1)
+#define C_CANCEL (C_UP+2)
+#define C_SCALE (C_UP+3)
+
+struct {
+	wAction_t cmd;
+	coOrd pos;
+} cmds[] = {
+		{ C_START, 0, 0 },
+		{ C_DOWN, 20.5, 12.4 },
+		{ C_MOVE, 20.5, 12.5 },
+		{ C_MOVE, 20.5, 12.3 },
+		{ C_MOVE, 39.3, 69.4 },
+		{ C_MOVE, 39.4, 4.5 },
+		{ C_MOVE, 2.4, 4.5 },
+		{ C_MOVE, 2.4, 50.3 },
+		{ C_UP, 0, 0 },
+		{ C_DOWN, 20.5, 12.4 },
+		{ C_UP, 0, 0 },
+		{ C_DOWN, 32.5, 4.4 },
+		{ C_UP, 0, 0 },
+		{ C_PRINT, 0, 0, },
+		{ C_START, 0, 0, },
+		{ C_DOWN, 45.3, 43.5 },
+		{ C_CANCEL, 0, 0 }
+	};
+
+main( INT_T argc, char * argv[] )
+{
+	INT_T i;
+	mapD.size.x = 4*12;
+	mapD.size.y = 3*12;
+	printD.scale = 1.0;
+	for (i=0; i<(sizeof cmds)/(sizeof cmds[0]); i++) {
+		switch (cmds[i].cmd) {
+		case C_START:
+			CmdPrint( cmds[i].cmd );
+			DumpMap( "Start\n", 0, 0 );
+			break;
+		case C_DOWN:
+			CmdPrint( cmds[i].cmd, cmds[i].pos );
+			DumpMap( "Down (%0.3f %0.3f)\n", cmds[i].pos.x, cmds[i].pos.y );
+			break;
+		case C_MOVE:
+			CmdPrint( cmds[i].cmd, cmds[i].pos );
+			DumpMap( "Move (%0.3f %0.3f)\n", cmds[i].pos.x, cmds[i].pos.y );
+			break;
+		case C_UP:
+			CmdPrint( cmds[i].cmd, cmds[i].pos );
+			DumpMap( "Up\n", 0, 0 );
+			break;
+		case C_PRINT:
+			DoPrintPrint( NULL );
+			DumpMap( "Print\n", 0, 0 );
+			break;
+		case C_CANCEL:
+			ClearPrint();
+			DumpMap( "Cancel\n", 0, 0 );
+			break;
+		case C_SCALE:
+			printD.scale = cmds[i].x;
+			break;
+		}
+	}
+}
+#endif