ref: 7ae78bc3363349f6af9b93e43dec67259467fdc9
dir: /hardcopy.c/
/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* hardcopy.c: printing to paper
*/
#include "vim.h"
#include "version.h"
#if defined(FEAT_PRINTER) || defined(PROTO)
/*
* To implement printing on a platform, the following functions must be
* defined:
*
* int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
* Called once. Code should display printer dialogue (if appropriate) and
* determine printer font and margin settings. Reset has_color if the printer
* doesn't support colors at all.
* Returns FAIL to abort.
*
* int mch_print_begin(prt_settings_T *settings)
* Called to start the print job.
* Return FALSE to abort.
*
* int mch_print_begin_page(char_u *msg)
* Called at the start of each page.
* "msg" indicates the progress of the print job, can be NULL.
* Return FALSE to abort.
*
* int mch_print_end_page()
* Called at the end of each page.
* Return FALSE to abort.
*
* int mch_print_blank_page()
* Called to generate a blank page for collated, duplex, multiple copy
* document. Return FALSE to abort.
*
* void mch_print_end(prt_settings_T *psettings)
* Called at normal end of print job.
*
* void mch_print_cleanup()
* Called if print job ends normally or is abandoned. Free any memory, close
* devices and handles. Also called when mch_print_begin() fails, but not
* when mch_print_init() fails.
*
* void mch_print_set_font(int Bold, int Italic, int Underline);
* Called whenever the font style changes.
*
* void mch_print_set_bg(long_u bgcol);
* Called to set the background color for the following text. Parameter is an
* RGB value.
*
* void mch_print_set_fg(long_u fgcol);
* Called to set the foreground color for the following text. Parameter is an
* RGB value.
*
* mch_print_start_line(int margin, int page_line)
* Sets the current position at the start of line "page_line".
* If margin is TRUE start in the left margin (for header and line number).
*
* int mch_print_text_out(char_u *p, int len);
* Output one character of text p[len] at the current position.
* Return TRUE if there is no room for another character in the same line.
*
* Note that the generic code has no idea of margins. The machine code should
* simply make the page look smaller! The header and the line numbers are
* printed in the margin.
*/
#ifdef FEAT_SYN_HL
static const long_u cterm_color_8[8] =
{
(long_u)0x000000L, (long_u)0xff0000L, (long_u)0x00ff00L, (long_u)0xffff00L,
(long_u)0x0000ffL, (long_u)0xff00ffL, (long_u)0x00ffffL, (long_u)0xffffffL
};
static const long_u cterm_color_16[16] =
{
(long_u)0x000000L, (long_u)0x0000c0L, (long_u)0x008000L, (long_u)0x004080L,
(long_u)0xc00000L, (long_u)0xc000c0L, (long_u)0x808000L, (long_u)0xc0c0c0L,
(long_u)0x808080L, (long_u)0x6060ffL, (long_u)0x00ff00L, (long_u)0x00ffffL,
(long_u)0xff8080L, (long_u)0xff40ffL, (long_u)0xffff00L, (long_u)0xffffffL
};
static int current_syn_id;
#endif
#define PRCOLOR_BLACK (long_u)0
#define PRCOLOR_WHITE (long_u)0xFFFFFFL
static int curr_italic;
static int curr_bold;
static int curr_underline;
static long_u curr_bg;
static long_u curr_fg;
static int page_count;
#if defined(FEAT_MBYTE) && defined(FEAT_POSTSCRIPT)
# define OPT_MBFONT_USECOURIER 0
# define OPT_MBFONT_ASCII 1
# define OPT_MBFONT_REGULAR 2
# define OPT_MBFONT_BOLD 3
# define OPT_MBFONT_OBLIQUE 4
# define OPT_MBFONT_BOLDOBLIQUE 5
# define OPT_MBFONT_NUM_OPTIONS 6
static option_table_T mbfont_opts[OPT_MBFONT_NUM_OPTIONS] =
{
{"c", FALSE, 0, NULL, 0, FALSE},
{"a", FALSE, 0, NULL, 0, FALSE},
{"r", FALSE, 0, NULL, 0, FALSE},
{"b", FALSE, 0, NULL, 0, FALSE},
{"i", FALSE, 0, NULL, 0, FALSE},
{"o", FALSE, 0, NULL, 0, FALSE},
};
#endif
/*
* These values determine the print position on a page.
*/
typedef struct
{
int lead_spaces; /* remaining spaces for a TAB */
int print_pos; /* virtual column for computing TABs */
colnr_T column; /* byte column */
linenr_T file_line; /* line nr in the buffer */
long_u bytes_printed; /* bytes printed so far */
int ff; /* seen form feed character */
} prt_pos_T;
static char_u *parse_list_options __ARGS((char_u *option_str, option_table_T *table, int table_size));
#ifdef FEAT_SYN_HL
static long_u darken_rgb __ARGS((long_u rgb));
static long_u prt_get_term_color __ARGS((int colorindex));
#endif
static void prt_set_fg __ARGS((long_u fg));
static void prt_set_bg __ARGS((long_u bg));
static void prt_set_font __ARGS((int bold, int italic, int underline));
static void prt_line_number __ARGS((prt_settings_T *psettings, int page_line, linenr_T lnum));
static void prt_header __ARGS((prt_settings_T *psettings, int pagenum, linenr_T lnum));
static void prt_message __ARGS((char_u *s));
static colnr_T hardcopy_line __ARGS((prt_settings_T *psettings, int page_line, prt_pos_T *ppos));
#ifdef FEAT_SYN_HL
static void prt_get_attr __ARGS((int hl_id, prt_text_attr_T* pattr, int modec));
#endif
/*
* Parse 'printoptions' and set the flags in "printer_opts".
* Returns an error message or NULL;
*/
char_u *
parse_printoptions()
{
return parse_list_options(p_popt, printer_opts, OPT_PRINT_NUM_OPTIONS);
}
#if (defined(FEAT_MBYTE) && defined(FEAT_POSTSCRIPT)) || defined(PROTO)
/*
* Parse 'printoptions' and set the flags in "printer_opts".
* Returns an error message or NULL;
*/
char_u *
parse_printmbfont()
{
return parse_list_options(p_pmfn, mbfont_opts, OPT_MBFONT_NUM_OPTIONS);
}
#endif
/*
* Parse a list of options in the form
* option:value,option:value,option:value
*
* "value" can start with a number which is parsed out, e.g. margin:12mm
*
* Returns an error message for an illegal option, NULL otherwise.
* Only used for the printer at the moment...
*/
static char_u *
parse_list_options(option_str, table, table_size)
char_u *option_str;
option_table_T *table;
int table_size;
{
char_u *stringp;
char_u *colonp;
char_u *commap;
char_u *p;
int idx = 0; /* init for GCC */
int len;
for (idx = 0; idx < table_size; ++idx)
table[idx].present = FALSE;
/*
* Repeat for all comma separated parts.
*/
stringp = option_str;
while (*stringp)
{
colonp = vim_strchr(stringp, ':');
if (colonp == NULL)
return (char_u *)N_("E550: Missing colon");
commap = vim_strchr(stringp, ',');
if (commap == NULL)
commap = option_str + STRLEN(option_str);
len = (int)(colonp - stringp);
for (idx = 0; idx < table_size; ++idx)
if (STRNICMP(stringp, table[idx].name, len) == 0)
break;
if (idx == table_size)
return (char_u *)N_("E551: Illegal component");
p = colonp + 1;
table[idx].present = TRUE;
if (table[idx].hasnum)
{
if (!VIM_ISDIGIT(*p))
return (char_u *)N_("E552: digit expected");
table[idx].number = getdigits(&p); /*advances p*/
}
table[idx].string = p;
table[idx].strlen = (int)(commap - p);
stringp = commap;
if (*stringp == ',')
++stringp;
}
return NULL;
}
#ifdef FEAT_SYN_HL
/*
* If using a dark background, the colors will probably be too bright to show
* up well on white paper, so reduce their brightness.
*/
static long_u
darken_rgb(rgb)
long_u rgb;
{
return ((rgb >> 17) << 16)
+ (((rgb & 0xff00) >> 9) << 8)
+ ((rgb & 0xff) >> 1);
}
static long_u
prt_get_term_color(colorindex)
int colorindex;
{
/* TODO: Should check for xterm with 88 or 256 colors. */
if (t_colors > 8)
return cterm_color_16[colorindex % 16];
return cterm_color_8[colorindex % 8];
}
static void
prt_get_attr(hl_id, pattr, modec)
int hl_id;
prt_text_attr_T *pattr;
int modec;
{
int colorindex;
long_u fg_color;
long_u bg_color;
char *color;
pattr->bold = (highlight_has_attr(hl_id, HL_BOLD, modec) != NULL);
pattr->italic = (highlight_has_attr(hl_id, HL_ITALIC, modec) != NULL);
pattr->underline = (highlight_has_attr(hl_id, HL_UNDERLINE, modec) != NULL);
pattr->undercurl = (highlight_has_attr(hl_id, HL_UNDERCURL, modec) != NULL);
# ifdef FEAT_GUI
if (gui.in_use)
{
bg_color = highlight_gui_color_rgb(hl_id, FALSE);
if (bg_color == PRCOLOR_BLACK)
bg_color = PRCOLOR_WHITE;
fg_color = highlight_gui_color_rgb(hl_id, TRUE);
}
else
# endif
{
bg_color = PRCOLOR_WHITE;
color = (char *)highlight_color(hl_id, (char_u *)"fg", modec);
if (color == NULL)
colorindex = 0;
else
colorindex = atoi(color);
if (colorindex >= 0 && colorindex < t_colors)
fg_color = prt_get_term_color(colorindex);
else
fg_color = PRCOLOR_BLACK;
}
if (fg_color == PRCOLOR_WHITE)
fg_color = PRCOLOR_BLACK;
else if (*p_bg == 'd')
fg_color = darken_rgb(fg_color);
pattr->fg_color = fg_color;
pattr->bg_color = bg_color;
}
#endif /* FEAT_SYN_HL */
static void
prt_set_fg(fg)
long_u fg;
{
if (fg != curr_fg)
{
curr_fg = fg;
mch_print_set_fg(fg);
}
}
static void
prt_set_bg(bg)
long_u bg;
{
if (bg != curr_bg)
{
curr_bg = bg;
mch_print_set_bg(bg);
}
}
static void
prt_set_font(bold, italic, underline)
int bold;
int italic;
int underline;
{
if (curr_bold != bold
|| curr_italic != italic
|| curr_underline != underline)
{
curr_underline = underline;
curr_italic = italic;
curr_bold = bold;
mch_print_set_font(bold, italic, underline);
}
}
/*
* Print the line number in the left margin.
*/
static void
prt_line_number(psettings, page_line, lnum)
prt_settings_T *psettings;
int page_line;
linenr_T lnum;
{
int i;
char_u tbuf[20];
prt_set_fg(psettings->number.fg_color);
prt_set_bg(psettings->number.bg_color);
prt_set_font(psettings->number.bold, psettings->number.italic, psettings->number.underline);
mch_print_start_line(TRUE, page_line);
/* Leave two spaces between the number and the text; depends on
* PRINT_NUMBER_WIDTH. */
sprintf((char *)tbuf, "%6ld", (long)lnum);
for (i = 0; i < 6; i++)
(void)mch_print_text_out(&tbuf[i], 1);
#ifdef FEAT_SYN_HL
if (psettings->do_syntax)
/* Set colors for next character. */
current_syn_id = -1;
else
#endif
{
/* Set colors and font back to normal. */
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(FALSE, FALSE, FALSE);
}
}
/*
* Get the currently effective header height.
*/
int
prt_header_height()
{
if (printer_opts[OPT_PRINT_HEADERHEIGHT].present)
return printer_opts[OPT_PRINT_HEADERHEIGHT].number;
return 2;
}
/*
* Return TRUE if using a line number for printing.
*/
int
prt_use_number()
{
return (printer_opts[OPT_PRINT_NUMBER].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_NUMBER].string[0]) == 'y');
}
/*
* Return the unit used in a margin item in 'printoptions'.
* Returns PRT_UNIT_NONE if not recognized.
*/
int
prt_get_unit(idx)
int idx;
{
int u = PRT_UNIT_NONE;
int i;
static char *(units[4]) = PRT_UNIT_NAMES;
if (printer_opts[idx].present)
for (i = 0; i < 4; ++i)
if (STRNICMP(printer_opts[idx].string, units[i], 2) == 0)
{
u = i;
break;
}
return u;
}
/*
* Print the page header.
*/
/*ARGSUSED*/
static void
prt_header(psettings, pagenum, lnum)
prt_settings_T *psettings;
int pagenum;
linenr_T lnum;
{
int width = psettings->chars_per_line;
int page_line;
char_u *tbuf;
char_u *p;
#ifdef FEAT_MBYTE
int l;
#endif
/* Also use the space for the line number. */
if (prt_use_number())
width += PRINT_NUMBER_WIDTH;
tbuf = alloc(width + IOSIZE);
if (tbuf == NULL)
return;
#ifdef FEAT_STL_OPT
if (*p_header != NUL)
{
linenr_T tmp_lnum, tmp_topline, tmp_botline;
int use_sandbox = FALSE;
/*
* Need to (temporarily) set current line number and first/last line
* number on the 'window'. Since we don't know how long the page is,
* set the first and current line number to the top line, and guess
* that the page length is 64.
*/
tmp_lnum = curwin->w_cursor.lnum;
tmp_topline = curwin->w_topline;
tmp_botline = curwin->w_botline;
curwin->w_cursor.lnum = lnum;
curwin->w_topline = lnum;
curwin->w_botline = lnum + 63;
printer_page_num = pagenum;
# ifdef FEAT_EVAL
use_sandbox = was_set_insecurely((char_u *)"printheader", 0);
# endif
build_stl_str_hl(curwin, tbuf, (size_t)(width + IOSIZE),
p_header, use_sandbox,
' ', width, NULL, NULL);
/* Reset line numbers */
curwin->w_cursor.lnum = tmp_lnum;
curwin->w_topline = tmp_topline;
curwin->w_botline = tmp_botline;
}
else
#endif
sprintf((char *)tbuf, _("Page %d"), pagenum);
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(TRUE, FALSE, FALSE);
/* Use a negative line number to indicate printing in the top margin. */
page_line = 0 - prt_header_height();
mch_print_start_line(TRUE, page_line);
for (p = tbuf; *p != NUL; )
{
if (mch_print_text_out(p,
#ifdef FEAT_MBYTE
(l = (*mb_ptr2len)(p))
#else
1
#endif
))
{
++page_line;
if (page_line >= 0) /* out of room in header */
break;
mch_print_start_line(TRUE, page_line);
}
#ifdef FEAT_MBYTE
p += l;
#else
p++;
#endif
}
vim_free(tbuf);
#ifdef FEAT_SYN_HL
if (psettings->do_syntax)
/* Set colors for next character. */
current_syn_id = -1;
else
#endif
{
/* Set colors and font back to normal. */
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(FALSE, FALSE, FALSE);
}
}
/*
* Display a print status message.
*/
static void
prt_message(s)
char_u *s;
{
screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
screen_puts(s, (int)Rows - 1, 0, hl_attr(HLF_R));
out_flush();
}
void
ex_hardcopy(eap)
exarg_T *eap;
{
linenr_T lnum;
int collated_copies, uncollated_copies;
prt_settings_T settings;
long_u bytes_to_print = 0;
int page_line;
int jobsplit;
memset(&settings, 0, sizeof(prt_settings_T));
settings.has_color = TRUE;
# ifdef FEAT_POSTSCRIPT
if (*eap->arg == '>')
{
char_u *errormsg = NULL;
/* Expand things like "%.ps". */
if (expand_filename(eap, eap->cmdlinep, &errormsg) == FAIL)
{
if (errormsg != NULL)
EMSG(errormsg);
return;
}
settings.outfile = skipwhite(eap->arg + 1);
}
else if (*eap->arg != NUL)
settings.arguments = eap->arg;
# endif
/*
* Initialise for printing. Ask the user for settings, unless forceit is
* set.
* The mch_print_init() code should set up margins if applicable. (It may
* not be a real printer - for example the engine might generate HTML or
* PS.)
*/
if (mch_print_init(&settings,
curbuf->b_fname == NULL
? (char_u *)buf_spname(curbuf)
: curbuf->b_sfname == NULL
? curbuf->b_fname
: curbuf->b_sfname,
eap->forceit) == FAIL)
return;
#ifdef FEAT_SYN_HL
# ifdef FEAT_GUI
if (gui.in_use)
settings.modec = 'g';
else
# endif
if (t_colors > 1)
settings.modec = 'c';
else
settings.modec = 't';
if (!syntax_present(curbuf))
settings.do_syntax = FALSE;
else if (printer_opts[OPT_PRINT_SYNTAX].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) != 'a')
settings.do_syntax =
(TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) == 'y');
else
settings.do_syntax = settings.has_color;
#endif
/* Set up printing attributes for line numbers */
settings.number.fg_color = PRCOLOR_BLACK;
settings.number.bg_color = PRCOLOR_WHITE;
settings.number.bold = FALSE;
settings.number.italic = TRUE;
settings.number.underline = FALSE;
#ifdef FEAT_SYN_HL
/*
* Syntax highlighting of line numbers.
*/
if (prt_use_number() && settings.do_syntax)
{
int id;
id = syn_name2id((char_u *)"LineNr");
if (id > 0)
id = syn_get_final_id(id);
prt_get_attr(id, &settings.number, settings.modec);
}
#endif
/*
* Estimate the total lines to be printed
*/
for (lnum = eap->line1; lnum <= eap->line2; lnum++)
bytes_to_print += (long_u)STRLEN(skipwhite(ml_get(lnum)));
if (bytes_to_print == 0)
{
MSG(_("No text to be printed"));
goto print_fail_no_begin;
}
/* Set colors and font to normal. */
curr_bg = (long_u)0xffffffffL;
curr_fg = (long_u)0xffffffffL;
curr_italic = MAYBE;
curr_bold = MAYBE;
curr_underline = MAYBE;
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(FALSE, FALSE, FALSE);
#ifdef FEAT_SYN_HL
current_syn_id = -1;
#endif
jobsplit = (printer_opts[OPT_PRINT_JOBSPLIT].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_JOBSPLIT].string[0]) == 'y');
if (!mch_print_begin(&settings))
goto print_fail_no_begin;
/*
* Loop over collated copies: 1 2 3, 1 2 3, ...
*/
page_count = 0;
for (collated_copies = 0;
collated_copies < settings.n_collated_copies;
collated_copies++)
{
prt_pos_T prtpos; /* current print position */
prt_pos_T page_prtpos; /* print position at page start */
int side;
memset(&page_prtpos, 0, sizeof(prt_pos_T));
page_prtpos.file_line = eap->line1;
prtpos = page_prtpos;
if (jobsplit && collated_copies > 0)
{
/* Splitting jobs: Stop a previous job and start a new one. */
mch_print_end(&settings);
if (!mch_print_begin(&settings))
goto print_fail_no_begin;
}
/*
* Loop over all pages in the print job: 1 2 3 ...
*/
for (page_count = 0; prtpos.file_line <= eap->line2; ++page_count)
{
/*
* Loop over uncollated copies: 1 1 1, 2 2 2, 3 3 3, ...
* For duplex: 12 12 12 34 34 34, ...
*/
for (uncollated_copies = 0;
uncollated_copies < settings.n_uncollated_copies;
uncollated_copies++)
{
/* Set the print position to the start of this page. */
prtpos = page_prtpos;
/*
* Do front and rear side of a page.
*/
for (side = 0; side <= settings.duplex; ++side)
{
/*
* Print one page.
*/
/* Check for interrupt character every page. */
ui_breakcheck();
if (got_int || settings.user_abort)
goto print_fail;
sprintf((char *)IObuff, _("Printing page %d (%d%%)"),
page_count + 1 + side,
prtpos.bytes_printed > 1000000
? (int)(prtpos.bytes_printed /
(bytes_to_print / 100))
: (int)((prtpos.bytes_printed * 100)
/ bytes_to_print));
if (!mch_print_begin_page(IObuff))
goto print_fail;
if (settings.n_collated_copies > 1)
sprintf((char *)IObuff + STRLEN(IObuff),
_(" Copy %d of %d"),
collated_copies + 1,
settings.n_collated_copies);
prt_message(IObuff);
/*
* Output header if required
*/
if (prt_header_height() > 0)
prt_header(&settings, page_count + 1 + side,
prtpos.file_line);
for (page_line = 0; page_line < settings.lines_per_page;
++page_line)
{
prtpos.column = hardcopy_line(&settings,
page_line, &prtpos);
if (prtpos.column == 0)
{
/* finished a file line */
prtpos.bytes_printed +=
STRLEN(skipwhite(ml_get(prtpos.file_line)));
if (++prtpos.file_line > eap->line2)
break; /* reached the end */
}
else if (prtpos.ff)
{
/* Line had a formfeed in it - start new page but
* stay on the current line */
break;
}
}
if (!mch_print_end_page())
goto print_fail;
if (prtpos.file_line > eap->line2)
break; /* reached the end */
}
/*
* Extra blank page for duplexing with odd number of pages and
* more copies to come.
*/
if (prtpos.file_line > eap->line2 && settings.duplex
&& side == 0
&& uncollated_copies + 1 < settings.n_uncollated_copies)
{
if (!mch_print_blank_page())
goto print_fail;
}
}
if (settings.duplex && prtpos.file_line <= eap->line2)
++page_count;
/* Remember the position where the next page starts. */
page_prtpos = prtpos;
}
vim_snprintf((char *)IObuff, IOSIZE, _("Printed: %s"),
settings.jobname);
prt_message(IObuff);
}
print_fail:
if (got_int || settings.user_abort)
{
sprintf((char *)IObuff, "%s", _("Printing aborted"));
prt_message(IObuff);
}
mch_print_end(&settings);
print_fail_no_begin:
mch_print_cleanup();
}
/*
* Print one page line.
* Return the next column to print, or zero if the line is finished.
*/
static colnr_T
hardcopy_line(psettings, page_line, ppos)
prt_settings_T *psettings;
int page_line;
prt_pos_T *ppos;
{
colnr_T col;
char_u *line;
int need_break = FALSE;
int outputlen;
int tab_spaces;
long_u print_pos;
#ifdef FEAT_SYN_HL
prt_text_attr_T attr;
int id;
#endif
if (ppos->column == 0 || ppos->ff)
{
print_pos = 0;
tab_spaces = 0;
if (!ppos->ff && prt_use_number())
prt_line_number(psettings, page_line, ppos->file_line);
ppos->ff = FALSE;
}
else
{
/* left over from wrap halfway a tab */
print_pos = ppos->print_pos;
tab_spaces = ppos->lead_spaces;
}
mch_print_start_line(0, page_line);
line = ml_get(ppos->file_line);
/*
* Loop over the columns until the end of the file line or right margin.
*/
for (col = ppos->column; line[col] != NUL && !need_break; col += outputlen)
{
outputlen = 1;
#ifdef FEAT_MBYTE
if (has_mbyte && (outputlen = (*mb_ptr2len)(line + col)) < 1)
outputlen = 1;
#endif
#ifdef FEAT_SYN_HL
/*
* syntax highlighting stuff.
*/
if (psettings->do_syntax)
{
id = syn_get_id(curwin, ppos->file_line, col, 1, NULL);
if (id > 0)
id = syn_get_final_id(id);
else
id = 0;
/* Get the line again, a multi-line regexp may invalidate it. */
line = ml_get(ppos->file_line);
if (id != current_syn_id)
{
current_syn_id = id;
prt_get_attr(id, &attr, psettings->modec);
prt_set_font(attr.bold, attr.italic, attr.underline);
prt_set_fg(attr.fg_color);
prt_set_bg(attr.bg_color);
}
}
#endif
/*
* Appropriately expand any tabs to spaces.
*/
if (line[col] == TAB || tab_spaces != 0)
{
if (tab_spaces == 0)
tab_spaces = (int)(curbuf->b_p_ts - (print_pos % curbuf->b_p_ts));
while (tab_spaces > 0)
{
need_break = mch_print_text_out((char_u *)" ", 1);
print_pos++;
tab_spaces--;
if (need_break)
break;
}
/* Keep the TAB if we didn't finish it. */
if (need_break && tab_spaces > 0)
break;
}
else if (line[col] == FF
&& printer_opts[OPT_PRINT_FORMFEED].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_FORMFEED].string[0])
== 'y')
{
ppos->ff = TRUE;
need_break = 1;
}
else
{
need_break = mch_print_text_out(line + col, outputlen);
#ifdef FEAT_MBYTE
if (has_mbyte)
print_pos += (*mb_ptr2cells)(line + col);
else
#endif
print_pos++;
}
}
ppos->lead_spaces = tab_spaces;
ppos->print_pos = (int)print_pos;
/*
* Start next line of file if we clip lines, or have reached end of the
* line, unless we are doing a formfeed.
*/
if (!ppos->ff
&& (line[col] == NUL
|| (printer_opts[OPT_PRINT_WRAP].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_WRAP].string[0])
== 'n')))
return 0;
return col;
}
# if defined(FEAT_POSTSCRIPT) || defined(PROTO)
/*
* PS printer stuff.
*
* Sources of information to help maintain the PS printing code:
*
* 1. PostScript Language Reference, 3rd Edition,
* Addison-Wesley, 1999, ISBN 0-201-37922-8
* 2. PostScript Language Program Design,
* Addison-Wesley, 1988, ISBN 0-201-14396-8
* 3. PostScript Tutorial and Cookbook,
* Addison Wesley, 1985, ISBN 0-201-10179-3
* 4. PostScript Language Document Structuring Conventions Specification,
* version 3.0,
* Adobe Technote 5001, 25th September 1992
* 5. PostScript Printer Description File Format Specification, Version 4.3,
* Adobe technote 5003, 9th February 1996
* 6. Adobe Font Metrics File Format Specification, Version 4.1,
* Adobe Technote 5007, 7th October 1998
* 7. Adobe CMap and CIDFont Files Specification, Version 1.0,
* Adobe Technote 5014, 8th October 1996
* 8. Adobe CJKV Character Collections and CMaps for CID-Keyed Fonts,
* Adoboe Technote 5094, 8th September, 2001
* 9. CJKV Information Processing, 2nd Edition,
* O'Reilly, 2002, ISBN 1-56592-224-7
*
* Some of these documents can be found in PDF form on Adobe's web site -
* http://www.adobe.com
*/
#define NUM_ELEMENTS(arr) (sizeof(arr)/sizeof((arr)[0]))
#define PRT_PS_DEFAULT_DPI (72) /* Default user space resolution */
#define PRT_PS_DEFAULT_FONTSIZE (10)
#define PRT_PS_DEFAULT_BUFFER_SIZE (80)
struct prt_mediasize_S
{
char *name;
float width; /* width and height in points for portrait */
float height;
};
#define PRT_MEDIASIZE_LEN (sizeof(prt_mediasize) / sizeof(struct prt_mediasize_S))
static struct prt_mediasize_S prt_mediasize[] =
{
{"A4", 595.0, 842.0},
{"letter", 612.0, 792.0},
{"10x14", 720.0, 1008.0},
{"A3", 842.0, 1191.0},
{"A5", 420.0, 595.0},
{"B4", 729.0, 1032.0},
{"B5", 516.0, 729.0},
{"executive", 522.0, 756.0},
{"folio", 595.0, 935.0},
{"ledger", 1224.0, 792.0}, /* Yes, it is wider than taller! */
{"legal", 612.0, 1008.0},
{"quarto", 610.0, 780.0},
{"statement", 396.0, 612.0},
{"tabloid", 792.0, 1224.0}
};
/* PS font names, must be in Roman, Bold, Italic, Bold-Italic order */
struct prt_ps_font_S
{
int wx;
int uline_offset;
int uline_width;
int bbox_min_y;
int bbox_max_y;
char *(ps_fontname[4]);
};
#define PRT_PS_FONT_ROMAN (0)
#define PRT_PS_FONT_BOLD (1)
#define PRT_PS_FONT_OBLIQUE (2)
#define PRT_PS_FONT_BOLDOBLIQUE (3)
/* Standard font metrics for Courier family */
static struct prt_ps_font_S prt_ps_courier_font =
{
600,
-100, 50,
-250, 805,
{"Courier", "Courier-Bold", "Courier-Oblique", "Courier-BoldOblique"}
};
#ifdef FEAT_MBYTE
/* Generic font metrics for multi-byte fonts */
static struct prt_ps_font_S prt_ps_mb_font =
{
1000,
-100, 50,
-250, 805,
{NULL, NULL, NULL, NULL}
};
#endif
/* Pointer to current font set being used */
static struct prt_ps_font_S* prt_ps_font;
/* Structures to map user named encoding and mapping to PS equivalents for
* building CID font name */
struct prt_ps_encoding_S
{
char *encoding;
char *cmap_encoding;
int needs_charset;
};
struct prt_ps_charset_S
{
char *charset;
char *cmap_charset;
int has_charset;
};
#ifdef FEAT_MBYTE
#define CS_JIS_C_1978 (0x01)
#define CS_JIS_X_1983 (0x02)
#define CS_JIS_X_1990 (0x04)
#define CS_NEC (0x08)
#define CS_MSWINDOWS (0x10)
#define CS_CP932 (0x20)
#define CS_KANJITALK6 (0x40)
#define CS_KANJITALK7 (0x80)
/* Japanese encodings and charsets */
static struct prt_ps_encoding_S j_encodings[] =
{
{"iso-2022-jp", NULL, (CS_JIS_C_1978|CS_JIS_X_1983|CS_JIS_X_1990|
CS_NEC)},
{"euc-jp", "EUC", (CS_JIS_C_1978|CS_JIS_X_1983|CS_JIS_X_1990)},
{"sjis", "RKSJ", (CS_JIS_C_1978|CS_JIS_X_1983|CS_MSWINDOWS|
CS_KANJITALK6|CS_KANJITALK7)},
{"cp932", "RKSJ", CS_JIS_X_1983},
{"ucs-2", "UCS2", CS_JIS_X_1990},
{"utf-8", "UTF8" , CS_JIS_X_1990}
};
static struct prt_ps_charset_S j_charsets[] =
{
{"JIS_C_1978", "78", CS_JIS_C_1978},
{"JIS_X_1983", NULL, CS_JIS_X_1983},
{"JIS_X_1990", "Hojo", CS_JIS_X_1990},
{"NEC", "Ext", CS_NEC},
{"MSWINDOWS", "90ms", CS_MSWINDOWS},
{"CP932", "90ms", CS_JIS_X_1983},
{"KANJITALK6", "83pv", CS_KANJITALK6},
{"KANJITALK7", "90pv", CS_KANJITALK7}
};
#define CS_GB_2312_80 (0x01)
#define CS_GBT_12345_90 (0x02)
#define CS_GBK2K (0x04)
#define CS_SC_MAC (0x08)
#define CS_GBT_90_MAC (0x10)
#define CS_GBK (0x20)
#define CS_SC_ISO10646 (0x40)
/* Simplified Chinese encodings and charsets */
static struct prt_ps_encoding_S sc_encodings[] =
{
{"iso-2022", NULL, (CS_GB_2312_80|CS_GBT_12345_90)},
{"gb18030", NULL, CS_GBK2K},
{"euc-cn", "EUC", (CS_GB_2312_80|CS_GBT_12345_90|CS_SC_MAC|
CS_GBT_90_MAC)},
{"gbk", "EUC", CS_GBK},
{"ucs-2", "UCS2", CS_SC_ISO10646},
{"utf-8", "UTF8", CS_SC_ISO10646}
};
static struct prt_ps_charset_S sc_charsets[] =
{
{"GB_2312-80", "GB", CS_GB_2312_80},
{"GBT_12345-90","GBT", CS_GBT_12345_90},
{"MAC", "GBpc", CS_SC_MAC},
{"GBT-90_MAC", "GBTpc", CS_GBT_90_MAC},
{"GBK", "GBK", CS_GBK},
{"GB18030", "GBK2K", CS_GBK2K},
{"ISO10646", "UniGB", CS_SC_ISO10646}
};
#define CS_CNS_PLANE_1 (0x01)
#define CS_CNS_PLANE_2 (0x02)
#define CS_CNS_PLANE_1_2 (0x04)
#define CS_B5 (0x08)
#define CS_ETEN (0x10)
#define CS_HK_GCCS (0x20)
#define CS_HK_SCS (0x40)
#define CS_HK_SCS_ETEN (0x80)
#define CS_MTHKL (0x100)
#define CS_MTHKS (0x200)
#define CS_DLHKL (0x400)
#define CS_DLHKS (0x800)
#define CS_TC_ISO10646 (0x1000)
/* Traditional Chinese encodings and charsets */
static struct prt_ps_encoding_S tc_encodings[] =
{
{"iso-2022", NULL, (CS_CNS_PLANE_1|CS_CNS_PLANE_2)},
{"euc-tw", "EUC", CS_CNS_PLANE_1_2},
{"big5", "B5", (CS_B5|CS_ETEN|CS_HK_GCCS|CS_HK_SCS|
CS_HK_SCS_ETEN|CS_MTHKL|CS_MTHKS|CS_DLHKL|
CS_DLHKS)},
{"cp950", "B5", CS_B5},
{"ucs-2", "UCS2", CS_TC_ISO10646},
{"utf-8", "UTF8", CS_TC_ISO10646},
{"utf-16", "UTF16", CS_TC_ISO10646},
{"utf-32", "UTF32", CS_TC_ISO10646}
};
static struct prt_ps_charset_S tc_charsets[] =
{
{"CNS_1992_1", "CNS1", CS_CNS_PLANE_1},
{"CNS_1992_2", "CNS2", CS_CNS_PLANE_2},
{"CNS_1993", "CNS", CS_CNS_PLANE_1_2},
{"BIG5", NULL, CS_B5},
{"CP950", NULL, CS_B5},
{"ETEN", "ETen", CS_ETEN},
{"HK_GCCS", "HKgccs", CS_HK_GCCS},
{"SCS", "HKscs", CS_HK_SCS},
{"SCS_ETEN", "ETHK", CS_HK_SCS_ETEN},
{"MTHKL", "HKm471", CS_MTHKL},
{"MTHKS", "HKm314", CS_MTHKS},
{"DLHKL", "HKdla", CS_DLHKL},
{"DLHKS", "HKdlb", CS_DLHKS},
{"ISO10646", "UniCNS", CS_TC_ISO10646}
};
#define CS_KR_X_1992 (0x01)
#define CS_KR_MAC (0x02)
#define CS_KR_X_1992_MS (0x04)
#define CS_KR_ISO10646 (0x08)
/* Korean encodings and charsets */
static struct prt_ps_encoding_S k_encodings[] =
{
{"iso-2022-kr", NULL, CS_KR_X_1992},
{"euc-kr", "EUC", (CS_KR_X_1992|CS_KR_MAC)},
{"johab", "Johab", CS_KR_X_1992},
{"cp1361", "Johab", CS_KR_X_1992},
{"uhc", "UHC", CS_KR_X_1992_MS},
{"cp949", "UHC", CS_KR_X_1992_MS},
{"ucs-2", "UCS2", CS_KR_ISO10646},
{"utf-8", "UTF8", CS_KR_ISO10646}
};
static struct prt_ps_charset_S k_charsets[] =
{
{"KS_X_1992", "KSC", CS_KR_X_1992},
{"CP1361", "KSC", CS_KR_X_1992},
{"MAC", "KSCpc", CS_KR_MAC},
{"MSWINDOWS", "KSCms", CS_KR_X_1992_MS},
{"CP949", "KSCms", CS_KR_X_1992_MS},
{"WANSUNG", "KSCms", CS_KR_X_1992_MS},
{"ISO10646", "UniKS", CS_KR_ISO10646}
};
/* Collections of encodings and charsets for multi-byte printing */
struct prt_ps_mbfont_S
{
int num_encodings;
struct prt_ps_encoding_S *encodings;
int num_charsets;
struct prt_ps_charset_S *charsets;
char *ascii_enc;
char *defcs;
};
static struct prt_ps_mbfont_S prt_ps_mbfonts[] =
{
{
NUM_ELEMENTS(j_encodings),
j_encodings,
NUM_ELEMENTS(j_charsets),
j_charsets,
"jis_roman",
"JIS_X_1983"
},
{
NUM_ELEMENTS(sc_encodings),
sc_encodings,
NUM_ELEMENTS(sc_charsets),
sc_charsets,
"gb_roman",
"GB_2312-80"
},
{
NUM_ELEMENTS(tc_encodings),
tc_encodings,
NUM_ELEMENTS(tc_charsets),
tc_charsets,
"cns_roman",
"BIG5"
},
{
NUM_ELEMENTS(k_encodings),
k_encodings,
NUM_ELEMENTS(k_charsets),
k_charsets,
"ks_roman",
"KS_X_1992"
}
};
#endif /* FEAT_MBYTE */
struct prt_ps_resource_S
{
char_u name[64];
char_u filename[MAXPATHL + 1];
int type;
char_u title[256];
char_u version[256];
};
/* Types of PS resource file currently used */
#define PRT_RESOURCE_TYPE_PROCSET (0)
#define PRT_RESOURCE_TYPE_ENCODING (1)
#define PRT_RESOURCE_TYPE_CMAP (2)
/* The PS prolog file version number has to match - if the prolog file is
* updated, increment the number in the file and here. Version checking was
* added as of VIM 6.2.
* The CID prolog file version number behaves as per PS prolog.
* Table of VIM and prolog versions:
*
* VIM Prolog CIDProlog
* 6.2 1.3
* 7.0 1.4 1.0
*/
#define PRT_PROLOG_VERSION ((char_u *)"1.4")
#define PRT_CID_PROLOG_VERSION ((char_u *)"1.0")
/* String versions of PS resource types - indexed by constants above so don't
* re-order!
*/
static char *prt_resource_types[] =
{
"procset",
"encoding",
"cmap"
};
/* Strings to look for in a PS resource file */
#define PRT_RESOURCE_HEADER "%!PS-Adobe-"
#define PRT_RESOURCE_RESOURCE "Resource-"
#define PRT_RESOURCE_PROCSET "ProcSet"
#define PRT_RESOURCE_ENCODING "Encoding"
#define PRT_RESOURCE_CMAP "CMap"
/* Data for table based DSC comment recognition, easy to extend if VIM needs to
* read more comments. */
#define PRT_DSC_MISC_TYPE (-1)
#define PRT_DSC_TITLE_TYPE (1)
#define PRT_DSC_VERSION_TYPE (2)
#define PRT_DSC_ENDCOMMENTS_TYPE (3)
#define PRT_DSC_TITLE "%%Title:"
#define PRT_DSC_VERSION "%%Version:"
#define PRT_DSC_ENDCOMMENTS "%%EndComments:"
struct prt_dsc_comment_S
{
char *string;
int len;
int type;
};
struct prt_dsc_line_S
{
int type;
char_u *string;
int len;
};
#define SIZEOF_CSTR(s) (sizeof(s) - 1)
static struct prt_dsc_comment_S prt_dsc_table[] =
{
{PRT_DSC_TITLE, SIZEOF_CSTR(PRT_DSC_TITLE), PRT_DSC_TITLE_TYPE},
{PRT_DSC_VERSION, SIZEOF_CSTR(PRT_DSC_VERSION),
PRT_DSC_VERSION_TYPE},
{PRT_DSC_ENDCOMMENTS, SIZEOF_CSTR(PRT_DSC_ENDCOMMENTS),
PRT_DSC_ENDCOMMENTS_TYPE}
};
static void prt_write_file_raw_len __ARGS((char_u *buffer, int bytes));
static void prt_write_file __ARGS((char_u *buffer));
static void prt_write_file_len __ARGS((char_u *buffer, int bytes));
static void prt_write_string __ARGS((char *s));
static void prt_write_int __ARGS((int i));
static void prt_write_boolean __ARGS((int b));
static void prt_def_font __ARGS((char *new_name, char *encoding, int height, char *font));
static void prt_real_bits __ARGS((double real, int precision, int *pinteger, int *pfraction));
static void prt_write_real __ARGS((double val, int prec));
static void prt_def_var __ARGS((char *name, double value, int prec));
static void prt_flush_buffer __ARGS((void));
static void prt_resource_name __ARGS((char_u *filename, void *cookie));
static int prt_find_resource __ARGS((char *name, struct prt_ps_resource_S *resource));
static int prt_open_resource __ARGS((struct prt_ps_resource_S *resource));
static int prt_check_resource __ARGS((struct prt_ps_resource_S *resource, char_u *version));
static void prt_dsc_start __ARGS((void));
static void prt_dsc_noarg __ARGS((char *comment));
static void prt_dsc_textline __ARGS((char *comment, char *text));
static void prt_dsc_text __ARGS((char *comment, char *text));
static void prt_dsc_ints __ARGS((char *comment, int count, int *ints));
static void prt_dsc_requirements __ARGS((int duplex, int tumble, int collate, int color, int num_copies));
static void prt_dsc_docmedia __ARGS((char *paper_name, double width, double height, double weight, char *colour, char *type));
static void prt_dsc_resources __ARGS((char *comment, char *type, char *strings));
static void prt_dsc_font_resource __ARGS((char *resource, struct prt_ps_font_S *ps_font));
static float to_device_units __ARGS((int idx, double physsize, int def_number));
static void prt_page_margins __ARGS((double width, double height, double *left, double *right, double *top, double *bottom));
static void prt_font_metrics __ARGS((int font_scale));
static int prt_get_cpl __ARGS((void));
static int prt_get_lpp __ARGS((void));
static int prt_add_resource __ARGS((struct prt_ps_resource_S *resource));
static int prt_resfile_next_line __ARGS((void));
static int prt_resfile_strncmp __ARGS((int offset, char *string, int len));
static int prt_resfile_skip_nonws __ARGS((int offset));
static int prt_resfile_skip_ws __ARGS((int offset));
static int prt_next_dsc __ARGS((struct prt_dsc_line_S *p_dsc_line));
#ifdef FEAT_MBYTE
static int prt_build_cid_fontname __ARGS((int font, char_u *name, int name_len));
static void prt_def_cidfont __ARGS((char *new_name, int height, char *cidfont));
static void prt_dup_cidfont __ARGS((char *original_name, char *new_name));
static int prt_match_encoding __ARGS((char *p_encoding, struct prt_ps_mbfont_S *p_cmap, struct prt_ps_encoding_S **pp_mbenc));
static int prt_match_charset __ARGS((char *p_charset, struct prt_ps_mbfont_S *p_cmap, struct prt_ps_charset_S **pp_mbchar));
#endif
/*
* Variables for the output PostScript file.
*/
static FILE *prt_ps_fd;
static int prt_file_error;
static char_u *prt_ps_file_name = NULL;
/*
* Various offsets and dimensions in default PostScript user space (points).
* Used for text positioning calculations
*/
static float prt_page_width;
static float prt_page_height;
static float prt_left_margin;
static float prt_right_margin;
static float prt_top_margin;
static float prt_bottom_margin;
static float prt_line_height;
static float prt_first_line_height;
static float prt_char_width;
static float prt_number_width;
static float prt_bgcol_offset;
static float prt_pos_x_moveto = 0.0;
static float prt_pos_y_moveto = 0.0;
/*
* Various control variables used to decide when and how to change the
* PostScript graphics state.
*/
static int prt_need_moveto;
static int prt_do_moveto;
static int prt_need_font;
static int prt_font;
static int prt_need_underline;
static int prt_underline;
static int prt_do_underline;
static int prt_need_fgcol;
static int prt_fgcol;
static int prt_need_bgcol;
static int prt_do_bgcol;
static int prt_bgcol;
static int prt_new_bgcol;
static int prt_attribute_change;
static float prt_text_run;
static int prt_page_num;
static int prt_bufsiz;
/*
* Variables controlling physical printing.
*/
static int prt_media;
static int prt_portrait;
static int prt_num_copies;
static int prt_duplex;
static int prt_tumble;
static int prt_collate;
/*
* Buffers used when generating PostScript output
*/
static char_u prt_line_buffer[257];
static garray_T prt_ps_buffer;
# ifdef FEAT_MBYTE
static int prt_do_conv;
static vimconv_T prt_conv;
static int prt_out_mbyte;
static int prt_custom_cmap;
static char prt_cmap[80];
static int prt_use_courier;
static int prt_in_ascii;
static int prt_half_width;
static char *prt_ascii_encoding;
static char_u prt_hexchar[] = "0123456789abcdef";
# endif
static void
prt_write_file_raw_len(buffer, bytes)
char_u *buffer;
int bytes;
{
if (!prt_file_error
&& fwrite(buffer, sizeof(char_u), bytes, prt_ps_fd)
!= (size_t)bytes)
{
EMSG(_("E455: Error writing to PostScript output file"));
prt_file_error = TRUE;
}
}
static void
prt_write_file(buffer)
char_u *buffer;
{
prt_write_file_len(buffer, (int)STRLEN(buffer));
}
static void
prt_write_file_len(buffer, bytes)
char_u *buffer;
int bytes;
{
#ifdef EBCDIC
ebcdic2ascii(buffer, bytes);
#endif
prt_write_file_raw_len(buffer, bytes);
}
/*
* Write a string.
*/
static void
prt_write_string(s)
char *s;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer), "%s", s);
prt_write_file(prt_line_buffer);
}
/*
* Write an int and a space.
*/
static void
prt_write_int(i)
int i;
{
sprintf((char *)prt_line_buffer, "%d ", i);
prt_write_file(prt_line_buffer);
}
/*
* Write a boolean and a space.
*/
static void
prt_write_boolean(b)
int b;
{
sprintf((char *)prt_line_buffer, "%s ", (b ? "T" : "F"));
prt_write_file(prt_line_buffer);
}
/*
* Write PostScript to re-encode and define the font.
*/
static void
prt_def_font(new_name, encoding, height, font)
char *new_name;
char *encoding;
int height;
char *font;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/_%s /VIM-%s /%s ref\n", new_name, encoding, font);
prt_write_file(prt_line_buffer);
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
sprintf((char *)prt_line_buffer, "/%s %d %f /_%s sffs\n",
new_name, height, 500./prt_ps_courier_font.wx, new_name);
else
#endif
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s %d /_%s ffs\n", new_name, height, new_name);
prt_write_file(prt_line_buffer);
}
#ifdef FEAT_MBYTE
/*
* Write a line to define the CID font.
*/
static void
prt_def_cidfont(new_name, height, cidfont)
char *new_name;
int height;
char *cidfont;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/_%s /%s[/%s] vim_composefont\n", new_name, prt_cmap, cidfont);
prt_write_file(prt_line_buffer);
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s %d /_%s ffs\n", new_name, height, new_name);
prt_write_file(prt_line_buffer);
}
/*
* Write a line to define a duplicate of a CID font
*/
static void
prt_dup_cidfont(original_name, new_name)
char *original_name;
char *new_name;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s %s d\n", new_name, original_name);
prt_write_file(prt_line_buffer);
}
#endif
/*
* Convert a real value into an integer and fractional part as integers, with
* the fractional part being in the range [0,10^precision). The fractional part
* is also rounded based on the precision + 1'th fractional digit.
*/
static void
prt_real_bits(real, precision, pinteger, pfraction)
double real;
int precision;
int *pinteger;
int *pfraction;
{
int i;
int integer;
float fraction;
integer = (int)real;
fraction = (float)(real - integer);
if (real < (double)integer)
fraction = -fraction;
for (i = 0; i < precision; i++)
fraction *= 10.0;
*pinteger = integer;
*pfraction = (int)(fraction + 0.5);
}
/*
* Write a real and a space. Save bytes if real value has no fractional part!
* We use prt_real_bits() as %f in sprintf uses the locale setting to decide
* what decimal point character to use, but PS always requires a '.'.
*/
static void
prt_write_real(val, prec)
double val;
int prec;
{
int integer;
int fraction;
prt_real_bits(val, prec, &integer, &fraction);
/* Emit integer part */
sprintf((char *)prt_line_buffer, "%d", integer);
prt_write_file(prt_line_buffer);
/* Only emit fraction if necessary */
if (fraction != 0)
{
/* Remove any trailing zeros */
while ((fraction % 10) == 0)
{
prec--;
fraction /= 10;
}
/* Emit fraction left padded with zeros */
sprintf((char *)prt_line_buffer, ".%0*d", prec, fraction);
prt_write_file(prt_line_buffer);
}
sprintf((char *)prt_line_buffer, " ");
prt_write_file(prt_line_buffer);
}
/*
* Write a line to define a numeric variable.
*/
static void
prt_def_var(name, value, prec)
char *name;
double value;
int prec;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s ", name);
prt_write_file(prt_line_buffer);
prt_write_real(value, prec);
sprintf((char *)prt_line_buffer, "d\n");
prt_write_file(prt_line_buffer);
}
/* Convert size from font space to user space at current font scale */
#define PRT_PS_FONT_TO_USER(scale, size) ((size) * ((scale)/1000.0))
static void
prt_flush_buffer()
{
if (prt_ps_buffer.ga_len > 0)
{
/* Any background color must be drawn first */
if (prt_do_bgcol && (prt_new_bgcol != PRCOLOR_WHITE))
{
int r, g, b;
if (prt_do_moveto)
{
prt_write_real(prt_pos_x_moveto, 2);
prt_write_real(prt_pos_y_moveto, 2);
prt_write_string("m\n");
prt_do_moveto = FALSE;
}
/* Size of rect of background color on which text is printed */
prt_write_real(prt_text_run, 2);
prt_write_real(prt_line_height, 2);
/* Lastly add the color of the background */
r = ((unsigned)prt_new_bgcol & 0xff0000) >> 16;
g = ((unsigned)prt_new_bgcol & 0xff00) >> 8;
b = prt_new_bgcol & 0xff;
prt_write_real(r / 255.0, 3);
prt_write_real(g / 255.0, 3);
prt_write_real(b / 255.0, 3);
prt_write_string("bg\n");
}
/* Draw underlines before the text as it makes it slightly easier to
* find the starting point.
*/
if (prt_do_underline)
{
if (prt_do_moveto)
{
prt_write_real(prt_pos_x_moveto, 2);
prt_write_real(prt_pos_y_moveto, 2);
prt_write_string("m\n");
prt_do_moveto = FALSE;
}
/* Underline length of text run */
prt_write_real(prt_text_run, 2);
prt_write_string("ul\n");
}
/* Draw the text
* Note: we write text out raw - EBCDIC conversion is handled in the
* PostScript world via the font encoding vector. */
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
prt_write_string("<");
else
#endif
prt_write_string("(");
prt_write_file_raw_len(prt_ps_buffer.ga_data, prt_ps_buffer.ga_len);
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
prt_write_string(">");
else
#endif
prt_write_string(")");
/* Add a moveto if need be and use the appropriate show procedure */
if (prt_do_moveto)
{
prt_write_real(prt_pos_x_moveto, 2);
prt_write_real(prt_pos_y_moveto, 2);
/* moveto and a show */
prt_write_string("ms\n");
prt_do_moveto = FALSE;
}
else /* Simple show */
prt_write_string("s\n");
ga_clear(&prt_ps_buffer);
ga_init2(&prt_ps_buffer, (int)sizeof(char), prt_bufsiz);
}
}
static void
prt_resource_name(filename, cookie)
char_u *filename;
void *cookie;
{
char_u *resource_filename = cookie;
if (STRLEN(filename) >= MAXPATHL)
*resource_filename = NUL;
else
STRCPY(resource_filename, filename);
}
static int
prt_find_resource(name, resource)
char *name;
struct prt_ps_resource_S *resource;
{
char_u buffer[MAXPATHL + 1];
STRCPY(resource->name, name);
/* Look for named resource file in runtimepath */
STRCPY(buffer, "print");
add_pathsep(buffer);
STRCAT(buffer, name);
STRCAT(buffer, ".ps");
resource->filename[0] = NUL;
return (do_in_runtimepath(buffer, FALSE, prt_resource_name,
resource->filename)
&& resource->filename[0] != NUL);
}
/* PS CR and LF characters have platform independent values */
#define PSLF (0x0a)
#define PSCR (0x0d)
/* Static buffer to read initial comments in a resource file, some can have a
* couple of KB of comments! */
#define PRT_FILE_BUFFER_LEN (2048)
struct prt_resfile_buffer_S
{
char_u buffer[PRT_FILE_BUFFER_LEN];
int len;
int line_start;
int line_end;
};
static struct prt_resfile_buffer_S prt_resfile;
static int
prt_resfile_next_line()
{
int idx;
/* Move to start of next line and then find end of line */
idx = prt_resfile.line_end + 1;
while (idx < prt_resfile.len)
{
if (prt_resfile.buffer[idx] != PSLF && prt_resfile.buffer[idx] != PSCR)
break;
idx++;
}
prt_resfile.line_start = idx;
while (idx < prt_resfile.len)
{
if (prt_resfile.buffer[idx] == PSLF || prt_resfile.buffer[idx] == PSCR)
break;
idx++;
}
prt_resfile.line_end = idx;
return (idx < prt_resfile.len);
}
static int
prt_resfile_strncmp(offset, string, len)
int offset;
char *string;
int len;
{
/* Force not equal if string is longer than remainder of line */
if (len > (prt_resfile.line_end - (prt_resfile.line_start + offset)))
return 1;
return STRNCMP(&prt_resfile.buffer[prt_resfile.line_start + offset],
string, len);
}
static int
prt_resfile_skip_nonws(offset)
int offset;
{
int idx;
idx = prt_resfile.line_start + offset;
while (idx < prt_resfile.line_end)
{
if (isspace(prt_resfile.buffer[idx]))
return idx - prt_resfile.line_start;
idx++;
}
return -1;
}
static int
prt_resfile_skip_ws(offset)
int offset;
{
int idx;
idx = prt_resfile.line_start + offset;
while (idx < prt_resfile.line_end)
{
if (!isspace(prt_resfile.buffer[idx]))
return idx - prt_resfile.line_start;
idx++;
}
return -1;
}
/* prt_next_dsc() - returns detail on next DSC comment line found. Returns true
* if a DSC comment is found, else false */
static int
prt_next_dsc(p_dsc_line)
struct prt_dsc_line_S *p_dsc_line;
{
int comment;
int offset;
/* Move to start of next line */
if (!prt_resfile_next_line())
return FALSE;
/* DSC comments always start %% */
if (prt_resfile_strncmp(0, "%%", 2) != 0)
return FALSE;
/* Find type of DSC comment */
for (comment = 0; comment < NUM_ELEMENTS(prt_dsc_table); comment++)
if (prt_resfile_strncmp(0, prt_dsc_table[comment].string,
prt_dsc_table[comment].len) == 0)
break;
if (comment != NUM_ELEMENTS(prt_dsc_table))
{
/* Return type of comment */
p_dsc_line->type = prt_dsc_table[comment].type;
offset = prt_dsc_table[comment].len;
}
else
{
/* Unrecognised DSC comment, skip to ws after comment leader */
p_dsc_line->type = PRT_DSC_MISC_TYPE;
offset = prt_resfile_skip_nonws(0);
if (offset == -1)
return FALSE;
}
/* Skip ws to comment value */
offset = prt_resfile_skip_ws(offset);
if (offset == -1)
return FALSE;
p_dsc_line->string = &prt_resfile.buffer[prt_resfile.line_start + offset];
p_dsc_line->len = prt_resfile.line_end - (prt_resfile.line_start + offset);
return TRUE;
}
/* Improved hand crafted parser to get the type, title, and version number of a
* PS resource file so the file details can be added to the DSC header comments.
*/
static int
prt_open_resource(resource)
struct prt_ps_resource_S *resource;
{
int offset;
int seen_all;
int seen_title;
int seen_version;
FILE *fd_resource;
struct prt_dsc_line_S dsc_line;
fd_resource = mch_fopen((char *)resource->filename, READBIN);
if (fd_resource == NULL)
{
EMSG2(_("E624: Can't open file \"%s\""), resource->filename);
return FALSE;
}
vim_memset(prt_resfile.buffer, NUL, PRT_FILE_BUFFER_LEN);
/* Parse first line to ensure valid resource file */
prt_resfile.len = (int)fread((char *)prt_resfile.buffer, sizeof(char_u),
PRT_FILE_BUFFER_LEN, fd_resource);
if (ferror(fd_resource))
{
EMSG2(_("E457: Can't read PostScript resource file \"%s\""),
resource->filename);
fclose(fd_resource);
return FALSE;
}
prt_resfile.line_end = -1;
prt_resfile.line_start = 0;
if (!prt_resfile_next_line())
return FALSE;
offset = 0;
if (prt_resfile_strncmp(offset, PRT_RESOURCE_HEADER,
(int)STRLEN(PRT_RESOURCE_HEADER)) != 0)
{
EMSG2(_("E618: file \"%s\" is not a PostScript resource file"),
resource->filename);
fclose(fd_resource);
return FALSE;
}
/* Skip over any version numbers and following ws */
offset += (int)STRLEN(PRT_RESOURCE_HEADER);
offset = prt_resfile_skip_nonws(offset);
if (offset == -1)
return FALSE;
offset = prt_resfile_skip_ws(offset);
if (offset == -1)
return FALSE;
if (prt_resfile_strncmp(offset, PRT_RESOURCE_RESOURCE,
(int)STRLEN(PRT_RESOURCE_RESOURCE)) != 0)
{
EMSG2(_("E619: file \"%s\" is not a supported PostScript resource file"),
resource->filename);
fclose(fd_resource);
return FALSE;
}
offset += (int)STRLEN(PRT_RESOURCE_RESOURCE);
/* Decide type of resource in the file */
if (prt_resfile_strncmp(offset, PRT_RESOURCE_PROCSET,
(int)STRLEN(PRT_RESOURCE_PROCSET)) == 0)
resource->type = PRT_RESOURCE_TYPE_PROCSET;
else if (prt_resfile_strncmp(offset, PRT_RESOURCE_ENCODING,
(int)STRLEN(PRT_RESOURCE_ENCODING)) == 0)
resource->type = PRT_RESOURCE_TYPE_ENCODING;
else if (prt_resfile_strncmp(offset, PRT_RESOURCE_CMAP,
(int)STRLEN(PRT_RESOURCE_CMAP)) == 0)
resource->type = PRT_RESOURCE_TYPE_CMAP;
else
{
EMSG2(_("E619: file \"%s\" is not a supported PostScript resource file"),
resource->filename);
fclose(fd_resource);
return FALSE;
}
/* Look for title and version of resource */
resource->title[0] = '\0';
resource->version[0] = '\0';
seen_title = FALSE;
seen_version = FALSE;
seen_all = FALSE;
while (!seen_all && prt_next_dsc(&dsc_line))
{
switch (dsc_line.type)
{
case PRT_DSC_TITLE_TYPE:
vim_strncpy(resource->title, dsc_line.string, dsc_line.len);
seen_title = TRUE;
if (seen_version)
seen_all = TRUE;
break;
case PRT_DSC_VERSION_TYPE:
vim_strncpy(resource->version, dsc_line.string, dsc_line.len);
seen_version = TRUE;
if (seen_title)
seen_all = TRUE;
break;
case PRT_DSC_ENDCOMMENTS_TYPE:
/* Wont find title or resource after this comment, stop searching */
seen_all = TRUE;
break;
case PRT_DSC_MISC_TYPE:
/* Not interested in whatever comment this line had */
break;
}
}
if (!seen_title || !seen_version)
{
EMSG2(_("E619: file \"%s\" is not a supported PostScript resource file"),
resource->filename);
fclose(fd_resource);
return FALSE;
}
fclose(fd_resource);
return TRUE;
}
static int
prt_check_resource(resource, version)
struct prt_ps_resource_S *resource;
char_u *version;
{
/* Version number m.n should match, the revision number does not matter */
if (STRNCMP(resource->version, version, STRLEN(version)))
{
EMSG2(_("E621: \"%s\" resource file has wrong version"),
resource->name);
return FALSE;
}
/* Other checks to be added as needed */
return TRUE;
}
static void
prt_dsc_start()
{
prt_write_string("%!PS-Adobe-3.0\n");
}
static void
prt_dsc_noarg(comment)
char *comment;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s\n", comment);
prt_write_file(prt_line_buffer);
}
static void
prt_dsc_textline(comment, text)
char *comment;
char *text;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: %s\n", comment, text);
prt_write_file(prt_line_buffer);
}
static void
prt_dsc_text(comment, text)
char *comment;
char *text;
{
/* TODO - should scan 'text' for any chars needing escaping! */
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: (%s)\n", comment, text);
prt_write_file(prt_line_buffer);
}
#define prt_dsc_atend(c) prt_dsc_text((c), "atend")
static void
prt_dsc_ints(comment, count, ints)
char *comment;
int count;
int *ints;
{
int i;
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s:", comment);
prt_write_file(prt_line_buffer);
for (i = 0; i < count; i++)
{
sprintf((char *)prt_line_buffer, " %d", ints[i]);
prt_write_file(prt_line_buffer);
}
prt_write_string("\n");
}
static void
prt_dsc_resources(comment, type, string)
char *comment; /* if NULL add to previous */
char *type;
char *string;
{
if (comment != NULL)
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: %s", comment, type);
else
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%+ %s", type);
prt_write_file(prt_line_buffer);
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
" %s\n", string);
prt_write_file(prt_line_buffer);
}
static void
prt_dsc_font_resource(resource, ps_font)
char *resource;
struct prt_ps_font_S *ps_font;
{
int i;
prt_dsc_resources(resource, "font",
ps_font->ps_fontname[PRT_PS_FONT_ROMAN]);
for (i = PRT_PS_FONT_BOLD ; i <= PRT_PS_FONT_BOLDOBLIQUE ; i++)
if (ps_font->ps_fontname[i] != NULL)
prt_dsc_resources(NULL, "font", ps_font->ps_fontname[i]);
}
static void
prt_dsc_requirements(duplex, tumble, collate, color, num_copies)
int duplex;
int tumble;
int collate;
int color;
int num_copies;
{
/* Only output the comment if we need to.
* Note: tumble is ignored if we are not duplexing
*/
if (!(duplex || collate || color || (num_copies > 1)))
return;
sprintf((char *)prt_line_buffer, "%%%%Requirements:");
prt_write_file(prt_line_buffer);
if (duplex)
{
prt_write_string(" duplex");
if (tumble)
prt_write_string("(tumble)");
}
if (collate)
prt_write_string(" collate");
if (color)
prt_write_string(" color");
if (num_copies > 1)
{
prt_write_string(" numcopies(");
/* Note: no space wanted so dont use prt_write_int() */
sprintf((char *)prt_line_buffer, "%d", num_copies);
prt_write_file(prt_line_buffer);
prt_write_string(")");
}
prt_write_string("\n");
}
static void
prt_dsc_docmedia(paper_name, width, height, weight, colour, type)
char *paper_name;
double width;
double height;
double weight;
char *colour;
char *type;
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%DocumentMedia: %s ", paper_name);
prt_write_file(prt_line_buffer);
prt_write_real(width, 2);
prt_write_real(height, 2);
prt_write_real(weight, 2);
if (colour == NULL)
prt_write_string("()");
else
prt_write_string(colour);
prt_write_string(" ");
if (type == NULL)
prt_write_string("()");
else
prt_write_string(type);
prt_write_string("\n");
}
void
mch_print_cleanup()
{
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
int i;
/* Free off all CID font names created, but first clear duplicate
* pointers to the same string (when the same font is used for more than
* one style).
*/
for (i = PRT_PS_FONT_ROMAN; i <= PRT_PS_FONT_BOLDOBLIQUE; i++)
{
if (prt_ps_mb_font.ps_fontname[i] != NULL)
vim_free(prt_ps_mb_font.ps_fontname[i]);
prt_ps_mb_font.ps_fontname[i] = NULL;
}
}
if (prt_do_conv)
{
convert_setup(&prt_conv, NULL, NULL);
prt_do_conv = FALSE;
}
#endif
if (prt_ps_fd != NULL)
{
fclose(prt_ps_fd);
prt_ps_fd = NULL;
prt_file_error = FALSE;
}
if (prt_ps_file_name != NULL)
{
vim_free(prt_ps_file_name);
prt_ps_file_name = NULL;
}
}
static float
to_device_units(idx, physsize, def_number)
int idx;
double physsize;
int def_number;
{
float ret;
int u;
int nr;
u = prt_get_unit(idx);
if (u == PRT_UNIT_NONE)
{
u = PRT_UNIT_PERC;
nr = def_number;
}
else
nr = printer_opts[idx].number;
switch (u)
{
case PRT_UNIT_INCH:
ret = (float)(nr * PRT_PS_DEFAULT_DPI);
break;
case PRT_UNIT_MM:
ret = (float)(nr * PRT_PS_DEFAULT_DPI) / (float)25.4;
break;
case PRT_UNIT_POINT:
ret = (float)nr;
break;
case PRT_UNIT_PERC:
default:
ret = (float)(physsize * nr) / 100;
break;
}
return ret;
}
/*
* Calculate margins for given width and height from printoptions settings.
*/
static void
prt_page_margins(width, height, left, right, top, bottom)
double width;
double height;
double *left;
double *right;
double *top;
double *bottom;
{
*left = to_device_units(OPT_PRINT_LEFT, width, 10);
*right = width - to_device_units(OPT_PRINT_RIGHT, width, 5);
*top = height - to_device_units(OPT_PRINT_TOP, height, 5);
*bottom = to_device_units(OPT_PRINT_BOT, height, 5);
}
static void
prt_font_metrics(font_scale)
int font_scale;
{
prt_line_height = (float)font_scale;
prt_char_width = (float)PRT_PS_FONT_TO_USER(font_scale, prt_ps_font->wx);
}
static int
prt_get_cpl()
{
if (prt_use_number())
{
prt_number_width = PRINT_NUMBER_WIDTH * prt_char_width;
#ifdef FEAT_MBYTE
/* If we are outputting multi-byte characters then line numbers will be
* printed with half width characters
*/
if (prt_out_mbyte)
prt_number_width /= 2;
#endif
prt_left_margin += prt_number_width;
}
else
prt_number_width = 0.0;
return (int)((prt_right_margin - prt_left_margin) / prt_char_width);
}
#ifdef FEAT_MBYTE
static int
prt_build_cid_fontname(font, name, name_len)
int font;
char_u *name;
int name_len;
{
char *fontname;
fontname = (char *)alloc(name_len + 1);
if (fontname == NULL)
return FALSE;
vim_strncpy((char_u *)fontname, name, name_len);
prt_ps_mb_font.ps_fontname[font] = fontname;
return TRUE;
}
#endif
/*
* Get number of lines of text that fit on a page (excluding the header).
*/
static int
prt_get_lpp()
{
int lpp;
/*
* Calculate offset to lower left corner of background rect based on actual
* font height (based on its bounding box) and the line height, handling the
* case where the font height can exceed the line height.
*/
prt_bgcol_offset = (float)PRT_PS_FONT_TO_USER(prt_line_height,
prt_ps_font->bbox_min_y);
if ((prt_ps_font->bbox_max_y - prt_ps_font->bbox_min_y) < 1000.0)
{
prt_bgcol_offset -= (float)PRT_PS_FONT_TO_USER(prt_line_height,
(1000.0 - (prt_ps_font->bbox_max_y -
prt_ps_font->bbox_min_y)) / 2);
}
/* Get height for topmost line based on background rect offset. */
prt_first_line_height = prt_line_height + prt_bgcol_offset;
/* Calculate lpp */
lpp = (int)((prt_top_margin - prt_bottom_margin) / prt_line_height);
/* Adjust top margin if there is a header */
prt_top_margin -= prt_line_height * prt_header_height();
return lpp - prt_header_height();
}
#ifdef FEAT_MBYTE
static int
prt_match_encoding(p_encoding, p_cmap, pp_mbenc)
char *p_encoding;
struct prt_ps_mbfont_S *p_cmap;
struct prt_ps_encoding_S **pp_mbenc;
{
int mbenc;
int enc_len;
struct prt_ps_encoding_S *p_mbenc;
*pp_mbenc = NULL;
/* Look for recognised encoding */
enc_len = (int)STRLEN(p_encoding);
p_mbenc = p_cmap->encodings;
for (mbenc = 0; mbenc < p_cmap->num_encodings; mbenc++)
{
if (STRNICMP(p_mbenc->encoding, p_encoding, enc_len) == 0)
{
*pp_mbenc = p_mbenc;
return TRUE;
}
p_mbenc++;
}
return FALSE;
}
static int
prt_match_charset(p_charset, p_cmap, pp_mbchar)
char *p_charset;
struct prt_ps_mbfont_S *p_cmap;
struct prt_ps_charset_S **pp_mbchar;
{
int mbchar;
int char_len;
struct prt_ps_charset_S *p_mbchar;
/* Look for recognised character set, using default if one is not given */
if (*p_charset == NUL)
p_charset = p_cmap->defcs;
char_len = (int)STRLEN(p_charset);
p_mbchar = p_cmap->charsets;
for (mbchar = 0; mbchar < p_cmap->num_charsets; mbchar++)
{
if (STRNICMP(p_mbchar->charset, p_charset, char_len) == 0)
{
*pp_mbchar = p_mbchar;
return TRUE;
}
p_mbchar++;
}
return FALSE;
}
#endif
/*ARGSUSED*/
int
mch_print_init(psettings, jobname, forceit)
prt_settings_T *psettings;
char_u *jobname;
int forceit;
{
int i;
char *paper_name;
int paper_strlen;
int fontsize;
char_u *p;
double left;
double right;
double top;
double bottom;
#ifdef FEAT_MBYTE
int props;
int cmap = 0;
char_u *p_encoding;
struct prt_ps_encoding_S *p_mbenc;
struct prt_ps_encoding_S *p_mbenc_first;
struct prt_ps_charset_S *p_mbchar = NULL;
#endif
#if 0
/*
* TODO:
* If "forceit" is false: pop up a dialog to select:
* - printer name
* - copies
* - collated/uncollated
* - duplex off/long side/short side
* - paper size
* - portrait/landscape
* - font size
*
* If "forceit" is true: use the default printer and settings
*/
if (forceit)
s_pd.Flags |= PD_RETURNDEFAULT;
#endif
/*
* Set up font and encoding.
*/
#ifdef FEAT_MBYTE
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL)
p_encoding = enc_skip(p_enc);
/* Look for a multi-byte font that matches the encoding and character set.
* Only look if multi-byte character set is defined, or using multi-byte
* encoding other than Unicode. This is because a Unicode encoding does not
* uniquely identify a CJK character set to use. */
p_mbenc = NULL;
props = enc_canon_props(p_encoding);
if (!(props & ENC_8BIT) && ((*p_pmcs != NUL) || !(props & ENC_UNICODE)))
{
p_mbenc_first = NULL;
for (cmap = 0; cmap < NUM_ELEMENTS(prt_ps_mbfonts); cmap++)
if (prt_match_encoding((char *)p_encoding, &prt_ps_mbfonts[cmap],
&p_mbenc))
{
if (p_mbenc_first == NULL)
p_mbenc_first = p_mbenc;
if (prt_match_charset((char *)p_pmcs, &prt_ps_mbfonts[cmap],
&p_mbchar))
break;
}
/* Use first encoding matched if no charset matched */
if (p_mbchar == NULL && p_mbenc_first != NULL)
p_mbenc = p_mbenc_first;
}
prt_out_mbyte = (p_mbenc != NULL);
if (prt_out_mbyte)
{
/* Build CMap name - will be same for all multi-byte fonts used */
prt_cmap[0] = NUL;
prt_custom_cmap = (p_mbchar == NULL);
if (!prt_custom_cmap)
{
/* Check encoding and character set are compatible */
if ((p_mbenc->needs_charset & p_mbchar->has_charset) == 0)
{
EMSG(_("E673: Incompatible multi-byte encoding and character set."));
return FALSE;
}
/* Add charset name if not empty */
if (p_mbchar->cmap_charset != NULL)
{
vim_strncpy((char_u *)prt_cmap,
(char_u *)p_mbchar->cmap_charset, sizeof(prt_cmap) - 3);
STRCAT(prt_cmap, "-");
}
}
else
{
/* Add custom CMap character set name */
if (*p_pmcs == NUL)
{
EMSG(_("E674: printmbcharset cannot be empty with multi-byte encoding."));
return FALSE;
}
vim_strncpy((char_u *)prt_cmap, p_pmcs, sizeof(prt_cmap) - 3);
STRCAT(prt_cmap, "-");
}
/* CMap name ends with (optional) encoding name and -H for horizontal */
if (p_mbenc->cmap_encoding != NULL && STRLEN(prt_cmap)
+ STRLEN(p_mbenc->cmap_encoding) + 3 < sizeof(prt_cmap))
{
STRCAT(prt_cmap, p_mbenc->cmap_encoding);
STRCAT(prt_cmap, "-");
}
STRCAT(prt_cmap, "H");
if (!mbfont_opts[OPT_MBFONT_REGULAR].present)
{
EMSG(_("E675: No default font specified for multi-byte printing."));
return FALSE;
}
/* Derive CID font names with fallbacks if not defined */
if (!prt_build_cid_fontname(PRT_PS_FONT_ROMAN,
mbfont_opts[OPT_MBFONT_REGULAR].string,
mbfont_opts[OPT_MBFONT_REGULAR].strlen))
return FALSE;
if (mbfont_opts[OPT_MBFONT_BOLD].present)
if (!prt_build_cid_fontname(PRT_PS_FONT_BOLD,
mbfont_opts[OPT_MBFONT_BOLD].string,
mbfont_opts[OPT_MBFONT_BOLD].strlen))
return FALSE;
if (mbfont_opts[OPT_MBFONT_OBLIQUE].present)
if (!prt_build_cid_fontname(PRT_PS_FONT_OBLIQUE,
mbfont_opts[OPT_MBFONT_OBLIQUE].string,
mbfont_opts[OPT_MBFONT_OBLIQUE].strlen))
return FALSE;
if (mbfont_opts[OPT_MBFONT_BOLDOBLIQUE].present)
if (!prt_build_cid_fontname(PRT_PS_FONT_BOLDOBLIQUE,
mbfont_opts[OPT_MBFONT_BOLDOBLIQUE].string,
mbfont_opts[OPT_MBFONT_BOLDOBLIQUE].strlen))
return FALSE;
/* Check if need to use Courier for ASCII code range, and if so pick up
* the encoding to use */
prt_use_courier = mbfont_opts[OPT_MBFONT_USECOURIER].present &&
(TOLOWER_ASC(mbfont_opts[OPT_MBFONT_USECOURIER].string[0]) == 'y');
if (prt_use_courier)
{
/* Use national ASCII variant unless ASCII wanted */
if (mbfont_opts[OPT_MBFONT_ASCII].present &&
(TOLOWER_ASC(mbfont_opts[OPT_MBFONT_ASCII].string[0]) == 'y'))
prt_ascii_encoding = "ascii";
else
prt_ascii_encoding = prt_ps_mbfonts[cmap].ascii_enc;
}
prt_ps_font = &prt_ps_mb_font;
}
else
#endif
{
#ifdef FEAT_MBYTE
prt_use_courier = FALSE;
#endif
prt_ps_font = &prt_ps_courier_font;
}
/*
* Find the size of the paper and set the margins.
*/
prt_portrait = (!printer_opts[OPT_PRINT_PORTRAIT].present
|| TOLOWER_ASC(printer_opts[OPT_PRINT_PORTRAIT].string[0]) == 'y');
if (printer_opts[OPT_PRINT_PAPER].present)
{
paper_name = (char *)printer_opts[OPT_PRINT_PAPER].string;
paper_strlen = printer_opts[OPT_PRINT_PAPER].strlen;
}
else
{
paper_name = "A4";
paper_strlen = 2;
}
for (i = 0; i < PRT_MEDIASIZE_LEN; ++i)
if (STRLEN(prt_mediasize[i].name) == (unsigned)paper_strlen
&& STRNICMP(prt_mediasize[i].name, paper_name,
paper_strlen) == 0)
break;
if (i == PRT_MEDIASIZE_LEN)
i = 0;
prt_media = i;
/*
* Set PS pagesize based on media dimensions and print orientation.
* Note: Media and page sizes have defined meanings in PostScript and should
* be kept distinct. Media is the paper (or transparency, or ...) that is
* printed on, whereas the page size is the area that the PostScript
* interpreter renders into.
*/
if (prt_portrait)
{
prt_page_width = prt_mediasize[i].width;
prt_page_height = prt_mediasize[i].height;
}
else
{
prt_page_width = prt_mediasize[i].height;
prt_page_height = prt_mediasize[i].width;
}
/*
* Set PS page margins based on the PS pagesize, not the mediasize - this
* needs to be done before the cpl and lpp are calculated.
*/
prt_page_margins(prt_page_width, prt_page_height, &left, &right, &top,
&bottom);
prt_left_margin = (float)left;
prt_right_margin = (float)right;
prt_top_margin = (float)top;
prt_bottom_margin = (float)bottom;
/*
* Set up the font size.
*/
fontsize = PRT_PS_DEFAULT_FONTSIZE;
for (p = p_pfn; (p = vim_strchr(p, ':')) != NULL; ++p)
if (p[1] == 'h' && VIM_ISDIGIT(p[2]))
fontsize = atoi((char *)p + 2);
prt_font_metrics(fontsize);
/*
* Return the number of characters per line, and lines per page for the
* generic print code.
*/
psettings->chars_per_line = prt_get_cpl();
psettings->lines_per_page = prt_get_lpp();
/* Catch margin settings that leave no space for output! */
if (psettings->chars_per_line <= 0 || psettings->lines_per_page <= 0)
return FAIL;
/*
* Sort out the number of copies to be printed. PS by default will do
* uncollated copies for you, so once we know how many uncollated copies are
* wanted cache it away and lie to the generic code that we only want one
* uncollated copy.
*/
psettings->n_collated_copies = 1;
psettings->n_uncollated_copies = 1;
prt_num_copies = 1;
prt_collate = (!printer_opts[OPT_PRINT_COLLATE].present
|| TOLOWER_ASC(printer_opts[OPT_PRINT_COLLATE].string[0]) == 'y');
if (prt_collate)
{
/* TODO: Get number of collated copies wanted. */
psettings->n_collated_copies = 1;
}
else
{
/* TODO: Get number of uncollated copies wanted and update the cached
* count.
*/
prt_num_copies = 1;
}
psettings->jobname = jobname;
/*
* Set up printer duplex and tumble based on Duplex option setting - default
* is long sided duplex printing (i.e. no tumble).
*/
prt_duplex = TRUE;
prt_tumble = FALSE;
psettings->duplex = 1;
if (printer_opts[OPT_PRINT_DUPLEX].present)
{
if (STRNICMP(printer_opts[OPT_PRINT_DUPLEX].string, "off", 3) == 0)
{
prt_duplex = FALSE;
psettings->duplex = 0;
}
else if (STRNICMP(printer_opts[OPT_PRINT_DUPLEX].string, "short", 5)
== 0)
prt_tumble = TRUE;
}
/* For now user abort not supported */
psettings->user_abort = 0;
/* If the user didn't specify a file name, use a temp file. */
if (psettings->outfile == NULL)
{
prt_ps_file_name = vim_tempname('p');
if (prt_ps_file_name == NULL)
{
EMSG(_(e_notmp));
return FAIL;
}
prt_ps_fd = mch_fopen((char *)prt_ps_file_name, WRITEBIN);
}
else
{
p = expand_env_save(psettings->outfile);
if (p != NULL)
{
prt_ps_fd = mch_fopen((char *)p, WRITEBIN);
vim_free(p);
}
}
if (prt_ps_fd == NULL)
{
EMSG(_("E324: Can't open PostScript output file"));
mch_print_cleanup();
return FAIL;
}
prt_bufsiz = psettings->chars_per_line;
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
prt_bufsiz *= 2;
#endif
ga_init2(&prt_ps_buffer, (int)sizeof(char), prt_bufsiz);
prt_page_num = 0;
prt_attribute_change = FALSE;
prt_need_moveto = FALSE;
prt_need_font = FALSE;
prt_need_fgcol = FALSE;
prt_need_bgcol = FALSE;
prt_need_underline = FALSE;
prt_file_error = FALSE;
return OK;
}
static int
prt_add_resource(resource)
struct prt_ps_resource_S *resource;
{
FILE* fd_resource;
char_u resource_buffer[512];
size_t bytes_read;
fd_resource = mch_fopen((char *)resource->filename, READBIN);
if (fd_resource == NULL)
{
EMSG2(_("E456: Can't open file \"%s\""), resource->filename);
return FALSE;
}
prt_dsc_resources("BeginResource", prt_resource_types[resource->type],
(char *)resource->title);
prt_dsc_textline("BeginDocument", (char *)resource->filename);
for (;;)
{
bytes_read = fread((char *)resource_buffer, sizeof(char_u),
sizeof(resource_buffer), fd_resource);
if (ferror(fd_resource))
{
EMSG2(_("E457: Can't read PostScript resource file \"%s\""),
resource->filename);
fclose(fd_resource);
return FALSE;
}
if (bytes_read == 0)
break;
prt_write_file_raw_len(resource_buffer, (int)bytes_read);
if (prt_file_error)
{
fclose(fd_resource);
return FALSE;
}
}
fclose(fd_resource);
prt_dsc_noarg("EndDocument");
prt_dsc_noarg("EndResource");
return TRUE;
}
int
mch_print_begin(psettings)
prt_settings_T *psettings;
{
time_t now;
int bbox[4];
char *p_time;
double left;
double right;
double top;
double bottom;
struct prt_ps_resource_S res_prolog;
struct prt_ps_resource_S res_encoding;
char buffer[256];
char_u *p_encoding;
char_u *p;
#ifdef FEAT_MBYTE
struct prt_ps_resource_S res_cidfont;
struct prt_ps_resource_S res_cmap;
#endif
/*
* PS DSC Header comments - no PS code!
*/
prt_dsc_start();
prt_dsc_textline("Title", (char *)psettings->jobname);
if (!get_user_name((char_u *)buffer, 256))
STRCPY(buffer, "Unknown");
prt_dsc_textline("For", buffer);
prt_dsc_textline("Creator", VIM_VERSION_LONG);
/* Note: to ensure Clean8bit I don't think we can use LC_TIME */
now = time(NULL);
p_time = ctime(&now);
/* Note: ctime() adds a \n so we have to remove it :-( */
p = vim_strchr((char_u *)p_time, '\n');
if (p != NULL)
*p = NUL;
prt_dsc_textline("CreationDate", p_time);
prt_dsc_textline("DocumentData", "Clean8Bit");
prt_dsc_textline("Orientation", "Portrait");
prt_dsc_atend("Pages");
prt_dsc_textline("PageOrder", "Ascend");
/* The bbox does not change with orientation - it is always in the default
* user coordinate system! We have to recalculate right and bottom
* coordinates based on the font metrics for the bbox to be accurate. */
prt_page_margins(prt_mediasize[prt_media].width,
prt_mediasize[prt_media].height,
&left, &right, &top, &bottom);
bbox[0] = (int)left;
if (prt_portrait)
{
/* In portrait printing the fixed point is the top left corner so we
* derive the bbox from that point. We have the expected cpl chars
* across the media and lpp lines down the media.
*/
bbox[1] = (int)(top - (psettings->lines_per_page + prt_header_height())
* prt_line_height);
bbox[2] = (int)(left + psettings->chars_per_line * prt_char_width
+ 0.5);
bbox[3] = (int)(top + 0.5);
}
else
{
/* In landscape printing the fixed point is the bottom left corner so we
* derive the bbox from that point. We have lpp chars across the media
* and cpl lines up the media.
*/
bbox[1] = (int)bottom;
bbox[2] = (int)(left + ((psettings->lines_per_page
+ prt_header_height()) * prt_line_height) + 0.5);
bbox[3] = (int)(bottom + psettings->chars_per_line * prt_char_width
+ 0.5);
}
prt_dsc_ints("BoundingBox", 4, bbox);
/* The media width and height does not change with landscape printing! */
prt_dsc_docmedia(prt_mediasize[prt_media].name,
prt_mediasize[prt_media].width,
prt_mediasize[prt_media].height,
(double)0, NULL, NULL);
/* Define fonts needed */
#ifdef FEAT_MBYTE
if (!prt_out_mbyte || prt_use_courier)
#endif
prt_dsc_font_resource("DocumentNeededResources", &prt_ps_courier_font);
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
prt_dsc_font_resource((prt_use_courier ? NULL
: "DocumentNeededResources"), &prt_ps_mb_font);
if (!prt_custom_cmap)
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
#endif
/* Search for external resources VIM supplies */
if (!prt_find_resource("prolog", &res_prolog))
{
EMSG(_("E456: Can't find PostScript resource file \"prolog.ps\""));
return FALSE;
}
if (!prt_open_resource(&res_prolog))
return FALSE;
if (!prt_check_resource(&res_prolog, PRT_PROLOG_VERSION))
return FALSE;
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
/* Look for required version of multi-byte printing procset */
if (!prt_find_resource("cidfont", &res_cidfont))
{
EMSG(_("E456: Can't find PostScript resource file \"cidfont.ps\""));
return FALSE;
}
if (!prt_open_resource(&res_cidfont))
return FALSE;
if (!prt_check_resource(&res_cidfont, PRT_CID_PROLOG_VERSION))
return FALSE;
}
#endif
/* Find an encoding to use for printing.
* Check 'printencoding'. If not set or not found, then use 'encoding'. If
* that cannot be found then default to "latin1".
* Note: VIM specific encoding header is always skipped.
*/
#ifdef FEAT_MBYTE
if (!prt_out_mbyte)
{
#endif
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL
|| !prt_find_resource((char *)p_encoding, &res_encoding))
{
/* 'printencoding' not set or not supported - find alternate */
#ifdef FEAT_MBYTE
int props;
p_encoding = enc_skip(p_enc);
props = enc_canon_props(p_encoding);
if (!(props & ENC_8BIT)
|| !prt_find_resource((char *)p_encoding, &res_encoding))
/* 8-bit 'encoding' is not supported */
#endif
{
/* Use latin1 as default printing encoding */
p_encoding = (char_u *)"latin1";
if (!prt_find_resource((char *)p_encoding, &res_encoding))
{
EMSG2(_("E456: Can't find PostScript resource file \"%s.ps\""),
p_encoding);
return FALSE;
}
}
}
if (!prt_open_resource(&res_encoding))
return FALSE;
/* For the moment there are no checks on encoding resource files to
* perform */
#ifdef FEAT_MBYTE
}
else
{
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL)
p_encoding = enc_skip(p_enc);
if (prt_use_courier)
{
/* Include ASCII range encoding vector */
if (!prt_find_resource(prt_ascii_encoding, &res_encoding))
{
EMSG2(_("E456: Can't find PostScript resource file \"%s.ps\""),
prt_ascii_encoding);
return FALSE;
}
if (!prt_open_resource(&res_encoding))
return FALSE;
/* For the moment there are no checks on encoding resource files to
* perform */
}
}
prt_conv.vc_type = CONV_NONE;
if (!(enc_canon_props(p_enc) & enc_canon_props(p_encoding) & ENC_8BIT)) {
/* Set up encoding conversion if required */
if (FAIL == convert_setup(&prt_conv, p_enc, p_encoding))
{
EMSG2(_("E620: Unable to convert to print encoding \"%s\""),
p_encoding);
return FALSE;
}
prt_do_conv = TRUE;
}
prt_do_conv = prt_conv.vc_type != CONV_NONE;
if (prt_out_mbyte && prt_custom_cmap)
{
/* Find user supplied CMap */
if (!prt_find_resource(prt_cmap, &res_cmap))
{
EMSG2(_("E456: Can't find PostScript resource file \"%s.ps\""),
prt_cmap);
return FALSE;
}
if (!prt_open_resource(&res_cmap))
return FALSE;
}
#endif
/* List resources supplied */
STRCPY(buffer, res_prolog.title);
STRCAT(buffer, " ");
STRCAT(buffer, res_prolog.version);
prt_dsc_resources("DocumentSuppliedResources", "procset", buffer);
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
STRCPY(buffer, res_cidfont.title);
STRCAT(buffer, " ");
STRCAT(buffer, res_cidfont.version);
prt_dsc_resources(NULL, "procset", buffer);
if (prt_custom_cmap)
{
STRCPY(buffer, res_cmap.title);
STRCAT(buffer, " ");
STRCAT(buffer, res_cmap.version);
prt_dsc_resources(NULL, "cmap", buffer);
}
}
if (!prt_out_mbyte || prt_use_courier)
#endif
{
STRCPY(buffer, res_encoding.title);
STRCAT(buffer, " ");
STRCAT(buffer, res_encoding.version);
prt_dsc_resources(NULL, "encoding", buffer);
}
prt_dsc_requirements(prt_duplex, prt_tumble, prt_collate,
#ifdef FEAT_SYN_HL
psettings->do_syntax
#else
0
#endif
, prt_num_copies);
prt_dsc_noarg("EndComments");
/*
* PS Document page defaults
*/
prt_dsc_noarg("BeginDefaults");
/* List font resources most likely common to all pages */
#ifdef FEAT_MBYTE
if (!prt_out_mbyte || prt_use_courier)
#endif
prt_dsc_font_resource("PageResources", &prt_ps_courier_font);
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
prt_dsc_font_resource((prt_use_courier ? NULL : "PageResources"),
&prt_ps_mb_font);
if (!prt_custom_cmap)
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
#endif
/* Paper will be used for all pages */
prt_dsc_textline("PageMedia", prt_mediasize[prt_media].name);
prt_dsc_noarg("EndDefaults");
/*
* PS Document prolog inclusion - all required procsets.
*/
prt_dsc_noarg("BeginProlog");
/* Add required procsets - NOTE: order is important! */
if (!prt_add_resource(&res_prolog))
return FALSE;
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
{
/* Add CID font procset, and any user supplied CMap */
if (!prt_add_resource(&res_cidfont))
return FALSE;
if (prt_custom_cmap && !prt_add_resource(&res_cmap))
return FALSE;
}
#endif
#ifdef FEAT_MBYTE
if (!prt_out_mbyte || prt_use_courier)
#endif
/* There will be only one Roman font encoding to be included in the PS
* file. */
if (!prt_add_resource(&res_encoding))
return FALSE;
prt_dsc_noarg("EndProlog");
/*
* PS Document setup - must appear after the prolog
*/
prt_dsc_noarg("BeginSetup");
/* Device setup - page size and number of uncollated copies */
prt_write_int((int)prt_mediasize[prt_media].width);
prt_write_int((int)prt_mediasize[prt_media].height);
prt_write_int(0);
prt_write_string("sps\n");
prt_write_int(prt_num_copies);
prt_write_string("nc\n");
prt_write_boolean(prt_duplex);
prt_write_boolean(prt_tumble);
prt_write_string("dt\n");
prt_write_boolean(prt_collate);
prt_write_string("c\n");
/* Font resource inclusion and definition */
#ifdef FEAT_MBYTE
if (!prt_out_mbyte || prt_use_courier)
{
/* When using Courier for ASCII range when printing multi-byte, need to
* pick up ASCII encoding to use with it. */
if (prt_use_courier)
p_encoding = (char_u *)prt_ascii_encoding;
#endif
prt_dsc_resources("IncludeResource", "font",
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_ROMAN]);
prt_def_font("F0", (char *)p_encoding, (int)prt_line_height,
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_ROMAN]);
prt_dsc_resources("IncludeResource", "font",
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_BOLD]);
prt_def_font("F1", (char *)p_encoding, (int)prt_line_height,
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_BOLD]);
prt_dsc_resources("IncludeResource", "font",
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
prt_def_font("F2", (char *)p_encoding, (int)prt_line_height,
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
prt_dsc_resources("IncludeResource", "font",
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
prt_def_font("F3", (char *)p_encoding, (int)prt_line_height,
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
#ifdef FEAT_MBYTE
}
if (prt_out_mbyte)
{
/* Define the CID fonts to be used in the job. Typically CJKV fonts do
* not have an italic form being a western style, so where no font is
* defined for these faces VIM falls back to an existing face.
* Note: if using Courier for the ASCII range then the printout will
* have bold/italic/bolditalic regardless of the setting of printmbfont.
*/
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_ROMAN]);
if (!prt_custom_cmap)
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
prt_def_cidfont("CF0", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_ROMAN]);
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD] != NULL)
{
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD]);
if (!prt_custom_cmap)
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
prt_def_cidfont("CF1", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD]);
}
else
/* Use ROMAN for BOLD */
prt_dup_cidfont("CF0", "CF1");
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE] != NULL)
{
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
if (!prt_custom_cmap)
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
prt_def_cidfont("CF2", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
}
else
/* Use ROMAN for OBLIQUE */
prt_dup_cidfont("CF0", "CF2");
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE] != NULL)
{
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
if (!prt_custom_cmap)
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
prt_def_cidfont("CF3", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
}
else
/* Use BOLD for BOLDOBLIQUE */
prt_dup_cidfont("CF1", "CF3");
}
#endif
/* Misc constant vars used for underlining and background rects */
prt_def_var("UO", PRT_PS_FONT_TO_USER(prt_line_height,
prt_ps_font->uline_offset), 2);
prt_def_var("UW", PRT_PS_FONT_TO_USER(prt_line_height,
prt_ps_font->uline_width), 2);
prt_def_var("BO", prt_bgcol_offset, 2);
prt_dsc_noarg("EndSetup");
/* Fail if any problems writing out to the PS file */
return !prt_file_error;
}
void
mch_print_end(psettings)
prt_settings_T *psettings;
{
prt_dsc_noarg("Trailer");
/*
* Output any info we don't know in toto until we finish
*/
prt_dsc_ints("Pages", 1, &prt_page_num);
prt_dsc_noarg("EOF");
/* Write CTRL-D to close serial communication link if used.
* NOTHING MUST BE WRITTEN AFTER THIS! */
prt_write_file((char_u *)IF_EB("\004", "\067"));
if (!prt_file_error && psettings->outfile == NULL
&& !got_int && !psettings->user_abort)
{
/* Close the file first. */
if (prt_ps_fd != NULL)
{
fclose(prt_ps_fd);
prt_ps_fd = NULL;
}
prt_message((char_u *)_("Sending to printer..."));
/* Not printing to a file: use 'printexpr' to print the file. */
if (eval_printexpr(prt_ps_file_name, psettings->arguments) == FAIL)
EMSG(_("E365: Failed to print PostScript file"));
else
prt_message((char_u *)_("Print job sent."));
}
mch_print_cleanup();
}
int
mch_print_end_page()
{
prt_flush_buffer();
prt_write_string("re sp\n");
prt_dsc_noarg("PageTrailer");
return !prt_file_error;
}
/*ARGSUSED*/
int
mch_print_begin_page(str)
char_u *str;
{
int page_num[2];
prt_page_num++;
page_num[0] = page_num[1] = prt_page_num;
prt_dsc_ints("Page", 2, page_num);
prt_dsc_noarg("BeginPageSetup");
prt_write_string("sv\n0 g\n");
#ifdef FEAT_MBYTE
prt_in_ascii = !prt_out_mbyte;
if (prt_out_mbyte)
prt_write_string("CF0 sf\n");
else
#endif
prt_write_string("F0 sf\n");
prt_fgcol = PRCOLOR_BLACK;
prt_bgcol = PRCOLOR_WHITE;
prt_font = PRT_PS_FONT_ROMAN;
/* Set up page transformation for landscape printing. */
if (!prt_portrait)
{
prt_write_int(-((int)prt_mediasize[prt_media].width));
prt_write_string("sl\n");
}
prt_dsc_noarg("EndPageSetup");
/* We have reset the font attributes, force setting them again. */
curr_bg = (long_u)0xffffffff;
curr_fg = (long_u)0xffffffff;
curr_bold = MAYBE;
return !prt_file_error;
}
int
mch_print_blank_page()
{
return (mch_print_begin_page(NULL) ? (mch_print_end_page()) : FALSE);
}
static float prt_pos_x = 0;
static float prt_pos_y = 0;
void
mch_print_start_line(margin, page_line)
int margin;
int page_line;
{
prt_pos_x = prt_left_margin;
if (margin)
prt_pos_x -= prt_number_width;
prt_pos_y = prt_top_margin - prt_first_line_height -
page_line * prt_line_height;
prt_attribute_change = TRUE;
prt_need_moveto = TRUE;
#ifdef FEAT_MBYTE
prt_half_width = FALSE;
#endif
}
/*ARGSUSED*/
int
mch_print_text_out(p, len)
char_u *p;
int len;
{
int need_break;
char_u ch;
char_u ch_buff[8];
float char_width;
float next_pos;
#ifdef FEAT_MBYTE
int in_ascii;
int half_width;
#endif
char_width = prt_char_width;
#ifdef FEAT_MBYTE
/* Ideally VIM would create a rearranged CID font to combine a Roman and
* CJKV font to do what VIM is doing here - use a Roman font for characters
* in the ASCII range, and the original CID font for everything else.
* The problem is that GhostScript still (as of 8.13) does not support
* rearranged fonts even though they have been documented by Adobe for 7
* years! If they ever do, a lot of this code will disappear.
*/
if (prt_use_courier)
{
in_ascii = (len == 1 && *p < 0x80);
if (prt_in_ascii)
{
if (!in_ascii)
{
/* No longer in ASCII range - need to switch font */
prt_in_ascii = FALSE;
prt_need_font = TRUE;
prt_attribute_change = TRUE;
}
}
else if (in_ascii)
{
/* Now in ASCII range - need to switch font */
prt_in_ascii = TRUE;
prt_need_font = TRUE;
prt_attribute_change = TRUE;
}
}
if (prt_out_mbyte)
{
half_width = ((*mb_ptr2cells)(p) == 1);
if (half_width)
char_width /= 2;
if (prt_half_width)
{
if (!half_width)
{
prt_half_width = FALSE;
prt_pos_x += prt_char_width/4;
prt_need_moveto = TRUE;
prt_attribute_change = TRUE;
}
}
else if (half_width)
{
prt_half_width = TRUE;
prt_pos_x += prt_char_width/4;
prt_need_moveto = TRUE;
prt_attribute_change = TRUE;
}
}
#endif
/* Output any required changes to the graphics state, after flushing any
* text buffered so far.
*/
if (prt_attribute_change)
{
prt_flush_buffer();
/* Reset count of number of chars that will be printed */
prt_text_run = 0;
if (prt_need_moveto)
{
prt_pos_x_moveto = prt_pos_x;
prt_pos_y_moveto = prt_pos_y;
prt_do_moveto = TRUE;
prt_need_moveto = FALSE;
}
if (prt_need_font)
{
#ifdef FEAT_MBYTE
if (!prt_in_ascii)
prt_write_string("CF");
else
#endif
prt_write_string("F");
prt_write_int(prt_font);
prt_write_string("sf\n");
prt_need_font = FALSE;
}
if (prt_need_fgcol)
{
int r, g, b;
r = ((unsigned)prt_fgcol & 0xff0000) >> 16;
g = ((unsigned)prt_fgcol & 0xff00) >> 8;
b = prt_fgcol & 0xff;
prt_write_real(r / 255.0, 3);
if (r == g && g == b)
prt_write_string("g\n");
else
{
prt_write_real(g / 255.0, 3);
prt_write_real(b / 255.0, 3);
prt_write_string("r\n");
}
prt_need_fgcol = FALSE;
}
if (prt_bgcol != PRCOLOR_WHITE)
{
prt_new_bgcol = prt_bgcol;
if (prt_need_bgcol)
prt_do_bgcol = TRUE;
}
else
prt_do_bgcol = FALSE;
prt_need_bgcol = FALSE;
if (prt_need_underline)
prt_do_underline = prt_underline;
prt_need_underline = FALSE;
prt_attribute_change = FALSE;
}
#ifdef FEAT_MBYTE
if (prt_do_conv)
{
/* Convert from multi-byte to 8-bit encoding */
p = string_convert(&prt_conv, p, &len);
if (p == NULL)
p = (char_u *)"";
}
if (prt_out_mbyte)
{
/* Multi-byte character strings are represented more efficiently as hex
* strings when outputting clean 8 bit PS.
*/
do
{
ch = prt_hexchar[(unsigned)(*p) >> 4];
ga_append(&prt_ps_buffer, ch);
ch = prt_hexchar[(*p) & 0xf];
ga_append(&prt_ps_buffer, ch);
p++;
}
while (--len);
}
else
#endif
{
/* Add next character to buffer of characters to output.
* Note: One printed character may require several PS characters to
* represent it, but we only count them as one printed character.
*/
ch = *p;
if (ch < 32 || ch == '(' || ch == ')' || ch == '\\')
{
/* Convert non-printing characters to either their escape or octal
* sequence, ensures PS sent over a serial line does not interfere
* with the comms protocol. Note: For EBCDIC we need to write out
* the escape sequences as ASCII codes!
* Note 2: Char codes < 32 are identical in EBCDIC and ASCII AFAIK!
*/
ga_append(&prt_ps_buffer, IF_EB('\\', 0134));
switch (ch)
{
case BS: ga_append(&prt_ps_buffer, IF_EB('b', 0142)); break;
case TAB: ga_append(&prt_ps_buffer, IF_EB('t', 0164)); break;
case NL: ga_append(&prt_ps_buffer, IF_EB('n', 0156)); break;
case FF: ga_append(&prt_ps_buffer, IF_EB('f', 0146)); break;
case CAR: ga_append(&prt_ps_buffer, IF_EB('r', 0162)); break;
case '(': ga_append(&prt_ps_buffer, IF_EB('(', 0050)); break;
case ')': ga_append(&prt_ps_buffer, IF_EB(')', 0051)); break;
case '\\': ga_append(&prt_ps_buffer, IF_EB('\\', 0134)); break;
default:
sprintf((char *)ch_buff, "%03o", (unsigned int)ch);
#ifdef EBCDIC
ebcdic2ascii(ch_buff, 3);
#endif
ga_append(&prt_ps_buffer, ch_buff[0]);
ga_append(&prt_ps_buffer, ch_buff[1]);
ga_append(&prt_ps_buffer, ch_buff[2]);
break;
}
}
else
ga_append(&prt_ps_buffer, ch);
}
#ifdef FEAT_MBYTE
/* Need to free any translated characters */
if (prt_do_conv && (*p != NUL))
vim_free(p);
#endif
prt_text_run += char_width;
prt_pos_x += char_width;
/* The downside of fp - use relative error on right margin check */
next_pos = prt_pos_x + prt_char_width;
need_break = (next_pos > prt_right_margin) &&
((next_pos - prt_right_margin) > (prt_right_margin*1e-5));
if (need_break)
prt_flush_buffer();
return need_break;
}
void
mch_print_set_font(iBold, iItalic, iUnderline)
int iBold;
int iItalic;
int iUnderline;
{
int font = 0;
if (iBold)
font |= 0x01;
if (iItalic)
font |= 0x02;
if (font != prt_font)
{
prt_font = font;
prt_attribute_change = TRUE;
prt_need_font = TRUE;
}
if (prt_underline != iUnderline)
{
prt_underline = iUnderline;
prt_attribute_change = TRUE;
prt_need_underline = TRUE;
}
}
void
mch_print_set_bg(bgcol)
long_u bgcol;
{
prt_bgcol = (int)bgcol;
prt_attribute_change = TRUE;
prt_need_bgcol = TRUE;
}
void
mch_print_set_fg(fgcol)
long_u fgcol;
{
if (fgcol != (long_u)prt_fgcol)
{
prt_fgcol = (int)fgcol;
prt_attribute_change = TRUE;
prt_need_fgcol = TRUE;
}
}
# endif /*FEAT_POSTSCRIPT*/
#endif /*FEAT_PRINTER*/