antiword/src/draw.c

/*
 * draw.c
 * Copyright (C) 1998-2005 A.J. van Os; Released under GPL
 *
 * Description:
 * Functions to deal with the Draw format
 */

#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "DeskLib:KeyCodes.h"
#include "DeskLib:Error.h"
#include "DeskLib:Menu.h"
#include "DeskLib:Template.h"
#include "DeskLib:Window.h"
#include "DeskLib:EventMsg.h"
#include "flexlib:flex.h"
#include "drawfile.h"
#include "antiword.h"

/* The work area must be a little bit larger than the diagram */
#define WORKAREA_EXTENSION	    5
/* Diagram memory */
#define INITIAL_SIZE		32768	/* 32k */
#define EXTENSION_SIZE		 4096	/*  4k */
/* Main window title */
#define WINDOW_TITLE_LEN	   28
#define FILENAME_TITLE_LEN	(WINDOW_TITLE_LEN - 10)


#if !defined(__GNUC__)
int
flex_alloc(flex_ptr anchor, int n)
{
	void	*pvTmp;

	TRACE_MSG("flex_alloc");

	if (anchor == NULL || n < 0) {
		return 0;
	}
	if (n == 0) {
		n = 1;
	}
	pvTmp = malloc(n);
	if (pvTmp == NULL) {
		return 0;
	}
	*anchor = pvTmp;
	return 1;
} /* end of flex_alloc */

void
flex_free(flex_ptr anchor)
{
	TRACE_MSG("flex_free");

	if (anchor == NULL || *anchor == NULL) {
		return;
	}
	free(*anchor);
	*anchor = NULL;
} /* end of flex_free */

int
flex_extend(flex_ptr anchor, int newsize)
{
	void	*pvTmp;

	TRACE_MSG("flex_extend");

	if (anchor == NULL || newsize < 0) {
		return 0;
	}
	if (newsize == 0) {
		newsize = 1;
	}
	pvTmp = realloc(*anchor, newsize);
	if (pvTmp == NULL) {
		return 0;
	}
	*anchor = pvTmp;
	return 1;
} /* end of flex_extend */
#endif /* !__GNUC__ */

/*
 * vCreateMainWindow - create the Main window
 *
 * remark: does not return if the Main window can't be created
 */
static window_handle
tCreateMainWindow(void)
{
	window_handle	tMainWindow;

	TRACE_MSG("tCreateMainWindow");

	tMainWindow = Window_Create("MainWindow", template_TITLEMIN);
	if (tMainWindow == 0) {
		werr(1, "I can't find the 'MainWindow' template");
	}
	return tMainWindow;
} /* end of tCreateMainWindow */

/*
 * vCreateScaleWindow - create the Scale view window
 *
 * remark: does not return if the Scale view window can't be created
 */
static window_handle
tCreateScaleWindow(void)
{
	window_handle	tScaleWindow;

	TRACE_MSG("tCreateScaleWindow");

	tScaleWindow = Window_Create("ScaleView", template_TITLEMIN);
	if (tScaleWindow == 0) {
		werr(1, "I can't find the 'ScaleView' template");
	}
	return tScaleWindow;
} /* end of tCreateScaleWindow */

/*
 * pCreateDiagram - create and initialize a diagram
 *
 * remark: does not return if the diagram can't be created
 */
diagram_type *
pCreateDiagram(const char *szTask, const char *szFilename)
{
	diagram_type	*pDiag;
	options_type	tOptions;
	window_handle	tMainWindow, tScaleWindow;
	wimp_box	tBox;

	TRACE_MSG("pCreateDiagram");

	fail(szTask == NULL || szTask[0] == '\0');

	/* Create the main window */
	tMainWindow = tCreateMainWindow();

	/* Create the scale view window */
	tScaleWindow = tCreateScaleWindow();

	/* Get the necessary memory */
	pDiag = xmalloc(sizeof(diagram_type));
	if (flex_alloc((flex_ptr)&pDiag->tInfo.data, INITIAL_SIZE) != 1) {
		werr(1, "Memory allocation failed, unable to continue");
	}

	/* Initialize the diagram */
	vGetOptions(&tOptions);
	pDiag->tMainWindow = tMainWindow;
	pDiag->tScaleWindow = tScaleWindow;
	pDiag->iScaleFactorCurr = tOptions.iScaleFactor;
	pDiag->iScaleFactorTemp = tOptions.iScaleFactor;
	pDiag->tMemorySize = INITIAL_SIZE;
	tBox.min.x = 0;
	tBox.min.y = -(Drawfile_ScreenToDraw(32 + 3) * 8 + 1);
	tBox.max.x = Drawfile_ScreenToDraw(16) * MIN_SCREEN_WIDTH + 1;
	tBox.max.y = 0;
	Error_CheckFatal(Drawfile_CreateDiagram(&pDiag->tInfo,
					pDiag->tMemorySize, szTask, tBox));
	DBG_DEC(pDiag->tInfo.length);
	pDiag->lXleft = 0;
	pDiag->lYtop = 0;
	strncpy(pDiag->szFilename,
			szBasename(szFilename), sizeof(pDiag->szFilename) - 1);
	pDiag->szFilename[sizeof(pDiag->szFilename) - 1] = '\0';
	/* Return success */
	return pDiag;
} /* end of pCreateDiagram */

