Check in remainder of groff 1.08
This commit is contained in:
jtc
parent
ae3013a732
commit
721687044c
|
|
@ -0,0 +1,259 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,544 @@
|
|||
#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 begining 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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/*
|
||||
* $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 */
|
||||
|
|
@ -0,0 +1,664 @@
|
|||
/*
|
||||
* 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 */},
|
||||
{ "rn", /* 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);
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
* 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 seperating 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 */ );
|
||||
|
|
@ -0,0 +1,233 @@
|
|||
/*
|
||||
* $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 */
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
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()
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
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:
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
.if exists(/usr/X386)
|
||||
|
||||
BINDIR= /usr/X386/bin
|
||||
MANDIR= /usr/X386/man/cat
|
||||
|
||||
PROG= gxditview
|
||||
CFLAGS+= -I/usr/X386/include -DFONTPATH=\"/usr/share/groff_font\"
|
||||
SRCS+= xditview.c Dvi.c draw.c font.c lex.c page.c parse.c \
|
||||
XFontName.c DviChar.c device.c
|
||||
LDADD+= -L/usr/X386/lib -lXaw -lXmu -lXt -lXext -lX11 -lm
|
||||
|
||||
afterinstall:
|
||||
install -c -o ${BINOWN} -g ${BINGRP} -m 444 GXditview.ad \
|
||||
$(DESTDIR)/usr/X386/lib/X11/app-defaults
|
||||
.endif
|
||||
|
||||
.include <bsd.prog.mk>
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/*
|
||||
* $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 */
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
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 accomodate the
|
||||
default value.
|
||||
|
||||
Option in Print dialog to specify that only the current page should be
|
||||
printed.
|
||||
|
|
@ -0,0 +1,256 @@
|
|||
/*
|
||||
* 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;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
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];
|
||||
|
|
@ -0,0 +1,581 @@
|
|||
/* 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
|
||||
|
||||
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. */
|
||||
#define INT_MIN (-INT_MAX-1)
|
||||
#define INT_MAX 2147483647
|
||||
|
||||
#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", ¤t_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, ¤t_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(*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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
|
||||
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();
|
||||
|
|
@ -0,0 +1,721 @@
|
|||
/*
|
||||
* 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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,471 @@
|
|||
/*
|
||||
* 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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,217 @@
|
|||
.\" -*- 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.
|
||||
.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
|
||||
Malcom Slaney (Schlumberger Palo Alto Research)
|
||||
.br
|
||||
Mark Moraes (University of Toronto)
|
||||
.br
|
||||
James Clark
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
/*
|
||||
* 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);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,334 @@
|
|||
/*
|
||||
* 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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#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};
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#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};
|
||||
|
|
@ -0,0 +1,587 @@
|
|||
/*
|
||||
* 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/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, *rindex ();
|
||||
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 = rindex (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, ¢er_width);
|
||||
XtSetArg (centerArgs[1], XtNheight, ¢er_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:
|
||||
*/
|
||||
|
|
@ -0,0 +1,303 @@
|
|||
/*
|
||||
* 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:
|
||||
*/
|
||||
Loading…
Reference in New Issue