examples/PIPS/antiword/src/saveas.c

/*
 * 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 */

---