/*
 * bDestroyDiagram - remove a diagram by freeing the memory it uses
 */
BOOL
bDestroyDiagram(event_pollblock *pEvent, void *pvReference)
{
	diagram_type	*pDiag;
	window_handle	tWindow;

	TRACE_MSG("bDestroyDiagram");

	fail(pEvent == NULL);
	fail(pvReference == NULL);

	if (pEvent == NULL || pvReference == NULL) {
		return FALSE;
	}

	pDiag = (diagram_type *)pvReference;

	switch (pEvent->type) {
	case event_CLOSE:
		tWindow = pEvent->data.openblock.window;
		break;
	case event_KEY:
		tWindow = pEvent->data.key.caret.window;
		break;
	default:
		DBG_DEC(pEvent->type);
		return FALSE;
	}
	if (tWindow != pDiag->tMainWindow) {
		return FALSE;
	}

	/* Delete the main window */
	Window_Delete(pDiag->tMainWindow);
	pDiag->tMainWindow = 0;

	/* Delete the scale window */
	Window_Delete(pDiag->tScaleWindow);
	pDiag->tScaleWindow = 0;

#if defined(__GNUC__)
	/*
	 * Remove all references to the diagram that will be free-ed
	 * by undoing the EventMsg_Claim's from within the Menu_Warn's
	 */
	while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
					bSaveTextfile, pDiag))
		; /* EMPTY */
	while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
					bSaveDrawfile, pDiag))
		; /* EMPTY */
	while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
					bScaleOpenAction, pDiag))
		; /* EMPTY */
#endif /* __GNUC__ */

	/* Free the memory */
	if (pDiag->tInfo.data != NULL && pDiag->tMemorySize != 0) {
		flex_free((flex_ptr)&pDiag->tInfo.data);
	}
	/* Just to be on the save side */
	pDiag->tInfo.data = NULL;
	pDiag->tInfo.length = 0;
	pDiag->tMemorySize = 0;

	/* Destroy the diagram itself */
	pDiag = xfree(pDiag);
	return TRUE;
} /* end of bDestroyDiagram */

/*
 * vExtendDiagramSize - make sure the diagram is big enough
 */
static void
vExtendDiagramSize(diagram_type *pDiag, size_t tSize)
{
	TRACE_MSG("vExtendDiagramSize");

	fail(pDiag == NULL || tSize % 4 != 0);

	while (pDiag->tInfo.length + tSize > pDiag->tMemorySize) {
		if (flex_extend((flex_ptr)&pDiag->tInfo.data,
				pDiag->tMemorySize + EXTENSION_SIZE) != 1) {
			werr(1, "Memory extend failed, unable to continue");
		}
		pDiag->tMemorySize += EXTENSION_SIZE;
		NO_DBG_DEC(pDiag->tMemorySize);
	}
	TRACE_MSG("end of vExtendDiagramSize");
} /* end of vExtendDiagramSize */

/*
 * vPrologue2 - prologue part 2; add a font list to a diagram
 */
void
vPrologue2(diagram_type *pDiag, int iWordVersion)
{
	drawfile_object	*pNew;
	const font_table_type	*pTmp;
	char	*pcTmp;
	size_t	tRealSize, tSize;
	int	iCount;

	TRACE_MSG("vPrologue2");

	fail(pDiag == NULL);

	if (tGetFontTableLength() == 0) {
		return;
	}
	tRealSize = offsetof(drawfile_object, data);
	pTmp = NULL;
	while ((pTmp = pGetNextFontTableRecord(pTmp)) != NULL) {
		tRealSize += 2 + strlen(pTmp->szOurFontname);
	}
	DBG_DEC(tRealSize);
	tSize = ROUND4(tRealSize);
	vExtendDiagramSize(pDiag, tSize);
	pNew = xmalloc(tSize);
	memset(pNew, 0, tSize);
	pNew->type = drawfile_TYPE_FONT_TABLE;
	pNew->size = tSize;
	pcTmp = (char *)&pNew->data.font_table.font_def[0].font_ref;
	iCount = 0;
	pTmp = NULL;
	while ((pTmp = pGetNextFontTableRecord(pTmp)) != NULL) {
		*pcTmp = ++iCount;
		pcTmp++;
		strcpy(pcTmp, pTmp->szOurFontname);
		pcTmp += 1 + strlen(pTmp->szOurFontname);
	}
	Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
			pDiag->tMemorySize, pNew, TRUE));
	pNew = xfree(pNew);
} /* end of vPrologue2 */

