SaveText

/* Copyright 1997 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/***************************************************/
/* File   : SaveText.c                             */
/*                                                 */
/* Purpose: Save a web page as text.               */
/*                                                 */
/* Author : Merlyn Kline for Customer browser     */
/*          This source adapted by A.D.Hodgkinson  */
/*                                                 */
/* History: 24-Nov-97: Created.                    */
/***************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

#include "swis.h"
#include "flex.h"

#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */

#include "wimp.h"
#include "wimplib.h"
#include "event.h"

#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "Utils.h"

#include "Fetch.h"
#include "Filetypes.h"
#include "Forms.h"
#include "Protocols.h"
#include "Reformat.h"
#include "Save.h"
#include "SaveObject.h"

#include "SaveText.h"

/* Local statics */

static int    references         = 0;
static char   savetext_hr_text[] = "\n  --------------------------------------------------------------------------\n"; /* Use [] not char *, as sizeof() is called on this entity */
static FILE * outfile            = NULL;

/* Static function prototypes */

static int    savetext_write_bytes       (const char * s, unsigned int n);

static char * savetext_create_image_text (HStream * t, char * s, int size);
static int    savetext_write_ref         (int getsize);
static int    savetext_summarise_refs    (browser_data * b, HStream * stream, int getsize);
static int    savetext_save              (browser_data * b, HStream * stream, int getsize);

/*************************************************/
/* savetext_write_bytes()                        */
/*                                               */
/* Outputs a given number of bytes of a given    */
/* string to the FILE * set up in the global     */
/* 'outfile', returning a success flag.          */
/*                                               */
/* Parameters: Pointer to a string;              */
/*                                               */
/*             Number of characters from the     */
/*             string to save.                   */
/*                                               */
/* Returns:    1 if successful, 0 if failed.     */
/*                                               */
/* Assumes:    An appropriately opened file is   */
/*             accessible through the global     */
/*             FILE * 'outfile'.                 */
/*************************************************/

static int savetext_write_bytes(const char * s, unsigned int n)
{
  if (!s || !outfile) return 0;

  while (n && *s)
  {
    if (fputc(*s, outfile) == EOF) return 0;

    s++, n--;
  }

  return 1;
}

/*************************************************/
/* savetext_create_image_text()                  */
/*                                               */
/* Creates a string that can be used to          */
/* represent an image, using the ALT text if     */
/* present or a generic alternative from the     */
/* Messages file.                                */
/*                                               */
/* Parameters: Pointer to an HStream struct      */
/*             representing the image;           */
/*                                               */
/*             Pointer to a buffer to hold the   */
/*             string;                           */
/*                                               */
/*             Size of the buffer.               */
/*************************************************/

static char * savetext_create_image_text(HStream * t, char * s, int size)
{
  /* Quick sanity check */

  if (!s || size < 3) return s;

  /* Want to have '[', ALT text, then ']' */

  s[0] = '[';
  s[1] = 0;

  /* If there's any ALT text, strncpy this in after the opening '[' */

  if (t->text) strncpy(s + 1, t->text, size - 1);

  /* Force a terminator in the penultimate byte. This gives us room */
  /* for the closing ']', even if the strncpy above filled up the   */
  /* buffer.                                                        */

  s[size - 2] = 0;

  /* What if there was no ALT text? */

  if (s[1] == 0)
  {
    char * generic = lookup_token("SaveTextImage:Image",0,0);

    /* If there's room, use a generic string instead */

    if (size > strlen(generic) + 2) strcat(s, generic);
  }

  /* Append the closing ']' */

  strcat(s, "]");

  return s;
}

/*************************************************/
/* savetext_write_ref()                          */
/*                                               */
/* Build a reference number, returning either    */
/* a size of entity or a success flag following  */
/* writing the reference to the output file.     */
/*                                               */
/* The format specifier for the reference is     */
/* read from the Messages file.                  */
/*                                               */
/* Parameters: 1 to return the size of the       */
/*             constructed entity, 0 to return a */
/*             success flag having tried to      */
/*             write the entity to disc.         */
/*************************************************/

