Subversion Repositories planix.SVN

/*

 * saveas.c

 * Copyright (C) 1998-2001 A.J. van Os; Released under GPL

 *

 * Description:

 * Functions to save the results as a textfile or a drawfile

 */

#include <stdio.h>

#include <string.h>

#include "DeskLib:Menu.h"

#include "DeskLib:Save.h"

#include "DeskLib:Template.h"

#include "DeskLib:Window.h"

#include "drawfile.h"

#include "antiword.h"

/* The window handle of the save window */

static window_handle	tSaveWindow = 0;

/* Xfer_send box fields */

#define DRAG_SPRITE	3

#define OK_BUTTON	0

#define CANCEL_BUTTON	(-1)

#define FILENAME_ICON	2

/*

 * saveas - a wrapper around Save_InitSaveWindowhandler

 */

static void

saveas(int iFileType, char *szOutfile, size_t tEstSize,

	save_filesaver save_function, void *pvReference)

{

	TRACE_MSG("saveas");

	if (tSaveWindow == 0) {

		tSaveWindow = Window_Create("xfer_send", template_TITLEMIN);

	}

	Icon_SetText(tSaveWindow, FILENAME_ICON, szOutfile);

	Window_Show(tSaveWindow, open_UNDERPOINTER);

	(void)Save_InitSaveWindowHandler(tSaveWindow, FALSE, TRUE, TRUE,

		DRAG_SPRITE, OK_BUTTON, CANCEL_BUTTON, FILENAME_ICON,

		save_function, NULL, NULL, tEstSize, iFileType, pvReference);

} /* end of saveas */

static BOOL

bWrite2File(void *pvBytes, size_t tSize, FILE *pFile, const char *szFilename)

{

	if (fwrite(pvBytes, sizeof(char), tSize, pFile) != tSize) {

		werr(0, "I can't write to '%s'", szFilename);

		return FALSE;

	}

	return TRUE;

} /* end of bWrite2File */

/*

 * bText2File - Save the generated draw file to a Text file

 */

static BOOL

bText2File(char *szFilename, void *pvHandle)

{

	FILE	*pFile;

	diagram_type	*pDiag;

	drawfile_object	*pObj;

	drawfile_text	*pText;

	const char	*pcTmp;

	int	iToGo, iX, iYtopPrev, iHeight, iLines;

	BOOL	bFirst, bIndent, bSuccess;

	TRACE_MSG("bText2File");

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

	fail(pvHandle == NULL);

	DBG_MSG(szFilename);

	pDiag = (diagram_type *)pvHandle;

	pFile = fopen(szFilename, "w");

	if (pFile == NULL) {

		werr(0, "I can't open '%s' for writing", szFilename);

		return FALSE;

	}

	bFirst = TRUE;

	iYtopPrev = 0;

	iHeight = (int)lWord2DrawUnits20(DEFAULT_FONT_SIZE);

	bSuccess = TRUE;

	fail(pDiag->tInfo.length < offsetof(drawfile_diagram, objects));

	iToGo = pDiag->tInfo.length - offsetof(drawfile_diagram, objects);

	DBG_DEC(iToGo);

	pcTmp = (const char *)pDiag->tInfo.data +

				offsetof(drawfile_diagram, objects);

	while (iToGo > 0 && bSuccess) {

		pObj = (drawfile_object *)pcTmp;

		switch (pObj->type) {

		case drawfile_TYPE_TEXT:

			pText = &pObj->data.text;

			/* Compute the number of lines */

			iLines = (iYtopPrev - pText->bbox.max.y +

					iHeight / 2) / iHeight;

			DBG_DEC_C(iLines < 0, iYtopPrev);

			DBG_DEC_C(iLines < 0, pText->bbox.max.y);

			fail(iLines < 0);

			bIndent = iLines > 0 || bFirst;

			bFirst = FALSE;

			/* Print the newlines */

			while (iLines > 0 && bSuccess) {

				bSuccess = bWrite2File("\n",

					1, pFile, szFilename);

				iLines--;

			}

			/* Print the indentation */

			if (bIndent && bSuccess) {

				for (iX = Drawfile_ScreenToDraw(8);

				     iX <= pText->bbox.min.x && bSuccess;

				     iX += Drawfile_ScreenToDraw(16)) {

					bSuccess = bWrite2File(" ",

						1, pFile, szFilename);

				}

			}

			if (!bSuccess) {

				break;

			}

			/* Print the text object */

			bSuccess = bWrite2File(pText->text,

				strlen(pText->text), pFile, szFilename);

			/* Setup for the next object */

			iYtopPrev = pText->bbox.max.y;

			iHeight = pText->bbox.max.y - pText->bbox.min.y;

			break;

		case drawfile_TYPE_FONT_TABLE:

		case drawfile_TYPE_PATH:

		case drawfile_TYPE_SPRITE:

		case drawfile_TYPE_JPEG:

			/* These are not relevant in a textfile */

			break;

		default:

			DBG_DEC(pObj->type);

			bSuccess = FALSE;

			break;

		}

		pcTmp += pObj->size;

		iToGo -= pObj->size;

	}

	DBG_DEC_C(iToGo != 0, iToGo);

	if (bSuccess) {

		bSuccess = bWrite2File("\n", 1, pFile, szFilename);

	}

	(void)fclose(pFile);

	if (bSuccess) {

		vSetFiletype(szFilename, FILETYPE_TEXT);

	} else {

		(void)remove(szFilename);

		werr(0, "Unable to save textfile '%s'", szFilename);

	}

	return bSuccess;

} /* end of bText2File */