/*
 * vSubstring2Diagram - put a sub string into a diagram
 */
void
vSubstring2Diagram(diagram_type *pDiag,
	char *szString, size_t tStringLength, long lStringWidth,
	UCHAR ucFontColor, USHORT usFontstyle, drawfile_fontref tFontRef,
	USHORT usFontSize, USHORT usMaxFontSize)
{
	drawfile_object	*pNew;
	long	lSizeX, lSizeY, lOffset, l20, lYMove;
	size_t	tRealSize, tSize;

	TRACE_MSG("vSubstring2Diagram");

	fail(pDiag == NULL || szString == NULL);
	fail(pDiag->lXleft < 0);
	fail(tStringLength != strlen(szString));
	fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
	fail(usMaxFontSize < MIN_FONT_SIZE || usMaxFontSize > MAX_FONT_SIZE);
	fail(usFontSize > usMaxFontSize);

	if (szString[0] == '\0' || tStringLength == 0) {
		return;
	}

	if (tFontRef == 0) {
		lOffset = Drawfile_ScreenToDraw(2);
		l20 = Drawfile_ScreenToDraw(32 + 3);
		lSizeX = Drawfile_ScreenToDraw(16);
		lSizeY = Drawfile_ScreenToDraw(32);
	} else {
		lOffset = lToBaseLine(usMaxFontSize);
		l20 = lWord2DrawUnits20(usMaxFontSize);
		lSizeX = lWord2DrawUnits00(usFontSize);
		lSizeY = lWord2DrawUnits00(usFontSize);
	}

	lYMove = 0;

	/* Up for superscript */
	if (bIsSuperscript(usFontstyle)) {
		lYMove = lMilliPoints2DrawUnits((((long)usFontSize + 1) / 2) * 375);
	}
	/* Down for subscript */
	if (bIsSubscript(usFontstyle)) {
		lYMove = -lMilliPoints2DrawUnits((long)usFontSize * 125);
	}

	tRealSize = offsetof(drawfile_object, data);
	tRealSize += sizeof(drawfile_text) + tStringLength;
	tSize = ROUND4(tRealSize);
	vExtendDiagramSize(pDiag, tSize);
	pNew = xmalloc(tSize);
	memset(pNew, 0, tSize);
	pNew->type = drawfile_TYPE_TEXT;
	pNew->size = tSize;
	pNew->data.text.bbox.min.x = (int)pDiag->lXleft;
	pNew->data.text.bbox.min.y = (int)(pDiag->lYtop + lYMove);
	pNew->data.text.bbox.max.x = (int)(pDiag->lXleft + lStringWidth);
	pNew->data.text.bbox.max.y = (int)(pDiag->lYtop + l20 + lYMove);
	pNew->data.text.fill.value = (int)ulColor2Color(ucFontColor);
	pNew->data.text.bg_hint.value = 0xffffff00;	/* White */
	pNew->data.text.style.font_ref = tFontRef;
	pNew->data.text.style.reserved[0] = 0;
	pNew->data.text.style.reserved[1] = 0;
	pNew->data.text.style.reserved[2] = 0;
	pNew->data.text.xsize = (int)lSizeX;
	pNew->data.text.ysize = (int)lSizeY;
	pNew->data.text.base.x = (int)pDiag->lXleft;
	pNew->data.text.base.y = (int)(pDiag->lYtop + lOffset + lYMove);
	strncpy(pNew->data.text.text, szString, tStringLength);
	pNew->data.text.text[tStringLength] = '\0';
	Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
			pDiag->tMemorySize, pNew, TRUE));
	pNew = xfree(pNew);
	/*draw_translateText(&pDiag->tInfo);*/
	pDiag->lXleft += lStringWidth;
	TRACE_MSG("leaving vSubstring2Diagram");
} /* end of vSubstring2Diagram */

/*
 * vImage2Diagram - put an image into a diagram
 */
