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

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.