796 lines
19 KiB
C
796 lines
19 KiB
C
/* $XTermId: print.c,v 1.138 2011/07/14 23:49:10 tom Exp $ */
|
|
|
|
/************************************************************
|
|
|
|
Copyright 1997-2010,2011 by Thomas E. Dickey
|
|
|
|
All Rights Reserved
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and associated documentation files (the
|
|
"Software"), to deal in the Software without restriction, including
|
|
without limitation the rights to use, copy, modify, merge, publish,
|
|
distribute, sublicense, and/or sell copies of the Software, and to
|
|
permit persons to whom the Software is furnished to do so, subject to
|
|
the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included
|
|
in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
|
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name(s) of the above copyright
|
|
holders shall not be used in advertising or otherwise to promote the
|
|
sale, use or other dealings in this Software without prior written
|
|
authorization.
|
|
|
|
********************************************************/
|
|
|
|
#include <xterm.h>
|
|
#include <data.h>
|
|
#include <menu.h>
|
|
#include <error.h>
|
|
#include <xstrings.h>
|
|
|
|
#include <stdio.h>
|
|
#include <sys/stat.h>
|
|
|
|
#undef CTRL
|
|
#define CTRL(c) ((c) & 0x1f)
|
|
|
|
#define SHIFT_IN '\017'
|
|
#define SHIFT_OUT '\016'
|
|
|
|
#define CSET_IN 'A'
|
|
#define CSET_OUT '0'
|
|
|
|
#define isForm(c) ((c) == '\r' || (c) == '\n' || (c) == '\f')
|
|
#define Strlen(a) strlen((const char *)a)
|
|
#define Strcmp(a,b) strcmp((const char *)a,(const char *)b)
|
|
#define Strncmp(a,b,c) strncmp((const char *)a,(const char *)b,c)
|
|
|
|
#define SPS PrinterOf(screen)
|
|
|
|
#ifdef VMS
|
|
#define VMS_TEMP_PRINT_FILE "sys$scratch:xterm_print.txt"
|
|
#endif
|
|
|
|
static void charToPrinter(XtermWidget /* xw */ ,
|
|
unsigned /* chr */ );
|
|
static void printLine(XtermWidget /* xw */ ,
|
|
int /* row */ ,
|
|
unsigned /* chr */ ,
|
|
PrinterFlags * /* p */ );
|
|
static void send_CharSet(XtermWidget /* xw */ ,
|
|
LineData * /* ld */ );
|
|
static void send_SGR(XtermWidget /* xw */ ,
|
|
unsigned /* attr */ ,
|
|
unsigned /* fg */ ,
|
|
unsigned /* bg */ );
|
|
static void stringToPrinter(XtermWidget /* xw */ ,
|
|
const char * /*str */ );
|
|
|
|
void
|
|
closePrinter(XtermWidget xw GCC_UNUSED)
|
|
{
|
|
if (xtermHasPrinter(xw) != 0) {
|
|
TScreen *screen = TScreenOf(xw);
|
|
#ifdef VMS
|
|
char pcommand[256];
|
|
(void) sprintf(pcommand, "%s %s;",
|
|
SPS.printer_command,
|
|
VMS_TEMP_PRINT_FILE);
|
|
#endif
|
|
|
|
if (SPS.fp != 0) {
|
|
fclose(SPS.fp);
|
|
TRACE(("closed printer, waiting...\n"));
|
|
#ifdef VMS /* This is a quick hack, really should use
|
|
spawn and check status or system services
|
|
and go straight to the queue */
|
|
(void) system(pcommand);
|
|
#else /* VMS */
|
|
while (nonblocking_wait() > 0)
|
|
#endif /* VMS */
|
|
;
|
|
SPS.fp = 0;
|
|
SPS.isOpen = False;
|
|
TRACE(("closed printer\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
printCursorLine(XtermWidget xw)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
|
|
TRACE(("printCursorLine\n"));
|
|
printLine(xw, screen->cur_row, '\n', getPrinterFlags(xw, NULL, 0));
|
|
}
|
|
|
|
#define NO_COLOR ((unsigned)-1)
|
|
|
|
/*
|
|
* DEC's manual doesn't document whether trailing blanks are removed, or what
|
|
* happens with a line that is entirely blank. This function prints the
|
|
* characters that xterm would allow as a selection (which may include blanks).
|
|
*/
|
|
static void
|
|
printLine(XtermWidget xw, int row, unsigned chr, PrinterFlags * p)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
int inx = ROW2INX(screen, row);
|
|
LineData *ld;
|
|
Char attr = 0;
|
|
unsigned ch;
|
|
int last = MaxCols(screen);
|
|
int col;
|
|
#if OPT_ISO_COLORS && OPT_PRINT_COLORS
|
|
#define ColorOf(ld,col) (ld->color[col])
|
|
#endif
|
|
unsigned fg = NO_COLOR, last_fg = NO_COLOR;
|
|
unsigned bg = NO_COLOR, last_bg = NO_COLOR;
|
|
int cs = CSET_IN;
|
|
int last_cs = CSET_IN;
|
|
|
|
ld = getLineData(screen, inx);
|
|
if (ld == 0)
|
|
return;
|
|
|
|
TRACE(("printLine(row=%d/%d, top=%d:%d, chr=%d):%s\n",
|
|
row, ROW2INX(screen, row), screen->topline, screen->max_row, chr,
|
|
visibleIChars(ld->charData, (unsigned) last)));
|
|
|
|
while (last > 0) {
|
|
if ((ld->attribs[last - 1] & CHARDRAWN) == 0)
|
|
last--;
|
|
else
|
|
break;
|
|
}
|
|
if (last) {
|
|
if (p->print_attributes) {
|
|
send_CharSet(xw, ld);
|
|
send_SGR(xw, 0, NO_COLOR, NO_COLOR);
|
|
}
|
|
for (col = 0; col < last; col++) {
|
|
ch = ld->charData[col];
|
|
#if OPT_PRINT_COLORS
|
|
if (screen->colorMode) {
|
|
if (p->print_attributes > 1) {
|
|
fg = (ld->attribs[col] & FG_COLOR)
|
|
? extract_fg(xw, ColorOf(ld, col), ld->attribs[col])
|
|
: NO_COLOR;
|
|
bg = (ld->attribs[col] & BG_COLOR)
|
|
? extract_bg(xw, ColorOf(ld, col), ld->attribs[col])
|
|
: NO_COLOR;
|
|
}
|
|
}
|
|
#endif
|
|
if ((((ld->attribs[col] & SGR_MASK) != attr)
|
|
#if OPT_PRINT_COLORS
|
|
|| (last_fg != fg) || (last_bg != bg)
|
|
#endif
|
|
)
|
|
&& ch) {
|
|
attr = CharOf(ld->attribs[col] & SGR_MASK);
|
|
#if OPT_PRINT_COLORS
|
|
last_fg = fg;
|
|
last_bg = bg;
|
|
#endif
|
|
if (p->print_attributes)
|
|
send_SGR(xw, attr, fg, bg);
|
|
}
|
|
|
|
if (ch == 0)
|
|
ch = ' ';
|
|
|
|
#if OPT_WIDE_CHARS
|
|
if (screen->utf8_mode)
|
|
cs = CSET_IN;
|
|
else
|
|
#endif
|
|
cs = (ch >= ' ' && ch != ANSI_DEL) ? CSET_IN : CSET_OUT;
|
|
if (last_cs != cs) {
|
|
if (p->print_attributes) {
|
|
charToPrinter(xw,
|
|
(unsigned) ((cs == CSET_OUT)
|
|
? SHIFT_OUT
|
|
: SHIFT_IN));
|
|
}
|
|
last_cs = cs;
|
|
}
|
|
|
|
/* FIXME: we shouldn't have to map back from the
|
|
* alternate character set, except that the
|
|
* corresponding charset information is not encoded
|
|
* into the CSETS array.
|
|
*/
|
|
charToPrinter(xw,
|
|
((cs == CSET_OUT)
|
|
? (ch == ANSI_DEL ? 0x5f : (ch + 0x5f))
|
|
: ch));
|
|
if_OPT_WIDE_CHARS(screen, {
|
|
size_t off;
|
|
for_each_combData(off, ld) {
|
|
ch = ld->combData[off][col];
|
|
if (ch == 0)
|
|
break;
|
|
charToPrinter(xw, ch);
|
|
}
|
|
});
|
|
}
|
|
if (p->print_attributes) {
|
|
send_SGR(xw, 0, NO_COLOR, NO_COLOR);
|
|
if (cs != CSET_IN)
|
|
charToPrinter(xw, SHIFT_IN);
|
|
}
|
|
}
|
|
|
|
/* finish line (protocol for attributes needs a CR */
|
|
if (p->print_attributes)
|
|
charToPrinter(xw, '\r');
|
|
|
|
if (chr && !(p->printer_newline)) {
|
|
if (LineTstWrapped(ld))
|
|
chr = '\0';
|
|
}
|
|
|
|
if (chr)
|
|
charToPrinter(xw, chr);
|
|
|
|
return;
|
|
}
|
|
|
|
#define PrintNewLine() (unsigned) (((top < bot) || p->printer_newline) ? '\n' : '\0')
|
|
|
|
static void
|
|
printLines(XtermWidget xw, int top, int bot, PrinterFlags * p)
|
|
{
|
|
TRACE(("printLines, rows %d..%d\n", top, bot));
|
|
while (top <= bot) {
|
|
printLine(xw, top, PrintNewLine(), p);
|
|
++top;
|
|
}
|
|
}
|
|
|
|
void
|
|
xtermPrintScreen(XtermWidget xw, Bool use_DECPEX, PrinterFlags * p)
|
|
{
|
|
if (XtIsRealized((Widget) xw)) {
|
|
TScreen *screen = TScreenOf(xw);
|
|
Bool extent = (use_DECPEX && p->printer_extent);
|
|
Boolean was_open = SPS.isOpen;
|
|
|
|
printLines(xw,
|
|
extent ? 0 : screen->top_marg,
|
|
extent ? screen->max_row : screen->bot_marg,
|
|
p);
|
|
if (p->printer_formfeed)
|
|
charToPrinter(xw, '\f');
|
|
|
|
if (!was_open || SPS.printer_autoclose) {
|
|
closePrinter(xw);
|
|
}
|
|
} else {
|
|
Bell(xw, XkbBI_MinorError, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If p->print_everything is zero, use this behavior:
|
|
* If the alternate screen is active, we'll print only that. Otherwise, print
|
|
* the normal screen plus all scrolled-back lines. The distinction is made
|
|
* because the normal screen's buffer is part of the overall scrollback buffer.
|
|
*
|
|
* Otherwise, decode bits:
|
|
* 1 = current screen
|
|
* 2 = normal screen
|
|
* 4 = alternate screen
|
|
* 8 = saved lines
|
|
*/
|
|
void
|
|
xtermPrintEverything(XtermWidget xw, PrinterFlags * p)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
Boolean was_open = SPS.isOpen;
|
|
int save_which = screen->whichBuf;
|
|
int done_which = 0;
|
|
|
|
if (p->print_everything) {
|
|
if (p->print_everything & 8) {
|
|
printLines(xw, -screen->savedlines, -(screen->topline + 1), p);
|
|
}
|
|
if (p->print_everything & 4) {
|
|
screen->whichBuf = 1;
|
|
done_which |= 2;
|
|
printLines(xw, 0, screen->max_row, p);
|
|
screen->whichBuf = save_which;
|
|
}
|
|
if (p->print_everything & 2) {
|
|
screen->whichBuf = 0;
|
|
done_which |= 1;
|
|
printLines(xw, 0, screen->max_row, p);
|
|
screen->whichBuf = save_which;
|
|
}
|
|
if (p->print_everything & 1) {
|
|
if (!(done_which & (1 << screen->whichBuf))) {
|
|
printLines(xw, 0, screen->max_row, p);
|
|
}
|
|
}
|
|
} else {
|
|
int top = 0;
|
|
int bot = screen->max_row;
|
|
if (!screen->whichBuf) {
|
|
top = -screen->savedlines - screen->topline;
|
|
bot -= screen->topline;
|
|
}
|
|
printLines(xw, top, bot, p);
|
|
}
|
|
if (p->printer_formfeed)
|
|
charToPrinter(xw, '\f');
|
|
|
|
if (!was_open || SPS.printer_autoclose) {
|
|
closePrinter(xw);
|
|
}
|
|
}
|
|
|
|
static void
|
|
send_CharSet(XtermWidget xw, LineData * ld)
|
|
{
|
|
#if OPT_DEC_CHRSET
|
|
const char *msg = 0;
|
|
|
|
switch (GetLineDblCS(ld)) {
|
|
case CSET_SWL:
|
|
msg = "\033#5";
|
|
break;
|
|
case CSET_DHL_TOP:
|
|
msg = "\033#3";
|
|
break;
|
|
case CSET_DHL_BOT:
|
|
msg = "\033#4";
|
|
break;
|
|
case CSET_DWL:
|
|
msg = "\033#6";
|
|
break;
|
|
}
|
|
if (msg != 0)
|
|
stringToPrinter(xw, msg);
|
|
#else
|
|
(void) xw;
|
|
(void) ld;
|
|
#endif /* OPT_DEC_CHRSET */
|
|
}
|
|
|
|
static void
|
|
send_SGR(XtermWidget xw, unsigned attr, unsigned fg, unsigned bg)
|
|
{
|
|
char msg[80];
|
|
|
|
strcpy(msg, "\033[0");
|
|
if (attr & BOLD)
|
|
strcat(msg, ";1");
|
|
if (attr & UNDERLINE)
|
|
strcat(msg, ";4"); /* typo? DEC documents this as '2' */
|
|
if (attr & BLINK)
|
|
strcat(msg, ";5");
|
|
if (attr & INVERSE) /* typo? DEC documents this as invisible */
|
|
strcat(msg, ";7");
|
|
#if OPT_PRINT_COLORS
|
|
if (bg != NO_COLOR) {
|
|
sprintf(msg + strlen(msg), ";%u", (bg < 8) ? (40 + bg) : (92 + bg));
|
|
}
|
|
if (fg != NO_COLOR) {
|
|
#if OPT_PC_COLORS
|
|
if (TScreenOf(xw)->boldColors
|
|
&& fg > 8
|
|
&& (attr & BOLD) != 0)
|
|
fg -= 8;
|
|
#endif
|
|
sprintf(msg + strlen(msg), ";%u", (fg < 8) ? (30 + fg) : (82 + fg));
|
|
}
|
|
#else
|
|
(void) bg;
|
|
(void) fg;
|
|
#endif
|
|
strcat(msg, "m");
|
|
stringToPrinter(xw, msg);
|
|
}
|
|
|
|
/*
|
|
* This implementation only knows how to write to a pipe.
|
|
*/
|
|
static void
|
|
charToPrinter(XtermWidget xw, unsigned chr)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
|
|
if (!SPS.isOpen && xtermHasPrinter(xw)) {
|
|
switch (SPS.toFile) {
|
|
/*
|
|
* write to a pipe.
|
|
*/
|
|
case False:
|
|
#ifdef VMS
|
|
/*
|
|
* This implementation only knows how to write to a file. When the
|
|
* file is closed the print command executes. Print command must
|
|
* be of the form:
|
|
* print/que=name/delete [/otherflags].
|
|
*/
|
|
SPS.fp = fopen(VMS_TEMP_PRINT_FILE, "w");
|
|
#else
|
|
{
|
|
FILE *input;
|
|
int my_pipe[2];
|
|
int c;
|
|
pid_t my_pid;
|
|
|
|
if (pipe(my_pipe))
|
|
SysError(ERROR_FORK);
|
|
if ((my_pid = fork()) < 0)
|
|
SysError(ERROR_FORK);
|
|
|
|
if (my_pid == 0) {
|
|
TRACE_CLOSE();
|
|
close(my_pipe[1]); /* printer is silent */
|
|
close(screen->respond);
|
|
|
|
close(fileno(stdout));
|
|
dup2(fileno(stderr), 1);
|
|
|
|
if (fileno(stderr) != 2) {
|
|
dup2(fileno(stderr), 2);
|
|
close(fileno(stderr));
|
|
}
|
|
|
|
/* don't want privileges! */
|
|
if (xtermResetIds(screen) < 0)
|
|
exit(1);
|
|
|
|
SPS.fp = popen(SPS.printer_command, "w");
|
|
input = fdopen(my_pipe[0], "r");
|
|
while ((c = fgetc(input)) != EOF) {
|
|
fputc(c, SPS.fp);
|
|
if (isForm(c))
|
|
fflush(SPS.fp);
|
|
}
|
|
pclose(SPS.fp);
|
|
exit(0);
|
|
} else {
|
|
close(my_pipe[0]); /* won't read from printer */
|
|
SPS.fp = fdopen(my_pipe[1], "w");
|
|
TRACE(("opened printer from pid %d/%d\n",
|
|
(int) getpid(), (int) my_pid));
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
case True:
|
|
TRACE(("opening \"%s\" as printer output\n", SPS.printer_command));
|
|
SPS.fp = fopen(SPS.printer_command, "w");
|
|
break;
|
|
}
|
|
SPS.isOpen = True;
|
|
}
|
|
if (SPS.fp != 0) {
|
|
#if OPT_WIDE_CHARS
|
|
if (chr > 127) {
|
|
Char temp[10];
|
|
*convertToUTF8(temp, chr) = 0;
|
|
fputs((char *) temp, SPS.fp);
|
|
} else
|
|
#endif
|
|
fputc((int) chr, SPS.fp);
|
|
if (isForm(chr))
|
|
fflush(SPS.fp);
|
|
}
|
|
}
|
|
|
|
static void
|
|
stringToPrinter(XtermWidget xw, const char *str)
|
|
{
|
|
while (*str)
|
|
charToPrinter(xw, CharOf(*str++));
|
|
}
|
|
|
|
/*
|
|
* This module implements the MC (Media Copy) and related printing control
|
|
* sequences for VTxxx emulation. This is based on the description in the
|
|
* VT330/VT340 Programmer Reference Manual EK-VT3XX-TP-001 (Digital Equipment
|
|
* Corp., March 1987).
|
|
*/
|
|
void
|
|
xtermMediaControl(XtermWidget xw, int param, int private_seq)
|
|
{
|
|
TRACE(("MediaCopy param=%d, private=%d\n", param, private_seq));
|
|
|
|
if (private_seq) {
|
|
switch (param) {
|
|
case 1:
|
|
printCursorLine(xw);
|
|
break;
|
|
case 4:
|
|
setPrinterControlMode(xw, 0);
|
|
break;
|
|
case 5:
|
|
setPrinterControlMode(xw, 1);
|
|
break;
|
|
case 10: /* VT320 */
|
|
xtermPrintScreen(xw, False, getPrinterFlags(xw, NULL, 0));
|
|
break;
|
|
case 11: /* VT320 */
|
|
xtermPrintEverything(xw, getPrinterFlags(xw, NULL, 0));
|
|
break;
|
|
}
|
|
} else {
|
|
switch (param) {
|
|
case -1:
|
|
case 0:
|
|
xtermPrintScreen(xw, True, getPrinterFlags(xw, NULL, 0));
|
|
break;
|
|
case 4:
|
|
setPrinterControlMode(xw, 0);
|
|
break;
|
|
case 5:
|
|
setPrinterControlMode(xw, 2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* When in autoprint mode, the printer prints a line from the screen when you
|
|
* move the cursor off that line with an LF, FF, or VT character, or an
|
|
* autowrap occurs. The printed line ends with a CR and the character (LF, FF
|
|
* or VT) that moved the cursor off the previous line.
|
|
*/
|
|
void
|
|
xtermAutoPrint(XtermWidget xw, unsigned chr)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
|
|
if (SPS.printer_controlmode == 1) {
|
|
TRACE(("AutoPrint %d\n", chr));
|
|
printLine(xw, screen->cursorp.row, chr, getPrinterFlags(xw, NULL, 0));
|
|
if (SPS.fp != 0)
|
|
fflush(SPS.fp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* When in printer controller mode, the terminal sends received characters to
|
|
* the printer without displaying them on the screen. The terminal sends all
|
|
* characters and control sequences to the printer, except NUL, XON, XOFF, and
|
|
* the printer controller sequences.
|
|
*
|
|
* This function eats characters, returning 0 as long as it must buffer or
|
|
* divert to the printer. We're only invoked here when in printer controller
|
|
* mode, and handle the exit from that mode.
|
|
*/
|
|
#define LB '['
|
|
|
|
int
|
|
xtermPrinterControl(XtermWidget xw, int chr)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
/* *INDENT-OFF* */
|
|
static const struct {
|
|
const Char seq[5];
|
|
int active;
|
|
} tbl[] = {
|
|
{ { ANSI_CSI, '5', 'i' }, 2 },
|
|
{ { ANSI_CSI, '4', 'i' }, 0 },
|
|
{ { ANSI_ESC, LB, '5', 'i' }, 2 },
|
|
{ { ANSI_ESC, LB, '4', 'i' }, 0 },
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
static Char bfr[10];
|
|
static size_t length;
|
|
size_t n;
|
|
|
|
TRACE(("In printer:%04X\n", chr));
|
|
|
|
switch (chr) {
|
|
case 0:
|
|
case CTRL('Q'):
|
|
case CTRL('S'):
|
|
return 0; /* ignored by application */
|
|
|
|
case ANSI_CSI:
|
|
case ANSI_ESC:
|
|
case '[':
|
|
case '4':
|
|
case '5':
|
|
case 'i':
|
|
bfr[length++] = CharOf(chr);
|
|
for (n = 0; n < sizeof(tbl) / sizeof(tbl[0]); n++) {
|
|
size_t len = Strlen(tbl[n].seq);
|
|
|
|
if (length == len
|
|
&& Strcmp(bfr, tbl[n].seq) == 0) {
|
|
setPrinterControlMode(xw, tbl[n].active);
|
|
if (SPS.printer_autoclose
|
|
&& SPS.printer_controlmode == 0)
|
|
closePrinter(xw);
|
|
length = 0;
|
|
return 0;
|
|
} else if (len > length
|
|
&& Strncmp(bfr, tbl[n].seq, length) == 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
length--;
|
|
|
|
/* FALLTHRU */
|
|
|
|
default:
|
|
for (n = 0; n < length; n++)
|
|
charToPrinter(xw, bfr[n]);
|
|
bfr[0] = CharOf(chr);
|
|
length = 1;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If there is no printer command, we will ignore printer controls.
|
|
*/
|
|
Bool
|
|
xtermHasPrinter(XtermWidget xw)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
|
|
return (strlen(SPS.printer_command) != 0);
|
|
}
|
|
|
|
#define showPrinterControlMode(mode) \
|
|
(((mode) == 0) \
|
|
? "normal" \
|
|
: ((mode) == 1 \
|
|
? "autoprint" \
|
|
: "printer controller"))
|
|
|
|
void
|
|
setPrinterControlMode(XtermWidget xw, int mode)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
|
|
if (xtermHasPrinter(xw)
|
|
&& SPS.printer_controlmode != mode) {
|
|
TRACE(("%s %s mode\n",
|
|
(mode
|
|
? "set"
|
|
: "reset"),
|
|
(mode
|
|
? showPrinterControlMode(mode)
|
|
: showPrinterControlMode(SPS.printer_controlmode))));
|
|
SPS.printer_controlmode = mode;
|
|
update_print_redir();
|
|
}
|
|
}
|
|
|
|
PrinterFlags *
|
|
getPrinterFlags(XtermWidget xw, String * params, Cardinal *param_count)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
static const struct {
|
|
const char *name;
|
|
unsigned offset;
|
|
int value;
|
|
} table[] = {
|
|
{ "noFormFeed", XtOffsetOf(PrinterFlags, printer_formfeed), 0 },
|
|
{ "FormFeed", XtOffsetOf(PrinterFlags, printer_formfeed), 1 },
|
|
{ "noNewLine", XtOffsetOf(PrinterFlags, printer_newline), 0 },
|
|
{ "NewLine", XtOffsetOf(PrinterFlags, printer_newline), 1 },
|
|
{ "noAttrs", XtOffsetOf(PrinterFlags, print_attributes), 0 },
|
|
{ "monoAttrs", XtOffsetOf(PrinterFlags, print_attributes), 1 },
|
|
{ "colorAttrs", XtOffsetOf(PrinterFlags, print_attributes), 2 },
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
TScreen *screen = TScreenOf(xw);
|
|
PrinterFlags *result = &(screen->printer_flags);
|
|
|
|
TRACE(("getPrinterFlags %d params\n", param_count ? *param_count : 0));
|
|
|
|
result->printer_extent = SPS.printer_extent;
|
|
result->printer_formfeed = SPS.printer_formfeed;
|
|
result->printer_newline = SPS.printer_newline;
|
|
result->print_attributes = SPS.print_attributes;
|
|
result->print_everything = SPS.print_everything;
|
|
|
|
if (param_count != 0 && *param_count != 0) {
|
|
Cardinal j;
|
|
unsigned k;
|
|
for (j = 0; j < *param_count; ++j) {
|
|
TRACE(("param%d:%s\n", j, params[j]));
|
|
for (k = 0; k < XtNumber(table); ++k) {
|
|
if (!x_strcasecmp(params[j], table[k].name)) {
|
|
int *ptr = (int *) (void *) ((char *) result + table[k].offset);
|
|
TRACE(("...PrinterFlags(%s) %d->%d\n",
|
|
table[k].name,
|
|
*ptr,
|
|
table[k].value));
|
|
*ptr = table[k].value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Print a timestamped copy of everything.
|
|
*/
|
|
void
|
|
xtermPrintImmediately(XtermWidget xw, String filename, int opts, int attrs)
|
|
{
|
|
TScreen *screen = TScreenOf(xw);
|
|
PrinterState save_state = screen->printer_state;
|
|
char *my_filename = malloc(TIMESTAMP_LEN + strlen(filename));
|
|
|
|
if (my_filename != 0) {
|
|
unsigned save_umask = umask(0177);
|
|
|
|
timestamp_filename(my_filename, filename);
|
|
SPS.fp = 0;
|
|
SPS.isOpen = False;
|
|
SPS.toFile = True;
|
|
SPS.printer_command = my_filename;
|
|
SPS.printer_autoclose = True;
|
|
SPS.printer_formfeed = False;
|
|
SPS.printer_newline = True;
|
|
SPS.print_attributes = attrs;
|
|
SPS.print_everything = opts;
|
|
xtermPrintEverything(xw, getPrinterFlags(xw, NULL, 0));
|
|
|
|
umask(save_umask);
|
|
screen->printer_state = save_state;
|
|
}
|
|
}
|
|
|
|
void
|
|
xtermPrintOnXError(XtermWidget xw, int n)
|
|
{
|
|
#if OPT_PRINT_ON_EXIT
|
|
/*
|
|
* The user may have requested that the contents of the screen will be
|
|
* written to a file if an X error occurs.
|
|
*/
|
|
if (TScreenOf(xw)->write_error && !IsEmpty(resource.printFileOnXError)) {
|
|
Boolean printIt = False;
|
|
|
|
switch (n) {
|
|
case ERROR_XERROR:
|
|
/* FALLTHRU */
|
|
case ERROR_XIOERROR:
|
|
/* FALLTHRU */
|
|
case ERROR_ICEERROR:
|
|
printIt = True;
|
|
break;
|
|
}
|
|
|
|
if (printIt) {
|
|
xtermPrintImmediately(xw,
|
|
resource.printFileOnXError,
|
|
resource.printOptsOnXError,
|
|
resource.printModeOnXError);
|
|
}
|
|
}
|
|
#else
|
|
(void) xw;
|
|
(void) n;
|
|
#endif
|
|
}
|