void
vImage2Diagram(diagram_type *pDiag, const imagedata_type *pImg,
	UCHAR *pucImage, size_t tImageSize)
{
  	drawfile_object	*pNew;
	long	lWidth, lHeight;
	size_t	tRealSize, tSize;

	TRACE_MSG("vImage2Diagram");

	fail(pDiag == NULL);
	fail(pImg == NULL);
	fail(pDiag->lXleft < 0);
	fail(pImg->eImageType != imagetype_is_dib &&
	     pImg->eImageType != imagetype_is_jpeg);

	DBG_DEC_C(pDiag->lXleft != 0, pDiag->lXleft);

	lWidth = lPoints2DrawUnits(pImg->iHorSizeScaled);
	lHeight = lPoints2DrawUnits(pImg->iVerSizeScaled);
	DBG_DEC(lWidth);
	DBG_DEC(lHeight);

	pDiag->lYtop -= lHeight;

	tRealSize = offsetof(drawfile_object, data);
	switch (pImg->eImageType) {
	case imagetype_is_dib:
		tRealSize += sizeof(drawfile_sprite) + tImageSize;
		tSize = ROUND4(tRealSize);
		vExtendDiagramSize(pDiag, tSize);
		pNew = xmalloc(tSize);
		memset(pNew, 0, tSize);
		pNew->type = drawfile_TYPE_SPRITE;
		pNew->size = tSize;
		pNew->data.sprite.bbox.min.x = (int)pDiag->lXleft;
		pNew->data.sprite.bbox.min.y = (int)pDiag->lYtop;
		pNew->data.sprite.bbox.max.x = (int)(pDiag->lXleft + lWidth);
		pNew->data.sprite.bbox.max.y = (int)(pDiag->lYtop + lHeight);
		memcpy(&pNew->data.sprite.header, pucImage, tImageSize);
		break;
	case imagetype_is_jpeg:
#if defined(DEBUG)
		(void)bGetJpegInfo(pucImage, tImageSize);
#endif /* DEBUG */
		tRealSize += sizeof(drawfile_jpeg) + tImageSize;
		tSize = ROUND4(tRealSize);
		vExtendDiagramSize(pDiag, tSize);
		pNew = xmalloc(tSize);
		memset(pNew, 0, tSize);
		pNew->type = drawfile_TYPE_JPEG;
		pNew->size = tSize;
		pNew->data.jpeg.bbox.min.x = (int)pDiag->lXleft;
		pNew->data.jpeg.bbox.min.y = (int)pDiag->lYtop;
		pNew->data.jpeg.bbox.max.x = (int)(pDiag->lXleft + lWidth);
		pNew->data.jpeg.bbox.max.y = (int)(pDiag->lYtop + lHeight);
		pNew->data.jpeg.width = (int)lWidth;
		pNew->data.jpeg.height = (int)lHeight;
		pNew->data.jpeg.xdpi = 90;
		pNew->data.jpeg.ydpi = 90;
		pNew->data.jpeg.trfm.entries[0][0] = 0x10000;
		pNew->data.jpeg.trfm.entries[0][1] = 0;
		pNew->data.jpeg.trfm.entries[1][0] = 0;
		pNew->data.jpeg.trfm.entries[1][1] = 0x10000;
		pNew->data.jpeg.trfm.entries[2][0] = (int)pDiag->lXleft;
		pNew->data.jpeg.trfm.entries[2][1] = (int)pDiag->lYtop;
		pNew->data.jpeg.len = tImageSize;
		memcpy(pNew->data.jpeg.data, pucImage, tImageSize);
		break;
	default:
		DBG_DEC(pImg->eImageType);
		pNew = NULL;
		break;
	}

	Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
					pDiag->tMemorySize, pNew, TRUE));
	pNew = xfree(pNew);
	pDiag->lXleft = 0;
} /* end of vImage2Diagram */

/*
 * bAddDummyImage - add a dummy image
 *
 * return TRUE when successful, otherwise FALSE
 */
