saveas.c

   1 /*
   2  * saveas.c
   3  * Copyright (C) 1998-2001 A.J. van Os; Released under GPL
   4  *
   5  * Description:
   6  * Functions to save the results as a textfile or a drawfile
   7  */
   8
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include "saveas.h"
  12 #include "event.h"
  13 #include "antiword.h"
  14
  15 static BOOL
  16 bWrite2File(void *pvBytes, size_t tSize, FILE *pFile, const char *szFilename)
  17 {
  18         if (fwrite(pvBytes, sizeof(char), tSize, pFile) != tSize) {
  19                 werr(0, "I can't write to '%s'", szFilename);
  20                 return FALSE;
  21         }
  22         return TRUE;
  23 } /* end of bWrite2File */
  24
  25 /*
  26  * bText2File - Save the generated draw file to a Text file
  27  */
  28 static BOOL
  29 bText2File(char *szFilename, void *pvHandle)
  30 {
  31         FILE    *pFile;
  32         diagram_type    *pDiag;
  33         draw_textstrhdr tText;
  34         char    *pcTmp;
  35         int     iToGo, iSize, iX, iYtopPrev, iHeight, iLines;
  36         BOOL    bFirst, bIndent, bSuccess;
  37
  38         fail(szFilename == NULL || szFilename[0] == '\0');
  39         fail(pvHandle == NULL);
  40
  41         DBG_MSG("bText2File");
  42         DBG_MSG(szFilename);
  43
  44         pDiag = (diagram_type *)pvHandle;
  45         pFile = fopen(szFilename, "w");
  46         if (pFile == NULL) {
  47                 werr(0, "I can't open '%s' for writing", szFilename);
  48                 return FALSE;
  49         }
  50         bFirst = TRUE;
  51         iYtopPrev = 0;
  52         iHeight = (int)lWord2DrawUnits20(DEFAULT_FONT_SIZE);
  53         bSuccess = TRUE;
  54         iToGo = pDiag->tInfo.length - sizeof(draw_fileheader);
  55         DBG_DEC(iToGo);
  56         pcTmp = pDiag->tInfo.data + sizeof(draw_fileheader);
  57         while (iToGo > 0 && bSuccess) {
  58                 tText = *(draw_textstrhdr *)pcTmp;
  59                 switch (tText.tag) {
  60                 case draw_OBJFONTLIST:
  61                         /* These are not relevant in a textfile */
  62                         iSize = ((draw_fontliststrhdr *)pcTmp)->size;
  63                         pcTmp += iSize;
  64                         iToGo -= iSize;
  65                         break;
  66                 case draw_OBJTEXT:
  67                         /* Compute the number of lines */
  68                         iLines =
  69                         (iYtopPrev - tText.bbox.y1 + iHeight / 2) / iHeight;
  70                         fail(iLines < 0);
  71                         bIndent = iLines > 0 || bFirst;
  72                         bFirst = FALSE;
  73                         /* Print the newlines */
  74                         while (iLines > 0 && bSuccess) {
  75                                 bSuccess = bWrite2File("\n",
  76                                         1, pFile, szFilename);
  77                                 iLines--;
  78                         }
  79                         /* Print the indentation */
  80                         if (bIndent && bSuccess) {
  81                                 for (iX = draw_screenToDraw(8);
  82                                      iX <= tText.bbox.x0 && bSuccess;
  83                                      iX += draw_screenToDraw(16)) {
  84                                         bSuccess = bWrite2File(" ",
  85                                                 1, pFile, szFilename);
  86                                 }
  87                         }
  88                         if (!bSuccess) {
  89                                 break;
  90                         }
  91                         /* Print the text object */
  92                         pcTmp += sizeof(tText);
  93                         bSuccess = bWrite2File(pcTmp,
  94                                 strlen(pcTmp), pFile, szFilename);
  95                         pcTmp += tText.size - sizeof(tText);
  96                         /* Setup for the next text object */
  97                         iToGo -= tText.size;
  98                         iYtopPrev = tText.bbox.y1;
  99                         iHeight = tText.bbox.y1 - tText.bbox.y0;
 100                         break;
 101                 case draw_OBJPATH:
 102                         /* These are not relevant in a textfile */
 103                         iSize = ((draw_pathstrhdr *)pcTmp)->size;
 104                         pcTmp += iSize;
 105                         iToGo -= iSize;
 106                         break;
 107                 case draw_OBJSPRITE:
 108                 case draw_OBJJPEG:
 109                         /* These are not relevant in a textfile */
 110                         iSize = ((draw_spristrhdr *)pcTmp)->size;
 111                         pcTmp += iSize;
 112                         iToGo -= iSize;
 113                         break;
 114                 default:
 115                         DBG_DEC(tText.tag);
 116                         bSuccess = FALSE;
 117                         break;
 118                 }
 119         }
 120         DBG_DEC_C(iToGo != 0, iToGo);
 121         if (bSuccess) {
 122                 bSuccess = bWrite2File("\n", 1, pFile, szFilename);
 123         }
 124         (void)fclose(pFile);
 125         if (bSuccess) {
 126                 vSetFiletype(szFilename, FILETYPE_TEXT);
 127         } else {
 128                 (void)remove(szFilename);
 129                 werr(0, "Unable to save textfile '%s'", szFilename);
 130         }
 131         return bSuccess;
 132 } /* end of bText2File */
 133
 134 /*
 135  * vSaveTextfile
 136  */
 137 void
 138 vSaveTextfile(diagram_type *pDiagram)
 139 {
 140         wimp_emask      tMask;
 141         int             iRecLen, iNbrRecs, iEstSize;
 142
 143         fail(pDiagram == NULL);
 144
 145         DBG_MSG("vSaveTextfile");
 146         iRecLen = sizeof(draw_textstrhdr) + DEFAULT_SCREEN_WIDTH * 2 / 3;
 147         iNbrRecs = pDiagram->tInfo.length / iRecLen + 1;
 148         iEstSize = iNbrRecs * DEFAULT_SCREEN_WIDTH * 2 / 3;
 149         DBG_DEC(iEstSize);
 150
 151         tMask = event_getmask();
 152         event_setmask(0);
 153         saveas(FILETYPE_TEXT, "WordText",
 154                 iEstSize, bText2File,
 155                 NULL, NULL, pDiagram);
 156         event_setmask(tMask);
 157 } /* end of vSaveTextfile */
 158
 159 /*
 160  * bDraw2File - Save the generated draw file to a Draw file
 161  *
 162  * Remark: This is not a simple copy action. The origin of the
 163  * coordinates (0,0) must move from the top-left corner to the
 164  * bottom-left corner.
 165  */
 166 static BOOL
 167 bDraw2File(char *szFilename, void *pvHandle)
 168 {
 169         FILE            *pFile;
 170         diagram_type    *pDiagram;
 171         draw_fileheader tHdr;
 172         draw_textstrhdr tText;
 173         draw_pathstrhdr tPath;
 174         draw_spristrhdr tSprite;
 175         draw_jpegstrhdr tJpeg;
 176         int     *piPath;
 177         char    *pcTmp;
 178         int     iYadd, iToGo, iSize;
 179         BOOL    bSuccess;
 180
 181         fail(szFilename == NULL || szFilename[0] == '\0');
 182         fail(pvHandle == NULL);
 183
 184         DBG_MSG("bDraw2File");
 185         NO_DBG_MSG(szFilename);
 186
 187         pDiagram = (diagram_type *)pvHandle;
 188         pFile = fopen(szFilename, "wb");
 189         if (pFile == NULL) {
 190                 werr(0, "I can't open '%s' for writing", szFilename);
 191                 return FALSE;
 192         }
 193         iToGo = pDiagram->tInfo.length;
 194         DBG_DEC(iToGo);
 195         pcTmp = pDiagram->tInfo.data;
 196         tHdr = *(draw_fileheader *)pcTmp;
 197         iYadd = -tHdr.bbox.y0;
 198         tHdr.bbox.y0 += iYadd;
 199         tHdr.bbox.y1 += iYadd;
 200         bSuccess = bWrite2File(&tHdr, sizeof(tHdr), pFile, szFilename);
 201         iToGo -= sizeof(tHdr);
 202         DBG_DEC(iToGo);
 203         pcTmp += sizeof(tHdr);
 204         while (iToGo > 0 && bSuccess) {
 205                 tText = *(draw_textstrhdr *)pcTmp;
 206                 switch (tText.tag) {
 207                 case draw_OBJFONTLIST:
 208                         iSize = ((draw_fontliststrhdr *)pcTmp)->size;
 209                         bSuccess = bWrite2File(pcTmp,
 210                                         iSize, pFile, szFilename);
 211                         pcTmp += iSize;
 212                         iToGo -= iSize;
 213                         break;
 214                 case draw_OBJTEXT:
 215                         /* First correct the coordinates */
 216                         tText.bbox.y0 += iYadd;
 217                         tText.bbox.y1 += iYadd;
 218                         tText.coord.y += iYadd;
 219                         /* Now write the information to file */
 220                         bSuccess = bWrite2File(&tText,
 221                                 sizeof(tText), pFile, szFilename);
 222                         pcTmp += sizeof(tText);
 223                         iSize = tText.size - sizeof(tText);
 224                         if (bSuccess) {
 225                                 bSuccess = bWrite2File(pcTmp,
 226                                         iSize, pFile, szFilename);
 227                                 pcTmp += iSize;
 228                         }
 229                         iToGo -= tText.size;
 230                         break;
 231                 case draw_OBJPATH:
 232                         tPath = *(draw_pathstrhdr *)pcTmp;
 233                         /* First correct the coordinates */
 234                         tPath.bbox.y0 += iYadd;
 235                         tPath.bbox.y1 += iYadd;
 236                         /* Now write the information to file */
 237                         bSuccess = bWrite2File(&tPath,
 238                                 sizeof(tPath), pFile, szFilename);
 239                         pcTmp += sizeof(tPath);
 240                         iSize = tPath.size - sizeof(tPath);
 241                         fail(iSize < 14 * sizeof(int));
 242                         /* Second correct the path coordinates */
 243                         piPath = xmalloc(iSize);
 244                         memcpy(piPath, pcTmp, iSize);
 245                         piPath[ 2] += iYadd;
 246                         piPath[ 5] += iYadd;
 247                         piPath[ 8] += iYadd;
 248                         piPath[11] += iYadd;
 249                         if (bSuccess) {
 250                                 bSuccess = bWrite2File(piPath,
 251                                         iSize, pFile, szFilename);
 252                                 pcTmp += iSize;
 253                         }
 254                         piPath = xfree(piPath);
 255                         iToGo -= tPath.size;
 256                         break;
 257                 case draw_OBJSPRITE:
 258                         tSprite = *(draw_spristrhdr *)pcTmp;
 259                         /* First correct the coordinates */
 260                         tSprite.bbox.y0 += iYadd;
 261                         tSprite.bbox.y1 += iYadd;
 262                         /* Now write the information to file */
 263                         bSuccess = bWrite2File(&tSprite,
 264                                 sizeof(tSprite), pFile, szFilename);
 265                         pcTmp += sizeof(tSprite);
 266                         iSize = tSprite.size - sizeof(tSprite);
 267                         if (bSuccess) {
 268                                 bSuccess = bWrite2File(pcTmp,
 269                                         iSize, pFile, szFilename);
 270                                 pcTmp += iSize;
 271                         }
 272                         iToGo -= tSprite.size;
 273                         break;
 274                 case draw_OBJJPEG:
 275                         tJpeg = *(draw_jpegstrhdr *)pcTmp;
 276                         /* First correct the coordinates */
 277                         tJpeg.bbox.y0 += iYadd;
 278                         tJpeg.bbox.y1 += iYadd;
 279                         tJpeg.trfm[5] += iYadd;
 280                         /* Now write the information to file */
 281                         bSuccess = bWrite2File(&tJpeg,
 282                                 sizeof(tJpeg), pFile, szFilename);
 283                         pcTmp += sizeof(tJpeg);
 284                         iSize = tJpeg.size - sizeof(tJpeg);
 285                         if (bSuccess) {
 286                                 bSuccess = bWrite2File(pcTmp,
 287                                         iSize, pFile, szFilename);
 288                                 pcTmp += iSize;
 289                         }
 290                         iToGo -= tJpeg.size;
 291                         break;
 292                 default:
 293                         DBG_DEC(tText.tag);
 294                         bSuccess = FALSE;
 295                         break;
 296                 }
 297         }
 298         DBG_DEC_C(iToGo != 0, iToGo);
 299         (void)fclose(pFile);
 300         if (bSuccess) {
 301                 vSetFiletype(szFilename, FILETYPE_DRAW);
 302         } else {
 303                 (void)remove(szFilename);
 304                 werr(0, "Unable to save drawfile '%s'", szFilename);
 305         }
 306         return bSuccess;
 307 } /* end of bDraw2File */
 308
 309 /*
 310  * vSaveDrawfile
 311  */
 312 void
 313 vSaveDrawfile(diagram_type *pDiagram)
 314 {
 315         wimp_emask      tMask;
 316         int             iEstSize;
 317
 318         fail(pDiagram == NULL);
 319
 320         DBG_MSG("vSaveDrawfile");
 321         iEstSize = pDiagram->tInfo.length;
 322         DBG_DEC(iEstSize);
 323
 324         tMask = event_getmask();
 325         event_setmask(0);
 326         saveas(FILETYPE_DRAW, "WordDraw",
 327                 iEstSize, bDraw2File,
 328                 NULL, NULL, pDiagram);
 329         event_setmask(tMask);
 330 } /* end of vSaveDrawfile */