static int savetext_write_ref(int getsize)
{
  char * format = lookup_token("SaveTextRef: [Ref %%d]",0,0);
  char   j[64];
  int    nl;

  /* Increment the reference (anchor) count */

  references++;

  /* Check the length */

  nl = utils_number_length(references);

  if (nl + strlen(format) >= sizeof(j))
  {
    /* If it won't fit, use a simple indicator that will */

    sprintf(j, " [%d]", references);
  }
  else
  {
    /* If it will fit, use the format specified in the Messages file */

    sprintf(j, format, references);
  }

  /* Return either the size or return through the */
  /* disc output routine.                         */

  if (getsize) return strlen(j);

  return savetext_write_bytes(j, strlen(j));
}

/*************************************************/
/* savetext_summarise_refs()                     */
/*                                               */
/* Build a summary of all of the references made */
/* through the text file so far.                 */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the file;             */
/*                                               */
/*             Pointer to the first HStream of   */
/*             the list from which the refs. are */
/*             to be built;                      */
/*                                               */
/*             1 to return the size of the       */
/*             constructed entity, 0 to return a */
/*             success flag having tried to      */
/*             write the entity to disc.         */
/*************************************************/

static int savetext_summarise_refs(browser_data * b, HStream * stream, int getsize)
{
  char         j[512];
  int          size = 0;
  static int   n    = 0;
  HStream    * curr;
  HStream    * last;

  /* If there are no references, there's nothing to do. */

  if (!references) return getsize ? 0 : 1;

  if (stream == b->stream)
  {
    n = 0;

    /* Output a separator and section title, if we're not in a table cell */

    sprintf(j,
            "\n\n==============================================================================\n\n%s\n\n",
            lookup_token("SaveTextRefs:References in this document:",0,0));

    size += strlen(j);

    /* If required, try to output this to the file  */

    if (!getsize && !savetext_write_bytes(j, strlen(j))) return 0;
  }

  last = NULL;
  curr = stream;

  while (curr)
  {
    if (ISBODY(curr))
    {
      if (curr->tagno == TAG_TABLE)
      {
        table_stream   * table = (table_stream *) curr;
        table_row      * R;
        table_headdata * D;
        HStream        * attached;

        /* Scan the rows and cells */

        R = table->List;

        while (R)
        {
          D = R->List;

          while (D)
          {
            if (D->Tag)
            {
              switch (D->Tag)
              {
                case TagTableData:
                case TagTableHead:
                {
                  attached = (HStream *) D->List;

                  /* Deal with the cell contents */

                  if (getsize) size += savetext_summarise_refs(b, attached, getsize);
                  else if (!savetext_summarise_refs(b, attached, getsize)) return 0;
                }
                break;
              }
            }

            D = D->Next;
          }

          R = R->Next;
        }
      }

      /* If the current item is a link, and the last item wasn't */
      /* a link or wasn't the same link as this one (remember,   */
      /* multiple tokens can represent the same link), then      */
      /* output this as a reference. We're relying on the        */
      /* conditions under which a reference is output here being */
      /* exactly the same as those which mark a reference when   */
      /* the body of the page is being output.                   */

      if (
           ISLINK(curr)             &&
           curr->tagno != TAG_TABLE &&
           (
             !last                        ||
             !ISLINK(last)                ||
             !ISBODY(last)                ||
             last->tagno  == TAG_TABLE    ||
             last->anchor != curr->anchor
           )
         )
      {
        /* Increment the local reference counter */

        n++;
        sprintf(j, "%8d. ", n);

        /* Output the reference number if required */

        size += strlen(j);
        if (!getsize && !savetext_write_bytes(j, strlen(j))) return 0;

        /* If required, output the anchor text */

        size += strlen(curr->anchor);
        if (!getsize && !savetext_write_bytes(curr->anchor, strlen(curr->anchor))) return 0;

        /* Add a line break */

        size++;
        if (!getsize && !savetext_write_bytes("\n", 1)) return 0;
      }
    }

    /* Move on to the next item */

    last = curr;
    curr = curr->next;
  }

  /* Finished; return either the total size that would have been */
  /* output to a file, or flag success.                          */

  return getsize ? size : 1;
}