BOOL
bAddDummyImage(diagram_type *pDiag, const imagedata_type *pImg)
{
  	drawfile_object	*pNew;
	int	*piTmp;
	long	lWidth, lHeight;
	size_t	tRealSize, tSize;

	TRACE_MSG("bAddDummyImage");

	fail(pDiag == NULL);
	fail(pImg == NULL);
	fail(pDiag->lXleft < 0);

	if (pImg->iVerSizeScaled <= 0 || pImg->iHorSizeScaled <= 0) {
		return FALSE;
	}

	DBG_DEC_C(pDiag->lXleft != 0, pDiag->lXleft);

	lWidth = lPoints2DrawUnits(pImg->iHorSizeScaled);
	lHeight = lPoints2DrawUnits(pImg->iVerSizeScaled);

	pDiag->lYtop -= lHeight;

	tRealSize = offsetof(drawfile_object, data);
	tRealSize += sizeof(drawfile_path) + (14 - 1) * sizeof(int);
	tSize = ROUND4(tRealSize);
	vExtendDiagramSize(pDiag, tSize);
	pNew = xmalloc(tSize);
	memset(pNew, 0, tSize);
	pNew->type = drawfile_TYPE_PATH;
	pNew->size = tSize;
	pNew->data.path.bbox.min.x = (int)pDiag->lXleft;
	pNew->data.path.bbox.min.y = (int)pDiag->lYtop;
	pNew->data.path.bbox.max.x = (int)(pDiag->lXleft + lWidth);
	pNew->data.path.bbox.max.y = (int)(pDiag->lYtop + lHeight);
	pNew->data.path.fill.value = -1;
	pNew->data.path.outline.value = 0x4d4d4d00;	/* Gray 70 percent */
	pNew->data.path.width = (int)lMilliPoints2DrawUnits(500);
	pNew->data.path.style.flags = 0;
	pNew->data.path.style.reserved = 0;
	pNew->data.path.style.cap_width = 0;
	pNew->data.path.style.cap_length = 0;
	piTmp = pNew->data.path.path;
	*piTmp++ = drawfile_PATH_MOVE_TO;
	*piTmp++ = pNew->data.path.bbox.min.x;
	*piTmp++ = pNew->data.path.bbox.min.y;
	*piTmp++ = drawfile_PATH_LINE_TO;
	*piTmp++ = pNew->data.path.bbox.min.x;
	*piTmp++ = pNew->data.path.bbox.max.y;
	*piTmp++ = drawfile_PATH_LINE_TO;
	*piTmp++ = pNew->data.path.bbox.max.x;
	*piTmp++ = pNew->data.path.bbox.max.y;
	*piTmp++ = drawfile_PATH_LINE_TO;
	*piTmp++ = pNew->data.path.bbox.max.x;
	*piTmp++ = pNew->data.path.bbox.min.y;
	*piTmp++ = drawfile_PATH_CLOSE_LINE;
	*piTmp++ = drawfile_PATH_END_PATH;

	Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
					pDiag->tMemorySize, pNew, TRUE));
	pNew = xfree(pNew);
	pDiag->lXleft = 0;
	return TRUE;
} /* end of bAddDummyImage */

/*
 * vMove2NextLine - move to the next line
 */
void
vMove2NextLine(diagram_type *pDiag, drawfile_fontref tFontRef,
	USHORT usFontSize)
{
	long	l20;

	TRACE_MSG("vMove2NextLine");

	fail(pDiag == NULL);
	fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);

	if (tFontRef == 0) {
		l20 = Drawfile_ScreenToDraw(32 + 3);
	} else {
		l20 = lWord2DrawUnits20(usFontSize);
	}
	pDiag->lYtop -= l20;
} /* end of vMove2NextLine */

/*
 * Create an start of paragraph (Phase 1)
 */
void
vStartOfParagraph1(diagram_type *pDiag, long lBeforeIndentation)
{
	TRACE_MSG("vStartOfParagraph1");

	fail(pDiag == NULL);
	fail(lBeforeIndentation < 0);

	pDiag->lXleft = 0;
	pDiag->lYtop -= lMilliPoints2DrawUnits(lBeforeIndentation);
} /* end of vStartOfParagraph1 */

/*
 * Create an start of paragraph (Phase 2)
 * DUMMY function
 */
void
vStartOfParagraph2(diagram_type *pDiag)
{
	TRACE_MSG("vStartOfParagraph2");
} /* end of vStartOfParagraph2 */

/*
 * Create an end of paragraph
 */
void
vEndOfParagraph(diagram_type *pDiag,
	drawfile_fontref tFontRef, USHORT usFontSize, long lAfterIndentation)
{
	TRACE_MSG("vEndOfParagraph");

	fail(pDiag == NULL);
	fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
	fail(lAfterIndentation < 0);

	pDiag->lXleft = 0;
	pDiag->lYtop -= lMilliPoints2DrawUnits(lAfterIndentation);
} /* end of vEndOfParagraph */

/*
 * Create an end of page
 */
void
vEndOfPage(diagram_type *pDiag, long lAfterIndentation, BOOL bNewSection)
{
	TRACE_MSG("vEndOfPage");

	fail(pDiag == NULL);
	fail(lAfterIndentation < 0);

	pDiag->lXleft = 0;
	pDiag->lYtop -= lMilliPoints2DrawUnits(lAfterIndentation);
} /* end of vEndOfPage */

/*
 * vSetHeaders - set the headers
 * DUMMY function
 */
void
vSetHeaders(diagram_type *pDiag, USHORT usIstd)
{
	TRACE_MSG("vSetHeaders");
} /* end of vSetHeaders */

/*
 * Create a start of list
 * DUMMY function
 */
void
vStartOfList(diagram_type *pDiag, UCHAR ucNFC, BOOL bIsEndOfTable)
{
	TRACE_MSG("vStartOfList");
} /* end of vStartOfList */

/*
 * Create an end of list
 * DUMMY function
 */