/*

 * bSaveTextfile - save the diagram as a text file

 */

BOOL

bSaveTextfile(event_pollblock *pEvent, void *pvReference)

{

	diagram_type	*pDiag;

	size_t	tRecLen, tNbrRecs, tEstSize;

	TRACE_MSG("bSaveTextfile");

	fail(pEvent == NULL);

	fail(pvReference == NULL);

	pDiag = (diagram_type *)pvReference;

	switch (pEvent->type) {

	case event_SEND:	/* From a menu */

		fail(pEvent->data.message.header.action != message_MENUWARN);

		if (menu_currentopen != pDiag->pSaveMenu ||

		    pEvent->data.message.data.menuwarn.selection[0] !=

							SAVEMENU_SAVETEXT) {

			return FALSE;

		}

		break;

	case event_KEY:		/* From a key short cut */

		if (pEvent->data.key.caret.window != pDiag->tMainWindow) {

			return FALSE;

		}

		break;

	default:

		DBG_DEC(pEvent->type);

		return FALSE;

	}

	tRecLen = sizeof(drawfile_text) + DEFAULT_SCREEN_WIDTH * 2 / 3;

	tNbrRecs = pDiag->tInfo.length / tRecLen + 1;

	tEstSize = tNbrRecs * DEFAULT_SCREEN_WIDTH * 2 / 3;

	DBG_DEC(tEstSize);

	saveas(FILETYPE_TEXT, "WordText", tEstSize, bText2File, pDiag);

	return TRUE;

} /* end of bSaveTextfile */

/*

 * bDraw2File - Save the generated draw file to a Draw file

 *

 * Remark: This is not a simple copy action. The origin of the

 * coordinates (0,0) must move from the top-left corner to the

 * bottom-left corner.

 */

static BOOL

bDraw2File(char *szFilename, void *pvHandle)