/*************************************************/
/* savetext_save()                               */
/*                                               */
/* Does the work of outputting the page as text  */
/* to a file (the FILE * should already be set   */
/* up in 'outfile') or works out how large the   */
/* file would be.                                */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the file;             */
/*                                               */
/*             Pointer to the first HStream of   */
/*             the list to output;               */
/*                                               */
/*             1 to return the size of the       */
/*             constructed file, 0 to return a   */
/*             success flag having tried to      */
/*             write the file to disc.           */
/*************************************************/

static int savetext_save(browser_data * b, HStream * stream, int getsize)
{
  HStream * curr;
  HStream * last;
  int       size = 0, s;

  curr = stream;
  last = NULL;

  /* Only zero references if we're working on the main document */
  /* stream - table cells should all add to the reference list  */

  if (stream == b->stream) references = 0;

  /* Go through the tokens */

  while (curr)
  {
    if (ISBODY(curr))
    {
      /* If we're on a line break, then write (or account for writing) */
      /* a new line, then tabs to indent to the current level of       */
      /* indentation (whatever that may be).                           */

      if (reformat_newline(curr, last, 0))
      {
        if (getsize) size += 1 + curr->indent;
        else
        {
          int i = curr->indent;

          if (!savetext_write_bytes("\n", 1)) return 0;

          while (i)
          {
            if (!savetext_write_bytes("\t", i)) return 0;
            i --;
          }
        }
      }

      /* Output a line break for paragraphs */

      if (curr->style & P)
      {
        if (getsize) size += 1;
        else if (!savetext_write_bytes("\n", 1)) return 0;
      }

      /* Hmm. A table. This'll be fun, then. */

      if (curr->tagno == TAG_TABLE)
      {
        table_stream   * table = (table_stream *) curr;
        table_row      * R;
        table_headdata * D;
        HStream        * attached;
        char             j[512];
        char             n[64];
        char           * l;
        int              cell = 0;

        strcpy(j, "\n[");

        /* Compile a description of the table */

        sprintf(n, "%d", table->RowSpan);
        l = lookup_token("SaveTextTable:Table - %0", 0, n);
        strcat(j, l);

        sprintf(n, "%d", table->ColSpan);
        if (table->RowSpan == 1) l = lookup_token("SaveTextRow: row and %0",   0, n);
        else                     l = lookup_token("SaveTextRows: rows and %0", 0, n);
        strcat(j, l);

        if (table->ColSpan == 1) l = lookup_token("SaveTextCol: column",   0, 0);
        else                     l = lookup_token("SaveTextCols: columns", 0, 0);
        strcat(j, l);

        strcat(j, "]\n");

        /* Output this description */

        if (getsize) size += strlen(j);
        else if (!savetext_write_bytes(j, strlen(j))) return 0;

        /* Scan the rows and cells */

        R = table->List;

        while (R)
        {
          D = R->List;

          while (D)
          {
            if (D->Tag)
            {
              switch (D->Tag)
              {
                case TagTableData:
                case TagTableHead:
                {
                  cell ++;

                  attached = (HStream *) D->List;

                  /* Compile a description of the cell */

                  if (cell > 1)
                  {
                    if (getsize) size += 1;
                    else if (!savetext_write_bytes("\n", 1)) return 0;
                  }

                  if (getsize) size += 2;
                  else if (!savetext_write_bytes("\n[", 2)) return 0;

                  l = lookup_token("SaveTextCell:Row %%d, column %%d", 0, 0);

                  sprintf(j,
                          l,
                          D->RowOffs + 1,
                          D->ColOffs + 1);

                  /* Output this description */

                  if (getsize) size += strlen(j);
                  else if (!savetext_write_bytes(j, strlen(j))) return 0;

                  if (getsize) size += 3;
                  else if (!savetext_write_bytes("]\n\n", 3)) return 0;

                  /* Deal with the cell contents */

                  if (getsize) size += savetext_save(b, attached, getsize);
                  else if (!savetext_save(b, attached, getsize)) return 0;
                }
                break;
              }
            }

            D = D->Next;
          }

          R = R->Next;
        }
      }

      /* Output image data */

      else if (
                (curr->style & IMG) ||
                (
                  curr->tagno         == TAG_INPUT &&
                  HtmlINPUTtype(curr) == inputtype_IMAGE
                )
              )
      {
        char j[128]; /* Don't really want more than about 127 characters of ALT text in one go, surely?! */

        savetext_create_image_text(curr, j, sizeof(j));

        if (getsize) size += strlen(j);
        else if (!savetext_write_bytes(j, strlen(j))) return 0;
      }

      /* For bullets, output an asterisk */

      else if (ISBULLET(curr))
      {
        if (getsize) size += 2;
        else if (!savetext_write_bytes("* ", 2)) return 0;
      }

      /* Horizontal rules */

      else if (curr->style & HR)
      {
        if (getsize) size += sizeof(savetext_hr_text) - 1; /* ('-1' as sizeof includes the terminating null byte */
        else if (!savetext_write_bytes(savetext_hr_text, sizeof(savetext_hr_text) - 1)) return 0;
      }

      /* Text areas: ' [', the text area value, then '] ' */

      else if (curr->tagno == TAG_SELECT)
      {
        if (getsize) size += 4 + strlen(form_get_field(b, curr)->text);
        else
        {
          if (!savetext_write_bytes(" [",                          2))                                  return 0;
          if (!savetext_write_bytes(form_get_field(b, curr)->text, strlen(form_get_field(b, curr)->text))) return 0;
          if (!savetext_write_bytes("] ",                          2))                                  return 0;
        }
      }

      /* Selection lists - ' [', the current displayed item, */
      /* ']', then '[>] ' to represent the popup.            */

      else if(curr->tagno == TAG_STYLE)
      {
        if (getsize) size += 7 + strlen(form_get_field_text(b, curr));
        else
        {
          if (!savetext_write_bytes(" [",                         2))                                 return 0;
          if (!savetext_write_bytes(form_get_field_text(b, curr), strlen(form_get_field_text(b, curr)))) return 0;
          if (!savetext_write_bytes("][>] ",                      5))                                 return 0;
        }
      }

      /* Various INPUT field types */

      else if (curr->tagno == TAG_INPUT)
      {
        switch (HtmlINPUTtype(curr))
        {
          /* Single line normal writable */

          case inputtype_TEXT:
          {
            if (getsize) size += 4 +strlen(form_get_field(b, curr)->text);
            else
            {
              if (!savetext_write_bytes(" [",                          2))                                  return 0;
              if (!savetext_write_bytes(form_get_field(b, curr)->text, strlen(form_get_field(b, curr)->text))) return 0;
              if (!savetext_write_bytes("] ",                          2))                                  return 0;
            }
          }
          break;

          /* Single line password writable - output '*'s instead of the actual text */

          case inputtype_PASSWORD:
          {
            if (getsize) size += 4 + strlen(form_get_field(b, curr)->text);
            else
            {
              int j ,l;

              if (!savetext_write_bytes(" [", 2)) return 0;

              l = strlen(form_get_field(b, curr)->text);

              for (j = 0; j < l; j++)
              {
                if (!savetext_write_bytes("*",1)) return 0;
              }

              if (!savetext_write_bytes("] ", 2)) return 0;
            }
          }
          break;

          /* Check box; '[Y]' if selected, '[_]' if not */

          case inputtype_CHECKBOX:
          {
            if (getsize) size += 3;
            else if (!savetext_write_bytes(form_get_field(b, curr)->checked ? "[Y]" : "[_]", 3)) return 0;
          }
          break;

          /* Radio button; '(O)' if selected, '(_)' if not */

          case inputtype_RADIO:
          {
            if (getsize) size += 3;
            else if (!savetext_write_bytes(form_get_field(b, curr)->checked ? "(O)" : "(_)", 3)) return 0;
          }
          break;

          /* Hidden items give no text */

          case inputtype_HIDDEN: break;

          /* Sumbit / Reset buttons */

          case inputtype_SUBMIT: /* same as TYPE_RESET: no break */
          case inputtype_BUTTON: /* Again, no break              */
          case inputtype_RESET:
          {
            const char * p;

            p = form_button_text(curr);

            if (getsize) size += strlen(p) + 4;
            else
            {
              if (!savetext_write_bytes(" <", 2))         return 0;
              if (!savetext_write_bytes(p,    strlen(p))) return 0;
              if (!savetext_write_bytes("> ", 2))         return 0;
            }
          }
          break;
        }
      }

      /* For anything else, try to extract some generic text */

      else
      {
        char * d = curr->text;

        if (getsize && d) size += strlen(d);
        else if (d && !savetext_write_bytes(d, strlen(d))) return 0;
      }

      /* If we've got a link and the last item wasn't a link or */
      /* was, but to a different URL as this one, then output a */
      /* marker pointing to a reference that will be added on   */
      /* at the end of the document.                            */
      /*                                                        */
      /* Note that these conditions MUST be kept in step with   */
      /* those in savetext_summarise_refs, which actually       */
      /* writes the references pointed to by these markers.     */

      if (
           ISLINK(curr)             &&
           curr->tagno != TAG_TABLE &&
           (
             !last                        ||
             !ISLINK(last)                ||
             !ISBODY(last)                ||
             last->tagno  == TAG_TABLE    ||
             last->anchor != curr->anchor
           )
         )
      {
        s = savetext_write_ref(getsize);

        if (getsize) size += s;
        else if (!s) return 0;
      }
    }

    last = curr;
    curr = curr->next;
  }

  /* Summarise the references if we're not in a table cell */

  if (stream == b->stream)
  {
    s = savetext_summarise_refs(b, b->stream, getsize);
    if (getsize) size += s;
    else if (!s) return 0;
  }

  /* Return whatever was requested - size, or a success flag */

  return getsize ? size : 1;
}