void
vEndOfList(diagram_type *pDiag)
{
	TRACE_MSG("vEndOfList");
} /* end of vEndOfList */

/*
 * Create a start of a list item
 * DUMMY function
 */
void
vStartOfListItem(diagram_type *pDiag, BOOL bNoMarks)
{
	TRACE_MSG("vStartOfListItem");
} /* end of vStartOfListItem */

/*
 * Create an end of a table
 * DUMMY function
 */
void
vEndOfTable(diagram_type *pDiag)
{
	TRACE_MSG("vEndOfTable");
} /* end of vEndTable */

/*
 * Add a table row
 * DUMMY function
 *
 * Returns TRUE when conversion type is XML
 */
BOOL
bAddTableRow(diagram_type *pDiag, char **aszColTxt,
	int iNbrOfColumns, const short *asColumnWidth, UCHAR ucBorderInfo)
{
	TRACE_MSG("bAddTableRow");

	return FALSE;
} /* end of bAddTableRow */

/*
 * vForceRedraw - force a redraw of the main window
 */
static void
vForceRedraw(diagram_type *pDiag)
{
	window_state		tWindowState;
	window_redrawblock	tRedraw;
	int	x0, y0, x1, y1;

	TRACE_MSG("vForceRedraw");

	fail(pDiag == NULL);

	DBG_DEC(pDiag->iScaleFactorCurr);

	/* Read the size of the current diagram */
	Drawfile_QueryBox(&pDiag->tInfo, &tRedraw.rect, TRUE);
	/* Adjust the size of the work area */
	x0 = tRedraw.rect.min.x * pDiag->iScaleFactorCurr / 100 - 1;
	y0 = tRedraw.rect.min.y * pDiag->iScaleFactorCurr / 100 - 1;
	x1 = tRedraw.rect.max.x * pDiag->iScaleFactorCurr / 100 + 1;
	y1 = tRedraw.rect.max.y * pDiag->iScaleFactorCurr / 100 + 1;
	/* Work area extension */
	x0 -= WORKAREA_EXTENSION;
	y0 -= WORKAREA_EXTENSION;
	x1 += WORKAREA_EXTENSION;
	y1 += WORKAREA_EXTENSION;
	Window_SetExtent(pDiag->tMainWindow, x0, y0, x1, y1);
	/* Widen the box slightly to be sure all the edges are drawn */
	x0 -= 5;
	y0 -= 5;
	x1 += 5;
	y1 += 5;
	/* Force the redraw */
	Window_ForceRedraw(pDiag->tMainWindow, x0, y0, x1, y1);
	/* Reopen the window to show the correct size */
	Error_CheckFatal(Wimp_GetWindowState(pDiag->tMainWindow, &tWindowState));
	tWindowState.openblock.behind = -1;
	Error_CheckFatal(Wimp_OpenWindow(&tWindowState.openblock));
} /* end of vForceRedraw */

/*
 * vShowDiagram - put the diagram on the screen
 */
void
vShowDiagram(diagram_type *pDiag)
{
	wimp_box	tRect;
	int	x0, y0, x1, y1;

	TRACE_MSG("vShowDiagram");

	fail(pDiag == NULL);

	Window_Show(pDiag->tMainWindow, open_NEARLAST);
	Drawfile_QueryBox(&pDiag->tInfo, &tRect, TRUE);
	/* Work area extension */
	x0 = tRect.min.x - WORKAREA_EXTENSION;
	y0 = tRect.min.y - WORKAREA_EXTENSION;
	x1 = tRect.max.x + WORKAREA_EXTENSION;
	y1 = tRect.max.y + WORKAREA_EXTENSION;
	Window_SetExtent(pDiag->tMainWindow, x0, y0, x1, y1);
	vForceRedraw(pDiag);
} /* end of vShowDiagram */

/*
 * vMainButtonClick - handle mouse buttons clicks for the main screen
 */
void
vMainButtonClick(mouse_block *pMouse)
{
	caret_block	tCaret;
	window_state	ws;

	TRACE_MSG("vMainButtonClick");

	fail(pMouse == NULL);

	DBG_DEC(pMouse->button.data.select);
	DBG_DEC(pMouse->button.data.adjust);
	DBG_DEC(pMouse->window);
	DBG_DEC(pMouse->icon);

	if (pMouse->window >= 0 &&
	    pMouse->icon == -1 &&
	    (pMouse->button.data.select || pMouse->button.data.adjust)) {
		/* Get the input focus */
		Error_CheckFatal(Wimp_GetWindowState(pMouse->window, &ws));
		tCaret.window = pMouse->window;
		tCaret.icon = -1;
		tCaret.offset.x = pMouse->pos.x - ws.openblock.screenrect.min.x;
		tCaret.offset.y = pMouse->pos.y - ws.openblock.screenrect.max.y;
		tCaret.height = (int)BIT(25);
		tCaret.index = 0;
		Error_CheckFatal(Wimp_SetCaretPosition(&tCaret));
	}
} /* end of vMainButtonClick */

