Subversion Repositories openrisc

/* Public Domain Curses */
 
#include <curspriv.h>
 
RCSID("$Id: scr_dump.c,v 1.1 2009/05/10 08:29:53 jld Exp $")
 
/*man-start**************************************************************
 
  Name:                                                         scr_dump
 
  Synopsis:
        int putwin(WINDOW *win, FILE *filep);
        WINDOW *getwin(FILE *filep);
        int scr_dump(const char *filename);
        int scr_init(const char *filename);
        int scr_restore(const char *filename);
        int scr_set(const char *filename);
 
  Description:
        getwin() reads window-related data previously stored in a file 
        by putwin(). It then creates and initialises a new window using 
        that data.
 
        putwin() writes all data associated with a window into a file, 
        using an unspecified format. This information can be retrieved 
        later using getwin().
 
        scr_dump() writes the current contents of the virtual screen to 
        the file named by filename in an unspecified format.
 
        scr_restore() function sets the virtual screen to the contents 
        of the file named by filename, which must have been written 
        using scr_dump(). The next refresh operation restores the screen 
        to the way it looked in the dump file.
 
        In PDCurses, scr_init() does nothing, and scr_set() is a synonym 
        for scr_restore(). Also, scr_dump() and scr_restore() save and 
        load from curscr. This differs from some other implementations, 
        where scr_init() works with curscr, and scr_restore() works with 
        newscr; but the effect should be the same. (PDCurses has no 
        newscr.)
 
  Return Value:
        On successful completion, getwin() returns a pointer to the 
        window it created. Otherwise, it returns a null pointer. Other 
        functions return OK or ERR.
 
  Portability                                X/Open    BSD    SYS V
        putwin                                  Y
        getwin                                  Y
        scr_dump                                Y
        scr_init                                Y
        scr_restore                             Y
        scr_set                                 Y
 
**man-end****************************************************************/
 
#include <stdlib.h>
#include <string.h>
 
#define DUMPVER 1   /* Should be updated whenever the WINDOW struct is
                       changed */
 
int putwin(WINDOW *win, FILE *filep)
{
    static const char *marker = "PDC";
    static const unsigned char version = DUMPVER;
 
    PDC_LOG(("putwin() - called\n"));
 
    /* write the marker and the WINDOW struct */
 
    if (filep && fwrite(marker, strlen(marker), 1, filep)
              && fwrite(&version, 1, 1, filep)
              && fwrite(win, sizeof(WINDOW), 1, filep))
    {
        int i;
 
        /* write each line */
 
        for (i = 0; i < win->_maxy && win->_y[i]; i++)
            if (!fwrite(win->_y[i], win->_maxx * sizeof(chtype), 1, filep))
                return ERR;
 
        return OK;
    }
 
    return ERR;
}
 
WINDOW *getwin(FILE *filep)
{
    WINDOW *win;
    char marker[4];
    int i, nlines, ncols;
 
    PDC_LOG(("getwin() - called\n"));
 
    if ( !(win = malloc(sizeof(WINDOW))) )
        return (WINDOW *)NULL;
 
    /* check for the marker, and load the WINDOW struct */
 
    if (!filep || !fread(marker, 4, 1, filep) || strncmp(marker, "PDC", 3)
        || marker[3] != DUMPVER || !fread(win, sizeof(WINDOW), 1, filep))
    {
        free(win);
        return (WINDOW *)NULL;
    }
 
    nlines = win->_maxy;
    ncols = win->_maxx;
 
    /* allocate the line pointer array */
 
    if ( !(win->_y = malloc(nlines * sizeof(chtype *))) )
    {
        free(win);
        return (WINDOW *)NULL;
    }
 
    /* allocate the minchng and maxchng arrays */
 
    if ( !(win->_firstch = malloc(nlines * sizeof(int))) )
    {
        free(win->_y);
        free(win);
        return (WINDOW *)NULL;
    }
 
    if ( !(win->_lastch = malloc(nlines * sizeof(int))) )
    {
        free(win->_firstch);
        free(win->_y);
        free(win);
        return (WINDOW *)NULL;
    }
 
    /* allocate the lines */
 
    if ( !(win = PDC_makelines(win)) )
        return (WINDOW *)NULL;
 
    /* read them */
 
    for (i = 0; i < nlines; i++)
    {
        if (!fread(win->_y[i], ncols * sizeof(chtype), 1, filep))
        {
            delwin(win);
            return (WINDOW *)NULL;
        }
    }
 
    touchwin(win);
 
    return win;
}
 
int scr_dump(const char *filename)
{
    FILE *filep;
 
    PDC_LOG(("scr_dump() - called: filename %s\n", filename));
 
    if (filename && (filep = fopen(filename, "wb")) != NULL)
    {
        int result = putwin(curscr, filep);
        fclose(filep);
        return result;
    }
 
    return ERR;
}
 
int scr_init(const char *filename)
{
    PDC_LOG(("scr_init() - called: filename %s\n", filename));
 
    return OK;
}
 
int scr_restore(const char *filename)
{
    FILE *filep;
 
    PDC_LOG(("scr_restore() - called: filename %s\n", filename));
 
    if (filename && (filep = fopen(filename, "rb")) != NULL)
    {
        WINDOW *replacement = getwin(filep);
        fclose(filep);
 
        if (replacement)
        {
            int result = overwrite(replacement, curscr);
            delwin(replacement);
            return result;
        }
    }
 
    return ERR;
}
 
int scr_set(const char *filename)
{
    PDC_LOG(("scr_set() - called: filename %s\n", filename));
 
    return scr_restore(filename);
}