/*************************************************/
/* savetext_save_text()                          */
/*                                               */
/* Save a given browser page as a text file.     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the page to save as   */
/*             text;                             */
/*                                               */
/*             Pointer to the pathname to save   */
/*             to.                               */
/*************************************************/

_kernel_oserror * savetext_save_text(browser_data * b, const char * pathname)
{
  int success = 0;

  /* If we seem to have left a file open, close it */

  if (outfile)
  {
    fclose(outfile);
    outfile = NULL;
  }

  /* Only proceed if we've got a pathname */

  if (pathname && *pathname)
  {
    save_record_path(pathname);

    outfile = fopen(pathname, "wb");

    if (!outfile) RetLastE;

    success = savetext_save(b, b->stream, 0);

    fclose(outfile);
    outfile = NULL;

    if (!success) RetLastE;

    /* Set the filetype */

    return _swix(OS_File,
                 _INR(0,2) | _INR(4,5),

                 18,
                 pathname,
                 FileType_TEXT);
  }

  return NULL;
}

/*************************************************/
/* savetext_text_size()                          */
/*                                               */
/* Returns the size of file that would be        */
/* written by savetext_save_text for the given   */
/* browser.                                      */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the page to save as   */
/*             text, for which the file size is  */
/*             to be returned.                   */
/*                                               */
/* Returns:    Size of file that would be        */
/*             written by savetext_save_text for */
/*             the given browser.                */
/*************************************************/

int savetext_text_size(browser_data * b)
{
  return savetext_save(b, b->stream, 1);
}