/*
 * bMainKeyPressed - handle pressed keys for the main window
 */
BOOL
bMainKeyPressed(event_pollblock *pEvent, void *pvReference)
{
	diagram_type 	*pDiag;

	TRACE_MSG("bMainKeyPressed");

	fail(pEvent == NULL);
	fail(pEvent->type != event_KEY);
	fail(pvReference == NULL);

	pDiag = (diagram_type *)pvReference;

	fail(pEvent->data.key.caret.window != pDiag->tMainWindow);


	switch (pEvent->data.key.code) {
	case keycode_CTRL_F2:		/* Ctrl F2 */
		bDestroyDiagram(pEvent, pvReference);
		break;
	case keycode_F3:		/* F3 */
		bSaveDrawfile(pEvent, pvReference);
		break;
	case keycode_SHIFT_F3:		/* Shift F3 */
		bSaveTextfile(pEvent, pvReference);
		break;
	default:
		DBG_DEC(pEvent->data.key.code);
		Error_CheckFatal(Wimp_ProcessKey(pEvent->data.key.code));
	}
	return TRUE;
} /* end of bMainKeyPressed */

/*
 * bRedrawMainWindow - redraw the main window
 */
BOOL
bRedrawMainWindow(event_pollblock *pEvent, void *pvReference)
{
	window_redrawblock	tBlock;
	diagram_type	*pDiag;
	drawfile_info	*pInfo;
	double		dScaleFactor;
	BOOL		bMore;

	TRACE_MSG("bRedrawMainWindow");

	fail(pEvent == NULL);
	fail(pEvent->type != event_REDRAW);
	fail(pvReference == NULL);

	pDiag = (diagram_type *)pvReference;

	fail(pDiag->tMainWindow != pEvent->data.openblock.window);
	fail(pDiag->iScaleFactorCurr < MIN_SCALE_FACTOR);
	fail(pDiag->iScaleFactorCurr > MAX_SCALE_FACTOR);

	dScaleFactor = (double)pDiag->iScaleFactorCurr / 100.0;
	pInfo = &pDiag->tInfo;

	tBlock.window = pEvent->data.openblock.window;
	Error_CheckFatal(Wimp_RedrawWindow(&tBlock, &bMore));

	/* If there is no real diagram just go thru the motions */
	while (bMore) {
		if (pInfo->data != NULL && pInfo->length != 0) {
			Error_CheckFatal(Drawfile_RenderDiagram(pInfo,
						&tBlock, dScaleFactor));
		}
		Error_CheckFatal(Wimp_GetRectangle(&tBlock, &bMore));
	}
	return TRUE;
} /* end of bRedrawMainWindow */

/*
 * bScaleOpenAction - action to be taken when the Scale view window opens
 */
BOOL
bScaleOpenAction(event_pollblock *pEvent, void *pvReference)
{
	window_state	tWindowState;
	diagram_type	*pDiag;

	TRACE_MSG("bScaleOpenAction");

	fail(pEvent == NULL);
	fail(pEvent->type != event_SEND);
	fail(pEvent->data.message.header.action != message_MENUWARN);
	fail(pvReference == NULL);

	pDiag = (diagram_type *)pvReference;

	if (menu_currentopen != pDiag->pSaveMenu ||
	    pEvent->data.message.data.menuwarn.selection[0] != SAVEMENU_SCALEVIEW) {
		return FALSE;
	}

	Error_CheckFatal(Wimp_GetWindowState(pDiag->tScaleWindow,
						&tWindowState));
	if (tWindowState.flags.data.open) {
		/* The window is already open */
		return TRUE;
	}

	DBG_MSG("vScaleOpenAction for real");

	pDiag->iScaleFactorTemp = pDiag->iScaleFactorCurr;
	vUpdateWriteableNumber(pDiag->tScaleWindow,
			SCALE_SCALE_WRITEABLE, pDiag->iScaleFactorTemp);
	Window_Show(pDiag->tScaleWindow, open_UNDERPOINTER);
	return TRUE;
} /* end of bScaleOpenAction */

/*
 * vSetTitle - set the title of a window
 */
