NCURSES_SP_NAME(getwin) (NCURSES_SP_DCLx FILE *filep)
{
WINDOW tmp, *nwin;
int n;
bool old_format = FALSE;
T((T_CALLED("getwin(%p)"), (void *) filep));
if (filep == 0) {
returnWin(0);
}
/*
* Read the first 4 bytes to determine first if this is an old-format
* screen-dump, or new-format.
*/
if (read_block(&tmp, 4, filep) < 0) {
returnWin(0);
}
/*
* If this is a new-format file, and we do not support it, give up.
*/
if (!memcmp(&tmp, my_magic, 4)) {
#if NCURSES_EXT_PUTWIN
if (read_win(&tmp, filep) < 0)
#endif
returnWin(0);
} else if (read_block(((char *) &tmp) + 4, sizeof(WINDOW) - 4, filep) < 0) {
returnWin(0);
} else {
old_format = TRUE;
}
/*
* Check the window-size:
*/
if (tmp._maxy == 0 ||
tmp._maxy > MAX_SIZE ||
tmp._maxx == 0 ||
tmp._maxx > MAX_SIZE) {
returnWin(0);
}
if (tmp._flags & _ISPAD) {
nwin = NCURSES_SP_NAME(newpad) (NCURSES_SP_ARGx
tmp._maxy + 1,
tmp._maxx + 1);
} else {
nwin = NCURSES_SP_NAME(newwin) (NCURSES_SP_ARGx
tmp._maxy + 1,
tmp._maxx + 1, 0, 0);
}
/*
* We deliberately do not restore the _parx, _pary, or _parent
* fields, because the window hierarchy within which they
* made sense is probably gone.
*/
if (nwin != 0) {
size_t linesize = sizeof(NCURSES_CH_T) * (size_t) (tmp._maxx + 1);
nwin->_curx = tmp._curx;
nwin->_cury = tmp._cury;
nwin->_maxy = tmp._maxy;
nwin->_maxx = tmp._maxx;
nwin->_begy = tmp._begy;
nwin->_begx = tmp._begx;
nwin->_yoffset = tmp._yoffset;
nwin->_flags = tmp._flags & ~(_SUBWIN);
WINDOW_ATTRS(nwin) = WINDOW_ATTRS(&tmp);
nwin->_nc_bkgd = tmp._nc_bkgd;
nwin->_notimeout = tmp._notimeout;
nwin->_clear = tmp._clear;
nwin->_leaveok = tmp._leaveok;
nwin->_idlok = tmp._idlok;
nwin->_idcok = tmp._idcok;
nwin->_immed = tmp._immed;
nwin->_scroll = tmp._scroll;
nwin->_sync = tmp._sync;
nwin->_use_keypad = tmp._use_keypad;
nwin->_delay = tmp._delay;
nwin->_regtop = tmp._regtop;
nwin->_regbottom = tmp._regbottom;
if (tmp._flags & _ISPAD)
nwin->_pad = tmp._pad;
if (old_format) {
T(("reading old-format screen dump"));
for (n = 0; n <= nwin->_maxy; n++) {
if (read_block(nwin->_line[n].text, linesize, filep) < 0) {
delwin(nwin);
returnWin(0);
}
}
}
#if NCURSES_EXT_PUTWIN
else {
char *txt = 0;
bool success = TRUE;
NCURSES_CH_T prior = blank;
T(("reading new-format screen dump"));
for (n = 0; n <= nwin->_maxy; n++) {
long row;
char *next;
if ((txt = read_txt(filep)) == 0) {
T(("...failed to read string for row %d", n + 1));
success = FALSE;
break;
}
row = strtol(txt, &next, 10);
if (row != (n + 1) || *next != ':') {
T(("...failed to read row-number %d", n + 1));
success = FALSE;
break;
}
if (read_row(++next, &prior, nwin->_line[n].text, tmp._maxx
+ 1) < 0) {
T(("...failed to read cells for row %d", n + 1));
success = FALSE;
break;
}
free(txt);
txt = 0;
}
if (!success) {
free(txt);
delwin(nwin);
returnWin(0);
}
}
#endif
touchwin(nwin);
}
returnWin(nwin);
}
bool IE_Imp_MSWrite::read_pap (pap_t process)
{
static const char *text_align[] = {"left", "center", "right", "justify"};
int fcMac, pnPara, fcFirst, cfod, fc, fcLim;
unsigned char page[0x80];
UT_String properties, tmp, lastprops;
if (process == All) { UT_DEBUGMSG(("PAP:\n")); }
fcMac = wri_struct_value(wri_file_header, "fcMac");
pnPara = wri_struct_value(wri_file_header, "pnPara");
fcFirst = 0x80;
while (true)
{
gsf_input_seek(mFile, pnPara++ * 0x80, G_SEEK_SET);
gsf_input_read(mFile, 0x80, page);
fc = READ_DWORD(page);
cfod = page[0x7f];
if (process == All)
{
UT_DEBUGMSG((" fcFirst = %d\n", fc));
UT_DEBUGMSG((" cfod = %d\n", cfod));
}
if (fc != fcFirst) UT_WARNINGMSG(("read_pap: fcFirst wrong.\n"));
// read all FODs (format descriptors)
for (int fod = 0; fod < cfod; fod++)
{
int bfprop, cch;
int jc, dxaRight, dxaLeft, dxaLeft1, dyaLine, fGraphics;
int rhcPage, rHeaderFooter, rhcFirst;
int tabs, dxaTab[14], jcTab[14];
if (process == All) { UT_DEBUGMSG((" PAP-FOD #%02d:\n", fod + 1)); }
// read a FOD (format descriptor)
fcLim = READ_DWORD(page + 4 + fod * 6);
bfprop = READ_WORD(page + 8 + fod * 6);
if (process == All)
{
UT_DEBUGMSG((" fcLim = %d\n", fcLim));
UT_DEBUGMSG((bfprop == 0xffff ? " bfprop = 0x%04X\n" : " bfprop = %d\n", bfprop));
}
// default PAP values
jc = 0;
dxaRight = dxaLeft = dxaLeft1 = 0;
dyaLine = 240;
rhcPage = rHeaderFooter = rhcFirst = 0;
fGraphics = 0;
tabs = 0;
// if the PAP FPROPs (formatting properties) differ from the defaults, get them
if (bfprop != 0xffff && bfprop + (cch = page[bfprop + 4]) < 0x80)
{
if (process == All) { UT_DEBUGMSG((" cch = %d\n", cch)); }
if (cch >= 2) jc = page[bfprop + 6] & 3;
if (cch >= 6) dxaRight = READ_WORD(page + bfprop + 9);
if (cch >= 8) dxaLeft = READ_WORD(page + bfprop + 11);
if (cch >= 10) dxaLeft1 = READ_WORD(page + bfprop + 13);
if (cch >= 12) dyaLine = READ_WORD(page + bfprop + 15);
if (cch >= 17)
{
rhcPage = page[bfprop + 21] & 1;
rHeaderFooter = page[bfprop + 21] & 6;
rhcFirst = page[bfprop + 21] & 8;
fGraphics = page[bfprop + 21] & 0x10;
}
for (int n = 0; n < 14; n++)
{
if (cch >= 4 * (n + 1) + 26)
{
dxaTab[tabs] = READ_WORD(page + bfprop + n * 4 + 27);
jcTab[tabs] = page[bfprop + n * 4 + 29] & 3;
tabs++;
}
}
if (dxaRight & 0x8000) dxaRight = -0x10000 + dxaRight;
if (dxaLeft & 0x8000) dxaLeft = -0x10000 + dxaLeft;
if (dxaLeft1 & 0x8000) dxaLeft1 = -0x10000 + dxaLeft1;
if (dyaLine < 240) dyaLine = 240;
if (process == All && rHeaderFooter)
{
if (rhcPage)
{
if (!hasFooter)
{
hasFooter = true;
page1Footer = rhcFirst;
}
}
else
{
if (!hasHeader)
{
hasHeader = true;
page1Header = rhcFirst;
}
}
}
}
if ((process == All && !rHeaderFooter) ||
(rHeaderFooter && ((process == Header && !rhcPage) ||
(process == Footer && rhcPage))))
{
UT_DEBUGMSG((" jc = %d\n", jc));
UT_DEBUGMSG((" dxaRight = %d\n", dxaRight));
UT_DEBUGMSG((" dxaLeft = %d\n", dxaLeft));
UT_DEBUGMSG((" dxaLeft1 = %d\n", dxaLeft1));
UT_DEBUGMSG((" dyaLine = %d\n", dyaLine));
UT_DEBUGMSG((" rhcPage = %d\n", rhcPage));
UT_DEBUGMSG((" rHeaderFooter = %d\n", rHeaderFooter));
UT_DEBUGMSG((" rhcFirst = %d\n", rhcFirst));
UT_DEBUGMSG((" fGraphics = %d\n", fGraphics));
UT_LocaleTransactor lt(LC_NUMERIC, "C");
UT_String_sprintf(properties, "text-align:%s; line-height:%.1f",
text_align[jc],
static_cast<float>(dyaLine) / 240.0);
if (tabs)
{
properties += "; tabstops:";
UT_DEBUGMSG((" Tabs:\n"));
for (int n = 0; n < tabs; n++)
{
UT_String_sprintf(tmp, "%.4fin/%c0",
static_cast<float>(dxaTab[n]) / 1440.0,
jcTab[n] ? 'D' : 'L');
properties += tmp;
UT_DEBUGMSG((" #%02d dxa = %d, jcTab = %d\n", n + 1, dxaTab[n], jcTab[n]));
if (n != tabs - 1) properties += ",";
}
}
if (process == Header || process == Footer)
{
// For reasons unknown, the left and right margins from the paper
// are included in the indents of the headers and footers.
dxaLeft -= xaLeft;
dxaRight -= xaRight;
}
if (dxaLeft1)
{
UT_String_sprintf(tmp, "; text-indent:%.4fin",
static_cast<float>(dxaLeft1) / 1440.0);
properties += tmp;
}
if (dxaLeft)
{
UT_String_sprintf(tmp, "; margin-left:%.4fin",
static_cast<float>(dxaLeft) / 1440.0);
properties += tmp;
}
if (dxaRight)
{
UT_String_sprintf(tmp, "; margin-right:%.4fin",
static_cast<float>(dxaRight) / 1440.0);
properties += tmp;
}
// new attributes, only if there was a line feed or FPROPs have changed
if (lf || strcmp(properties.c_str(), lastprops.c_str()) != 0)
{
const gchar *attributes[3];
attributes[0] = PT_PROPS_ATTRIBUTE_NAME;
attributes[1] = properties.c_str();
attributes[2] = NULL;
appendStrux(PTX_Block, attributes);
lastprops = properties;
}
if (fGraphics) read_pic(fcFirst, fcLim - fcFirst);
else read_txt(fcFirst, fcLim - 1);
}
fcFirst = fcLim;
if (fcLim >= fcMac)
{
UT_DEBUGMSG((" PAP-FODs end, fcLim (%d) >= fcMac (%d)\n", fcLim, fcMac));
return true;
}
}
}
}
static int
read_win(WINDOW *win, FILE *fp)
{
int code = ERR;
char *txt;
char *name;
char *value;
size_t n;
int color;
#if NCURSES_WIDECHAR
NCURSES_CH_T prior;
#endif
chtype prior2;
memset(win, 0, sizeof(WINDOW));
for (;;) {
txt = read_txt(fp);
if (txt == 0)
break;
if (!strcmp(txt, "rows:")) {
free(txt);
code = OK;
break;
}
if ((value = strchr(txt, '=')) == 0) {
free(txt);
continue;
}
*value++ = '\0';
name = !strcmp(txt, "flag") ? value : txt;
for (n = 0; n < SIZEOF(scr_params); ++n) {
if (!strcmp(name, scr_params[n].name)) {
void *data = (void *) ((char *) win + scr_params[n].offset);
switch (scr_params[n].type) {
case pATTR:
(void) decode_attr(value, data, &color);
break;
case pBOOL:
*(bool *) data = TRUE;
break;
case pCHAR:
prior2 = ' ';
decode_chtype(value, prior2, data);
break;
case pINT:
*(int *) data = atoi(value);
break;
case pSHORT:
*(short *) data = (short) atoi(value);
break;
case pSIZE:
*(NCURSES_SIZE_T *) data = (NCURSES_SIZE_T) atoi(value);
break;
#if NCURSES_WIDECHAR
case pCCHAR:
prior = blank;
decode_cchar(value, &prior, data);
break;
#endif
}
break;
}
}
free(txt);
}
return code;
}
