jimzah/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src.git synced 2024-12-04 16:49:40 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Nuke xditview. It was in the same category as xroach.

Browse Source 
Screeched-For By: Michael Smith
This commit is contained in:
Jordan K. Hubbard 1996-06-16 13:15:35 +00:00
parent a85b3068a1
commit faf4b6d3b5
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=16402
30 changed files with 1 additions and 5857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gnu/usr.bin/groff/Makefile
View File

@ -5,7 +5,7 @@ SUBDIR= libgroff libdriver libbib\
refer lookbib indxbib lkbib \
tfmtodit addftinfo pfbtops psbb \
devX100 devX100-12 devX75 devX75-12 devascii devdvi devlatin1 \
devkoi8-r devps tmac mm man xditview
devkoi8-r devps tmac mm man
# BSD already provides soelim
MISC= soelim

274
gnu/usr.bin/groff/xditview/ChangeLog
View File

@ -1,274 +0,0 @@
Sat Feb 12 10:38:47 1994 James Clark (jjc@jclark.com)
* DviChar.c (Adobe_Symbol_map): Rename radicalex to rn.
Thu May 27 20:30:12 1993 James Clark (jjc@jclark.com)
* device.c (isascii): Define if necessary.
(canonicalize_name): Cast argument to isdigit() to unsigned char.
Thu Apr 29 18:36:57 1993 James Clark (jjc at jclark.com)
* xditview.c: Include <X11/Xos.h>.
(NewFile): Don't declare rindex(). Use strrchr() rather than
rindex().
Tue Mar 30 15:12:09 1993 James Clark (jjc at jclark)
* draw.c (charExists): Check that fi->per_char is not NULL.
Sat Dec 12 17:42:40 1992 James Clark (jjc at jclark)
* Dvi.c (SetGeometry): Cast XtMakeGeometryRequest arguments.
* draw.c (DrawPolygon, DrawFilledPolygon): Cast Xtfree argument.
* font.c (DisposeFontSizes): Add declaration.
* draw.c (FakeCharacter): Add declaration.
Wed Oct 28 13:24:00 1992 James Clark (jjc at jclark)
* Imakefile (install.dev): Deleted.
(fonts): New target.
Mon Oct 12 10:50:44 1992 James Clark (jjc at jclark)
* Imakefile (install.dev): Say when we're installing devX*-12.
* Imakefile (install.dev): Depends on DESC and FontMap.
Thu Oct 1 20:03:45 1992 James Clark (jjc at jclark)
* xditview.c (Syntax): Mention -filename option.
Sat Aug 15 12:56:39 1992 James Clark (jjc at jclark)
* GXditview.ad: Bind space and return to NextPage. Bind backspace
and delete to previous page.
* DviChar.c (Adobe_Symbol_map): Add `an'.
* DviChar.c (Adobe_Symbol_map): Add arrowvertex, arrowverttp, and
arrowvertbt.
Mon Aug 10 11:54:27 1992 James Clark (jjc at jclark)
* FontMap: Add m/p fields to the fonts names.
Sat Aug 8 12:00:28 1992 James Clark (jjc at jclark)
* DESC: Leave font positions 5-9 blank.
Tue Jul 28 11:37:05 1992 James Clark (jjc at jclark)
* Imakefile: Don't use gendef. Pass definition of FONTPATH using
DEFINES.
(path.h): Deleted.
(device.c): Don't include path.h. Provide default definition of
FONTPATH.
Mon Jul 6 14:06:53 1992 James Clark (jjc at jclark)
* Imakefile: Don't install tmac.X and tmac.Xps.
* tmac.X, tmac.Xps: Moved to ../macros.
* Imakefile: Don't install eqnchar.
* eqnchar: Deleted.
Sun Jun 14 12:55:02 1992 James Clark (jjc@jclark)
* tmac.Xps: Handle OE, oe, lq, rq.
* draw.c (FakeCharacter): Don't handle these.
* draw.c (FakeCharacter): Don't handle f/.
Mon Jun 8 11:46:37 1992 James Clark (jjc@jclark)
* tmac.X: Translate char160 to space.
Sun Jun 7 14:39:53 1992 James Clark (jjc@jclark)
* tmac.X: Do `mso tmac.psic' before restoring compatibility mode.
* tmac.X: Add \(OE, \(oe, \(ah, \(ao, \(ho.
* tmac.Xps: Make it work in compatibility mode.
Redo existing character definitions with .Xps-char.
Add more character definitions.
(Xps-char): New macro.
Sat Jun 6 21:46:03 1992 James Clark (jjc@jclark)
* DviChar.c (Adobe_Symbol_map): Add +h, +f, +p, Fn, lz.
* tmac.X: Add \(bq, \(Bq, \(aq.
* tmac.Xps: Handle \(aq, \(bq, \(Bq, \(Fn.
Wed Jun 3 11:11:15 1992 James Clark (jjc@jclark)
* DviChar.c (Adobe_Symbol_map): Add wp.
Tue Apr 21 09:21:59 1992 James Clark (jjc at jclark)
* GXditview.ad: Bind n, p, q keys to NextPage, PreviousPage and
Quit actions.
* xditview.c (RerasterizeAction): New function.
(xditview_actions): Add RerasterizeAction.
* GXditview.ad: Bind r key to Rerasterize action.
Fri Apr 17 08:25:36 1992 James Clark (jjc at jclark)
* xditview.c: Add -filename option.
(main): Copy any -filename argument into current_file_name.
Mon Mar 16 10:21:58 1992 James Clark (jjc at jclark)
* tmac.X: Load tmac.pspic.
Sun Mar 8 11:27:19 1992 James Clark (jjc at jclark)
* Lex.c (GetLine, GetWord, GetNumber): Rewrite.
Sat Oct 12 22:58:52 1991 James Clark (jjc at jclark)
* Dvi.c (SetDevice): If the size change request is refused but a
larger geometry is offered, request that.
Wed Oct 9 12:27:48 1991 James Clark (jjc at jclark)
* font.c (InstallFontSizes): Ignore FontNameAverageWidth component.
* Dvi.c (default_font_map): Add `adobe' to font names to avoid
ambiguity.
* FontMap: New file.
* FontMap.X100, FontMap.X75: Deleted.
* xtotroff.c (main, usage): Add -s and -r options.
(MapFont): Change the font pattern to have the selected resolution and
size.
* Imakefile (install.dev): Use FontMap and supply appropriate -s
and -r options.
* xtotroff.c (MapFont): Check for ambiguity by comparing canonicalized
font names.
* DviP.h (DviFontList): Add initialized and scalable members.
(font.c): Add support for scalable fonts based on R5 xditview.
* DviChar.c: Use xmalloc rather than malloc.
* xditview.c (xmalloc): New function.
* xtotroff.c (xmalloc): New function.
* other files: Use XtMalloc and XtFree instead of malloc and free.
Thu Aug 29 20:15:31 1991 James Clark (jjc at jclark)
* draw.c (setGC): Do multiplication in floating point to avoid
overflow.
Tue Aug 13 12:04:41 1991 James Clark (jjc at jclark)
* draw.c (FakeCharacter): Remove casts in defintion of pack2.
Tue Jul 30 11:42:39 1991 James Clark (jjc at jclark)
* tmac.Xps: New file.
* Imakefile (install): Install tmac.Xps.
Tue Jul 2 09:31:37 1991 James Clark (jjc at jclark)
* xtotroff.c (main): Pass argv[0] to usage().
Sun Jun 30 12:34:06 1991 James Clark (jjc at jclark)
* xtotroff.c (MapFont): Handle the case where XLoadQueryFont
returns NULL.
Sat Jun 29 12:32:52 1991 James Clark (jjc at jclark)
* Imakefile: Use ../gendef to generate path.h.
Sun Jun 16 13:26:34 1991 James Clark (jjc at jclark)
* Imakefile (depend.o): Change to device.o.
Sun Jun 2 12:17:56 1991 James Clark (jjc at jclark)
* Imakefile: Remove spaces from the beginning of variable
assignment lines.
Sun May 26 14:14:01 1991 James Clark (jjc at jclark)
* xditview.c (Syntax): Update.
* Dvi.c (DviSaveToFile, SaveToFile): New functions.
(FindPage): Check that we're not readingTmp before checking for
end of file of normal input file.
(ClassPartInitialize): New function.
* Dvi.h: Add declaration of DviSaveToFile.
* DviP.h: Add save method to DviClassPart. Declare
InheritSaveToFile.
* xditview.c (DoPrint, Print, PrintAction): New functions.
* xditview.c: Add print menu entry.
* xditview.c: Provide printCommand application resource.
* lex.c: Don't output EOF to temporary file.
* Dvi.c (QueryGeometry): Check request->request_mode.
* Dvi.c (SetDevice): New function.
(SetDeviceResolution): Deleted.
* Dvi.c: Add resolution resource.
* DviP.h: Add definitions of XtNResolution and XtCResolution.
* xditview.c: Add -resolution argument.
* GXditview.ad: Add default for GXditview.height.
* Dvi.c (Initialize, SetDevice): Use default_resolution.
* Dvi.c: Make MY_HEIGHT and MY_WIDTH use the paperlength and
paperwidth commands in the DESC file.
* Dvi.c: Add SS font to default font map.
* draw.c: Rewritten so as not to assume device and display
resolution is the same.
* DviP.h: Include device.h. Add device_font member to DviFontList.
Add adjustable arrary to DviCharCache. Add text_x_width,
text_device_width, word_flag, device_font, device_font_number,
device, native, device_resolution, display_resolution,
paperlength, paperwidth, scale_factor, sizescale members.
* Dvi.c (Initialize): Initialize new variable used by draw.c
(Destroy): Call device_destroy.
* font.c (MaxFontPosition): New function.
(LookupFontSizeBySize): Handle sizescale.
(InstallFont): Load the device font.
(ForgetFonts): New function.
(QueryDeviceFont): New function.
* parse.c (ParseInput): Handle t and u commands. Split off
character output into draw.c.
(ParseDeviceControl): Ignore res command. Use the device argument
to the T command.
* font.c (MapXNameToDviName): Ifdefed out.
* path.h: New file.
* device.c, device.h: New files.
* DviChar.c: Add entries for lB, rB, oq, lC, rC, md.
* INSTALL: New file.
* libxdvi: Merged into main directory.
* xtotroff.c, xditview.c: Change includes accordingly.
* devX75, devX100: Merged into main directory.
* xditview.man: Renamed to gxditview.man.
* Xditview.ad: Renamed to GXditview.ad.
* xditview.c (main): Use class of GXditview rather than xditview.
* Imakefile: New file.
* Makefile: Deleted.
* xtotroff.c (MapFont): Unlink output file before opening it.
* Started separate ChangeLog.

9
gnu/usr.bin/groff/xditview/DESC
View File

@ -1,9 +0,0 @@
styles R I B BI
fonts 6 0 0 0 0 0 S
sizes 8 10 12 14 18 24 0
res 75
X11
hor 1
vert 1
unitwidth 10
postpro gxditview

544
gnu/usr.bin/groff/xditview/Dvi.c
View File

@ -1,544 +0,0 @@
#ifndef SABER
#ifndef lint
static char Xrcsid[] = "$XConsortium: Dvi.c,v 1.9 89/12/10 16:12:25 rws Exp $";
#endif /* lint */
#endif /* SABER */
/*
* Dvi.c - Dvi display widget
*
*/
#define XtStrlen(s) ((s) ? strlen(s) : 0)
/* The following are defined for the reader's convenience. Any
Xt..Field macro in this code just refers to some field in
one of the substructures of the WidgetRec. */
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xmu/Converters.h>
#include <stdio.h>
#include <ctype.h>
#include "DviP.h"
/****************************************************************
*
* Full class record constant
*
****************************************************************/
/* Private Data */
static char default_font_map[] = "\
TR -adobe-times-medium-r-normal--*-100-*-*-*-*-iso8859-1\n\
TI -adobe-times-medium-i-normal--*-100-*-*-*-*-iso8859-1\n\
TB -adobe-times-bold-r-normal--*-100-*-*-*-*-iso8859-1\n\
TBI -adobe-times-bold-i-normal--*-100-*-*-*-*-iso8859-1\n\
CR -adobe-courier-medium-r-normal--*-100-*-*-*-*-iso8859-1\n\
CI -adobe-courier-medium-o-normal--*-100-*-*-*-*-iso8859-1\n\
CB -adobe-courier-bold-r-normal--*-100-*-*-*-*-iso8859-1\n\
CBI -adobe-courier-bold-o-normal--*-100-*-*-*-*-iso8859-1\n\
HR -adobe-helvetica-medium-r-normal--*-100-*-*-*-*-iso8859-1\n\
HI -adobe-helvetica-medium-o-normal--*-100-*-*-*-*-iso8859-1\n\
HB -adobe-helvetica-bold-r-normal--*-100-*-*-*-*-iso8859-1\n\
HBI -adobe-helvetica-bold-o-normal--*-100-*-*-*-*-iso8859-1\n\
NR -adobe-new century schoolbook-medium-r-normal--*-100-*-*-*-*-iso8859-1\n\
NI -adobe-new century schoolbook-medium-i-normal--*-100-*-*-*-*-iso8859-1\n\
NB -adobe-new century schoolbook-bold-r-normal--*-100-*-*-*-*-iso8859-1\n\
NBI -adobe-new century schoolbook-bold-i-normal--*-100-*-*-*-*-iso8859-1\n\
S -adobe-symbol-medium-r-normal--*-100-*-*-*-*-adobe-fontspecific\n\
SS -adobe-symbol-medium-r-normal--*-100-*-*-*-*-adobe-fontspecific\n\
";
#define offset(field) XtOffset(DviWidget, field)
#define MY_WIDTH(dw) ((int)(dw->dvi.paperwidth * dw->dvi.scale_factor + .5))
#define MY_HEIGHT(dw) ((int)(dw->dvi.paperlength * dw->dvi.scale_factor + .5))
static XtResource resources[] = {
{XtNfontMap, XtCFontMap, XtRString, sizeof (char *),
offset(dvi.font_map_string), XtRString, default_font_map},
{XtNforeground, XtCForeground, XtRPixel, sizeof (unsigned long),
offset(dvi.foreground), XtRString, "black"},
{XtNbackground, XtCBackground, XtRPixel, sizeof (unsigned long),
offset(dvi.background), XtRString, "white"},
{XtNpageNumber, XtCPageNumber, XtRInt, sizeof (int),
offset(dvi.requested_page), XtRString, "1"},
{XtNlastPageNumber, XtCLastPageNumber, XtRInt, sizeof (int),
offset (dvi.last_page), XtRString, "0"},
{XtNfile, XtCFile, XtRFile, sizeof (FILE *),
offset (dvi.file), XtRFile, (char *) 0},
{XtNseek, XtCSeek, XtRBoolean, sizeof (Boolean),
offset(dvi.seek), XtRString, "false"},
{XtNfont, XtCFont, XtRFontStruct, sizeof (XFontStruct *),
offset(dvi.default_font), XtRString, "xtdefaultfont"},
{XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
offset(dvi.backing_store), XtRString, "default"},
{XtNnoPolyText, XtCNoPolyText, XtRBoolean, sizeof (Boolean),
offset(dvi.noPolyText), XtRString, "false"},
{XtNresolution, XtCResolution, XtRInt, sizeof(int),
offset(dvi.default_resolution), XtRString, "75"},
};
#undef offset
static void ClassInitialize ();
static void ClassPartInitialize();
static void Initialize(), Realize (), Destroy (), Redisplay ();
static Boolean SetValues (), SetValuesHook ();
static XtGeometryResult QueryGeometry ();
static void ShowDvi ();
static void CloseFile (), OpenFile ();
static void FindPage ();
static void SaveToFile ();
DviClassRec dviClassRec = {
{
&widgetClassRec, /* superclass */
"Dvi", /* class_name */
sizeof(DviRec), /* size */
ClassInitialize, /* class_initialize */
ClassPartInitialize, /* class_part_initialize */
FALSE, /* class_inited */
Initialize, /* initialize */
NULL, /* initialize_hook */
Realize, /* realize */
NULL, /* actions */
0, /* num_actions */
resources, /* resources */
XtNumber(resources), /* resource_count */
NULLQUARK, /* xrm_class */
FALSE, /* compress_motion */
TRUE, /* compress_exposure */
TRUE, /* compress_enterleave */
FALSE, /* visible_interest */
Destroy, /* destroy */
NULL, /* resize */
Redisplay, /* expose */
SetValues, /* set_values */
SetValuesHook, /* set_values_hook */
NULL, /* set_values_almost */
NULL, /* get_values_hook */
NULL, /* accept_focus */
XtVersion, /* version */
NULL, /* callback_private */
0, /* tm_table */
QueryGeometry, /* query_geometry */
NULL, /* display_accelerator */
NULL /* extension */
},{
SaveToFile, /* save */
},
};
WidgetClass dviWidgetClass = (WidgetClass) &dviClassRec;
static void ClassInitialize ()
{
XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
NULL, 0 );
}
/****************************************************************
*
* Private Procedures
*
****************************************************************/
/* ARGSUSED */
static void Initialize(request, new)
Widget request, new;
{
DviWidget dw = (DviWidget) new;
dw->dvi.current_page = 0;
dw->dvi.font_map = 0;
dw->dvi.cache.index = 0;
dw->dvi.text_x_width = 0;
dw->dvi.text_device_width = 0;
dw->dvi.word_flag = 0;
dw->dvi.file = 0;
dw->dvi.tmpFile = 0;
dw->dvi.state = 0;
dw->dvi.readingTmp = 0;
dw->dvi.cache.char_index = 0;
dw->dvi.cache.font_size = -1;
dw->dvi.cache.font_number = -1;
dw->dvi.cache.adjustable[0] = 0;
dw->dvi.file_map = 0;
dw->dvi.fonts = 0;
dw->dvi.seek = False;
dw->dvi.device_resolution = dw->dvi.default_resolution;
dw->dvi.display_resolution = dw->dvi.default_resolution;
dw->dvi.paperlength = dw->dvi.default_resolution*11;
dw->dvi.paperwidth = (dw->dvi.default_resolution*8
+ dw->dvi.default_resolution/2);
dw->dvi.scale_factor = 1.0;
dw->dvi.sizescale = 1;
dw->dvi.line_thickness = -1;
dw->dvi.line_width = 1;
dw->dvi.fill = DVI_FILL_MAX;
dw->dvi.device_font = 0;
dw->dvi.device_font_number = -1;
dw->dvi.device = 0;
dw->dvi.native = 0;
}
#include <X11/bitmaps/gray>
static void
Realize (w, valueMask, attrs)
Widget w;
XtValueMask *valueMask;
XSetWindowAttributes *attrs;
{
DviWidget dw = (DviWidget) w;
XGCValues values;
if (dw->dvi.backing_store != Always + WhenMapped + NotUseful) {
attrs->backing_store = dw->dvi.backing_store;
*valueMask |= CWBackingStore;
}
XtCreateWindow (w, (unsigned)InputOutput, (Visual *) CopyFromParent,
*valueMask, attrs);
values.foreground = dw->dvi.foreground;
values.cap_style = CapRound;
values.join_style = JoinRound;
values.line_width = dw->dvi.line_width;
dw->dvi.normal_GC = XCreateGC (XtDisplay (w), XtWindow (w),
GCForeground|GCCapStyle|GCJoinStyle
|GCLineWidth,
&values);
dw->dvi.gray = XCreateBitmapFromData(XtDisplay (w), XtWindow (w),
gray_bits,
gray_width, gray_height);
values.background = dw->dvi.background;
values.stipple = dw->dvi.gray;
dw->dvi.fill_GC = XCreateGC (XtDisplay (w), XtWindow (w),
GCForeground|GCBackground|GCStipple,
&values);
dw->dvi.fill_type = DVI_FILL_BLACK;
if (dw->dvi.file)
OpenFile (dw);
ParseFontMap (dw);
}
static void
Destroy(w)
Widget w;
{
DviWidget dw = (DviWidget) w;
XFreeGC (XtDisplay (w), dw->dvi.normal_GC);
XFreeGC (XtDisplay (w), dw->dvi.fill_GC);
XFreePixmap (XtDisplay (w), dw->dvi.gray);
DestroyFontMap (dw->dvi.font_map);
DestroyFileMap (dw->dvi.file_map);
device_destroy (dw->dvi.device);
}
/*
* Repaint the widget window
*/
/* ARGSUSED */
static void
Redisplay(w, event, region)
Widget w;
XEvent *event;
Region region;
{
DviWidget dw = (DviWidget) w;
XRectangle extents;
XClipBox (region, &extents);
dw->dvi.extents.x1 = extents.x;
dw->dvi.extents.y1 = extents.y;
dw->dvi.extents.x2 = extents.x + extents.width;
dw->dvi.extents.y2 = extents.y + extents.height;
ShowDvi (dw);
}
/*
* Set specified arguments into widget
*/
/* ARGSUSED */
static Boolean
SetValues (current, request, new)
DviWidget current, request, new;
{
Boolean redisplay = FALSE;
char *new_map;
int cur, req;
if (current->dvi.font_map_string != request->dvi.font_map_string) {
new_map = XtMalloc (strlen (request->dvi.font_map_string) + 1);
if (new_map) {
redisplay = TRUE;
strcpy (new_map, request->dvi.font_map_string);
new->dvi.font_map_string = new_map;
if (current->dvi.font_map_string)
XtFree (current->dvi.font_map_string);
current->dvi.font_map_string = 0;
ParseFontMap (new);
}
}
req = request->dvi.requested_page;
cur = current->dvi.requested_page;
if (cur != req) {
if (!request->dvi.file)
req = 0;
else {
if (req < 1)
req = 1;
if (current->dvi.last_page != 0 &&
req > current->dvi.last_page)
req = current->dvi.last_page;
}
if (cur != req)
redisplay = TRUE;
new->dvi.requested_page = req;
if (current->dvi.last_page == 0 && req > cur)
FindPage (new);
}
return redisplay;
}
/*
* use the set_values_hook entry to check when
* the file is set
*/
static Boolean
SetValuesHook (dw, args, num_argsp)
DviWidget dw;
ArgList args;
Cardinal *num_argsp;
{
Cardinal i;
for (i = 0; i < *num_argsp; i++) {
if (!strcmp (args[i].name, XtNfile)) {
CloseFile (dw);
OpenFile (dw);
return TRUE;
}
}
return FALSE;
}
static void CloseFile (dw)
DviWidget dw;
{
if (dw->dvi.tmpFile)
fclose (dw->dvi.tmpFile);
ForgetPagePositions (dw);
}
static void OpenFile (dw)
DviWidget dw;
{
char tmpName[sizeof ("/tmp/dviXXXXXX")];
dw->dvi.tmpFile = 0;
if (!dw->dvi.seek) {
strcpy (tmpName, "/tmp/dviXXXXXX");
mktemp (tmpName);
dw->dvi.tmpFile = fopen (tmpName, "w+");
unlink (tmpName);
}
dw->dvi.requested_page = 1;
dw->dvi.last_page = 0;
}
static XtGeometryResult
QueryGeometry (w, request, geometry_return)
Widget w;
XtWidgetGeometry *request, *geometry_return;
{
XtGeometryResult ret;
DviWidget dw = (DviWidget) w;
ret = XtGeometryYes;
if (((request->request_mode & CWWidth)
&& request->width < MY_WIDTH(dw))
|| ((request->request_mode & CWHeight)
&& request->height < MY_HEIGHT(dw)))
ret = XtGeometryAlmost;
geometry_return->width = MY_WIDTH(dw);
geometry_return->height = MY_HEIGHT(dw);
geometry_return->request_mode = CWWidth|CWHeight;
return ret;
}
SetDevice (dw, name)
DviWidget dw;
char *name;
{
XtWidgetGeometry request, reply;
XtGeometryResult ret;
ForgetFonts (dw);
dw->dvi.device = device_load (name);
if (!dw->dvi.device)
return;
dw->dvi.sizescale = dw->dvi.device->sizescale;
dw->dvi.device_resolution = dw->dvi.device->res;
dw->dvi.native = dw->dvi.device->X11;
dw->dvi.paperlength = dw->dvi.device->paperlength;
dw->dvi.paperwidth = dw->dvi.device->paperwidth;
if (dw->dvi.native) {
dw->dvi.display_resolution = dw->dvi.device_resolution;
dw->dvi.scale_factor = 1.0;
}
else {
dw->dvi.display_resolution = dw->dvi.default_resolution;
dw->dvi.scale_factor = ((double)dw->dvi.display_resolution
/ dw->dvi.device_resolution);
}
request.request_mode = CWWidth|CWHeight;
request.width = MY_WIDTH(dw);
request.height = MY_HEIGHT(dw);
ret = XtMakeGeometryRequest ((Widget)dw, &request, &reply);
if (ret == XtGeometryAlmost
&& reply.height >= request.height
&& reply.width >= request.width) {
request.width = reply.width;
request.height = reply.height;
XtMakeGeometryRequest ((Widget)dw, &request, &reply);
}
}
static void
ShowDvi (dw)
DviWidget dw;
{
if (!dw->dvi.file) {
static char Error[] = "No file selected";
XSetFont (XtDisplay(dw), dw->dvi.normal_GC,
dw->dvi.default_font->fid);
XDrawString (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
20, 20, Error, strlen (Error));
return;
}
FindPage (dw);
dw->dvi.display_enable = 1;
ParseInput (dw);
if (dw->dvi.last_page && dw->dvi.requested_page > dw->dvi.last_page)
dw->dvi.requested_page = dw->dvi.last_page;
}
static void
FindPage (dw)
DviWidget dw;
{
int i;
long file_position;
if (dw->dvi.requested_page < 1)
dw->dvi.requested_page = 1;
if (dw->dvi.last_page != 0 && dw->dvi.requested_page > dw->dvi.last_page)
dw->dvi.requested_page = dw->dvi.last_page;
file_position = SearchPagePosition (dw, dw->dvi.requested_page);
if (file_position != -1) {
FileSeek(dw, file_position);
dw->dvi.current_page = dw->dvi.requested_page;
} else {
for (i=dw->dvi.requested_page; i > 0; i--) {
file_position = SearchPagePosition (dw, i);
if (file_position != -1)
break;
}
if (file_position == -1)
file_position = 0;
FileSeek (dw, file_position);
dw->dvi.current_page = i;
dw->dvi.display_enable = 0;
while (dw->dvi.current_page != dw->dvi.requested_page) {
dw->dvi.current_page = ParseInput (dw);
/*
* at EOF, seek back to the beginning of this page.
*/
if (!dw->dvi.readingTmp && feof (dw->dvi.file)) {
file_position = SearchPagePosition (dw,
dw->dvi.current_page);
if (file_position != -1)
FileSeek (dw, file_position);
dw->dvi.requested_page = dw->dvi.current_page;
break;
}
}
}
}
void DviSaveToFile(w, fp)
Widget w;
FILE *fp;
{
XtCheckSubclass(w, dviWidgetClass, NULL);
(*((DviWidgetClass) XtClass(w))->command_class.save)(w, fp);
}
static
void SaveToFile(w, fp)
Widget w;
FILE *fp;
{
DviWidget dw = (DviWidget)w;
long pos;
int c;
if (dw->dvi.tmpFile) {
pos = ftell(dw->dvi.tmpFile);
if (dw->dvi.ungot) {
pos--;
dw->dvi.ungot = 0;
/* The ungot character is in the tmpFile, so we don't
want to read it from file. */
(void)getc(dw->dvi.file);
}
}
else
pos = ftell(dw->dvi.file);
FileSeek(dw, 0L);
while (DviGetC(dw, &c) != EOF)
if (putc(c, fp) == EOF) {
/* XXX print error message */
break;
}
FileSeek(dw, pos);
}
static
void ClassPartInitialize(widget_class)
WidgetClass widget_class;
{
DviWidgetClass wc = (DviWidgetClass)widget_class;
DviWidgetClass super = (DviWidgetClass) wc->core_class.superclass;
if (wc->command_class.save == InheritSaveToFile)
wc->command_class.save = super->command_class.save;
}
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/

46
gnu/usr.bin/groff/xditview/Dvi.h
View File

@ -1,46 +0,0 @@
/*
* $XConsortium: Dvi.h,v 1.4 89/07/21 14:22:06 jim Exp $
*/
#ifndef _XtDvi_h
#define _XtDvi_h
/***********************************************************************
*
* Dvi Widget
*
***********************************************************************/
/* Parameters:
Name Class RepType Default Value
---- ----- ------- -------------
background Background pixel White
foreground Foreground Pixel Black
fontMap FontMap char * ...
pageNumber PageNumber int 1
*/
#define XtNfontMap "fontMap"
#define XtNpageNumber "pageNumber"
#define XtNlastPageNumber "lastPageNumber"
#define XtNnoPolyText "noPolyText"
#define XtNseek "seek"
#define XtNresolution "resolution"
#define XtCFontMap "FontMap"
#define XtCPageNumber "PageNumber"
#define XtCLastPageNumber "LastPageNumber"
#define XtCNoPolyText "NoPolyText"
#define XtCSeek "Seek"
#define XtCResolution "Resolution"
typedef struct _DviRec *DviWidget; /* completely defined in DviPrivate.h */
typedef struct _DviClassRec *DviWidgetClass; /* completely defined in DviPrivate.h */
extern WidgetClass dviWidgetClass;
extern void DviSaveToFile();
#endif /* _XtDvi_h */
/* DON'T ADD STUFF AFTER THIS #endif */

664
gnu/usr.bin/groff/xditview/DviChar.c
View File

@ -1,664 +0,0 @@
/*
* DviChar.c
*
* Map DVI (ditroff output) character names to
* font indexes and back
*/
#include "DviChar.h"
extern char *xmalloc();
#define allocHash() ((DviCharNameHash *) xmalloc (sizeof (DviCharNameHash)))
struct map_list {
struct map_list *next;
DviCharNameMap *map;
};
static struct map_list *world;
static int standard_maps_loaded = 0;
static void load_standard_maps ();
static int hash_name ();
static dispose_hash(), compute_hash();
DviCharNameMap *
DviFindMap (encoding)
char *encoding;
{
struct map_list *m;
if (!standard_maps_loaded)
load_standard_maps ();
for (m = world; m; m=m->next)
if (!strcmp (m->map->encoding, encoding))
return m->map;
return 0;
}
void
DviRegisterMap (map)
DviCharNameMap *map;
{
struct map_list *m;
if (!standard_maps_loaded)
load_standard_maps ();
for (m = world; m; m = m->next)
if (!strcmp (m->map->encoding, map->encoding))
break;
if (!m) {
m = (struct map_list *) xmalloc (sizeof *m);
m->next = world;
world = m;
}
dispose_hash (map);
m->map = map;
compute_hash (map);
}
static
dispose_hash (map)
DviCharNameMap *map;
{
DviCharNameHash **buckets;
DviCharNameHash *h, *next;
int i;
buckets = map->buckets;
for (i = 0; i < DVI_HASH_SIZE; i++) {
for (h = buckets[i]; h; h=next) {
next = h->next;
free (h);
}
}
}
static int
hash_name (name)
char *name;
{
int i = 0;
while (*name)
i = (i << 1) ^ *name++;
if (i < 0)
i = -i;
return i;
}
static
compute_hash (map)
DviCharNameMap *map;
{
DviCharNameHash **buckets;
int c, s, i;
DviCharNameHash *h;
buckets = map->buckets;
for (i = 0; i < DVI_HASH_SIZE; i++)
buckets[i] = 0;
for (c = 0; c < DVI_MAP_SIZE; c++)
for (s = 0; s < DVI_MAX_SYNONYMS; s++) {
if (!map->dvi_names[c][s])
break;
i = hash_name (map->dvi_names[c][s]) % DVI_HASH_SIZE;
h = allocHash ();
h->next = buckets[i];
buckets[i] = h;
h->name = map->dvi_names[c][s];
h->position = c;
}
}
int
DviCharIndex (map, name)
DviCharNameMap *map;
char *name;
{
int i;
DviCharNameHash *h;
i = hash_name (name) % DVI_HASH_SIZE;
for (h = map->buckets[i]; h; h=h->next)
if (!strcmp (h->name, name))
return h->position;
return -1;
}
static DviCharNameMap ISO8859_1_map = {
"iso8859-1",
0,
{
{ 0, /* 0 */},
{ 0, /* 1 */},
{ 0, /* 2 */},
{ 0, /* 3 */},
{ 0, /* 4 */},
{ 0, /* 5 */},
{ 0, /* 6 */},
{ 0, /* 7 */},
{ 0, /* 8 */},
{ 0, /* 9 */},
{ 0, /* 10 */},
{ 0, /* 11 */},
{ 0, /* 12 */},
{ 0, /* 13 */},
{ 0, /* 14 */},
{ 0, /* 15 */},
{ 0, /* 16 */},
{ 0, /* 17 */},
{ 0, /* 18 */},
{ 0, /* 19 */},
{ 0, /* 20 */},
{ 0, /* 21 */},
{ 0, /* 22 */},
{ 0, /* 23 */},
{ 0, /* 24 */},
{ 0, /* 25 */},
{ 0, /* 26 */},
{ 0, /* 27 */},
{ 0, /* 28 */},
{ 0, /* 29 */},
{ 0, /* 30 */},
{ 0, /* 31 */},
{ 0, /* 32 */},
{ "!", /* 33 */},
{ "\"", /* 34 */},
{ "#","sh", /* 35 */},
{ "$","Do", /* 36 */},
{ "%", /* 37 */},
{ "&", /* 38 */},
{ "'", /* 39 */},
{ "(", /* 40 */},
{ ")", /* 41 */},
{ "*", /* 42 */},
{ "+", /* 43 */},
{ ",", /* 44 */},
{ "\\-", /* 45 */},
{ ".", /* 46 */},
{ "/","sl", /* 47 */},
{ "0", /* 48 */},
{ "1", /* 49 */},
{ "2", /* 50 */},
{ "3", /* 51 */},
{ "4", /* 52 */},
{ "5", /* 53 */},
{ "6", /* 54 */},
{ "7", /* 55 */},
{ "8", /* 56 */},
{ "9", /* 57 */},
{ ":", /* 58 */},
{ ";", /* 59 */},
{ "<", /* 60 */},
{ "=","eq", /* 61 */},
{ ">", /* 62 */},
{ "?", /* 63 */},
{ "@","at", /* 64 */},
{ "A", /* 65 */},
{ "B", /* 66 */},
{ "C", /* 67 */},
{ "D", /* 68 */},
{ "E", /* 69 */},
{ "F", /* 70 */},
{ "G", /* 71 */},
{ "H", /* 72 */},
{ "I", /* 73 */},
{ "J", /* 74 */},
{ "K", /* 75 */},
{ "L", /* 76 */},
{ "M", /* 77 */},
{ "N", /* 78 */},
{ "O", /* 79 */},
{ "P", /* 80 */},
{ "Q", /* 81 */},
{ "R", /* 82 */},
{ "S", /* 83 */},
{ "T", /* 84 */},
{ "U", /* 85 */},
{ "V", /* 86 */},
{ "W", /* 87 */},
{ "X", /* 88 */},
{ "Y", /* 89 */},
{ "Z", /* 90 */},
{ "[","lB", /* 91 */},
{ "\\","rs", /* 92 */},
{ "]","rB", /* 93 */},
{ "^","a^","ha" /* 94 */},
{ "_", /* 95 */},
{ "`","oq", /* 96 */},
{ "a", /* 97 */},
{ "b", /* 98 */},
{ "c", /* 99 */},
{ "d", /* 100 */},
{ "e", /* 101 */},
{ "f", /* 102 */},
{ "g", /* 103 */},
{ "h", /* 104 */},
{ "i", /* 105 */},
{ "j", /* 106 */},
{ "k", /* 107 */},
{ "l", /* 108 */},
{ "m", /* 109 */},
{ "n", /* 110 */},
{ "o", /* 111 */},
{ "p", /* 112 */},
{ "q", /* 113 */},
{ "r", /* 114 */},
{ "s", /* 115 */},
{ "t", /* 116 */},
{ "u", /* 117 */},
{ "v", /* 118 */},
{ "w", /* 119 */},
{ "x", /* 120 */},
{ "y", /* 121 */},
{ "z", /* 122 */},
{ "{","lC", /* 123 */},
{ "|","or","ba" /* 124 */},
{ "}","rC", /* 125 */},
{ "~","a~","ap","ti" /* 126 */},
{ 0, /* 127 */},
{ 0, /* 128 */},
{ 0, /* 129 */},
{ 0, /* 130 */},
{ 0, /* 131 */},
{ 0, /* 132 */},
{ 0, /* 133 */},
{ 0, /* 134 */},
{ 0, /* 135 */},
{ 0, /* 136 */},
{ 0, /* 137 */},
{ 0, /* 138 */},
{ 0, /* 139 */},
{ 0, /* 140 */},
{ 0, /* 141 */},
{ 0, /* 142 */},
{ 0, /* 143 */},
{ 0, /* 144 */},
{ 0, /* 145 */},
{ 0, /* 146 */},
{ 0, /* 147 */},
{ 0, /* 148 */},
{ 0, /* 149 */},
{ 0, /* 150 */},
{ 0, /* 151 */},
{ 0, /* 152 */},
{ 0, /* 153 */},
{ 0, /* 154 */},
{ 0, /* 155 */},
{ 0, /* 156 */},
{ 0, /* 157 */},
{ 0, /* 158 */},
{ 0, /* 159 */},
{ 0, /* 160 */},
{ "r!", "\241", /* 161 */},
{ "ct", "\242", /* 162 */},
{ "Po", "\243", /* 163 */},
{ "Cs", "\244", /* 164 */},
{ "Ye", "\245", /* 165 */},
{ "bb", "\246", /* 166 */},
{ "sc", "\247", /* 167 */},
{ "ad", "\250", /* 168 */},
{ "co", "\251", /* 169 */},
{ "Of", "\252", /* 170 */},
{ "Fo", "\253", /* 171 */},
{ "no", "\254", /* 172 */},
{ "-", "hy", "\255" /* 173 */},
{ "rg", "\256", /* 174 */},
{ "a-", "\257", /* 175 */},
{ "de", "\260", /* 176 */},
{ "+-", "\261", /* 177 */},
{ "S2", "\262", /* 178 */},
{ "S3", "\263", /* 179 */},
{ "aa", "\264", /* 180 */},
/* Omit *m here; we want *m to match the other greek letters in the
symbol font. */
{ "\265", /* 181 */},
{ "ps", "\266", /* 182 */},
{ "md", "\267", /* 183 */},
{ "ac", "\270", /* 184 */},
{ "S1", "\271", /* 185 */},
{ "Om", "\272", /* 186 */},
{ "Fc", "\273", /* 187 */},
{ "14", "\274", /* 188 */},
{ "12", "\275", /* 189 */},
{ "34", "\276", /* 190 */},
{ "r?", "\277", /* 191 */},
{ "`A", "\300", /* 192 */},
{ "'A", "\301", /* 193 */},
{ "^A", "\302", /* 194 */},
{ "~A", "\303", /* 195 */},
{ ":A", "\304", /* 196 */},
{ "oA", "\305", /* 197 */},
{ "AE", "\306", /* 198 */},
{ ",C", "\307", /* 199 */},
{ "`E", "\310", /* 200 */},
{ "'E", "\311", /* 201 */},
{ "^E", "\312", /* 202 */},
{ ":E", "\313", /* 203 */},
{ "`I", "\314", /* 204 */},
{ "'I", "\315", /* 205 */},
{ "^I", "\316", /* 206 */},
{ ":I", "\317", /* 207 */},
{ "-D", "\320", /* 208 */},
{ "~N", "\321", /* 209 */},
{ "`O", "\322", /* 210 */},
{ "'O", "\323", /* 211 */},
{ "^O", "\324", /* 212 */},
{ "~O", "\325", /* 213 */},
{ ":O", "\326", /* 214 */},
{ "mu", "\327", /* 215 */},
{ "/O", "\330", /* 216 */},
{ "`U", "\331", /* 217 */},
{ "'U", "\332", /* 218 */},
{ "^U", "\333", /* 219 */},
{ ":U", "\334", /* 220 */},
{ "'Y", "\335", /* 221 */},
{ "TP", "\336", /* 222 */},
{ "ss", "\337", /* 223 */},
{ "`a", "\340", /* 224 */},
{ "'a", "\341", /* 225 */},
{ "^a", "\342", /* 226 */},
{ "~a", "\343", /* 227 */},
{ ":a", "\344", /* 228 */},
{ "oa", "\345", /* 229 */},
{ "ae", "\346", /* 230 */},
{ ",c", "\347", /* 231 */},
{ "`e", "\350", /* 232 */},
{ "'e", "\351", /* 233 */},
{ "^e", "\352", /* 234 */},
{ ":e", "\353", /* 235 */},
{ "`i", "\354", /* 236 */},
{ "'i", "\355", /* 237 */},
{ "^i", "\356", /* 238 */},
{ ":i", "\357", /* 239 */},
{ "Sd", "\360", /* 240 */},
{ "~n", "\361", /* 241 */},
{ "`o", "\362", /* 242 */},
{ "'o", "\363", /* 243 */},
{ "^o", "\364", /* 244 */},
{ "~o", "\365", /* 245 */},
{ ":o", "\366", /* 246 */},
{ "di", "\367", /* 247 */},
{ "/o", "\370", /* 248 */},
{ "`u", "\371", /* 249 */},
{ "'u", "\372", /* 250 */},
{ "^u", "\373", /* 251 */},
{ ":u", "\374", /* 252 */},
{ "'y", "\375", /* 253 */},
{ "Tp", "\376", /* 254 */},
{ ":y", "\377", /* 255 */},
}};
static DviCharNameMap Adobe_Symbol_map = {
"adobe-fontspecific",
1,
{
{ 0, /* 0 */},
{ 0, /* 1 */},
{ 0, /* 2 */},
{ 0, /* 3 */},
{ 0, /* 4 */},
{ 0, /* 5 */},
{ 0, /* 6 */},
{ 0, /* 7 */},
{ 0, /* 8 */},
{ 0, /* 9 */},
{ 0, /* 10 */},
{ 0, /* 11 */},
{ 0, /* 12 */},
{ 0, /* 13 */},
{ 0, /* 14 */},
{ 0, /* 15 */},
{ 0, /* 16 */},
{ 0, /* 17 */},
{ 0, /* 18 */},
{ 0, /* 19 */},
{ 0, /* 20 */},
{ 0, /* 21 */},
{ 0, /* 22 */},
{ 0, /* 23 */},
{ 0, /* 24 */},
{ 0, /* 25 */},
{ 0, /* 26 */},
{ 0, /* 27 */},
{ 0, /* 28 */},
{ 0, /* 29 */},
{ 0, /* 30 */},
{ 0, /* 31 */},
{ 0, /* 32 */},
{ "!", /* 33 */},
{ "fa", /* 34 */},
{ "#", "sh", /* 35 */},
{ "te", /* 36 */},
{ "%", /* 37 */},
{ "&", /* 38 */},
{ "st", /* 39 */},
{ "(", /* 40 */},
{ ")", /* 41 */},
{ "**", /* 42 */},
{ "+", "pl", /* 43 */},
{ ",", /* 44 */},
{ "\\-", "mi", /* 45 */},
{ ".", /* 46 */},
{ "/", "sl", /* 47 */},
{ "0", /* 48 */},
{ "1", /* 49 */},
{ "2", /* 50 */},
{ "3", /* 51 */},
{ "4", /* 52 */},
{ "5", /* 53 */},
{ "6", /* 54 */},
{ "7", /* 55 */},
{ "8", /* 56 */},
{ "9", /* 57 */},
{ ":", /* 58 */},
{ ";", /* 59 */},
{ "<", /* 60 */},
{ "=", "eq", /* 61 */},
{ ">", /* 62 */},
{ "?", /* 63 */},
{ "=~", /* 64 */},
{ "*A", /* 65 */},
{ "*B", /* 66 */},
{ "*X", /* 67 */},
{ "*D", /* 68 */},
{ "*E", /* 69 */},
{ "*F", /* 70 */},
{ "*G", /* 71 */},
{ "*Y", /* 72 */},
{ "*I", /* 73 */},
{ "+h", /* 74 */},
{ "*K", /* 75 */},
{ "*L", /* 76 */},
{ "*M", /* 77 */},
{ "*N", /* 78 */},
{ "*O", /* 79 */},
{ "*P", /* 80 */},
{ "*H", /* 81 */},
{ "*R", /* 82 */},
{ "*S", /* 83 */},
{ "*T", /* 84 */},
{ 0, /* 85 */},
{ "ts", /* 86 */},
{ "*W", /* 87 */},
{ "*C", /* 88 */},
{ "*Q", /* 89 */},
{ "*Z", /* 90 */},
{ "[", "lB", /* 91 */},
{ "tf", "3d", /* 92 */},
{ "]", "rB", /* 93 */},
{ "pp", /* 94 */},
{ "_", /* 95 */},
{ "radicalex", /* 96 */},
{ "*a", /* 97 */},
{ "*b", /* 98 */},
{ "*x", /* 99 */},
{ "*d", /* 100 */},
{ "*e", /* 101 */},
{ "*f", /* 102 */},
{ "*g", /* 103 */},
{ "*y", /* 104 */},
{ "*i", /* 105 */},
{ "+f", /* 106 */},
{ "*k", /* 107 */},
{ "*l", /* 108 */},
{ "*m", "\265", /* 109 */},
{ "*n", /* 110 */},
{ "*o", /* 111 */},
{ "*p", /* 112 */},
{ "*h", /* 113 */},
{ "*r", /* 114 */},
{ "*s", /* 115 */},
{ "*t", /* 116 */},
{ "*u", /* 117 */},
{ "+p", /* 118 */},
{ "*w", /* 119 */},
{ "*c", /* 120 */},
{ "*q", /* 121 */},
{ "*z", /* 122 */},
{ "lC", "{", /* 123 */},
{ "ba", "or", "|", /* 124 */},
{ "rC", "}", /* 125 */},
{ "ap", /* 126 */},
{ 0, /* 127 */},
{ 0, /* 128 */},
{ 0, /* 129 */},
{ 0, /* 130 */},
{ 0, /* 131 */},
{ 0, /* 132 */},
{ 0, /* 133 */},
{ 0, /* 134 */},
{ 0, /* 135 */},
{ 0, /* 136 */},
{ 0, /* 137 */},
{ 0, /* 138 */},
{ 0, /* 139 */},
{ 0, /* 140 */},
{ 0, /* 141 */},
{ 0, /* 142 */},
{ 0, /* 143 */},
{ 0, /* 144 */},
{ 0, /* 145 */},
{ 0, /* 146 */},
{ 0, /* 147 */},
{ 0, /* 148 */},
{ 0, /* 149 */},
{ 0, /* 150 */},
{ 0, /* 151 */},
{ 0, /* 152 */},
{ 0, /* 153 */},
{ 0, /* 154 */},
{ 0, /* 155 */},
{ 0, /* 156 */},
{ 0, /* 157 */},
{ 0, /* 158 */},
{ 0, /* 159 */},
{ 0, /* 160 */},
{ "*U", /* 161 */},
{ "fm", /* 162 */},
{ "<=", /* 163 */},
{ "f/", /* 164 */},
{ "if", /* 165 */},
{ "Fn", /* 166 */},
{ "CL", /* 167 */},
{ "DI", /* 168 */},
{ "HE", /* 169 */},
{ "SP", /* 170 */},
{ "<>", /* 171 */},
{ "<-", /* 172 */},
{ "ua", "arrowverttp" /* 173 */},
{ "->", /* 174 */},
{ "da", "arrowvertbt" /* 175 */},
{ "de", "\260", /* 176 */},
{ "+-", "\261", /* 177 */},
{ "sd", /* 178 */},
{ ">=", /* 179 */},
{ "mu", "\327", /* 180 */},
{ "pt", /* 181 */},
{ "pd", /* 182 */},
{ "bu", /* 183 */},
{ "di", "\367", /* 184 */},
{ "!=", /* 185 */},
{ "==", /* 186 */},
{ "~=", "~~", /* 187 */},
{ 0, /* 188 */},
{ "arrowvertex", /* 189 */},
{ "an", /* 190 */},
{ "CR", /* 191 */},
{ "Ah", /* 192 */},
{ "Im", /* 193 */},
{ "Re", /* 194 */},
{ "wp", /* 195 */},
{ "c*", /* 196 */},
{ "c+", /* 197 */},
{ "es", /* 198 */},
{ "ca", /* 199 */},
{ "cu", /* 200 */},
{ "sp", /* 201 */},
{ "ip", /* 202 */},
{ 0, /* 203 */},
{ "sb", /* 204 */},
{ "ib", /* 205 */},
{ "mo", /* 206 */},
{ "nm", /* 207 */},
{ "/_", /* 208 */},
{ "gr", /* 209 */},
{ "rg", /* 210 */},
{ "co", /* 211 */},
{ "tm", /* 212 */},
{ 0, /* 213 */},
{ "sr", /* 214 */},
{ "md", /* 215 */},
{ "no", "\254", /* 216 */},
{ "AN", /* 217 */},
{ "OR", /* 218 */},
{ "hA", /* 219 */},
{ "lA", /* 220 */},
{ "uA", /* 221 */},
{ "rA", /* 222 */},
{ "dA", /* 223 */},
{ "lz", /* 224 */},
{ "la", /* 225 */},
{ 0, /* 226 */},
{ 0, /* 227 */},
{ 0, /* 228 */},
{ 0, /* 229 */},
{ "parenlefttp", /* 230 */},
{ "parenleftex", /* 231 */},
{ "parenleftbt", /* 232 */},
{ "bracketlefttp", "lc", /* 233 */},
{ "bracketleftex", /* 234 */},
{ "bracketleftbt", "lf", /* 235 */},
{ "bracelefttp", "lt", /* 236 */},
{ "braceleftmid", "lk", /* 237 */},
{ "braceleftbt", "lb", /* 238 */},
{ "bracerightex", "braceleftex", "bv", /* 239 */},
{ 0, /* 240 */},
{ "ra", /* 241 */},
{ "is", /* 242 */},
{ 0, /* 243 */},
{ 0, /* 244 */},
{ 0, /* 245 */},
{ "parenrighttp", /* 246 */},
{ "parenrightex", /* 247 */},
{ "parenrightbt", /* 248 */},
{ "bracketrighttp", "rc", /* 249 */},
{ "bracketrightex", /* 250 */},
{ "bracketrightbt", "rf", /* 251 */},
{ "bracerighttp", "rt" /* 252 */},
{ "bracerightmid", "rk" /* 253 */},
{ "bracerightbt", "rb" /* 254 */},
{ 0, /* 255 */},
}};
static void
load_standard_maps ()
{
standard_maps_loaded = 1;
DviRegisterMap (&ISO8859_1_map);
DviRegisterMap (&Adobe_Symbol_map);
}

37
gnu/usr.bin/groff/xditview/DviChar.h
View File

@ -1,37 +0,0 @@
/*
* DviChar.h
*
* descriptions for mapping dvi names to
* font indexes and back. Dvi fonts are all
* 256 elements (actually only 256-32 are usable).
*
* The encoding names are taken from X -
* case insensitive, a dash separating the
* CharSetRegistry from the CharSetEncoding
*/
# define DVI_MAX_SYNONYMS 10
# define DVI_MAP_SIZE 256
# define DVI_HASH_SIZE 256
typedef struct _dviCharNameHash {
struct _dviCharNameHash *next;
char *name;
int position;
} DviCharNameHash;
typedef struct _dviCharNameMap {
char *encoding;
int special;
char *dvi_names[DVI_MAP_SIZE][DVI_MAX_SYNONYMS];
DviCharNameHash *buckets[DVI_HASH_SIZE];
} DviCharNameMap;
extern DviCharNameMap *DviFindMap ( /* char *encoding */ );
extern void DviRegisterMap ( /* DviCharNameMap *map */ );
#ifdef NOTDEF
extern char *DviCharName ( /* DviCharNameMap *map, int index, int synonym */ );
#else
#define DviCharName(map,index,synonym) ((map)->dvi_names[index][synonym])
#endif
extern int DviCharIndex ( /* DviCharNameMap *map, char *name */ );

233
gnu/usr.bin/groff/xditview/DviP.h
View File

@ -1,233 +0,0 @@
/*
* $XConsortium: DviP.h,v 1.5 89/07/22 19:44:08 keith Exp $
*/
/*
* DviP.h - Private definitions for Dvi widget
*/
#ifndef _XtDviP_h
#define _XtDviP_h
#include "Dvi.h"
#include "DviChar.h"
#include "device.h"
/***********************************************************************
*
* Dvi Widget Private Data
*
***********************************************************************/
/************************************
*
* Class structure
*
***********************************/
/* Type for save method. */
typedef void (*DviSaveProc)();
/*
* New fields for the Dvi widget class record
*/
typedef struct _DviClass {
DviSaveProc save;
} DviClassPart;
/*
* Full class record declaration
*/
typedef struct _DviClassRec {
CoreClassPart core_class;
DviClassPart command_class;
} DviClassRec;
extern DviClassRec dviClassRec;
/***************************************
*
* Instance (widget) structure
*
**************************************/
/*
* a list of fonts we've used for this widget
*/
typedef struct _dviFontSizeList {
struct _dviFontSizeList *next;
int size;
char *x_name;
XFontStruct *font;
int doesnt_exist;
} DviFontSizeList;
typedef struct _dviFontList {
struct _dviFontList *next;
char *dvi_name;
char *x_name;
int dvi_number;
Boolean initialized;
Boolean scalable;
DviFontSizeList *sizes;
DviCharNameMap *char_map;
DeviceFont *device_font;
} DviFontList;
typedef struct _dviFontMap {
struct _dviFontMap *next;
char *dvi_name;
char *x_name;
} DviFontMap;
#define DVI_TEXT_CACHE_SIZE 256
#define DVI_CHAR_CACHE_SIZE 1024
typedef struct _dviCharCache {
XTextItem cache[DVI_TEXT_CACHE_SIZE];
char adjustable[DVI_TEXT_CACHE_SIZE];
char char_cache[DVI_CHAR_CACHE_SIZE];
int index;
int max;
int char_index;
int font_size;
int font_number;
XFontStruct *font;
int start_x, start_y;
int x, y;
} DviCharCache;
typedef struct _dviState {
struct _dviState *next;
int font_size;
int font_number;
int x;
int y;
} DviState;
typedef struct _dviFileMap {
struct _dviFileMap *next;
long position;
int page_number;
} DviFileMap;
/*
* New fields for the Dvi widget record
*/
typedef struct {
/*
* resource specifiable items
*/
char *font_map_string;
unsigned long foreground;
unsigned long background;
int requested_page;
int last_page;
XFontStruct *default_font;
FILE *file;
Boolean noPolyText;
Boolean seek; /* file is "seekable" */
int default_resolution;
/*
* private state
*/
FILE *tmpFile; /* used when reading stdin */
char readingTmp; /* reading now from tmp */
char ungot; /* have ungetc'd a char */
GC normal_GC;
GC fill_GC;
DviFileMap *file_map;
DviFontList *fonts;
DviFontMap *font_map;
int current_page;
int font_size;
int font_number;
DeviceFont *device_font;
int device_font_number;
Device *device;
int native;
int device_resolution;
int display_resolution;
int paperlength;
int paperwidth;
double scale_factor; /* display res / device res */
int sizescale;
int line_thickness;
int line_width;
#define DVI_FILL_MAX 1000
int fill;
#define DVI_FILL_WHITE 0
#define DVI_FILL_GRAY 1
#define DVI_FILL_BLACK 2
int fill_type;
Pixmap gray;
int backing_store;
XFontStruct *font;
int display_enable;
struct ExposedExtents {
int x1, y1, x2, y2;
} extents;
DviState *state;
DviCharCache cache;
int text_x_width;
int text_device_width;
int word_flag;
} DviPart;
#define DviGetIn(dw,cp)\
(dw->dvi.tmpFile ? (\
DviGetAndPut (dw, cp) \
) :\
(*cp = getc (dw->dvi.file))\
)
#define DviGetC(dw, cp)\
(dw->dvi.readingTmp ? (\
((*cp = getc (dw->dvi.tmpFile)) == EOF) ? (\
fseek (dw->dvi.tmpFile, 0l, 2),\
(dw->dvi.readingTmp = 0),\
DviGetIn (dw,cp)\
) : (\
*cp\
)\
) : (\
DviGetIn(dw,cp)\
)\
)
#define DviUngetC(dw, c)\
(dw->dvi.readingTmp ? (\
ungetc (c, dw->dvi.tmpFile)\
) : ( \
(dw->dvi.ungot = 1),\
ungetc (c, dw->dvi.file)))
/*
* Full widget declaration
*/
typedef struct _DviRec {
CorePart core;
DviPart dvi;
} DviRec;
#define InheritSaveToFile ((DviSaveProc)_XtInherit)
extern XFontStruct *QueryFont ();
extern DviCharNameMap *QueryFontMap ();
extern DeviceFont *QueryDeviceFont ();
extern char *GetWord(), *GetLine();
#endif /* _XtDviP_h */

17
gnu/usr.bin/groff/xditview/FontMap
View File

@ -1,17 +0,0 @@
TR -adobe-times-medium-r-normal--*-*-*-*-p-*-iso8859-1
TI -adobe-times-medium-i-normal--*-*-*-*-p-*-iso8859-1
TB -adobe-times-bold-r-normal--*-*-*-*-p-*-iso8859-1
TBI -adobe-times-bold-i-normal--*-*-*-*-p-*-iso8859-1
CR -adobe-courier-medium-r-normal--*-*-*-*-m-*-iso8859-1
CI -adobe-courier-medium-o-normal--*-*-*-*-m-*-iso8859-1
CB -adobe-courier-bold-r-normal--*-*-*-*-m-*-iso8859-1
CBI -adobe-courier-bold-o-normal--*-*-*-*-m-*-iso8859-1
HR -adobe-helvetica-medium-r-normal--*-*-*-*-p-*-iso8859-1
HI -adobe-helvetica-medium-o-normal--*-*-*-*-p-*-iso8859-1
HB -adobe-helvetica-bold-r-normal--*-*-*-*-p-*-iso8859-1
HBI -adobe-helvetica-bold-o-normal--*-*-*-*-p-*-iso8859-1
NR -adobe-new century schoolbook-medium-r-normal--*-*-*-*-p-*-iso8859-1
NI -adobe-new century schoolbook-medium-i-normal--*-*-*-*-p-*-iso8859-1
NB -adobe-new century schoolbook-bold-r-normal--*-*-*-*-p-*-iso8859-1
NBI -adobe-new century schoolbook-bold-i-normal--*-*-*-*-p-*-iso8859-1
S -adobe-symbol-medium-r-normal--*-*-*-*-p-*-adobe-fontspecific

57
gnu/usr.bin/groff/xditview/GXditview.ad
View File

@ -1,57 +0,0 @@
GXditview.height: 840
GXditview.paned.allowResize: true
GXditview.paned.viewport.allowVert: true
GXditview.paned.viewport.allowHoriz: true
GXditview.paned.viewport.skipAdjust: false
GXditview.paned.viewport.width: 600
GXditview.paned.viewport.height: 800
GXditview.paned.viewport.showGrip: false
GXditview.paned.label.skipAdjust: true
GXditview.paned.viewport.dvi.translations: #augment \
<Btn1Down>: XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
<Key>Next: NextPage()\n\
<Key>n: NextPage()\n\
<Key>space: NextPage()\n\
<Key>Return: NextPage()\n\
<Key>Prior: PreviousPage()\n\
<Key>p: PreviousPage()\n\
<Key>BackSpace: PreviousPage()\n\
<Key>Delete: PreviousPage()\n\
<Key>Select: SelectPage()\n\
<Key>Find: OpenFile()\n\
<Key>r: Rerasterize()\n\
<Key>q: Quit()
GXditview.paned.label.translations: #augment \
<Btn1Down>: XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
<Key>Next: NextPage()\n\
<Key>n: NextPage()\n\
<Key>space: NextPage()\n\
<Key>Return: NextPage()\n\
<Key>Prior: PreviousPage()\n\
<Key>p: PreviousPage()\n\
<Key>BackSpace: PreviousPage()\n\
<Key>Delete: PreviousPage()\n\
<Key>Select: SelectPage()\n\
<Key>Find: OpenFile()\n\
<Key>r: Rerasterize()\n\
<Key>q: Quit()
GXditview.menu.nextPage.label: Next Page
GXditview.menu.previousPage.label: Previous Page
GXditview.menu.selectPage.label: Select Page
GXditview.menu.print.label: Print
GXditview.menu.openFile.label: Open
GXditview.menu.quit.label: Quit
GXditview.promptShell.allowShellResize: true
GXditview.promptShell.promptDialog.value.translations: #override \
<Key>Return: Accept()
GXditview.promptShell.promptDialog.accept.label: Accept
GXditview.promptShell.promptDialog.accept.translations: #override \
<BtnUp>: Accept() unset()
GXditview.promptShell.promptDialog.cancel.label: Cancel
GXditview.promptShell.promptDialog.cancel.translations: #override \
<BtnUp>: Cancel() unset()

20
gnu/usr.bin/groff/xditview/INSTALL
View File

@ -1,20 +0,0 @@
This version of gxditview uses imake.
Here are the steps needed to install gxditview:
- edit the Imakefile if necessary
- xmkmf
- make depend
- make
- make install
- make install.man (installs the man page)
The gxditview binary will be installed in the usual place for X
binaries (eg /usr/bin/X11). Previous versions of gxditview were
installed along with the other groff binaries (eg in /usr/local/bin);
you will need to remove these by hand.

52
gnu/usr.bin/groff/xditview/Imakefile
View File

@ -1,52 +0,0 @@
GROFF_LIBDIR = /usr/local/lib/groff
GROFF_FONTDIR = $(GROFF_LIBDIR)/font
GROFF_FONTPATH = .:$(GROFF_FONTDIR):/usr/local/lib/font:/usr/lib/font
DPIS = 75 100
PROGRAMS = gxditview xtotroff
DEPLIBS = XawClientDepLibs
LOCAL_LIBRARIES = XawClientLibs
SRCS1 = xditview.c Dvi.c draw.c font.c lex.c page.c \
parse.c XFontName.c DviChar.c device.c
OBJS1 = xditview.o Dvi.o draw.o font.o lex.o page.o \
parse.o XFontName.o DviChar.o device.o
SRCS2 = xtotroff.c XFontName.c DviChar.c
OBJS2 = xtotroff.o XFontName.o DviChar.o
INCLUDES = -I$(TOOLKITSRC) -I$(TOP)
MATHLIB = -lm
DEFINES = $(SIGNAL_DEFINES) -DFONTPATH=\"$(GROFF_FONTPATH)\" # -DX_NOT_STDC_ENV
ComplexProgramTarget_1(gxditview,$(LOCAL_LIBRARIES),$(MATHLIB))
NormalProgramTarget(xtotroff,$(OBJS2),$(DEPXLIB),$(XLIB), /**/)
InstallAppDefaults(GXditview)
fonts: xtotroff DESC FontMap
@dir=`pwd`; \
fonts=`sed -e 's/[ ].*//' FontMap`; \
for dpi in $(DPIS); do \
echo Making devX$$dpi; \
test -d ../devX$$dpi || mkdir ../devX$$dpi; \
rm -f ../devX$$dpi/DESC; \
sed -e "s/res 75/res $$dpi/" DESC >../devX$$dpi/DESC; \
(cd ../devX$$dpi; \
rm -f Makefile.sub; \
echo DEV=X$$dpi >Makefile.sub; \
echo DEVFILES=DESC $$fonts >>Makefile.sub; \
$$dir/xtotroff -g -r $$dpi -s 10 $$dir/FontMap); \
echo Making devX$$dpi-12; \
test -d ../devX$$dpi-12 || mkdir ../devX$$dpi-12; \
rm -f ../devX$$dpi-12/DESC; \
sed -e "s/res 75/res $$dpi/" -e 's/unitwidth 10/unitwidth 12/' DESC \
>../devX$$dpi-12/DESC; \
(cd ../devX$$dpi-12; \
rm -f Makefile.sub; \
echo DEV=X$$dpi-12 >Makefile.sub; \
echo DEVFILES=DESC $$fonts >>Makefile.sub; \
$$dir/xtotroff -g -r $$dpi -s 12 $$dir/FontMap); \
done
extraclean: clean
-rm -f junk tmp grot old
FORCE:

35
gnu/usr.bin/groff/xditview/Makefile
View File

@ -1,35 +0,0 @@
.if exists(${X11BASE}/include/X11/Xlib.h)
.if exists(${X11BASE}/lib)
.if exists(${DESTDIR}${X11BASE}/bin)
.if exists(${DESTDIR}${X11BASE}/man/man1)
.if exists(${DESTDIR}${X11BASE}/lib/X11/app-defaults)
BINDIR= ${X11BASE}/bin
MANDIR= ${X11BASE}/man/man
MANDEPEND= gxditview.1
CLEANFILES+= ${MANDEPEND}
PROG= gxditview
CFLAGS+= -I${X11BASE}/include -DFONTPATH=\"$(fontpath)\"
SRCS+= xditview.c Dvi.c draw.c font.c lex.c page.c parse.c \
XFontName.c DviChar.c device.c
LDDESTDIR+= -L${X11BASE}/lib
LDADD+= -lXaw -lXmu -lXt -lSM -lICE -lXext -lX11 -lm
DPADD+= ${X11BASE}/lib/libXaw.a ${X11BASE}/lib/libXmu.a \
${X11BASE}/lib/libXt.a ${X11BASE}/lib/libSM.a \
${X11BASE}/lib/libICE.a ${X11BASE}/lib/libXext.a \
${X11BASE}/lib/libX11.a
afterinstall:
${INSTALL} -c -o ${BINOWN} -g ${BINGRP} -m 444 \
${.CURDIR}/GXditview.ad \
${DESTDIR}${X11BASE}/lib/X11/app-defaults/GXditview
.endif
.endif
.endif
.endif
.endif
.include "../Makefile.cfg"
.include <bsd.prog.mk>

46
gnu/usr.bin/groff/xditview/Menu.h
View File

@ -1,46 +0,0 @@
/*
* $XConsortium: Menu.h,v 1.2 89/07/21 14:22:10 jim Exp $
*/
#ifndef _XtMenu_h
#define _XtMenu_h
/***********************************************************************
*
* Menu Widget
*
***********************************************************************/
/* Parameters:
Name Class RepType Default Value
---- ----- ------- -------------
background Background pixel White
border BorderColor pixel Black
borderWidth BorderWidth int 1
height Height int 120
mappedWhenManaged MappedWhenManaged Boolean True
reverseVideo ReverseVideo Boolean False
width Width int 120
x Position int 0
y Position int 0
*/
#define XtNmenuEntries "menuEntries"
#define XtNhorizontalPadding "horizontalPadding"
#define XtNverticalPadding "verticalPadding"
#define XtNselection "Selection"
#define XtCMenuEntries "MenuEntries"
#define XtCPadding "Padding"
#define XtCSelection "Selection"
typedef struct _MenuRec *MenuWidget; /* completely defined in MenuPrivate.h */
typedef struct _MenuClassRec *MenuWidgetClass; /* completely defined in MenuPrivate.h */
extern WidgetClass menuWidgetClass;
extern Widget XawMenuCreate ();
#endif /* _XtMenu_h */
/* DON'T ADD STUFF AFTER THIS #endif */

14
gnu/usr.bin/groff/xditview/README
View File

@ -1,14 +0,0 @@
This is gxditview, a X11 previewer for groff based on MIT's xditview.
This version can be used with the output of gtroff -Tps as well as
with -TX75 and -TX100. You will need X11R5 to install it (it might
work on X11R4, but I haven't tested it.)
See the file INSTALL in this directory for installation instructions.
xditview is copyrighted by MIT under the usual X terms (see
gxditview.man); my changes to it are in the public domain.
Please report bugs to bug-groff@prep.ai.mit.edu.
James Clark
jjc@jclark.com

15
gnu/usr.bin/groff/xditview/TODO
View File

@ -1,15 +0,0 @@
Better error handling.
Resource and command-line option to specify font path.
Resource to specify name of environment variable from which to get the
font path.
Have character substitutions (currently done in draw.c:FakeCharacter)
specified in a resource (similar format to FontMap).
The initial width of the dialog box should expand to accommodate the
default value.
Option in Print dialog to specify that only the current page should be
printed.

256
gnu/usr.bin/groff/xditview/XFontName.c
View File

@ -1,256 +0,0 @@
/*
* XFontName.c
*
* build/parse X Font name strings
*/
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include "XFontName.h"
#include <ctype.h>
static char *
extractStringField (name, buffer, size, attrp, bit)
char *name;
char *buffer;
int size;
unsigned int *attrp;
unsigned int bit;
{
char *buf = buffer;
if (!*name)
return 0;
while (*name && *name != '-' && size > 0) {
*buf++ = *name++;
--size;
}
if (size <= 0)
return 0;
*buf = '\0';
if (buffer[0] != '*' || buffer[1] != '\0')
*attrp |= bit;
if (*name == '-')
return name+1;
return name;
}
static char *
extractUnsignedField (name, result, attrp, bit)
char *name;
unsigned int *result;
unsigned int *attrp;
unsigned int bit;
{
char buf[256];
char *c;
unsigned int i;
name = extractStringField (name, buf, sizeof (buf), attrp, bit);
if (!name)
return 0;
if (!(*attrp & bit))
return name;
i = 0;
for (c = buf; *c; c++) {
if (!isdigit (*c))
return 0;
i = i * 10 + (*c - '0');
}
*result = i;
return name;
}
Bool
XParseFontName (fontNameString, fontName, fontNameAttributes)
XFontNameString fontNameString;
XFontName *fontName;
unsigned int *fontNameAttributes;
{
char *name = fontNameString;
XFontName temp;
unsigned int attributes = 0;
#define GetString(field,bit)\
if (!(name = extractStringField \
(name, temp.field, sizeof (temp.field),\
&attributes, bit))) \
return False;
#define GetUnsigned(field,bit)\
if (!(name = extractUnsignedField \
(name, &temp.field, \
&attributes, bit))) \
return False;
GetString (Registry, FontNameRegistry)
GetString (Foundry, FontNameFoundry)
GetString (FamilyName, FontNameFamilyName)
GetString (WeightName, FontNameWeightName)
GetString (Slant, FontNameSlant)
GetString (SetwidthName, FontNameSetwidthName)
GetString (AddStyleName, FontNameAddStyleName)
GetUnsigned (PixelSize, FontNamePixelSize)
GetUnsigned (PointSize, FontNamePointSize)
GetUnsigned (ResolutionX, FontNameResolutionX)
GetUnsigned (ResolutionY, FontNameResolutionY)
GetString (Spacing, FontNameSpacing)
GetUnsigned (AverageWidth, FontNameAverageWidth)
GetString (CharSetRegistry, FontNameCharSetRegistry)
if (!*name) {
temp.CharSetEncoding[0] = '\0';
attributes |= FontNameCharSetEncoding;
} else {
GetString (CharSetEncoding, FontNameCharSetEncoding)
}
*fontName = temp;
*fontNameAttributes = attributes;
return True;
}
static char *
utoa (u, s, size)
unsigned int u;
char *s;
int size;
{
char *t;
t = s + size;
*--t = '\0';
do
*--t = (u % 10) + '0';
while (u /= 10);
return t;
}
Bool
XFormatFontName (fontName, fontNameAttributes, fontNameString)
XFontName *fontName;
unsigned int fontNameAttributes;
XFontNameString fontNameString;
{
XFontNameString tmp;
char *name = tmp, *f;
int left = sizeof (tmp) - 1;
char number[32];
#define PutString(field, bit)\
f = (fontNameAttributes & bit) ? \
fontName->field \
: "*"; \
if ((left -= strlen (f)) < 0) \
return False; \
while (*f) \
if ((*name++ = *f++) == '-') \
return False;
#define PutHyphen()\
if (--left < 0) \
return False; \
*name++ = '-';
#define PutUnsigned(field, bit) \
f = (fontNameAttributes & bit) ? \
utoa (fontName->field, number, sizeof (number)) \
: "*"; \
if ((left -= strlen (f)) < 0) \
return False; \
while (*f) \
*name++ = *f++;
PutString (Registry, FontNameRegistry)
PutHyphen ();
PutString (Foundry, FontNameFoundry)
PutHyphen ();
PutString (FamilyName, FontNameFamilyName)
PutHyphen ();
PutString (WeightName, FontNameWeightName)
PutHyphen ();
PutString (Slant, FontNameSlant)
PutHyphen ();
PutString (SetwidthName, FontNameSetwidthName)
PutHyphen ();
PutString (AddStyleName, FontNameAddStyleName)
PutHyphen ();
PutUnsigned (PixelSize, FontNamePixelSize)
PutHyphen ();
PutUnsigned (PointSize, FontNamePointSize)
PutHyphen ();
PutUnsigned (ResolutionX, FontNameResolutionX)
PutHyphen ();
PutUnsigned (ResolutionY, FontNameResolutionY)
PutHyphen ();
PutString (Spacing, FontNameSpacing)
PutHyphen ();
PutUnsigned (AverageWidth, FontNameAverageWidth)
PutHyphen ();
PutString (CharSetRegistry, FontNameCharSetRegistry)
PutHyphen ();
PutString (CharSetEncoding, FontNameCharSetEncoding)
*name = '\0';
strcpy (fontNameString, tmp);
return True;
}
Bool
XCompareFontName (name1, name2, fontNameAttributes)
XFontName *name1, *name2;
unsigned int fontNameAttributes;
{
#define CompareString(field,bit) \
if (fontNameAttributes & bit) \
if (strcmp (name1->field, name2->field)) \
return False;
#define CompareUnsigned(field,bit) \
if (fontNameAttributes & bit) \
if (name1->field != name2->field) \
return False;
CompareString (Registry, FontNameRegistry)
CompareString (Foundry, FontNameFoundry)
CompareString (FamilyName, FontNameFamilyName)
CompareString (WeightName, FontNameWeightName)
CompareString (Slant, FontNameSlant)
CompareString (SetwidthName, FontNameSetwidthName)
CompareString (AddStyleName, FontNameAddStyleName)
CompareUnsigned (PixelSize, FontNamePixelSize)
CompareUnsigned (PointSize, FontNamePointSize)
CompareUnsigned (ResolutionX, FontNameResolutionX)
CompareUnsigned (ResolutionY, FontNameResolutionY)
CompareString (Spacing, FontNameSpacing)
CompareUnsigned (AverageWidth, FontNameAverageWidth)
CompareString (CharSetRegistry, FontNameCharSetRegistry)
CompareString (CharSetEncoding, FontNameCharSetEncoding)
return True;
}
XCopyFontName (name1, name2, fontNameAttributes)
XFontName *name1, *name2;
unsigned int fontNameAttributes;
{
#define CopyString(field,bit) \
if (fontNameAttributes & bit) \
strcpy (name2->field, name1->field);
#define CopyUnsigned(field,bit) \
if (fontNameAttributes & bit) \
name2->field = name1->field;
CopyString (Registry, FontNameRegistry)
CopyString (Foundry, FontNameFoundry)
CopyString (FamilyName, FontNameFamilyName)
CopyString (WeightName, FontNameWeightName)
CopyString (Slant, FontNameSlant)
CopyString (SetwidthName, FontNameSetwidthName)
CopyString (AddStyleName, FontNameAddStyleName)
CopyUnsigned (PixelSize, FontNamePixelSize)
CopyUnsigned (PointSize, FontNamePointSize)
CopyUnsigned (ResolutionX, FontNameResolutionX)
CopyUnsigned (ResolutionY, FontNameResolutionY)
CopyString (Spacing, FontNameSpacing)
CopyUnsigned (AverageWidth, FontNameAverageWidth)
CopyString (CharSetRegistry, FontNameCharSetRegistry)
CopyString (CharSetEncoding, FontNameCharSetEncoding)
return True;
}

45
gnu/usr.bin/groff/xditview/XFontName.h
View File

@ -1,45 +0,0 @@
typedef struct _xFontName {
char Registry[256];
char Foundry[256];
char FamilyName[256];
char WeightName[256];
char Slant[3];
char SetwidthName[256];
char AddStyleName[256];
unsigned int PixelSize;
unsigned int PointSize;
unsigned int ResolutionX;
unsigned int ResolutionY;
char Spacing[2];
unsigned int AverageWidth;
char CharSetRegistry[256];
char CharSetEncoding[256];
} XFontName;
#define FontNameRegistry (1<<0)
#define FontNameFoundry (1<<1)
#define FontNameFamilyName (1<<2)
#define FontNameWeightName (1<<3)
#define FontNameSlant (1<<4)
#define FontNameSetwidthName (1<<5)
#define FontNameAddStyleName (1<<6)
#define FontNamePixelSize (1<<7)
#define FontNamePointSize (1<<8)
#define FontNameResolutionX (1<<9)
#define FontNameResolutionY (1<<10)
#define FontNameSpacing (1<<11)
#define FontNameAverageWidth (1<<12)
#define FontNameCharSetRegistry (1<<13)
#define FontNameCharSetEncoding (1<<14)
#define SlantRoman "R"
#define SlantItalic "I"
#define SlantOblique "O"
#define SlantReverseItalic "RI"
#define SlantReverseOblique "RO"
#define SpacingMonoSpaced "M"
#define SpacingProportional "P"
#define SpacingCharacterCell "C"
typedef char XFontNameString[256];

589
gnu/usr.bin/groff/xditview/device.c
View File

@ -1,589 +0,0 @@
/* device.c */
#include <stdio.h>
#include <ctype.h>
#include <X11/Xos.h>
#include <X11/Intrinsic.h>
#include "device.h"
#ifndef FONTPATH
#define FONTPATH "/usr/local/lib/groff/font:/usr/local/lib/font:/usr/lib/font"
#endif
#ifndef isascii
#define isascii(c) (1)
#endif
extern void exit();
extern char *strtok(), *strchr();
extern char *getenv();
/* Name of environment variable containing path to be used for
searching for device and font description files. */
#define FONTPATH_ENV_VAR "GROFF_FONT_PATH"
#define WS " \t\r\n"
/* Minimum and maximum values a `signed int' can hold. */
#ifndef INT_MIN
#define INT_MIN (-INT_MAX-1)
#endif
#ifndef INT_MAX
#define INT_MAX 2147483647
#endif
#define CHAR_TABLE_SIZE 307
struct _DeviceFont {
char *name;
int special;
DeviceFont *next;
Device *dev;
struct charinfo *char_table[CHAR_TABLE_SIZE];
struct charinfo *code_table[256];
};
struct charinfo {
int width;
int code;
struct charinfo *next;
struct charinfo *code_next;
char name[1];
};
static char *current_filename = 0;
static int current_lineno = -1;
static void error();
static FILE *open_device_file();
static DeviceFont *load_font();
static Device *new_device();
static DeviceFont *new_font();
static void delete_font();
static unsigned hash_name();
static struct charinfo *add_char();
static int read_charset_section();
static char *canonicalize_name();
static
Device *new_device(name)
char *name;
{
Device *dev;
dev = XtNew(Device);
dev->sizescale = 1;
dev->res = 0;
dev->unitwidth = 0;
dev->fonts = 0;
dev->X11 = 0;
dev->paperlength = 0;
dev->paperwidth = 0;
dev->name = XtNewString(name);
return dev;
}
void device_destroy(dev)
Device *dev;
{
DeviceFont *f;
if (!dev)
return;
f = dev->fonts;
while (f) {
DeviceFont *tem = f;
f = f->next;
delete_font(tem);
}
XtFree(dev->name);
XtFree((char *)dev);
}
Device *device_load(name)
char *name;
{
Device *dev;
FILE *fp;
int err = 0;
char buf[256];
fp = open_device_file(name, "DESC", &current_filename);
if (!fp)
return 0;
dev = new_device(name);
current_lineno = 0;
while (fgets(buf, sizeof(buf), fp)) {
char *p;
current_lineno++;
p = strtok(buf, WS);
if (p) {
int *np = 0;
char *q;
if (strcmp(p, "charset") == 0)
break;
if (strcmp(p, "X11") == 0)
dev->X11 = 1;
else if (strcmp(p, "sizescale") == 0)
np = &dev->sizescale;
else if (strcmp(p, "res") == 0)
np = &dev->res;
else if (strcmp(p, "unitwidth") == 0)
np = &dev->unitwidth;
else if (strcmp(p, "paperwidth") == 0)
np = &dev->paperwidth;
else if (strcmp(p, "paperlength") == 0)
np = &dev->paperlength;
if (np) {
q = strtok((char *)0, WS);
if (!q || sscanf(q, "%d", np) != 1 || *np <= 0) {
error("bad argument");
err = 1;
break;
}
}
}
}
fclose(fp);
current_lineno = -1;
if (!err) {
if (dev->res == 0) {
error("missing res line");
err = 1;
}
else if (dev->unitwidth == 0) {
error("missing unitwidth line");
err = 1;
}
}
if (dev->paperlength == 0)
dev->paperlength = dev->res*11;
if (dev->paperwidth == 0)
dev->paperwidth = dev->res*8 + dev->res/2;
if (err) {
device_destroy(dev);
dev = 0;
}
XtFree(current_filename);
current_filename = 0;
return dev;
}
DeviceFont *device_find_font(dev, name)
Device *dev;
char *name;
{
DeviceFont *f;
if (!dev)
return 0;
for (f = dev->fonts; f; f = f->next)
if (strcmp(f->name, name) == 0)
return f;
return load_font(dev, name);
}
static
DeviceFont *load_font(dev, name)
Device *dev;
char *name;
{
FILE *fp;
char buf[256];
DeviceFont *f;
int special = 0;
fp = open_device_file(dev->name, name, &current_filename);
if (!fp)
return 0;
current_lineno = 0;
for (;;) {
char *p;
if (!fgets(buf, sizeof(buf), fp)) {
error("no charset line");
return 0;
}
current_lineno++;
p = strtok(buf, WS);
/* charset must be on a line by itself */
if (p && strcmp(p, "charset") == 0 && strtok((char *)0, WS) == 0)
break;
if (p && strcmp(p, "special") == 0)
special = 1;
}
f = new_font(name, dev);
f->special = special;
if (!read_charset_section(f, fp)) {
delete_font(f);
f = 0;
}
else {
f->next = dev->fonts;
dev->fonts = f;
}
fclose(fp);
XtFree(current_filename);
current_filename = 0;
return f;
}
static
DeviceFont *new_font(name, dev)
char *name;
Device *dev;
{
int i;
DeviceFont *f;
f = XtNew(DeviceFont);
f->name = XtNewString(name);
f->dev = dev;
f->special = 0;
f->next = 0;
for (i = 0; i < CHAR_TABLE_SIZE; i++)
f->char_table[i] = 0;
for (i = 0; i < 256; i++)
f->code_table[i] = 0;
return f;
}
static
void delete_font(f)
DeviceFont *f;
{
int i;
if (!f)
return;
XtFree(f->name);
for (i = 0; i < CHAR_TABLE_SIZE; i++) {
struct charinfo *ptr = f->char_table[i];
while (ptr) {
struct charinfo *tem = ptr;
ptr = ptr->next;
XtFree((char *)tem);
}
}
XtFree((char *)f);
}
static
unsigned hash_name(name)
char *name;
{
unsigned n = 0;
/* XXX do better than this */
while (*name)
n = (n << 1) ^ *name++;
return n;
}
static
int scale_round(n, x, y)
int n, x, y;
{
int y2;
if (x == 0)
return 0;
y2 = y/2;
if (n >= 0) {
if (n <= (INT_MAX - y2)/x)
return (n*x + y2)/y;
}
else if (-(unsigned)n <= (-(unsigned)INT_MIN - y2)/x)
return (n*x - y2)/y;
return (int)(n*(double)x/(double)y + .5);
}
static
char *canonicalize_name(s)
char *s;
{
static char ch[2];
if (s[0] == 'c' && s[1] == 'h' && s[2] == 'a' && s[3] == 'r') {
char *p;
int n;
for (p = s + 4; *p; p++)
if (!isascii(*p) || !isdigit((unsigned char)*p))
return s;
n = atoi(s + 4);
if (n >= 0 && n <= 0xff) {
ch[0] = (char)n;
return ch;
}
}
return s;
}
/* Return 1 if the character is present in the font; widthp gets the
width if non-null. */
int device_char_width(f, ps, name, widthp)
DeviceFont *f;
int ps;
char *name;
int *widthp;
{
struct charinfo *p;
name = canonicalize_name(name);
for (p = f->char_table[hash_name(name) % CHAR_TABLE_SIZE];; p = p->next) {
if (!p)
return 0;
if (strcmp(p->name, name) == 0)
break;
}
*widthp = scale_round(p->width, ps, f->dev->unitwidth);
return 1;
}
int device_code_width(f, ps, code, widthp)
DeviceFont *f;
int ps;
int code;
int *widthp;
{
struct charinfo *p;
for (p = f->code_table[code & 0xff];; p = p->code_next) {
if (!p)
return 0;
if (p->code == code)
break;
}
*widthp = scale_round(p->width, ps, f->dev->unitwidth);
return 1;
}
char *device_name_for_code(f, code)
DeviceFont *f;
int code;
{
static struct charinfo *state = 0;
if (f)
state = f->code_table[code & 0xff];
for (; state; state = state->code_next)
if (state->code == code && state->name[0] != '\0') {
char *name = state->name;
state = state->code_next;
return name;
}
return 0;
}
int device_font_special(f)
DeviceFont *f;
{
return f->special;
}
static
struct charinfo *add_char(f, name, width, code)
DeviceFont *f;
char *name;
int width, code;
{
struct charinfo **pp;
struct charinfo *ci;
name = canonicalize_name(name);
if (strcmp(name, "---") == 0)
name = "";
ci = (struct charinfo *)XtMalloc(XtOffsetOf(struct charinfo, name[0])
+ strlen(name) + 1);
strcpy(ci->name, name);
ci->width = width;
ci->code = code;
if (*name != '\0') {
pp = &f->char_table[hash_name(name) % CHAR_TABLE_SIZE];
ci->next = *pp;
*pp = ci;
}
pp = &f->code_table[code & 0xff];
ci->code_next = *pp;
*pp = ci;
return ci;
}
/* Return non-zero for success. */
static
int read_charset_section(f, fp)
DeviceFont *f;
FILE *fp;
{
struct charinfo *last_charinfo = 0;
char buf[256];
while (fgets(buf, sizeof(buf), fp)) {
char *name;
int width;
int code;
char *p;
current_lineno++;
name = strtok(buf, WS);
if (!name)
continue; /* ignore blank lines */
p = strtok((char *)0, WS);
if (!p) /* end of charset section */
break;
if (strcmp(p, "\"") == 0) {
if (!last_charinfo) {
error("first line of charset section cannot use `\"'");
return 0;
}
else
(void)add_char(f, name,
last_charinfo->width, last_charinfo->code);
}
else {
char *q;
if (sscanf(p, "%d", &width) != 1) {
error("bad width field");
return 0;
}
p = strtok((char *)0, WS);
if (!p) {
error("missing type field");
return 0;
}
p = strtok((char *)0, WS);
if (!p) {
error("missing code field");
return 0;
}
code = (int)strtol(p, &q, 0);
if (q == p) {
error("bad code field");
return 0;
}
last_charinfo = add_char(f, name, width, code);
}
}
return 1;
}
static
FILE *find_file(file, path, result)
char *file, *path, **result;
{
char *buf = NULL;
int bufsiz = 0;
int flen;
FILE *fp;
*result = NULL;
if (file == NULL)
return NULL;
if (*file == '\0')
return NULL;
if (*file == '/') {
fp = fopen(file, "r");
if (fp)
*result = XtNewString(file);
return fp;
}
flen = strlen(file);
if (!path)
return NULL;
while (*path) {
int len;
char *start, *end;
start = path;
end = strchr(path, ':');
if (end)
path = end + 1;
else
path = end = strchr(path, '\0');
if (start >= end)
continue;
if (end[-1] == '/')
--end;
len = (end - start) + 1 + flen + 1;
if (len > bufsiz) {
if (buf)
buf = XtRealloc(buf, len);
else
buf = XtMalloc(len);
bufsiz = len;
}
memcpy(buf, start, end - start);
buf[end - start] = '/';
strcpy(buf + (end - start) + 1, file);
fp = fopen(buf, "r");
if (fp) {
*result = buf;
return fp;
}
}
XtFree(buf);
return NULL;
}
static
FILE *open_device_file(device_name, file_name, result)
char *device_name, *file_name, **result;
{
char *buf, *path;
FILE *fp;
buf = XtMalloc(3 + strlen(device_name) + 1 + strlen(file_name) + 1);
sprintf(buf, "dev%s/%s", device_name, file_name);
path = getenv(FONTPATH_ENV_VAR);
if (!path)
path = FONTPATH;
fp = find_file(buf, path, result);
if (!fp) {
fprintf(stderr, "can't find device file `%s'\n", file_name);
fflush(stderr);
}
XtFree(buf);
return fp;
}
static
void error(s)
char *s;
{
if (current_filename) {
fprintf(stderr, "%s:", current_filename);
if (current_lineno > 0)
fprintf(stderr, "%d:", current_lineno);
putc(' ', stderr);
}
fputs(s, stderr);
putc('\n', stderr);
fflush(stderr);
}
/*
Local Variables:
c-indent-level: 4
c-continued-statement-offset: 4
c-brace-offset: -4
c-argdecl-indent: 4
c-label-offset: -4
c-tab-always-indent: nil
End:
*/

21
gnu/usr.bin/groff/xditview/device.h
View File

@ -1,21 +0,0 @@
typedef struct _DeviceFont DeviceFont;
typedef struct _Device {
char *name;
int sizescale;
int res;
int unitwidth;
int paperlength;
int paperwidth;
int X11;
DeviceFont *fonts;
} Device;
extern void device_destroy();
extern Device *device_load();
extern DeviceFont *device_find_font();
extern int device_char_width();
extern char *device_name_for_code();
extern int device_code_width();
extern int device_font_special();

721
gnu/usr.bin/groff/xditview/draw.c
View File

@ -1,721 +0,0 @@
/*
* draw.c
*
* accept dvi function calls and translate to X
*/
#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
/* math.h on a Sequent doesn't define M_PI, apparently */
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#include "DviP.h"
#define DeviceToX(dw, n) ((int)((n) * (dw)->dvi.scale_factor + .5))
#define XPos(dw) (DeviceToX((dw), (dw)->dvi.state->x - \
(dw)->dvi.text_device_width) + (dw)->dvi.text_x_width)
#define YPos(dw) (DeviceToX((dw), (dw)->dvi.state->y))
static int FakeCharacter();
HorizontalMove(dw, delta)
DviWidget dw;
int delta;
{
dw->dvi.state->x += delta;
}
HorizontalGoto(dw, NewPosition)
DviWidget dw;
int NewPosition;
{
dw->dvi.state->x = NewPosition;
}
VerticalMove(dw, delta)
DviWidget dw;
int delta;
{
dw->dvi.state->y += delta;
}
VerticalGoto(dw, NewPosition)
DviWidget dw;
int NewPosition;
{
dw->dvi.state->y = NewPosition;
}
AdjustCacheDeltas (dw)
DviWidget dw;
{
int extra;
int nadj;
int i;
nadj = 0;
extra = DeviceToX(dw, dw->dvi.text_device_width)
- dw->dvi.text_x_width;
if (extra == 0)
return;
for (i = 0; i <= dw->dvi.cache.index; i++)
if (dw->dvi.cache.adjustable[i])
++nadj;
if (nadj == 0)
return;
dw->dvi.text_x_width += extra;
for (i = 0; i <= dw->dvi.cache.index; i++)
if (dw->dvi.cache.adjustable[i]) {
int x;
int *deltap;
x = extra/nadj;
deltap = &dw->dvi.cache.cache[i].delta;
#define MIN_DELTA 2
if (*deltap > 0 && x + *deltap < MIN_DELTA) {
x = MIN_DELTA - *deltap;
if (x <= 0)
*deltap = MIN_DELTA;
else
x = 0;
}
else
*deltap += x;
extra -= x;
--nadj;
dw->dvi.cache.adjustable[i] = 0;
}
}
FlushCharCache (dw)
DviWidget dw;
{
if (dw->dvi.cache.char_index != 0) {
AdjustCacheDeltas (dw);
XDrawText (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
dw->dvi.cache.start_x, dw->dvi.cache.start_y,
dw->dvi.cache.cache, dw->dvi.cache.index + 1);
}
dw->dvi.cache.index = 0;
dw->dvi.cache.max = DVI_TEXT_CACHE_SIZE;
#if 0
if (dw->dvi.noPolyText)
dw->dvi.cache.max = 1;
#endif
dw->dvi.cache.char_index = 0;
dw->dvi.cache.cache[0].nchars = 0;
dw->dvi.cache.start_x = dw->dvi.cache.x = XPos (dw);
dw->dvi.cache.start_y = dw->dvi.cache.y = YPos (dw);
}
Newline (dw)
DviWidget dw;
{
FlushCharCache (dw);
dw->dvi.text_x_width = dw->dvi.text_device_width = 0;
dw->dvi.word_flag = 0;
}
Word (dw)
DviWidget dw;
{
dw->dvi.word_flag = 1;
}
#define charWidth(fi,c) (\
(fi)->per_char ?\
(fi)->per_char[(c) - (fi)->min_char_or_byte2].width\
:\
(fi)->max_bounds.width\
)
static
int charExists (fi, c)
XFontStruct *fi;
int c;
{
XCharStruct *p;
if (fi->per_char == NULL ||
c < fi->min_char_or_byte2 || c > fi->max_char_or_byte2)
return 0;
p = fi->per_char + (c - fi->min_char_or_byte2);
return (p->lbearing != 0 || p->rbearing != 0 || p->width != 0
|| p->ascent != 0 || p->descent != 0 || p->attributes != 0);
}
static
DoCharacter (dw, c, wid)
DviWidget dw;
int c;
int wid; /* width in device units */
{
register XFontStruct *font;
register XTextItem *text;
int x, y;
x = XPos(dw);
y = YPos(dw);
/*
* quick and dirty extents calculation:
*/
if (!(y + 24 >= dw->dvi.extents.y1
&& y - 24 <= dw->dvi.extents.y2
#if 0
&& x + 24 >= dw->dvi.extents.x1
&& x - 24 <= dw->dvi.extents.x2
#endif
))
return;
if (y != dw->dvi.cache.y
|| dw->dvi.cache.char_index >= DVI_CHAR_CACHE_SIZE) {
FlushCharCache (dw);
x = dw->dvi.cache.x;
}
/*
* load a new font, if the current block is not empty,
* step to the next.
*/
if (dw->dvi.cache.font_size != dw->dvi.state->font_size ||
dw->dvi.cache.font_number != dw->dvi.state->font_number)
{
dw->dvi.cache.font_size = dw->dvi.state->font_size;
dw->dvi.cache.font_number = dw->dvi.state->font_number;
dw->dvi.cache.font = QueryFont (dw,
dw->dvi.cache.font_number,
dw->dvi.cache.font_size);
if (dw->dvi.cache.cache[dw->dvi.cache.index].nchars != 0) {
++dw->dvi.cache.index;
if (dw->dvi.cache.index >= dw->dvi.cache.max)
FlushCharCache (dw);
dw->dvi.cache.cache[dw->dvi.cache.index].nchars = 0;
dw->dvi.cache.adjustable[dw->dvi.cache.index] = 0;
}
}
if (x != dw->dvi.cache.x || dw->dvi.word_flag) {
if (dw->dvi.cache.cache[dw->dvi.cache.index].nchars != 0) {
++dw->dvi.cache.index;
if (dw->dvi.cache.index >= dw->dvi.cache.max)
FlushCharCache (dw);
dw->dvi.cache.cache[dw->dvi.cache.index].nchars = 0;
}
dw->dvi.cache.adjustable[dw->dvi.cache.index]
= dw->dvi.word_flag;
dw->dvi.word_flag = 0;
}
font = dw->dvi.cache.font;
text = &dw->dvi.cache.cache[dw->dvi.cache.index];
if (text->nchars == 0) {
text->chars = &dw->dvi.cache.char_cache[dw->dvi.cache.char_index];
text->delta = x - dw->dvi.cache.x;
if (font != dw->dvi.font) {
text->font = font->fid;
dw->dvi.font = font;
} else
text->font = None;
dw->dvi.cache.x += text->delta;
}
if (charExists(font, c)) {
int w;
dw->dvi.cache.char_cache[dw->dvi.cache.char_index++] = (char) c;
++text->nchars;
w = charWidth(font, c);
dw->dvi.cache.x += w;
if (wid != 0) {
dw->dvi.text_x_width += w;
dw->dvi.text_device_width += wid;
}
}
}
static
int FindCharWidth (dw, buf, widp)
DviWidget dw;
char *buf;
int *widp;
{
int maxpos;
int i;
if (dw->dvi.device_font == 0
|| dw->dvi.state->font_number != dw->dvi.device_font_number) {
dw->dvi.device_font_number = dw->dvi.state->font_number;
dw->dvi.device_font
= QueryDeviceFont (dw, dw->dvi.device_font_number);
}
if (dw->dvi.device_font
&& device_char_width (dw->dvi.device_font,
dw->dvi.state->font_size, buf, widp))
return 1;
maxpos = MaxFontPosition (dw);
for (i = 1; i <= maxpos; i++) {
DeviceFont *f = QueryDeviceFont (dw, i);
if (f && device_font_special (f)
&& device_char_width (f, dw->dvi.state->font_size,
buf, widp)) {
dw->dvi.state->font_number = i;
return 1;
}
}
return 0;
}
/* Return the width of the character in device units. */
int PutCharacter (dw, buf)
DviWidget dw;
char *buf;
{
int prevFont;
int c = -1;
int wid = 0;
DviCharNameMap *map;
if (!dw->dvi.display_enable)
return 0; /* The width doesn't matter in this case. */
prevFont = dw->dvi.state->font_number;
if (!FindCharWidth (dw, buf, &wid))
return 0;
map = QueryFontMap (dw, dw->dvi.state->font_number);
if (map)
c = DviCharIndex (map, buf);
if (c >= 0)
DoCharacter (dw, c, wid);
else
(void) FakeCharacter (dw, buf, wid);
dw->dvi.state->font_number = prevFont;
return wid;
}
/* Return 1 if we can fake it; 0 otherwise. */
static
int FakeCharacter (dw, buf, wid)
DviWidget dw;
char *buf;
int wid;
{
int oldx, oldw;
char ch[2];
char *chars = 0;
if (buf[0] == '\0' || buf[1] == '\0' || buf[2] != '\0')
return 0;
#define pack2(c1, c2) (((c1) << 8) | (c2))
switch (pack2(buf[0], buf[1])) {
case pack2('f', 'i'):
chars = "fi";
break;
case pack2('f', 'l'):
chars = "fl";
break;
case pack2('f', 'f'):
chars = "ff";
break;
case pack2('F', 'i'):
chars = "ffi";
break;
case pack2('F', 'l'):
chars = "ffl";
break;
}
if (!chars)
return 0;
oldx = dw->dvi.state->x;
oldw = dw->dvi.text_device_width;
ch[1] = '\0';
for (; *chars; chars++) {
ch[0] = *chars;
dw->dvi.state->x += PutCharacter (dw, ch);
}
dw->dvi.state->x = oldx;
dw->dvi.text_device_width = oldw + wid;
return 1;
}
PutNumberedCharacter (dw, c)
DviWidget dw;
int c;
{
char *name;
int wid;
DviCharNameMap *map;
if (!dw->dvi.display_enable)
return;
if (dw->dvi.device_font == 0
|| dw->dvi.state->font_number != dw->dvi.device_font_number) {
dw->dvi.device_font_number = dw->dvi.state->font_number;
dw->dvi.device_font
= QueryDeviceFont (dw, dw->dvi.device_font_number);
}
if (dw->dvi.device_font == 0
|| !device_code_width (dw->dvi.device_font,
dw->dvi.state->font_size, c, &wid))
return;
if (dw->dvi.native) {
DoCharacter (dw, c, wid);
return;
}
map = QueryFontMap (dw, dw->dvi.state->font_number);
if (!map)
return;
for (name = device_name_for_code (dw->dvi.device_font, c);
name;
name = device_name_for_code ((DeviceFont *)0, c)) {
int code = DviCharIndex (map, name);
if (code >= 0) {
DoCharacter (dw, code, wid);
break;
}
if (FakeCharacter (dw, name, wid))
break;
}
}
ClearPage (dw)
DviWidget dw;
{
XClearWindow (XtDisplay (dw), XtWindow (dw));
}
static
setGC (dw)
DviWidget dw;
{
int desired_line_width;
if (dw->dvi.line_thickness < 0)
desired_line_width = (int)(((double)dw->dvi.device_resolution
* dw->dvi.state->font_size)
/ (10.0*72.0*dw->dvi.sizescale));
else
desired_line_width = dw->dvi.line_thickness;
if (desired_line_width != dw->dvi.line_width) {
XGCValues values;
values.line_width = DeviceToX(dw, desired_line_width);
if (values.line_width == 0)
values.line_width = 1;
XChangeGC(XtDisplay (dw), dw->dvi.normal_GC,
GCLineWidth, &values);
dw->dvi.line_width = desired_line_width;
}
}
static
setFillGC (dw)
DviWidget dw;
{
int fill_type;
if (dw->dvi.fill == DVI_FILL_MAX)
fill_type = DVI_FILL_BLACK;
else if (dw->dvi.fill == 0)
fill_type = DVI_FILL_WHITE;
else
fill_type = DVI_FILL_GRAY;
if (dw->dvi.fill_type != fill_type) {
XGCValues values;
switch (fill_type) {
case DVI_FILL_WHITE:
values.foreground = dw->dvi.background;
values.fill_style = FillSolid;
break;
case DVI_FILL_BLACK:
values.foreground = dw->dvi.foreground;
values.fill_style = FillSolid;
break;
case DVI_FILL_GRAY:
values.foreground = dw->dvi.foreground;
values.fill_style = FillOpaqueStippled;
break;
}
XChangeGC(XtDisplay (dw), dw->dvi.fill_GC,
GCFillStyle|GCForeground,
&values);
dw->dvi.fill_type = fill_type;
}
}
DrawLine (dw, x, y)
DviWidget dw;
int x, y;
{
int xp, yp;
AdjustCacheDeltas (dw);
setGC (dw);
xp = XPos (dw);
yp = YPos (dw);
XDrawLine (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
xp, yp,
xp + DeviceToX (dw, x), yp + DeviceToX (dw, y));
}
DrawCircle (dw, diam)
DviWidget dw;
int diam;
{
int d;
AdjustCacheDeltas (dw);
setGC (dw);
d = DeviceToX (dw, diam);
XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
XPos (dw), YPos (dw) - d/2,
d, d, 0, 64*360);
}
DrawFilledCircle (dw, diam)
DviWidget dw;
int diam;
{
int d;
AdjustCacheDeltas (dw);
setFillGC (dw);
d = DeviceToX (dw, diam);
XFillArc (XtDisplay (dw), XtWindow (dw), dw->dvi.fill_GC,
XPos (dw), YPos (dw) - d/2,
d, d, 0, 64*360);
}
DrawEllipse (dw, a, b)
DviWidget dw;
int a, b;
{
AdjustCacheDeltas (dw);
setGC (dw);
XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
XPos (dw), YPos (dw) - DeviceToX (dw, b/2),
DeviceToX (dw, a), DeviceToX (dw, b), 0, 64*360);
}
DrawFilledEllipse (dw, a, b)
DviWidget dw;
int a, b;
{
AdjustCacheDeltas (dw);
setFillGC (dw);
XFillArc (XtDisplay (dw), XtWindow (dw), dw->dvi.fill_GC,
XPos (dw), YPos (dw) - DeviceToX (dw, b/2),
DeviceToX (dw, a), DeviceToX (dw, b), 0, 64*360);
}
DrawArc (dw, x0, y0, x1, y1)
DviWidget dw;
int x0, y0, x1, y1;
{
int angle1, angle2;
int rad = (int)((sqrt ((double)x0*x0 + (double)y0*y0)
+ sqrt ((double)x1*x1 + (double)y1*y1) + 1.0)/2.0);
if ((x0 == 0 && y0 == 0) || (x1 == 0 && y1 == 0))
return;
angle1 = (int)(atan2 ((double)y0, (double)-x0)*180.0*64.0/M_PI);
angle2 = (int)(atan2 ((double)-y1, (double)x1)*180.0*64.0/M_PI);
angle2 -= angle1;
if (angle2 < 0)
angle2 += 64*360;
AdjustCacheDeltas (dw);
setGC (dw);
rad = DeviceToX (dw, rad);
XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
XPos (dw) + DeviceToX (dw, x0) - rad,
YPos (dw) + DeviceToX (dw, y0) - rad,
rad*2, rad*2, angle1, angle2);
}
DrawPolygon (dw, v, n)
DviWidget dw;
int *v;
int n;
{
XPoint *p;
int i;
int dx, dy;
n /= 2;
AdjustCacheDeltas (dw);
setGC (dw);
p = (XPoint *)XtMalloc((n + 2)*sizeof(XPoint));
p[0].x = XPos (dw);
p[0].y = YPos (dw);
dx = 0;
dy = 0;
for (i = 0; i < n; i++) {
dx += v[2*i];
p[i + 1].x = DeviceToX (dw, dx) + p[0].x;
dy += v[2*i + 1];
p[i + 1].y = DeviceToX (dw, dy) + p[0].y;
}
p[n+1].x = p[0].x;
p[n+1].y = p[0].y;
XDrawLines (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
p, n + 2, CoordModeOrigin);
XtFree((char *)p);
}
DrawFilledPolygon (dw, v, n)
DviWidget dw;
int *v;
int n;
{
XPoint *p;
int i;
int dx, dy;
n /= 2;
if (n < 2)
return;
AdjustCacheDeltas (dw);
setFillGC (dw);
p = (XPoint *)XtMalloc((n + 1)*sizeof(XPoint));
p[0].x = XPos (dw);
p[0].y = YPos (dw);
dx = 0;
dy = 0;
for (i = 0; i < n; i++) {
dx += v[2*i];
p[i + 1].x = DeviceToX (dw, dx) + p[0].x;
dy += v[2*i + 1];
p[i + 1].y = DeviceToX (dw, dy) + p[0].y;
}
XFillPolygon (XtDisplay (dw), XtWindow (dw), dw->dvi.fill_GC,
p, n + 1, Complex, CoordModeOrigin);
XtFree((char *)p);
}
#define POINTS_MAX 10000
static
appendPoint(points, pointi, x, y)
XPoint *points;
int *pointi;
int x, y;
{
if (*pointi < POINTS_MAX) {
points[*pointi].x = x;
points[*pointi].y = y;
*pointi += 1;
}
}
#define FLATNESS 1
static
flattenCurve(points, pointi, x2, y2, x3, y3, x4, y4)
XPoint *points;
int *pointi;
int x2, y2, x3, y3, x4, y4;
{
int x1, y1, dx, dy, n1, n2, n;
x1 = points[*pointi - 1].x;
y1 = points[*pointi - 1].y;
dx = x4 - x1;
dy = y4 - y1;
n1 = dy*(x2 - x1) - dx*(y2 - y1);
n2 = dy*(x3 - x1) - dx*(y3 - y1);
if (n1 < 0)
n1 = -n1;
if (n2 < 0)
n2 = -n2;
n = n1 > n2 ? n1 : n2;
if (n*n / (dy*dy + dx*dx) <= FLATNESS*FLATNESS)
appendPoint (points, pointi, x4, y4);
else {
flattenCurve (points, pointi,
(x1 + x2)/2, (y1 + y2)/2,
(x1 + x2*2 + x3)/4, (y1 + y2*2 + y3)/4,
(x1 +3*x2 + 3*x3 + x4)/8, (y1 +3*y2 + 3*y3 + y4)/8);
flattenCurve (points, pointi,
(x2 + x3*2 + x4)/4, (y2 + y3*2 + y4)/4,
(x3 + x4)/2, (y3 + y4)/2,
x4, y4);
}
}
DrawSpline (dw, v, n)
DviWidget dw;
int *v;
int n;
{
int sx, sy, tx, ty;
int ox, oy, dx, dy;
int i;
int pointi;
XPoint points[POINTS_MAX];
if (n == 0 || (n & 1) != 0)
return;
AdjustCacheDeltas (dw);
setGC (dw);
ox = XPos (dw);
oy = YPos (dw);
dx = v[0];
dy = v[1];
sx = ox;
sy = oy;
tx = sx + DeviceToX (dw, dx);
ty = sy + DeviceToX (dw, dy);
pointi = 0;
appendPoint (points, &pointi, sx, sy);
appendPoint (points, &pointi, (sx + tx)/2, (sy + ty)/2);
for (i = 2; i < n; i += 2) {
int ux = ox + DeviceToX (dw, dx += v[i]);
int uy = oy + DeviceToX (dw, dy += v[i+1]);
flattenCurve (points, &pointi,
(sx + tx*5)/6, (sy + ty*5)/6,
(tx*5 + ux)/6, (ty*5 + uy)/6,
(tx + ux)/2, (ty + uy)/2);
sx = tx;
sy = ty;
tx = ux;
ty = uy;
}
appendPoint (points, &pointi, tx, ty);
XDrawLines (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
points, pointi, CoordModeOrigin);
}
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/

471
gnu/usr.bin/groff/xditview/font.c
View File

@ -1,471 +0,0 @@
/*
* font.c
*
* map dvi fonts to X fonts
*/
#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <ctype.h>
#include "DviP.h"
#include "XFontName.h"
static DisposeFontSizes();
static char *
savestr (s)
char *s;
{
char *n;
if (!s)
return 0;
n = XtMalloc (strlen (s) + 1);
if (n)
strcpy (n, s);
return n;
}
static DviFontList *
LookupFontByPosition (dw, position)
DviWidget dw;
int position;
{
DviFontList *f;
for (f = dw->dvi.fonts; f; f = f->next)
if (f->dvi_number == position)
break;
return f;
}
int
MaxFontPosition (dw)
DviWidget dw;
{
DviFontList *f;
int n = -1;
for (f = dw->dvi.fonts; f; f = f->next)
if (f->dvi_number > n)
n = f->dvi_number;
return n;
}
static DviFontSizeList *
LookupFontSizeBySize (dw, f, size)
DviWidget dw;
DviFontList *f;
int size;
{
DviFontSizeList *fs, *best = 0, *smallest = 0;
int bestsize = 0;
XFontName fontName;
unsigned int fontNameAttributes;
char fontNameString[2048];
int decipointsize;
if (f->scalable) {
decipointsize = (10*size)/dw->dvi.sizescale;
for (best = f->sizes; best; best = best->next)
if (best->size == decipointsize)
return best;
best = (DviFontSizeList *) XtMalloc(sizeof *best);
best->next = f->sizes;
best->size = decipointsize;
f->sizes = best;
XParseFontName (f->x_name, &fontName, &fontNameAttributes);
fontNameAttributes &= ~(FontNamePixelSize|FontNameAverageWidth);
fontNameAttributes |= FontNameResolutionX;
fontNameAttributes |= FontNameResolutionY;
fontNameAttributes |= FontNamePointSize;
fontName.ResolutionX = dw->dvi.display_resolution;
fontName.ResolutionY = dw->dvi.display_resolution;
fontName.PointSize = decipointsize;
XFormatFontName (&fontName, fontNameAttributes, fontNameString);
best->x_name = savestr (fontNameString);
best->doesnt_exist = 0;
best->font = 0;
return best;
}
for (fs = f->sizes; fs; fs=fs->next) {
if (dw->dvi.sizescale*fs->size <= 10*size
&& fs->size >= bestsize) {
best = fs;
bestsize = fs->size;
}
if (smallest == 0 || fs->size < smallest->size)
smallest = fs;
}
return best ? best : smallest;
}
static char *
SkipFontNameElement (n)
char *n;
{
while (*n != '-')
if (!*++n)
return 0;
return n+1;
}
# define SizePosition 8
# define EncodingPosition 13
static
ConvertFontNameToSize (n)
char *n;
{
int i, size;
for (i = 0; i < SizePosition; i++) {
n = SkipFontNameElement (n);
if (!n)
return -1;
}
size = atoi (n);
return size;
}
static char *
ConvertFontNameToEncoding (n)
char *n;
{
int i;
for (i = 0; i < EncodingPosition; i++) {
n = SkipFontNameElement (n);
if (!n)
return 0;
}
return n;
}
DviFontSizeList *
InstallFontSizes (dw, x_name, scalablep)
DviWidget dw;
char *x_name;
Boolean *scalablep;
{
char fontNameString[2048];
char **fonts;
int i, count;
int size;
DviFontSizeList *sizes, *new;
XFontName fontName;
unsigned int fontNameAttributes;
*scalablep = FALSE;
if (!XParseFontName (x_name, &fontName, &fontNameAttributes))
return 0;
fontNameAttributes &= ~(FontNamePixelSize|FontNamePointSize
|FontNameAverageWidth);
fontNameAttributes |= FontNameResolutionX;
fontNameAttributes |= FontNameResolutionY;
fontName.ResolutionX = dw->dvi.display_resolution;
fontName.ResolutionY = dw->dvi.display_resolution;
XFormatFontName (&fontName, fontNameAttributes, fontNameString);
fonts = XListFonts (XtDisplay (dw), fontNameString, 10000000, &count);
sizes = 0;
for (i = 0; i < count; i++) {
size = ConvertFontNameToSize (fonts[i]);
if (size == 0) {
DisposeFontSizes (dw, sizes);
sizes = 0;
*scalablep = TRUE;
break;
}
if (size != -1) {
new = (DviFontSizeList *) XtMalloc (sizeof *new);
new->next = sizes;
new->size = size;
new->x_name = savestr (fonts[i]);
new->doesnt_exist = 0;
new->font = 0;
sizes = new;
}
}
XFreeFontNames (fonts);
return sizes;
}
static
DisposeFontSizes (dw, fs)
DviWidget dw;
DviFontSizeList *fs;
{
DviFontSizeList *next;
for (; fs; fs=next) {
next = fs->next;
if (fs->x_name)
XtFree (fs->x_name);
if (fs->font) {
XUnloadFont (XtDisplay (dw), fs->font->fid);
XFree ((char *)fs->font);
}
XtFree ((char *) fs);
}
}
static DviFontList *
InstallFont (dw, position, dvi_name, x_name)
DviWidget dw;
int position;
char *dvi_name;
char *x_name;
{
DviFontList *f;
char *encoding;
if ((f = LookupFontByPosition (dw, position)) != NULL) {
/*
* ignore gratuitous font loading
*/
if (!strcmp (f->dvi_name, dvi_name) &&
!strcmp (f->x_name, x_name))
return f;
DisposeFontSizes (dw, f->sizes);
if (f->dvi_name)
XtFree (f->dvi_name);
if (f->x_name)
XtFree (f->x_name);
f->device_font = 0;
} else {
f = (DviFontList *) XtMalloc (sizeof (*f));
f->next = dw->dvi.fonts;
dw->dvi.fonts = f;
}
f->initialized = FALSE;
f->dvi_name = savestr (dvi_name);
f->device_font = device_find_font (dw->dvi.device, dvi_name);
f->x_name = savestr (x_name);
f->dvi_number = position;
f->sizes = 0;
f->scalable = FALSE;
if (f->x_name) {
encoding = ConvertFontNameToEncoding (f->x_name);
f->char_map = DviFindMap (encoding);
} else
f->char_map = 0;
/*
* force requery of fonts
*/
dw->dvi.font = 0;
dw->dvi.font_number = -1;
dw->dvi.cache.font = 0;
dw->dvi.cache.font_number = -1;
dw->dvi.device_font = 0;
dw->dvi.device_font_number = -1;
return f;
}
ForgetFonts (dw)
DviWidget dw;
{
DviFontList *f = dw->dvi.fonts;
while (f) {
DviFontList *tem = f;
if (f->sizes)
DisposeFontSizes (dw, f->sizes);
if (f->dvi_name)
XtFree (f->dvi_name);
if (f->x_name)
XtFree (f->x_name);
f = f->next;
XtFree ((char *) tem);
}
/*
* force requery of fonts
*/
dw->dvi.font = 0;
dw->dvi.font_number = -1;
dw->dvi.cache.font = 0;
dw->dvi.cache.font_number = -1;
dw->dvi.device_font = 0;
dw->dvi.device_font_number = -1;
dw->dvi.fonts = 0;
}
static char *
MapDviNameToXName (dw, dvi_name)
DviWidget dw;
char *dvi_name;
{
DviFontMap *fm;
for (fm = dw->dvi.font_map; fm; fm=fm->next)
if (!strcmp (fm->dvi_name, dvi_name))
return fm->x_name;
return 0;
}
#if 0
static char *
MapXNameToDviName (dw, x_name)
DviWidget dw;
char *x_name;
{
DviFontMap *fm;
for (fm = dw->dvi.font_map; fm; fm=fm->next)
if (!strcmp (fm->x_name, x_name))
return fm->dvi_name;
return 0;
}
#endif
ParseFontMap (dw)
DviWidget dw;
{
char dvi_name[1024];
char x_name[2048];
char *m, *s;
DviFontMap *fm, *new;
if (dw->dvi.font_map)
DestroyFontMap (dw->dvi.font_map);
fm = 0;
m = dw->dvi.font_map_string;
while (*m) {
s = m;
while (*m && !isspace (*m))
++m;
strncpy (dvi_name, s, m-s);
dvi_name[m-s] = '\0';
while (isspace (*m))
++m;
s = m;
while (*m && *m != '\n')
++m;
strncpy (x_name, s, m-s);
x_name[m-s] = '\0';
new = (DviFontMap *) XtMalloc (sizeof *new);
new->x_name = savestr (x_name);
new->dvi_name = savestr (dvi_name);
new->next = fm;
fm = new;
++m;
}
dw->dvi.font_map = fm;
}
DestroyFontMap (font_map)
DviFontMap *font_map;
{
DviFontMap *next;
for (; font_map; font_map = next) {
next = font_map->next;
if (font_map->x_name)
XtFree (font_map->x_name);
if (font_map->dvi_name)
XtFree (font_map->dvi_name);
XtFree ((char *) font_map);
}
}
/* ARGSUSED */
SetFontPosition (dw, position, dvi_name, extra)
DviWidget dw;
int position;
char *dvi_name;
char *extra; /* unused */
{
char *x_name;
x_name = MapDviNameToXName (dw, dvi_name);
if (x_name)
(void) InstallFont (dw, position, dvi_name, x_name);
}
XFontStruct *
QueryFont (dw, position, size)
DviWidget dw;
int position;
int size;
{
DviFontList *f;
DviFontSizeList *fs;
f = LookupFontByPosition (dw, position);
if (!f)
return dw->dvi.default_font;
if (!f->initialized) {
f->sizes = InstallFontSizes (dw, f->x_name, &f->scalable);
f->initialized = TRUE;
}
fs = LookupFontSizeBySize (dw, f, size);
if (!fs)
return dw->dvi.default_font;
if (!fs->font) {
if (fs->x_name)
fs->font = XLoadQueryFont (XtDisplay (dw), fs->x_name);
if (!fs->font)
fs->font = dw->dvi.default_font;
}
return fs->font;
}
DeviceFont *
QueryDeviceFont (dw, position)
DviWidget dw;
int position;
{
DviFontList *f;
f = LookupFontByPosition (dw, position);
if (!f)
return 0;
return f->device_font;
}
DviCharNameMap *
QueryFontMap (dw, position)
DviWidget dw;
int position;
{
DviFontList *f;
f = LookupFontByPosition (dw, position);
if (f)
return f->char_map;
else
return 0;
}
#if 0
LoadFont (dw, position, size)
DviWidget dw;
int position;
int size;
{
XFontStruct *font;
font = QueryFont (dw, position, size);
dw->dvi.font_number = position;
dw->dvi.font_size = size;
dw->dvi.font = font;
XSetFont (XtDisplay (dw), dw->dvi.normal_GC, font->fid);
return;
}
#endif
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/

246
gnu/usr.bin/groff/xditview/gxditview.man
View File

@ -1,246 +0,0 @@
.\" -*- nroff -*-
.TH GXDITVIEW 1 "Release 5" "X Version 11"
.SH NAME
gxditview \- display gtroff output files
.SH SYNOPSIS
.B gxditview
.RI [\fB\- toolkitoption\ .\|.\|.\|]
.RI [\fB\- option\ .\|.\|.\|]
.RI [ filename ]
.SH DESCRIPTION
The
.I gxditview
program displays gtroff output on an X display.
It uses the standard X11 fonts,
so it does not require access to the server machine for font loading.
.PP
If
.I filename
is
.BR \- ,
.I gxditview
will read the standard input.
.PP
The left mouse button brings up a menu with the following entries:
.TP 8
.B "Next Page"
Display the next page.
.TP
.B "Previous Page"
Display the previous page.
.TP
.B "Select Page"
Select a particular numbered page specified by a dialog box.
.TP
.B Print
Print the gtroff output using a command specified by a dialog box.
The default command initially displayed is controlled by the
.B printCommand
application resource, and by the
.B \-printCommand
option.
.TP
.B Open
Open for display a new file specified by a dialog box.
The file should contain gtroff output.
If the filename starts with
.B |
it will be taken to be a command to read from.
.TP
.B Quit
Exit from
.IR gxditview .
.PP
The
.BR n ,
Space
and Return keys are bound to the
.B Next\ Page
action.
The
.BR p ,
BackSpace
and
Delete
keys are bound to the
.B Previous\ Page
action.
The
.B q
key is bound to the
.B Quit
action.
The
.B r
key is bound to the
.B Rerasterize
action which rereads the current file, and redisplays the current page;
if the current file is a command, the command will be reexecuted.
.PP
The
.B paperlength
and
.B paperwidth
commands in the DESC file specify the length and width in machine units
of the virtual page displayed by
.IR gxditview .
.SH OPTIONS
.I Gxditview
accepts all of the standard X Toolkit command line options along with the
additional options listed below:
.TP 8
.B \-help
This option indicates that a brief summary of the allowed options should be
printed.
.TP
.B \-page
This option specifies the page number of the document to be displayed.
.TP
.BI \-backingStore\ backing-store-type
Redisplay of the gtroff output window can take upto a second or so,
this option causes the server to save the window contents so that when
it is scrolled around the viewport, the window is painted from
contents saved in backing store.
.I backing-store-type
can be one of
.BR Always ,
.B WhenMapped
or
.BR NotUseful .
.TP
.BI \-printCommand\ command
The default command displayed in the dialog box for the
.B Print
menu entry will be
.IR command .
.TP
.BI \-resolution\ res
The gtroff output file will be displayed at a resolution of
.I res
dpi,
unless the DESC file contains the
.B X11
command, in which case the device resolution will be used.
This corresponds the
.I Dvi
widget's
.B resolution
resource.
The default is 75.
.TP
.BI \-filename\ string
The default filename displayed in the dialog box for the
.B Open
menu entry will be
.IR string .
This can be either a filename, or a command starting with
.BR | .
.PP
The following standard X Toolkit command line arguments are commonly used with
.IR gxditview :
.TP 8
.BI \-bg\ color
This option specifies the color to use for the background of the window.
The default is \fIwhite\fP.
.TP
.BI \-bd\ color
This option specifies the color to use for the border of the window.
The default is \fIblack\fP.
.TP
.BI \-bw\ number
This option specifies the width in pixels of the border surrounding the window.
.TP
.BI \-fg\ color
This option specifies the color to use for displaying text. The default is
\fIblack\fP.
.TP
.BI \-fn\ font
This option specifies the font to be used for displaying widget text. The
default is \fIfixed\fP.
.TP
.B \-rv
This option indicates that reverse video should be simulated by swapping
the foreground and background colors.
.TP
.BI \-geometry\ geometry
This option specifies the preferred size and position of the window.
.TP
.BI \-display\ host : display
This option specifies the X server to contact.
.TP
.BI \-xrm\ resourcestring
This option specifies a resource string to be used.
.SH X DEFAULTS
This program uses the
.I Dvi
widget in the X Toolkit. It understands all of the core resource names and
classes as well as:
.PP
.TP 8
.BR width\ (class\ Width )
Specifies the width of the window.
.TP
.BR height\ (class\ Height )
Specifies the height of the window.
.TP
.BR foreground\ (class\ Foreground )
Specifies the default foreground color.
.TP
.BR font\ (class\ Font )
Specifies the font to be used for error messages.
.TP
.BR fontMap\ (class\ FontMap )
Specifies the mapping from groff font names to X font names. This
must be a string containing a sequence of lines. Each line contains
two whitespace separated fields: first the groff font name, and
secondly the X font name. The default is
.nf
"\e
TR -adobe-times-medium-r-normal--*-100-*-*-*-*-iso8859-1\en\e
TI -adobe-times-medium-i-normal--*-100-*-*-*-*-iso8859-1\en\e
TB -adobe-times-bold-r-normal--*-100-*-*-*-*-iso8859-1\en\e
TBI -adobe-times-bold-i-normal--*-100-*-*-*-*-iso8859-1\en\e
CR -adobe-courier-medium-r-normal--*-100-*-*-*-*-iso8859-1\en\e
CI -adobe-courier-medium-o-normal--*-100-*-*-*-*-iso8859-1\en\e
CB -adobe-courier-bold-r-normal--*-100-*-*-*-*-iso8859-1\en\e
CBI -adobe-courier-bold-o-normal--*-100-*-*-*-*-iso8859-1\en\e
HR -adobe-helvetica-medium-r-normal--*-100-*-*-*-*-iso8859-1\en\e
HI -adobe-helvetica-medium-o-normal--*-100-*-*-*-*-iso8859-1\en\e
HB -adobe-helvetica-bold-r-normal--*-100-*-*-*-*-iso8859-1\en\e
HBI -adobe-helvetica-bold-o-normal--*-100-*-*-*-*-iso8859-1\en\e
NR -adobe-new century schoolbook-medium-r-normal--*-100-*-*-*-*-iso8859-1\en\e
NI -adobe-new century schoolbook-medium-i-normal--*-100-*-*-*-*-iso8859-1\en\e
NB -adobe-new century schoolbook-bold-r-normal--*-100-*-*-*-*-iso8859-1\en\e
NBI -adobe-new century schoolbook-bold-i-normal--*-100-*-*-*-*-iso8859-1\en\e
S -adobe-symbol-medium-r-normal--*-100-*-*-*-*-adobe-fontspecific\en\e
SS -adobe-symbol-medium-r-normal--*-100-*-*-*-*-adobe-fontspecific\en\e
"
.fi
.SH "SEE ALSO"
.IR X (1),
.IR xrdb (1),
.IR gtroff (1),
.IR groff (1)
.SH ORIGIN
This program is derived from xditview;
portions of xditview originated in xtroff which was derived
from suntroff.
.SH COPYRIGHT
Copyright 1989, Massachusetts Institute of Technology.
.br
See
.IR X (1)
for a full statement of rights and permissions.
.SH AUTHORS
Keith Packard (MIT X Consortium)
.br
Richard L. Hyde (Purdue)
.br
David Slattengren (Berkeley)
.br
Malcolm Slaney (Schlumberger Palo Alto Research)
.br
Mark Moraes (University of Toronto)
.br
James Clark

103
gnu/usr.bin/groff/xditview/lex.c
View File

@ -1,103 +0,0 @@
#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include "DviP.h"
DviGetAndPut(dw, cp)
DviWidget dw;
int *cp;
{
if (dw->dvi.ungot) {
dw->dvi.ungot = 0;
*cp = getc (dw->dvi.file);
}
else {
*cp = getc (dw->dvi.file);
if (*cp != EOF)
putc (*cp, dw->dvi.tmpFile);
}
return *cp;
}
char *
GetLine(dw, Buffer, Length)
DviWidget dw;
char *Buffer;
int Length;
{
int i = 0, c;
Length--; /* Save room for final '\0' */
while (DviGetC (dw, &c) != EOF) {
if (Buffer && i < Length)
Buffer[i++] = c;
if (c == '\n') {
DviUngetC(dw, c);
break;
}
}
if (Buffer)
Buffer[i] = '\0';
return Buffer;
}
char *
GetWord(dw, Buffer, Length)
DviWidget dw;
char *Buffer;
int Length;
{
int i = 0, c;
Length--; /* Save room for final '\0' */
while (DviGetC(dw, &c) == ' ' || c == '\n')
;
while (c != EOF) {
if (Buffer && i < Length)
Buffer[i++] = c;
if (DviGetC(dw, &c) == ' ' || c == '\n') {
DviUngetC(dw, c);
break;
}
}
if (Buffer)
Buffer[i] = '\0';
return Buffer;
}
GetNumber(dw)
DviWidget dw;
{
int i = 0, c;
int negative = 0;
while (DviGetC(dw, &c) == ' ' || c == '\n')
;
if (c == '-') {
negative = 1;
DviGetC(dw, &c);
}
for (; c >= '0' && c <= '9'; DviGetC(dw, &c)) {
if (negative)
i = i*10 - (c - '0');
else
i = i*10 + c - '0';
}
if (c != EOF)
DviUngetC(dw, c);
return i;
}
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/

88
gnu/usr.bin/groff/xditview/page.c
View File

@ -1,88 +0,0 @@
/*
* page.c
*
* map page numbers to file position
*/
#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <ctype.h>
#include "DviP.h"
#ifdef X_NOT_STDC_ENV
extern long ftell();
#endif
static DviFileMap *
MapPageNumberToFileMap (dw, number)
DviWidget dw;
int number;
{
DviFileMap *m;
for (m = dw->dvi.file_map; m; m=m->next)
if (m->page_number == number)
break;
return m;
}
DestroyFileMap (m)
DviFileMap *m;
{
DviFileMap *next;
for (; m; m = next) {
next = m->next;
XtFree ((char *) m);
}
}
ForgetPagePositions (dw)
DviWidget dw;
{
DestroyFileMap (dw->dvi.file_map);
dw->dvi.file_map = 0;
}
RememberPagePosition(dw, number)
DviWidget dw;
int number;
{
DviFileMap *m;
if (!(m = MapPageNumberToFileMap (dw, number))) {
m = (DviFileMap *) XtMalloc (sizeof *m);
m->page_number = number;
m->next = dw->dvi.file_map;
dw->dvi.file_map = m;
}
if (dw->dvi.tmpFile)
m->position = ftell (dw->dvi.tmpFile);
else
m->position = ftell (dw->dvi.file);
}
SearchPagePosition (dw, number)
DviWidget dw;
int number;
{
DviFileMap *m;
if (!(m = MapPageNumberToFileMap (dw, number)))
return -1;
return m->position;
}
FileSeek(dw, position)
DviWidget dw;
long position;
{
if (dw->dvi.tmpFile) {
dw->dvi.readingTmp = 1;
fseek (dw->dvi.tmpFile, position, 0);
} else
fseek (dw->dvi.file, position, 0);
}

334
gnu/usr.bin/groff/xditview/parse.c
View File

@ -1,334 +0,0 @@
/*
* parse.c
*
* parse dvi input
*/
#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <ctype.h>
#include "DviP.h"
static int StopSeen = 0;
static ParseDrawFunction(), ParseDeviceControl();
static push_env(), pop_env();
#define HorizontalMove(dw, delta) ((dw)->dvi.state->x += (delta))
ParseInput(dw)
register DviWidget dw;
{
int n, k;
int c;
char Buffer[BUFSIZ];
int NextPage;
int otherc;
StopSeen = 0;
/*
* make sure some state exists
*/
if (!dw->dvi.state)
push_env (dw);
for (;;) {
switch (DviGetC(dw, &c)) {
case '\n':
break;
case ' ': /* when input is text */
case 0: /* occasional noise creeps in */
break;
case '{': /* push down current environment */
push_env(dw);
break;
case '}':
pop_env(dw);
break;
/*
* two motion digits plus a character
*/
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
HorizontalMove(dw, (c-'0')*10 +
DviGetC(dw,&otherc)-'0');
/* fall through */
case 'c': /* single ascii character */
DviGetC(dw,&c);
if (c == ' ')
break;
Buffer[0] = c;
Buffer[1] = '\0';
(void) PutCharacter (dw, Buffer);
break;
case 'C':
GetWord (dw, Buffer, BUFSIZ);
(void) PutCharacter (dw, Buffer);
break;
case 't':
Buffer[1] = '\0';
while (DviGetC (dw, &c) != EOF
&& c != ' ' && c != '\n') {
Buffer[0] = c;
HorizontalMove (dw, PutCharacter (dw, Buffer));
}
break;
case 'u':
n = GetNumber(dw);
Buffer[1] = '\0';
while (DviGetC (dw, &c) == ' ')
;
while (c != EOF && c != ' ' && c != '\n') {
Buffer[0] = c;
HorizontalMove (dw,
PutCharacter (dw, Buffer) + n);
DviGetC (dw, &c);
}
break;
case 'D': /* draw function */
(void) GetLine(dw, Buffer, BUFSIZ);
if (dw->dvi.display_enable)
ParseDrawFunction(dw, Buffer);
break;
case 's': /* ignore fractional sizes */
n = GetNumber(dw);
dw->dvi.state->font_size = n;
break;
case 'f':
n = GetNumber(dw);
dw->dvi.state->font_number = n;
break;
case 'H': /* absolute horizontal motion */
k = GetNumber(dw);
HorizontalGoto(dw, k);
break;
case 'h': /* relative horizontal motion */
k = GetNumber(dw);
HorizontalMove(dw, k);
break;
case 'w': /* word space */
Word (dw);
break;
case 'V':
n = GetNumber(dw);
VerticalGoto(dw, n);
break;
case 'v':
n = GetNumber(dw);
VerticalMove(dw, n);
break;
case 'P': /* new spread */
break;
case 'p': /* new page */
(void) GetNumber(dw);
NextPage = dw->dvi.current_page + 1;
RememberPagePosition(dw, NextPage);
FlushCharCache (dw);
return(NextPage);
case 'N':
n = GetNumber(dw);
PutNumberedCharacter (dw, n);
break;
case 'n': /* end of line */
GetNumber(dw);
GetNumber(dw);
Newline (dw);
HorizontalGoto(dw, 0);
break;
case '+': /* continuation of X device control */
case '#': /* comment */
GetLine(dw, NULL, 0);
break;
case 'x': /* device control */
ParseDeviceControl(dw);
break;
case EOF:
dw->dvi.last_page = dw->dvi.current_page;
FlushCharCache (dw);
return dw->dvi.current_page;
default:
break;
}
}
}
static
push_env(dw)
DviWidget dw;
{
DviState *new;
new = (DviState *) XtMalloc (sizeof (*new));
if (dw->dvi.state)
*new = *(dw->dvi.state);
else {
new->font_size = 10;
new->font_number = 1;
new->x = 0;
new->y = 0;
}
new->next = dw->dvi.state;
dw->dvi.state = new;
}
static
pop_env(dw)
DviWidget dw;
{
DviState *old;
old = dw->dvi.state;
dw->dvi.state = old->next;
XtFree ((char *) old);
}
static
InitTypesetter (dw)
DviWidget dw;
{
while (dw->dvi.state)
pop_env (dw);
push_env (dw);
FlushCharCache (dw);
}
#define DRAW_ARGS_MAX 128
static
ParseDrawFunction(dw, buf)
DviWidget dw;
char *buf;
{
int v[DRAW_ARGS_MAX];
int i;
char *ptr;
v[0] = v[1] = v[2] = v[3] = 0;
if (buf[0] == '\0')
return;
ptr = buf+1;
for (i = 0; i < DRAW_ARGS_MAX; i++) {
if (sscanf(ptr, "%d", v + i) != 1)
break;
while (*ptr == ' ')
ptr++;
while (*ptr != '\0' && *ptr != ' ')
ptr++;
}
switch (buf[0]) {
case 'l': /* draw a line */
DrawLine(dw, v[0], v[1]);
break;
case 'c': /* circle */
DrawCircle(dw, v[0]);
break;
case 'C':
DrawFilledCircle(dw, v[0]);
break;
case 'e': /* ellipse */
DrawEllipse(dw, v[0], v[1]);
break;
case 'E':
DrawFilledEllipse(dw, v[0], v[1]);
break;
case 'a': /* arc */
DrawArc(dw, v[0], v[1], v[2], v[3]);
break;
case 'p':
DrawPolygon(dw, v, i);
break;
case 'P':
DrawFilledPolygon(dw, v, i);
break;
case '~': /* wiggly line */
DrawSpline(dw, v, i);
break;
case 't':
dw->dvi.line_thickness = v[0];
break;
case 'f':
if (i > 0 && v[0] >= 0 && v[0] <= DVI_FILL_MAX)
dw->dvi.fill = v[0];
break;
default:
#if 0
warning("unknown drawing function %s", buf);
#endif
break;
}
if (buf[0] == 'e') {
if (i > 0)
dw->dvi.state->x += v[0];
}
else {
while (--i >= 0) {
if (i & 1)
dw->dvi.state->y += v[i];
else
dw->dvi.state->x += v[i];
}
}
}
static
ParseDeviceControl(dw) /* Parse the x commands */
DviWidget dw;
{
char str[20], str1[50];
int c, n;
extern int LastPage, CurrentPage;
GetWord (dw, str, 20);
switch (str[0]) { /* crude for now */
case 'T': /* output device */
GetWord (dw, str, 20);
SetDevice (dw, str);
break;
case 'i': /* initialize */
InitTypesetter (dw);
break;
case 't': /* trailer */
break;
case 'p': /* pause -- can restart */
break;
case 's': /* stop */
StopSeen = 1;
return;
case 'r': /* resolution when prepared */
break;
case 'f': /* font used */
n = GetNumber (dw);
GetWord (dw, str, 20);
GetLine (dw, str1, 50);
SetFontPosition (dw, n, str, str1);
break;
case 'H': /* char height */
break;
case 'S': /* slant */
break;
}
while (DviGetC (dw, &c) != '\n') /* skip rest of input line */
if (c == EOF)
return;
return;
}
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/

14
gnu/usr.bin/groff/xditview/xdit.bm
View File

@ -1,14 +0,0 @@
#define xdit_width 32
#define xdit_height 32
static char xdit_bits[] = {
0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x03, 0x02, 0x00, 0x00, 0x02,
0x8a, 0xa2, 0xfc, 0x03, 0x52, 0x14, 0x03, 0x04, 0x02, 0x80, 0x00, 0x08,
0x52, 0x54, 0x00, 0x10, 0x8a, 0x22, 0x8f, 0x23, 0x02, 0x20, 0x06, 0x21,
0x8a, 0x12, 0x8c, 0x40, 0x52, 0x14, 0x8c, 0x40, 0x02, 0x10, 0x58, 0x40,
0x52, 0x14, 0x30, 0x40, 0x8a, 0x12, 0x30, 0x40, 0x02, 0x10, 0x70, 0x40,
0x8a, 0x12, 0xc8, 0x40, 0x52, 0x24, 0xc4, 0xe0, 0x02, 0x20, 0x84, 0xe1,
0x52, 0x54, 0xce, 0xf3, 0x8a, 0xa2, 0x00, 0xf8, 0x02, 0x00, 0x03, 0xfc,
0x8a, 0x22, 0xfc, 0xf3, 0x52, 0x14, 0x00, 0xc2, 0x02, 0x00, 0x00, 0x02,
0x52, 0x14, 0x45, 0x02, 0x8a, 0xa2, 0x28, 0x02, 0x02, 0x00, 0x00, 0x02,
0x02, 0x00, 0x00, 0x02, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

14
gnu/usr.bin/groff/xditview/xdit_mask.bm
View File

@ -1,14 +0,0 @@
#define xdit_mask_width 32
#define xdit_mask_height 32
static char xdit_mask_bits[] = {
0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07,
0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x1f,
0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xc7,
0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07,
0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0x07,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

588
gnu/usr.bin/groff/xditview/xditview.c
View File

@ -1,588 +0,0 @@
/*
* Copyright 1991 Massachusetts Institute of Technology
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of M.I.T. not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. M.I.T. makes no representations about the
* suitability of this software for any purpose. It is provided "as is"
* without express or implied warranty.
*
* M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* xditview --
*
* Display ditroff output in an X window
*/
#ifndef SABER
#ifndef lint
static char rcsid[] = "$XConsortium: xditview.c,v 1.17 89/12/10 17:05:08 rws Exp $";
#endif /* lint */
#endif /* SABER */
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>
#include <X11/Xaw/Paned.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Box.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Dialog.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#include <signal.h>
#include "Dvi.h"
#include "xdit.bm"
#include "xdit_mask.bm"
#include "stdio.h"
extern FILE *popen();
extern void exit();
static struct app_resources {
char *print_command;
char *filename;
} app_resources;
#define offset(field) XtOffset(struct app_resources *, field)
/* Application resources. */
static XtResource resources[] = {
{"printCommand", "PrintCommand", XtRString, sizeof(char*),
offset(print_command), XtRString, NULL},
{"filename", "Filename", XtRString, sizeof(char*),
offset(filename), XtRString, NULL},
};
#undef offset
/* Command line options table. Only resources are entered here...there is a
pass over the remaining options after XtParseCommand is let loose. */
static XrmOptionDescRec options[] = {
{"-page", "*dvi.pageNumber", XrmoptionSepArg, NULL},
{"-backingStore", "*dvi.backingStore", XrmoptionSepArg, NULL},
{"-resolution", "*dvi.resolution", XrmoptionSepArg, NULL},
{"-printCommand", ".printCommand", XrmoptionSepArg, NULL},
{"-filename", ".filename", XrmoptionSepArg, NULL},
{"-noPolyText", "*dvi.noPolyText", XrmoptionNoArg, "TRUE"},
};
static char current_print_command[1024];
static char current_file_name[1024];
static FILE *current_file;
/*
* Report the syntax for calling xditview.
*/
static
Syntax(call)
char *call;
{
(void) printf ("Usage: %s [-fg <color>] [-bg <color>]\n", call);
(void) printf (" [-bd <color>] [-bw <pixels>] [-help]\n");
(void) printf (" [-display displayname] [-geometry geom]\n");
(void) printf (" [-page <page-number>] [-backing <backing-store>]\n");
(void) printf (" [-resolution <res>] [-print <command>]\n");
(void) printf (" [-filename <file>] [filename]\n\n");
exit(1);
}
static void NewFile (), SetPageNumber ();
static Widget toplevel, paned, viewport, dvi;
static Widget page;
static Widget simpleMenu;
static void NextPage(), PreviousPage(), SelectPage(), OpenFile(), Quit();
static void Print();
static struct menuEntry {
char *name;
void (*function)();
} menuEntries[] = {
"nextPage", NextPage,
"previousPage", PreviousPage,
"selectPage", SelectPage,
"print", Print,
"openFile", OpenFile,
"quit", Quit,
};
static void NextPageAction(), PreviousPageAction(), SelectPageAction();
static void OpenFileAction(), QuitAction();
static void AcceptAction(), CancelAction();
static void PrintAction();
static void RerasterizeAction();
XtActionsRec xditview_actions[] = {
"NextPage", NextPageAction,
"PreviousPage", PreviousPageAction,
"SelectPage", SelectPageAction,
"Print", PrintAction,
"OpenFile", OpenFileAction,
"Rerasterize", RerasterizeAction,
"Quit", QuitAction,
"Accept", AcceptAction,
"Cancel", CancelAction,
};
#define MenuNextPage 0
#define MenuPreviousPage 1
#define MenuSelectPage 2
#define MenuPrint 3
#define MenuOpenFile 4
#define MenuQuit 5
static char pageLabel[256] = "Page <none>";
void main(argc, argv)
int argc;
char **argv;
{
char *file_name = 0;
int i;
static Arg labelArgs[] = {
{XtNlabel, (XtArgVal) pageLabel},
};
Arg topLevelArgs[2];
Widget entry;
Arg pageNumberArgs[1];
int page_number;
toplevel = XtInitialize("main", "GXditview",
options, XtNumber (options),
&argc, argv);
if (argc > 2)
Syntax(argv[0]);
XtGetApplicationResources(toplevel, (XtPointer)&app_resources,
resources, XtNumber(resources),
NULL, (Cardinal) 0);
if (app_resources.print_command)
strcpy(current_print_command, app_resources.print_command);
XtAppAddActions(XtWidgetToApplicationContext(toplevel),
xditview_actions, XtNumber (xditview_actions));
XtSetArg (topLevelArgs[0], XtNiconPixmap,
XCreateBitmapFromData (XtDisplay (toplevel),
XtScreen(toplevel)->root,
xdit_bits, xdit_width, xdit_height));
XtSetArg (topLevelArgs[1], XtNiconMask,
XCreateBitmapFromData (XtDisplay (toplevel),
XtScreen(toplevel)->root,
xdit_mask_bits,
xdit_mask_width, xdit_mask_height));
XtSetValues (toplevel, topLevelArgs, 2);
if (argc > 1)
file_name = argv[1];
/*
* create the menu and insert the entries
*/
simpleMenu = XtCreatePopupShell ("menu", simpleMenuWidgetClass, toplevel,
NULL, 0);
for (i = 0; i < XtNumber (menuEntries); i++) {
entry = XtCreateManagedWidget(menuEntries[i].name,
smeBSBObjectClass, simpleMenu,
NULL, (Cardinal) 0);
XtAddCallback(entry, XtNcallback, menuEntries[i].function, NULL);
}
paned = XtCreateManagedWidget("paned", panedWidgetClass, toplevel,
NULL, (Cardinal) 0);
viewport = XtCreateManagedWidget("viewport", viewportWidgetClass, paned,
NULL, (Cardinal) 0);
dvi = XtCreateManagedWidget ("dvi", dviWidgetClass, viewport, NULL, 0);
page = XtCreateManagedWidget ("label", labelWidgetClass, paned,
labelArgs, XtNumber (labelArgs));
XtSetArg (pageNumberArgs[0], XtNpageNumber, &page_number);
XtGetValues (dvi, pageNumberArgs, 1);
if (file_name)
NewFile (file_name);
/* NewFile modifies current_file_name, so do this here. */
if (app_resources.filename)
strcpy(current_file_name, app_resources.filename);
XtRealizeWidget (toplevel);
if (file_name)
SetPageNumber (page_number);
XtMainLoop();
}
static void
SetPageNumber (number)
{
Arg arg[2];
int actual_number, last_page;
XtSetArg (arg[0], XtNpageNumber, number);
XtSetValues (dvi, arg, 1);
XtSetArg (arg[0], XtNpageNumber, &actual_number);
XtSetArg (arg[1], XtNlastPageNumber, &last_page);
XtGetValues (dvi, arg, 2);
if (actual_number == 0)
sprintf (pageLabel, "Page <none>");
else if (last_page > 0)
sprintf (pageLabel, "Page %d of %d", actual_number, last_page);
else
sprintf (pageLabel, "Page %d", actual_number);
XtSetArg (arg[0], XtNlabel, pageLabel);
XtSetValues (page, arg, 1);
}
static void
SelectPageNumber (number_string)
char *number_string;
{
SetPageNumber (atoi(number_string));
}
static int hadFile = 0;
static void
NewFile (name)
char *name;
{
Arg arg[2];
char *n;
FILE *new_file;
Boolean seek = 0;
if (current_file) {
if (!strcmp (current_file_name, "-"))
;
else if (current_file_name[0] == '|')
pclose (current_file);
else
fclose (current_file);
}
if (!strcmp (name, "-"))
new_file = stdin;
else if (name[0] == '|')
new_file = popen (name+1, "r");
else {
new_file = fopen (name, "r");
seek = 1;
}
if (!new_file) {
/* XXX display error message */
return;
}
XtSetArg (arg[0], XtNfile, new_file);
XtSetArg (arg[1], XtNseek, seek);
XtSetValues (dvi, arg, 2);
if (hadFile || name[0] != '-' || name[1] != '\0') {
XtSetArg (arg[0], XtNtitle, name);
if (name[0] != '/' && (n = strrchr (name, '/')))
n = n + 1;
else
n = name;
XtSetArg (arg[1], XtNiconName, n);
XtSetValues (toplevel, arg, 2);
}
hadFile = 1;
SelectPageNumber ("1");
strcpy (current_file_name, name);
current_file = new_file;
}
static char fileBuf[1024];
ResetMenuEntry (entry)
Widget entry;
{
Arg arg[1];
XtSetArg (arg[0], XtNpopupOnEntry, entry);
XtSetValues (XtParent(entry) , arg, (Cardinal) 1);
}
/*ARGSUSED*/
static void
NextPage (entry, name, data)
Widget entry;
caddr_t name, data;
{
NextPageAction();
ResetMenuEntry (entry);
}
static void
NextPageAction ()
{
Arg args[1];
int number;
XtSetArg (args[0], XtNpageNumber, &number);
XtGetValues (dvi, args, 1);
SetPageNumber (number+1);
}
/*ARGSUSED*/
static void
PreviousPage (entry, name, data)
Widget entry;
caddr_t name, data;
{
PreviousPageAction ();
ResetMenuEntry (entry);
}
static void
PreviousPageAction ()
{
Arg args[1];
int number;
XtSetArg (args[0], XtNpageNumber, &number);
XtGetValues (dvi, args, 1);
SetPageNumber (number-1);
}
/* ARGSUSED */
static void
SelectPage (entry, name, data)
Widget entry;
caddr_t name, data;
{
SelectPageAction ();
ResetMenuEntry (entry);
}
static void
SelectPageAction ()
{
MakePrompt (toplevel, "Page number", SelectPageNumber, "");
}
static void
DoPrint (name)
char *name;
{
FILE *print_file;
#ifdef SIGNALRETURNSINT
int (*handler)();
#else
void (*handler)();
#endif
/* Avoid dieing because of an invalid command. */
handler = signal(SIGPIPE, SIG_IGN);
print_file = popen(name, "w");
if (!print_file)
/* XXX print error message */
return;
DviSaveToFile(dvi, print_file);
pclose(print_file);
signal(SIGPIPE, handler);
strcpy(current_print_command, name);
}
static void
RerasterizeAction()
{
Arg args[1];
int number;
if (current_file_name[0] == 0) {
/* XXX display an error message */
return;
}
XtSetArg (args[0], XtNpageNumber, &number);
XtGetValues (dvi, args, 1);
NewFile(current_file_name);
SetPageNumber (number);
}
/* ARGSUSED */
static void
Print (entry, name, data)
Widget entry;
caddr_t name, data;
{
PrintAction ();
ResetMenuEntry (entry);
}
static void
PrintAction ()
{
if (current_print_command[0])
strcpy (fileBuf, current_print_command);
else
fileBuf[0] = '\0';
MakePrompt (toplevel, "Print command:", DoPrint, fileBuf);
}
/* ARGSUSED */
static void
OpenFile (entry, name, data)
Widget entry;
caddr_t name, data;
{
OpenFileAction ();
ResetMenuEntry (entry);
}
static void
OpenFileAction ()
{
if (current_file_name[0])
strcpy (fileBuf, current_file_name);
else
fileBuf[0] = '\0';
MakePrompt (toplevel, "File to open:", NewFile, fileBuf);
}
/* ARGSUSED */
static void
Quit (entry, closure, data)
Widget entry;
caddr_t closure, data;
{
QuitAction ();
}
static void
QuitAction ()
{
exit (0);
}
Widget promptShell, promptDialog;
void (*promptfunction)();
/* ARGSUSED */
static
void CancelAction (widget, event, params, num_params)
Widget widget;
XEvent *event;
String *params;
Cardinal *num_params;
{
if (promptShell) {
XtSetKeyboardFocus(toplevel, (Widget) None);
XtDestroyWidget(promptShell);
promptShell = (Widget) 0;
}
}
static
void AcceptAction (widget, event, params, num_params)
Widget widget;
XEvent *event;
String *params;
Cardinal *num_params;
{
(*promptfunction)(XawDialogGetValueString(promptDialog));
CancelAction (widget, event, params, num_params);
}
MakePrompt(centerw, prompt, func, def)
Widget centerw;
char *prompt;
void (*func)();
char *def;
{
static Arg dialogArgs[] = {
{XtNlabel, NULL},
{XtNvalue, NULL},
};
Arg valueArgs[1];
Arg centerArgs[2];
Position source_x, source_y;
Position dest_x, dest_y;
Dimension center_width, center_height;
Dimension prompt_width, prompt_height;
Widget valueWidget;
CancelAction ((Widget)NULL, (XEvent *) 0, (String *) 0, (Cardinal *) 0);
promptShell = XtCreatePopupShell ("promptShell", transientShellWidgetClass,
toplevel, NULL, (Cardinal) 0);
dialogArgs[0].value = (XtArgVal)prompt;
dialogArgs[1].value = (XtArgVal)def;
promptDialog = XtCreateManagedWidget( "promptDialog", dialogWidgetClass,
promptShell, dialogArgs, XtNumber (dialogArgs));
XawDialogAddButton(promptDialog, "accept", NULL, (caddr_t) 0);
XawDialogAddButton(promptDialog, "cancel", NULL, (caddr_t) 0);
valueWidget = XtNameToWidget (promptDialog, "value");
if (valueWidget) {
XtSetArg (valueArgs[0], XtNresizable, TRUE);
XtSetValues (valueWidget, valueArgs, 1);
/*
* as resizable isn't set until just above, the
* default value will be displayed incorrectly.
* rectify the situation by resetting the values
*/
XtSetValues (promptDialog, dialogArgs, XtNumber (dialogArgs));
}
XtSetKeyboardFocus (promptDialog, valueWidget);
XtSetKeyboardFocus (toplevel, valueWidget);
XtRealizeWidget (promptShell);
/*
* place the widget in the center of the "parent"
*/
XtSetArg (centerArgs[0], XtNwidth, &center_width);
XtSetArg (centerArgs[1], XtNheight, &center_height);
XtGetValues (centerw, centerArgs, 2);
XtSetArg (centerArgs[0], XtNwidth, &prompt_width);
XtSetArg (centerArgs[1], XtNheight, &prompt_height);
XtGetValues (promptShell, centerArgs, 2);
source_x = (center_width - prompt_width) / 2;
source_y = (center_height - prompt_height) / 3;
XtTranslateCoords (centerw, source_x, source_y, &dest_x, &dest_y);
XtSetArg (centerArgs[0], XtNx, dest_x);
XtSetArg (centerArgs[1], XtNy, dest_y);
XtSetValues (promptShell, centerArgs, 2);
XtMapWidget(promptShell);
promptfunction = func;
}
/* For DviChar.c */
char *xmalloc(n)
int n;
{
return XtMalloc(n);
}
/*
Local Variables:
c-indent-level: 4
c-continued-statement-offset: 4
c-brace-offset: -4
c-argdecl-indent: 4
c-label-offset: -4
c-tab-always-indent: nil
End:
*/

303
gnu/usr.bin/groff/xditview/xtotroff.c
View File

@ -1,303 +0,0 @@
/*
* xtotroff
*
* convert X font metrics into troff font metrics
*/
#include <X11/Xlib.h>
#include <stdio.h>
#include <ctype.h>
#include "XFontName.h"
#include "DviChar.h"
#ifdef X_NOT_STDC_ENV
char *malloc();
#else
#include <stdlib.h>
#endif
#define charWidth(fi,c) ((fi)->per_char[(c) - (fi)->min_char_or_byte2].width)
#define charHeight(fi,c) ((fi)->per_char[(c) - (fi)->min_char_or_byte2].ascent)
#define charDepth(fi,c) ((fi)->per_char[(c) - (fi)->min_char_or_byte2].descent)
#define charLBearing(fi,c) ((fi)->per_char[(c) - (fi)->min_char_or_byte2].lbearing)
#define charRBearing(fi,c) ((fi)->per_char[(c) - (fi)->min_char_or_byte2].rbearing)
Display *dpy;
int groff_flag = 0;
unsigned resolution = 75;
unsigned point_size = 10;
int charExists (fi, c)
XFontStruct *fi;
int c;
{
XCharStruct *p;
if (c < fi->min_char_or_byte2 || c > fi->max_char_or_byte2)
return 0;
p = fi->per_char + (c - fi->min_char_or_byte2);
return (p->lbearing != 0 || p->rbearing != 0 || p->width != 0
|| p->ascent != 0 || p->descent != 0 || p->attributes != 0);
}
/* Canonicalize the font name by replacing scalable parts by *s. */
CanonicalizeFontName (font_name, canon_font_name)
char *font_name, *canon_font_name;
{
unsigned int attributes;
XFontName parsed;
if (!XParseFontName(font_name, &parsed, &attributes)) {
fprintf (stderr, "not a standard name: %s\n", font_name);
return 0;
}
attributes &= ~(FontNamePixelSize|FontNameAverageWidth
|FontNamePointSize
|FontNameResolutionX|FontNameResolutionY);
XFormatFontName(&parsed, attributes, canon_font_name);
return 1;
}
int FontNamesAmbiguous(font_name, names, count)
char *font_name;
char **names;
int count;
{
char name1[2048], name2[2048];
int i;
if (count == 1)
return 0;
for (i = 0; i < count; i++) {
if (!CanonicalizeFontName(names[i], i == 0 ? name1 : name2)) {
fprintf(stderr, "bad font name: %s\n", names[i]);
return 1;
}
if (i > 0 && strcmp(name1, name2) != 0) {
fprintf(stderr, "ambiguous font name: %s\n", font_name);
fprintf(stderr, " matches %s\n", names[0]);
fprintf(stderr, " and %s\n", names[i]);
return 1;
}
}
return 0;
}
MapFont (font_name, troff_name)
char *font_name;
char *troff_name;
{
XFontStruct *fi;
int count;
char **names;
FILE *out;
int c;
unsigned int attributes;
XFontName parsed;
int j, k;
DviCharNameMap *char_map;
char encoding[256];
char *s;
int wid;
char name_string[2048];
if (!XParseFontName(font_name, &parsed, &attributes)) {
fprintf (stderr, "not a standard name: %s\n", font_name);
return 0;
}
attributes &= ~(FontNamePixelSize|FontNameAverageWidth);
attributes |= FontNameResolutionX;
attributes |= FontNameResolutionY;
attributes |= FontNamePointSize;
parsed.ResolutionX = resolution;
parsed.ResolutionY = resolution;
parsed.PointSize = point_size*10;
XFormatFontName(&parsed, attributes, name_string);
names = XListFonts (dpy, name_string, 100000, &count);
if (count < 1) {
fprintf (stderr, "bad font name: %s\n", font_name);
return 0;
}
if (FontNamesAmbiguous(font_name, names, count))
return 0;
XParseFontName(names[0], &parsed, &attributes);
sprintf (encoding, "%s-%s", parsed.CharSetRegistry,
parsed.CharSetEncoding);
for (s = encoding; *s; s++)
if (isupper (*s))
*s = tolower (*s);
char_map = DviFindMap (encoding);
if (!char_map) {
fprintf (stderr, "not a standard encoding: %s\n", encoding);
return 0;
}
fi = XLoadQueryFont (dpy, names[0]);
if (!fi) {
fprintf (stderr, "font does not exist: %s\n", names[0]);
return 0;
}
printf ("%s -> %s\n", names[0], troff_name);
(void) unlink (troff_name);
out = fopen (troff_name, "w");
if (!out) {
perror (troff_name);
return 0;
}
fprintf (out, "name %s\n", troff_name);
if (!strcmp (char_map->encoding, "adobe-fontspecific"))
fprintf (out, "special\n");
if (charExists (fi, ' ')) {
int w = charWidth (fi, ' ');
if (w > 0)
fprintf (out, "spacewidth %d\n", w);
}
fprintf (out, "charset\n");
for (c = fi->min_char_or_byte2; c <= fi->max_char_or_byte2; c++) {
char *name = DviCharName (char_map,c,0);
if (charExists (fi, c) && (groff_flag || name)) {
wid = charWidth (fi, c);
fprintf (out, "%s\t%d",
name ? name : "---",
wid);
if (groff_flag) {
int param[5];
param[0] = charHeight (fi, c);
param[1] = charDepth (fi, c);
param[2] = 0 /* charRBearing (fi, c) - wid */;
param[3] = 0 /* charLBearing (fi, c) */;
param[4] = 0; /* XXX */
for (j = 0; j < 5; j++)
if (param[j] < 0)
param[j] = 0;
for (j = 4; j >= 0; j--)
if (param[j] != 0)
break;
for (k = 0; k <= j; k++)
fprintf (out, ",%d", param[k]);
}
fprintf (out, "\t0\t0%o\n", c);
if (name) {
for (k = 1; DviCharName(char_map,c,k); k++) {
fprintf (out, "%s\t\"\n",
DviCharName (char_map,c,k));
}
}
}
}
XUnloadFont (dpy, fi->fid);
fclose (out);
return 1;
}
static usage(prog)
char *prog;
{
fprintf (stderr,
"usage: %s [-g] [-r resolution] [-s pointsize FontMap\n",
prog);
exit (1);
}
/* For use by DviChar.c */
char *xmalloc(n)
int n;
{
char *p = malloc(n);
if (!p) {
fprintf(stderr, "Out of memory\n");
exit(1);
}
return p;
}
main (argc, argv)
char **argv;
{
char troff_name[1024];
char font_name[1024];
char line[1024];
char *a, *b, c;
int position;
FILE *map;
int opt;
extern int optind;
extern char *optarg;
while ((opt = getopt(argc, argv, "gr:s:")) != EOF) {
switch (opt) {
case 'g':
groff_flag = 1;
break;
case 'r':
sscanf(optarg, "%u", &resolution);
break;
case 's':
sscanf(optarg, "%u", &point_size);
break;
default:
usage(argv[0]);
}
}
if (argc - optind != 1)
usage(argv[0]);
dpy = XOpenDisplay (0);
if (!dpy) {
fprintf (stderr, "Can't connect to the X server.\n");
fprintf (stderr, "Make sure the DISPLAY environment variable is set correctly.\n");
exit (1);
}
position = 1;
map = fopen (argv[optind], "r");
if (map == NULL) {
perror (argv[optind]);
exit (1);
}
while (fgets (line, sizeof (line), map)) {
for (a=line,b=troff_name; *a; a++,b++) {
c = (*b = *a);
if (c == ' ' || c == '\t')
break;
}
*b = '\0';
while (*a && (*a == ' ' || *a == '\t'))
++a;
for (b=font_name; *a; a++,b++)
if ((*b = *a) == '\n')
break;
*b = '\0';
if (!MapFont (font_name, troff_name))
exit (1);
++position;
}
exit (0);
}
/*
Local Variables:
c-indent-level: 8
c-continued-statement-offset: 8
c-brace-offset: -8
c-argdecl-indent: 8
c-label-offset: -8
c-tab-always-indent: nil
End:
*/