{

	FILE		*pFile;

	diagram_type	*pDiagram;

	wimp_box	*pBbox;

	drawfile_object	*pObj;

	drawfile_text	*pText;

	drawfile_path	*pPath;

	drawfile_sprite	*pSprite;

	drawfile_jpeg	*pJpeg;

	int	*piPath;

	char	*pcTmp;

	int	iYadd, iToGo, iSize;

	BOOL	bSuccess;

	TRACE_MSG("bDraw2File");

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

	fail(pvHandle == NULL);

	NO_DBG_MSG(szFilename);

	pDiagram = (diagram_type *)pvHandle;

	pFile = fopen(szFilename, "wb");

	if (pFile == NULL) {

		werr(0, "I can't open '%s' for writing", szFilename);

		return FALSE;

	}

	iToGo = pDiagram->tInfo.length;

	DBG_DEC(iToGo);

	pcTmp = pDiagram->tInfo.data;

	bSuccess = bWrite2File(pcTmp,

			offsetof(drawfile_diagram, bbox), pFile, szFilename);

	if (bSuccess) {

	  	pcTmp += offsetof(drawfile_diagram, bbox);

		iToGo -= offsetof(drawfile_diagram, bbox);

		pBbox = (wimp_box *)pcTmp;

		iYadd = -pBbox->min.y;

		pBbox->min.y += iYadd;

		pBbox->max.y += iYadd;

		bSuccess = bWrite2File(pcTmp,

				sizeof(*pBbox), pFile, szFilename);

		iToGo -= sizeof(*pBbox);

		DBG_DEC(iToGo);

		pcTmp += sizeof(*pBbox);

	} else {

		iYadd = 0;

	}

	while (iToGo > 0 && bSuccess) {

		pObj = (drawfile_object *)pcTmp;

		iSize = pObj->size;

		switch (pObj->type) {

		case drawfile_TYPE_FONT_TABLE:

			bSuccess = bWrite2File(pcTmp,

					iSize, pFile, szFilename);

			pcTmp += iSize;

			iToGo -= iSize;

			break;

		case drawfile_TYPE_TEXT:

			pText = &pObj->data.text;

			/* First correct the coordinates */

			pText->bbox.min.y += iYadd;

			pText->bbox.max.y += iYadd;

			pText->base.y += iYadd;

			/* Now write the information to file */

			bSuccess = bWrite2File(pcTmp,

					iSize, pFile, szFilename);

			pcTmp += pObj->size;

			iToGo -= pObj->size;

			break;

		case drawfile_TYPE_PATH:

			pPath = &pObj->data.path;

			/* First correct the coordinates */

			pPath->bbox.min.y += iYadd;

			pPath->bbox.max.y += iYadd;

			/* Now write the information to file */

			bSuccess = bWrite2File(pPath,

				sizeof(*pPath), pFile, szFilename);

			pcTmp += sizeof(*pPath);

			iSize = pObj->size - sizeof(*pPath);

			fail(iSize < 14 * sizeof(int));

			/* Second correct the path coordinates */

			piPath = xmalloc(iSize);

			memcpy(piPath, pcTmp, iSize);

			piPath[ 2] += iYadd;

			piPath[ 5] += iYadd;

			piPath[ 8] += iYadd;

			piPath[11] += iYadd;

			if (bSuccess) {

				bSuccess = bWrite2File(piPath,

					iSize, pFile, szFilename);

				pcTmp += iSize;

			}

			piPath = xfree(piPath);

			iToGo -= pObj->size;

			break;

		case drawfile_TYPE_SPRITE:

			pSprite = &pObj->data.sprite;

			/* First correct the coordinates */

			pSprite->bbox.min.y += iYadd;

			pSprite->bbox.max.y += iYadd;

			/* Now write the information to file */

			bSuccess = bWrite2File(pcTmp,

					iSize, pFile, szFilename);

			pcTmp += pObj->size;

			iToGo -= pObj->size;

			break;

		case drawfile_TYPE_JPEG:

			pJpeg = &pObj->data.jpeg;

			/* First correct the coordinates */

			pJpeg->bbox.min.y += iYadd;

			pJpeg->bbox.max.y += iYadd;

			pJpeg->trfm.entries[2][1] += iYadd;

			/* Now write the information to file */

			bSuccess = bWrite2File(pcTmp,

					iSize, pFile, szFilename);

			pcTmp += pObj->size;

			iToGo -= pObj->size;

			break;

		default:

			DBG_DEC(pObj->type);

			bSuccess = FALSE;

			break;

		}

	}

	DBG_DEC_C(iToGo != 0, iToGo);

	(void)fclose(pFile);

	if (bSuccess) {

		vSetFiletype(szFilename, FILETYPE_DRAW);

	} else {

		(void)remove(szFilename);

		werr(0, "Unable to save drawfile '%s'", szFilename);

	}

	return bSuccess;

} /* end of bDraw2File */

/*

 * bSaveDrawfile - save the diagram as a draw file

 */

BOOL

bSaveDrawfile(event_pollblock *pEvent, void *pvReference)

{

	diagram_type	*pDiag;

	size_t		tEstSize;

	TRACE_MSG("bSaveDrawfile");

	fail(pEvent == NULL);

	fail(pvReference == NULL);

	pDiag = (diagram_type *)pvReference;

	switch (pEvent->type) {

	case event_SEND:	/* From a menu */

		fail(pEvent->data.message.header.action != message_MENUWARN);

		if (menu_currentopen != pDiag->pSaveMenu ||

		    pEvent->data.message.data.menuwarn.selection[0] !=

							SAVEMENU_SAVEDRAW) {

			return FALSE;

		}

		break;

	case event_KEY:		/* From a key short cut */

		if (pEvent->data.key.caret.window != pDiag->tMainWindow) {

			return FALSE;

		}

		break;

	default:

		DBG_DEC(pEvent->type);

		return FALSE;

	}

	tEstSize = pDiag->tInfo.length;

	DBG_DEC(tEstSize);

	saveas(FILETYPE_DRAW, "WordDraw", tEstSize, bDraw2File, pDiag);

	return TRUE;

} /* end of bSaveDrawfile */