Mercurial > vim
view src/hardcopy.c @ 1029:82b2594be408 v7.0.155
updated for version 7.0-155
| author | vimboss |
|---|---|
| date | Wed, 01 Nov 2006 14:32:36 +0000 |
| parents | b2dcb8457067 |
| children | 2136af39a655 |
line wrap: on
line source
/* 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 origingal 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*/