void
vSetTitle(diagram_type *pDiag)
{
	char	szTitle[WINDOW_TITLE_LEN];

	TRACE_MSG("vSetTitle");

	fail(pDiag == NULL);
	fail(pDiag->szFilename[0] == '\0');

	(void)sprintf(szTitle, "%.*s at %d%%",
				FILENAME_TITLE_LEN,
				pDiag->szFilename,
				pDiag->iScaleFactorCurr % 1000);
	if (strlen(pDiag->szFilename) > FILENAME_TITLE_LEN) {
		szTitle[FILENAME_TITLE_LEN - 1] = OUR_ELLIPSIS;
	}

	Window_SetTitle(pDiag->tMainWindow, szTitle);
} /* end of vSetTitle */

/*
 * vScaleButtonClick - handle a mouse button click in the Scale view window
 */
void
vScaleButtonClick(mouse_block *pMouse, diagram_type *pDiag)
{
	BOOL	bCloseWindow, bRedraw;

	TRACE_MSG("vScaleButtonClick");

	fail(pMouse == NULL || pDiag == NULL);
	fail(pMouse->window != pDiag->tScaleWindow);

	bCloseWindow = FALSE;
	bRedraw = FALSE;
	switch (pMouse->icon) {
	case SCALE_CANCEL_BUTTON:
		bCloseWindow = TRUE;
		pDiag->iScaleFactorTemp = pDiag->iScaleFactorCurr;
		break;
	case SCALE_SCALE_BUTTON:
		bCloseWindow = TRUE;
		bRedraw = pDiag->iScaleFactorCurr != pDiag->iScaleFactorTemp;
		pDiag->iScaleFactorCurr = pDiag->iScaleFactorTemp;
		break;
	case SCALE_50_PCT:
		pDiag->iScaleFactorTemp = 50;
		break;
	case SCALE_75_PCT:
		pDiag->iScaleFactorTemp = 75;
		break;
	case SCALE_100_PCT:
		pDiag->iScaleFactorTemp = 100;
		break;
	case SCALE_150_PCT:
		pDiag->iScaleFactorTemp = 150;
		break;
	default:
		DBG_DEC(pMouse->icon);
		break;
	}
	if (bCloseWindow) {
		/* Close the scale window */
		Error_CheckFatal(Wimp_CloseWindow(pMouse->window));
		if (bRedraw) {
			/* Redraw the main window */
			vSetTitle(pDiag);
			vForceRedraw(pDiag);
		}
	} else {
		vUpdateWriteableNumber(pMouse->window,
				SCALE_SCALE_WRITEABLE,
				pDiag->iScaleFactorTemp);
	}
} /* end of vScaleButtonClick */

/*
 * bScaleKeyPressed - handle pressed keys for the scale window
 */
BOOL
bScaleKeyPressed(event_pollblock *pEvent, void *pvReference)
{
	icon_block	tIcon;
	diagram_type	*pDiag;
	caret_block	*pCaret;
	char		*pcChar;
	int		iTmp;

	TRACE_MSG("bScaleKeyPressed");

        fail(pEvent == NULL);
        fail(pEvent->type != event_KEY);
        fail(pvReference == NULL);

	pCaret = &pEvent->data.key.caret;
	pDiag = (diagram_type *)pvReference;

        fail(pEvent->data.key.caret.window != pDiag->tScaleWindow);

	DBG_DEC_C(pCaret->icon != SCALE_SCALE_WRITEABLE, pCaret->icon);
	DBG_DEC_C(pCaret->icon == SCALE_SCALE_WRITEABLE, pEvent->data.key.code);

	if (pEvent->data.key.code != '\r' ||
	    pCaret->icon != SCALE_SCALE_WRITEABLE) {
		Error_CheckFatal(Wimp_ProcessKey(pEvent->data.key.code));
		return TRUE;
	}

	Error_CheckFatal(Wimp_GetIconState(pCaret->window, pCaret->icon, &tIcon));
	if (!tIcon.flags.data.text || !tIcon.flags.data.indirected) {
		werr(1, "Icon %d must be indirected text", (int)pCaret->icon);
	}
	iTmp = (int)strtol(tIcon.data.indirecttext.buffer, &pcChar, 10);
	if (*pcChar != '\0' && *pcChar != '\r') {
		DBG_DEC(*pcChar);
	} else if (iTmp < MIN_SCALE_FACTOR) {
		pDiag->iScaleFactorTemp = MIN_SCALE_FACTOR;
	} else if (iTmp > MAX_SCALE_FACTOR) {
		pDiag->iScaleFactorTemp = MAX_SCALE_FACTOR;
	} else {
		pDiag->iScaleFactorTemp = iTmp;
	}
	pDiag->iScaleFactorCurr = pDiag->iScaleFactorTemp;
	/* Close the scale window */
	Error_CheckFatal(Wimp_CloseWindow(pCaret->window));
	/* Redraw the main window */
	vSetTitle(pDiag);
	vForceRedraw(pDiag);
	return TRUE;
} /* end of bScaleKeyPressed */