/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.13 */
/* EMACS_MODES: !fill, lnumb, !overwrite, !nodelete, !picture */
#include "string.h"
#include "stdlib.h"
#include "lp.h"
#include "lp.set.h"
#if defined(__STDC__)
char * tparm ( char * , ... );
int putp ( char * );
int tidbit ( char * , char * , ... );
#else
extern char *tparm();
int putp();
int tidbit();
#endif
extern short output_res_char,
output_res_line,
output_res_horz_inch,
output_res_vert_inch;
/**
** set_size()
**/
int
#if defined(__STDC__)
set_size (
char * str,
int which,
int putout
)
#else
set_size (str, which, putout)
char *str;
int which,
putout;
#endif
{
static int cleared_margins_already = 0;
double size;
int i,
isize,
ret;
short curval,
output_res,
output_res_inch;
char *rest,
*set_margin1,
*set_margin2,
*set_margin1_parm,
*set_margin2_parm,
*set_both_margins = 0,
*move1,
*move2,
*step2,
*p1,
*p2,
*sp1,
*sp2,
*carriage_return,
*parm_right_cursor,
*column_address,
*repeat_char,
*cursor_right,
*parm_down_cursor,
*row_address,
*cursor_down,
*clear_margins,
*finale,
*slines;
if (which == 'W') {
tidbit ((char *)0, "cols", &curval);
if (output_res_char == -1)
tidbit ((char *)0, "orc", &output_res_char);
output_res = output_res_char;
if (output_res_horz_inch == -1)
tidbit ((char *)0, "orhi", &output_res_horz_inch);
output_res_inch = output_res_horz_inch;
} else {
tidbit ((char *)0, "lines", &curval);
if (output_res_line == -1)
tidbit ((char *)0, "orl", &output_res_line);
output_res = output_res_line;
if (output_res_vert_inch == -1)
tidbit ((char *)0, "orvi", &output_res_vert_inch);
output_res_inch = output_res_vert_inch;
}
size = strtod(str, &rest);
if (size <= 0)
return (E_BAD_ARGS);
switch (*rest) {
case ' ':
case 0:
break;
case 'c':
/*
* Convert to inches.
*/
size /= 2.54;
/* fall through */
case 'i':
/*
* Convert to lines/columns.
*/
if (output_res == -1 || output_res_inch == -1)
return (E_FAILURE);
size *= output_res_inch / output_res;
break;
default:
return (E_BAD_ARGS);
}
if ((isize = R(size)) == curval)
return (E_SUCCESS);
/*
* We number things 0 through N (e.g. an 80 column
* page is numbered 0 to 79). Thus if we are asked
* to set a width of 132, we set the left margin at
* 0 and the right at 131.
* Of course, if we're using the "slines" string,
* we give the length as N+1.
*/
isize--;
/*
* When the width or length is set using the set-margin-at-
* current-position caps (e.g. smgl and smgr, smgt, smgb):
* If a parameterized motion capability exists, then we'll try
* to use it. However, if the instantiation of the capability
* (through tparm()) gives nothing, assume this means the motion
* is not allowed--don't try the next choice. This is the only
* way we have of checking for a width or length beyond the
* limits of the printer. If a parameterized motion capability
* doesn't exist, we have no way to check out-of-bounds width
* and length, sorry.
*
* When the width or length is set using parameterized caps
* (e.g. smglp and smgrp, or slines for length), the above is not
* a problem, of course.
*/
if (which == 'W') {
tidbit ((char *)0, "smgl", &set_margin1);
tidbit ((char *)0, "smgr", &set_margin2);
tidbit ((char *)0, "smglp", &set_margin1_parm);
tidbit ((char *)0, "smgrp", &set_margin2_parm);
tidbit ((char *)0, "smglr", &set_both_margins);
tidbit ((char *)0, "cr", &carriage_return);
tidbit ((char *)0, "cuf", &parm_right_cursor);
tidbit ((char *)0, "hpa", &column_address);
tidbit ((char *)0, "rep", &repeat_char);
tidbit ((char *)0, "cuf1", &cursor_right);
if (OKAY(carriage_return))
move1 = carriage_return;
else
move1 = "\r";
if (OKAY(parm_right_cursor)) {
move2 = tparm(parm_right_cursor, isize);
step2 = 0;
} else if (OKAY(column_address)) {
move2 = tparm(column_address, isize);
step2 = 0;
} else if (OKAY(repeat_char)) {
move2 = tparm(repeat_char, ' ', isize);
step2 = 0;
} else if (OKAY(cursor_right)) {
move2 = 0;
step2 = cursor_right;
} else {
move2 = 0;
step2 = " ";
}
finale = move1; /* i.e. carriage return */
} else {
tidbit ((char *)0, "smgt", &set_margin1);
tidbit ((char *)0, "smgb", &set_margin2);
tidbit ((char *)0, "smgtp", &set_margin1_parm);
tidbit ((char *)0, "smgbp", &set_margin2_parm);
tidbit ((char *)0, "smgtb", &set_both_margins);
/*
* For compatibility with SVR3.2 era Terminfo files,
* we check "u9" as an alias for "slines" IF a check
* of "slines" comes up empty.
*/
slines = 0; /* (in case compiled with old tidbit) */
tidbit ((char *)0, "slines", &slines);
if (!OKAY(slines))
tidbit ((char *)0, "u9", &slines);
tidbit ((char *)0, "cud", &parm_down_cursor);
tidbit ((char *)0, "vpa", &row_address);
tidbit ((char *)0, "cud1", &cursor_down);
move1 = ""; /* Assume we're already at top-of-page */
if (OKAY(parm_down_cursor)) {
move2 = tparm(parm_down_cursor, isize);
step2 = 0;
} else if (OKAY(row_address)) {
move2 = tparm(row_address, isize);
step2 = 0;
} else if (OKAY(cursor_down)) {
move2 = 0;
step2 = cursor_down;
} else {
move2 = 0;
step2 = "\n";
}
/*
* This has to be smarter, but we don't have the
* smarts ourselves, yet; i.e. what do we do if
* there is no "ff"?
*/
tidbit ((char *)0, "ff", &finale);
}
/*
* For a short while we needed a kludge in Terminfo
* whereby if only one of the left/right or top/bottom
* parameterized margin setters was defined, it was
* a parm-string that could set BOTH margins. We now have
* separate strings for setting both margins, but we still
* allow the kludge.
*/
if (!OKAY(set_both_margins)) {
if (OKAY(set_margin1_parm) && !OKAY(set_margin2_parm))
set_both_margins = set_margin1_parm;
else if (OKAY(set_margin2_parm) && !OKAY(set_margin1_parm))
set_both_margins = set_margin2_parm;
}
sp1 = sp2 = 0;
if (
which == 'L'
&& OKAY(slines)
&& (p1 = tparm(slines, isize + 1))
) {
if (putout)
putp (p1);
finale = 0;
ret = E_SUCCESS;
} else if (
OKAY(set_both_margins)
&& (p1 = tparm(set_both_margins, 0, isize))
&& *p1
&& (sp1 = Strdup(p1))
) {
if (putout) {
if (!cleared_margins_already) {
tidbit ((char *)0, "mgc", &clear_margins);
if (OKAY(clear_margins)) {
cleared_margins_already = 1;
putp (clear_margins);
}
}
putp (sp1);
}
ret = E_SUCCESS;
/*
* The "smgbp" string takes two parameters; each defines the
* position of the margin, the first counting lines from the top
* of the page, the second counting lines from the bottom of the
* page. This shows the flaw in using the set-margin commands
* for setting the page length, because BY DEFINITION the second
* parameter must be 0 for us. But giving 0 won't cause a change
* in the page length, will it!
*
* Anyway, the "smgrp" expects just one parameter (thus will
* ignore a second parameter) so we can safely give the second
* parameter without caring which of width or length we're
* setting.
*/
} else if (
OKAY(set_margin1_parm)
&& (p1 = tparm(set_margin1_parm, 0))
&& *p1
&& (sp1 = Strdup(p1))
&& OKAY(set_margin2_parm)
&& (p2 = tparm(set_margin2_parm, isize, 0))
&& *p2
&& (sp2 = Strdup(p2))
) {
if (putout) {
if (!cleared_margins_already) {
tidbit ((char *)0, "mgc", &clear_margins);
if (OKAY(clear_margins)) {
cleared_margins_already = 1;
putp (clear_margins);
}
}
putp (sp1);
putp (sp2);
}
ret = E_SUCCESS;
} else if (
OKAY(set_margin1)
&& OKAY(set_margin2)
&& (OKAY(move2) || OKAY(step2))
) {
register char *p,
*q;
register int free_it = 0;
if (putout) {
if (!cleared_margins_already) {
tidbit ((char *)0, "mgc", &clear_margins);
if (OKAY(clear_margins)) {
cleared_margins_already = 1;
putp (clear_margins);
}
}
putp (move1);
putp (set_margin1);
if (!move2) {
move2 = Malloc(isize * strlen(step2) + 1);
if (!move2)
return (E_MALLOC);
for (p = move2, i = 0; i < isize; i++)
for (q = step2; *q; )
*p++ = *q++;
*p = 0;
free_it = 1;
}
putp (move2);
putp (set_margin2);
if (free_it)
Free (move2);
}
ret = E_SUCCESS;
} else
ret = E_FAILURE;
if (putout && OKAY(finale))
putp (finale);
if (sp1)
Free (sp1);
if (sp2)
Free (sp2);
return (ret);
}