home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume17 / xdvi / part04b < prev    next >
Encoding:
Text File  |  1992-03-22  |  32.9 KB  |  1,006 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!cis.ohio-state.edu!zaphod.mps.ohio-state.edu!mips!msi!dcmartin
  3. From: vojta@powdermilk.berkeley.edu (Paul Vojta)
  4. Subject: v17i041: xdvi, dvi previewer, Part04/05, Part02/02
  5. Message-ID: <1992Mar23.190042.18862@msi.com>
  6. Originator: dcmartin@fascet
  7. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  8. Organization: Molecular Simulations, Inc.
  9. Date: Mon, 23 Mar 1992 19:00:42 GMT
  10. Approved: dcmartin@msi.com
  11.  
  12. Submitted-by: vojta@powdermilk.berkeley.edu (Paul Vojta)
  13. Posting-number: Volume 17, Issue 41
  14. Archive-name: xdvi/part04b
  15.  
  16. # this is part04.02 (part 2 of a multipart archive)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file xdvi.c continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 2; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping xdvi.c'
  34. else
  35. echo 'x - continuing file xdvi.c'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'xdvi.c' &&
  37. X    stderr);
  38. #endif    /* VMS */
  39. #else    /* X10 */
  40. X    Fputs("\
  41. Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l]\n\
  42. X    [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  43. X    [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  44. X    [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  45. X    [-hushspecials] [-hushchars] [-hush]\n\
  46. X    [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  47. [-cr <color>]\n\
  48. X    [-bw <width>] [-geometry <geometry> | =<geometry>]\n\
  49. X    [-display <host:display> | <host:display>] dvi_file\n", stderr);
  50. #endif    /* X10 */
  51. X    exit(1);
  52. }
  53. X
  54. static    int
  55. atopix(arg)
  56. X    _Xconst    char    *arg;
  57. {
  58. X    int    len    = strlen(arg);
  59. X
  60. X    return (len > 2 && arg[len - 2] == 'c' && arg[len - 1] == 'm' ?
  61. X        1.0 / 2.54 : 1.0) * atof(arg) * pixels_per_inch + 0.5;
  62. }
  63. X
  64. /**
  65. X **    Main programs start here.
  66. X **/
  67. X
  68. #ifndef X10
  69. static    char    *icon_geometry;
  70. static    Boolean    copy    = 2;
  71. static    Boolean    thorough;
  72. #endif    /* X10 */
  73. X
  74. #ifdef    TOOLKIT
  75. X
  76. static    XrmOptionDescRec    options[] = {
  77. {"-d",        ".debugLevel",    XrmoptionSepArg,    (caddr_t) NULL},
  78. {"-s",        ".shrinkFactor", XrmoptionSepArg,    (caddr_t) NULL},
  79. #ifndef    VMS
  80. {"-S",        ".densityPercent", XrmoptionSepArg,    (caddr_t) NULL},
  81. #endif
  82. {"-density",    ".densityPercent", XrmoptionSepArg,    (caddr_t) NULL},
  83. {"-p",        ".pixelsPerInch", XrmoptionSepArg,    (caddr_t) NULL},
  84. {"-margins",    ".Margin",    XrmoptionSepArg,    (caddr_t) NULL},
  85. {"-sidemargin",    ".sideMargin",    XrmoptionSepArg,    (caddr_t) NULL},
  86. {"-topmargin",    ".topMargin",    XrmoptionSepArg,    (caddr_t) NULL},
  87. {"-offsets",    ".Offset",    XrmoptionSepArg,    (caddr_t) NULL},
  88. {"-xoffset",    ".xOffset",    XrmoptionSepArg,    (caddr_t) NULL},
  89. {"-yoffset",    ".yOffset",    XrmoptionSepArg,    (caddr_t) NULL},
  90. {"-paper",    ".paper",    XrmoptionSepArg,    (caddr_t) NULL},
  91. {"-altfont",    ".altFont",    XrmoptionSepArg,    (caddr_t) NULL},
  92. {"-l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "on"},
  93. {"+l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "off"},
  94. {"-hushspecials", ".hushSpecials", XrmoptionNoArg,    (caddr_t) "on"},
  95. {"+hushspecials", ".hushSpecials", XrmoptionNoArg,    (caddr_t) "off"},
  96. {"-hushchars",    ".hushLostChars", XrmoptionNoArg,    (caddr_t) "on"},
  97. {"+hushchars",    ".hushLostChars", XrmoptionNoArg,    (caddr_t) "off"},
  98. {"-hush",    ".Hush",    XrmoptionNoArg,        (caddr_t) "on"},
  99. {"+hush",    ".Hush",    XrmoptionNoArg,        (caddr_t) "off"},
  100. {"-fg",        ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  101. {"-foreground",    ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  102. {"-bg",        ".background",    XrmoptionSepArg,    (caddr_t) NULL},
  103. {"-background",    ".background",    XrmoptionSepArg,    (caddr_t) NULL},
  104. {"-hl",        ".highlight",    XrmoptionSepArg,    (caddr_t) NULL},
  105. {"-cr",        ".cursorColor",    XrmoptionSepArg,    (caddr_t) NULL},
  106. {"-icongeometry",".iconGeometry",XrmoptionSepArg,    (caddr_t) NULL},
  107. {"-keep",    ".keepPosition",XrmoptionNoArg,        (caddr_t) "on"},
  108. {"+keep",    ".keepPosition",XrmoptionNoArg,        (caddr_t) "off"},
  109. {"-copy",    ".copy",    XrmoptionNoArg,        (caddr_t) "on"},
  110. {"+copy",    ".copy",    XrmoptionNoArg,        (caddr_t) "off"},
  111. {"-thorough",    ".thorough",    XrmoptionNoArg,        (caddr_t) "on"},
  112. {"+thorough",    ".thorough",    XrmoptionNoArg,        (caddr_t) "off"},
  113. #ifdef    BUTTONS
  114. {"-expert",    ".expert",    XrmoptionNoArg,        (caddr_t) "on"},
  115. {"+expert",    ".expert",    XrmoptionNoArg,        (caddr_t) "off"},
  116. #endif
  117. {"-mgs",    ".magnifierSize1",XrmoptionSepArg,    (caddr_t) NULL},
  118. {"-mgs1",    ".magnifierSize1",XrmoptionSepArg,    (caddr_t) NULL},
  119. {"-mgs2",    ".magnifierSize2",XrmoptionSepArg,    (caddr_t) NULL},
  120. {"-mgs3",    ".magnifierSize3",XrmoptionSepArg,    (caddr_t) NULL},
  121. {"-mgs4",    ".magnifierSize4",XrmoptionSepArg,    (caddr_t) NULL},
  122. {"-mgs5",    ".magnifierSize5",XrmoptionSepArg,    (caddr_t) NULL},
  123. };
  124. X
  125. static    XtResource    resources[] = {
  126. {"debugLevel", "DebugLevel", XtRString, sizeof(char *),
  127. X  (Cardinal) &debug_arg, XtRString, NULL},
  128. {"shrinkFactor", "ShrinkFactor", XtRInt, sizeof(int),
  129. X  (Cardinal) &shrink_factor, XtRInt, (caddr_t) &shrink_factor},
  130. {"densityPercent", "DensityPercent", XtRInt, sizeof(int),
  131. X  (Cardinal) &density, XtRInt, (caddr_t) &density},
  132. {"pixelsPerInch", "PixelsPerInch", XtRInt, sizeof(int),
  133. X  (Cardinal) &pixels_per_inch, XtRInt, (caddr_t) &pixels_per_inch},
  134. {"sideMargin", "Margin", XtRString, sizeof(char *),
  135. X  (Cardinal) &sidemargin, XtRString, NULL},
  136. {"topMargin", "Margin", XtRString, sizeof(char *),
  137. X  (Cardinal) &topmargin, XtRString, NULL},
  138. {"xOffset", "Offset", XtRString, sizeof(char *),
  139. X  (Cardinal) &xoffset, XtRString, NULL},
  140. {"yOffset", "Offset", XtRString, sizeof(char *),
  141. X  (Cardinal) &yoffset, XtRString, NULL},
  142. {"paper", "Paper", XtRString, sizeof(char *),
  143. X  (Cardinal) &paper, XtRString, (caddr_t) DEFAULT_PAPER},
  144. {"altFont", "AltFont", XtRString, sizeof(char *),
  145. X  (Cardinal) &alt_font, XtRString, (caddr_t) ALTFONT},
  146. {"listFonts", "ListFonts", XtRBoolean, sizeof(Boolean),
  147. X  (Cardinal) &list_fonts, XtRBoolean, (caddr_t) &list_fonts},
  148. {"reverseVideo", "ReverseVideo", XtRBoolean, sizeof(Boolean),
  149. X  (Cardinal) &reverse, XtRBoolean, (caddr_t) &reverse},
  150. {"hushSpecials", "Hush", XtRBoolean, sizeof(Boolean),
  151. X  (Cardinal) &hush_spec, XtRBoolean, (caddr_t) &hush_spec},
  152. {"hushLostChars", "Hush", XtRBoolean, sizeof(Boolean),
  153. X  (Cardinal) &hush_chars, XtRBoolean, (caddr_t) &hush_chars},
  154. {"foreground", "Foreground", XtRPixel, sizeof(Pixel),
  155. X  (Cardinal)&fore_Pixel, XtRPixel, (caddr_t) &fore_Pixel},
  156. {"foreground", "Foreground", XtRString, sizeof(char *),
  157. X  (Cardinal)&fore_color, XtRString, NULL},
  158. {"background", "Background", XtRPixel, sizeof(Pixel),
  159. X  (Cardinal)&back_Pixel, XtRPixel, (caddr_t) &back_Pixel},
  160. {"background", "Background", XtRString, sizeof(char *),
  161. X  (Cardinal)&back_color, XtRString, NULL},
  162. {"borderColor", "BorderColor", XtRPixel, sizeof(Pixel),
  163. X  (Cardinal)&brdr_Pixel, XtRPixel, (caddr_t) &brdr_Pixel},
  164. {"borderColor", "BorderColor", XtRString, sizeof(char *),
  165. X  (Cardinal)&brdr_color, XtRString, NULL},
  166. {"highlight", "Highlight", XtRPixel, sizeof(Pixel),
  167. X  (Cardinal)&hl_Pixel, XtRPixel, (caddr_t) &hl_Pixel},
  168. {"highlight", "Highlight", XtRString, sizeof(char *),
  169. X  (Cardinal)&high_color, XtRString, NULL},
  170. {"cursorColor", "CursorColor", XtRPixel, sizeof(Pixel),
  171. X  (Cardinal)&cr_Pixel, XtRPixel, (caddr_t) &cr_Pixel},
  172. {"cursorColor", "CursorColor", XtRString, sizeof(char *),
  173. X  (Cardinal)&curs_color, XtRString, NULL},
  174. {"iconGeometry", "IconGeometry", XtRString, sizeof(char *),
  175. X  (Cardinal)&icon_geometry, XtRString, NULL},
  176. {"keepPosition", "KeepPosition", XtRBoolean, sizeof(Boolean),
  177. X  (Cardinal)&keep_flag, XtRBoolean, (caddr_t) &keep_flag},
  178. {"copy", "Copy", XtRBoolean, sizeof(Boolean),
  179. X  (Cardinal)©, XtRBoolean, (caddr_t) ©},
  180. {"thorough", "Thorough", XtRBoolean, sizeof(Boolean),
  181. X  (Cardinal)&thorough, XtRBoolean, (caddr_t) &thorough},
  182. #ifdef    BUTTONS
  183. {"expert", "Expert", XtRBoolean, sizeof(Boolean),
  184. X  (Cardinal)&expert, XtRBoolean, (caddr_t) &expert},
  185. #endif
  186. {"magnifierSize1", "MagnifierSize", XtRInt, sizeof(int),
  187. X  (Cardinal) &mg_size[0], XtRInt, (caddr_t) &mg_size[0]},
  188. {"magnifierSize2", "MagnifierSize", XtRInt, sizeof(int),
  189. X  (Cardinal) &mg_size[1], XtRInt, (caddr_t) &mg_size[1]},
  190. {"magnifierSize3", "MagnifierSize", XtRInt, sizeof(int),
  191. X  (Cardinal) &mg_size[2], XtRInt, (caddr_t) &mg_size[2]},
  192. {"magnifierSize4", "MagnifierSize", XtRInt, sizeof(int),
  193. X  (Cardinal) &mg_size[3], XtRInt, (caddr_t) &mg_size[3]},
  194. {"magnifierSize5", "MagnifierSize", XtRInt, sizeof(int),
  195. X  (Cardinal) &mg_size[4], XtRInt, (caddr_t) &mg_size[4]},
  196. };
  197. X
  198. static    Arg    temp_args1[] = {
  199. X    {XtNiconX,    (XtArgVal) 0},
  200. X    {XtNiconY,    (XtArgVal) 0},
  201. };
  202. X
  203. static    Arg    temp_args2 = {XtNborderWidth,    (XtArgVal) &bwidth};
  204. X
  205. static    Pixmap    icon_pm;
  206. X
  207. static    Arg    temp_args3[] = {
  208. X    {XtNiconPixmap,    (XtArgVal) &icon_pm},
  209. };
  210. X
  211. static    Arg    temp_args4[] = {
  212. X    {XtNtitle,    (XtArgVal) 0},
  213. X    {XtNinput,    (XtArgVal) True},
  214. };
  215. X
  216. static    Arg    set_wh_args[] = {
  217. X    {XtNwidth,    (XtArgVal) 0},
  218. X    {XtNheight,    (XtArgVal) 0},
  219. };
  220. #else    /* !TOOLKIT */
  221. X
  222. static    char    *display;
  223. static    char    *geometry;
  224. static    char    *margins;
  225. static    char    *offsets;
  226. static    Boolean    hush;
  227. X
  228. #ifndef X10
  229. static    Boolean    iconic    = False;
  230. X
  231. static    Pixel
  232. string_to_pixel(strp)        /* adapted from the toolkit */
  233. X    char    **strp;
  234. {
  235. X    char    *str = *strp;
  236. X    Status    status;
  237. X    XColor    color, junk;
  238. X
  239. X    if (*str == '#') {    /* an rgb definition */
  240. X        status = XParseColor(DISP, DefaultColormapOfScreen(SCRN),
  241. X        str, &color);
  242. X        if (status != 0)
  243. X        status = XAllocColor(DISP, DefaultColormapOfScreen(SCRN),
  244. X            &color);
  245. X    }
  246. X    else    /* a name */
  247. X        status = XAllocNamedColor(DISP, DefaultColormapOfScreen(SCRN),
  248. X        str, &color, &junk);
  249. X    if (status == 0) {
  250. X        Fprintf(stderr, "Cannot allocate colormap entry for \"%s\"\n", str);
  251. X        *strp = NULL;
  252. X        return (Pixel) 0;
  253. X    }
  254. X    return color.pixel;
  255. }
  256. #endif    /* X10 */
  257. X
  258. static    struct option {
  259. X    _Xconst    char    *name;
  260. X    _Xconst    char    *resource;
  261. X    enum    {FalseArg, TrueArg, StickyArg, SepArg} argclass;
  262. X    enum    {BooleanArg, StringArg, NumberArg} argtype;
  263. X    int    classcount;
  264. X    caddr_t    address;
  265. }    options[] = {
  266. X        /* the display option MUST be first */
  267. {"-display",    NULL,        SepArg,    StringArg, 1,    (caddr_t) &display},
  268. {"-d",        "debugLevel",    SepArg,    StringArg, 1,    (caddr_t) &debug_arg},
  269. {"+",        NULL,        StickyArg, StringArg, 1,(caddr_t) &curr_page},
  270. {"-s",        "shrinkFactor", SepArg, NumberArg, 1,    (caddr_t) &shrink_factor},
  271. {"-S",        NULL,        SepArg, NumberArg, 2,    (caddr_t) &density},
  272. {"-density",    "densityPercent", SepArg, NumberArg, 1,    (caddr_t) &density},
  273. {"-p",        "pixelsPerInch", SepArg, NumberArg, 1,    (caddr_t) &pixels_per_inch},
  274. {"-margins",    "Margin",    SepArg,    StringArg, 3,    (caddr_t) &margins},
  275. {"-sidemargin",    "sideMargin",    SepArg,    StringArg, 1,    (caddr_t) &sidemargin},
  276. {"-topmargin",    "topMargin",    SepArg,    StringArg, 1,    (caddr_t) &topmargin},
  277. {"-offsets",    "Offset",    SepArg,    StringArg, 3,    (caddr_t) &offsets},
  278. {"-xoffset",    "xOffset",    SepArg,    StringArg, 1,    (caddr_t) &xoffset},
  279. {"-yoffset",    "yOffset",    SepArg,    StringArg, 1,    (caddr_t) &yoffset},
  280. {"-paper",    "paper",    SepArg,    StringArg, 1,    (caddr_t) &paper},
  281. {"-altfont",    "altFont",    SepArg,    StringArg, 1,    (caddr_t) &alt_font},
  282. {"-l",        NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &list_fonts},
  283. {"+l",        "listFonts",    FalseArg, BooleanArg, 1,(caddr_t) &list_fonts},
  284. {"-rv",        NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &reverse},
  285. {"+rv",        "reverseVideo",    FalseArg, BooleanArg, 1,(caddr_t) &reverse},
  286. {"-hush",    NULL,        TrueArg, BooleanArg, 6,    (caddr_t) &hush},
  287. {"+hush",    "Hush",        FalseArg, BooleanArg, 5,(caddr_t) &hush},
  288. {"-hushspecials", NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &hush_spec},
  289. {"+hushspecials", "hushSpecials", FalseArg, BooleanArg, 1,(caddr_t) &hush_spec},
  290. {"-hushchars",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &hush_chars},
  291. {"+hushchars",    "hushLostChars", FalseArg, BooleanArg, 1,(caddr_t) &hush_chars},
  292. {"-bw",        NULL,        SepArg,    NumberArg, 2,    (caddr_t) &bwidth},
  293. {"-borderwidth", "borderWidth",    SepArg,    NumberArg, 1,    (caddr_t) &bwidth},
  294. {"-fg",        NULL,        SepArg,    StringArg, 2,    (caddr_t) &fore_color},
  295. {"-foreground",    "foreground",    SepArg,    StringArg, 1,    (caddr_t) &fore_color},
  296. {"-bg",        NULL,        SepArg,    StringArg, 2,    (caddr_t) &back_color},
  297. {"-background",    "background",    SepArg,    StringArg, 1,    (caddr_t) &back_color},
  298. {"-bd",        NULL,        SepArg,    StringArg, 2,    (caddr_t) &brdr_color},
  299. {"-bordercolor","borderColor",    SepArg,    StringArg, 1,    (caddr_t) &brdr_color},
  300. {"-hl",        "highlight",    SepArg,    StringArg, 1,    (caddr_t) &high_color},
  301. {"-cr",        "cursorColor",    SepArg,    StringArg, 1,    (caddr_t) &curs_color},
  302. #ifdef    X10
  303. {"=",        NULL,        StickyArg, StringArg, 2,(caddr_t) &geometry},
  304. #endif
  305. {"-geometry",    "geometry",    SepArg,    StringArg, 1,    (caddr_t) &geometry},
  306. #ifndef    X10
  307. {"-icongeometry","iconGeometry",StickyArg, StringArg, 1,(caddr_t) &icon_geometry},
  308. {"-iconic",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &iconic},
  309. {"+iconic",    "iconic",    FalseArg, BooleanArg, 1,(caddr_t) &iconic},
  310. {"-keep",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &keep_flag},
  311. {"+keep",    "keepPosition",    FalseArg, BooleanArg, 1,(caddr_t) &keep_flag},
  312. {"-copy",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) ©},
  313. {"+copy",    "copy",        FalseArg, BooleanArg, 1,(caddr_t) ©},
  314. {"-thorough",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &thorough},
  315. {"+thorough",    "thorough",    FalseArg, BooleanArg, 1,(caddr_t) &thorough},
  316. #endif    /* X10 */
  317. {"-mgs",    NULL,        SepArg, NumberArg, 2,    (caddr_t) &mg_size[0]},
  318. {"-mgs1",    "magnifierSize1",SepArg, NumberArg, 1,    (caddr_t) &mg_size[0]},
  319. {"-mgs2",    "magnifierSize2",SepArg, NumberArg, 1,    (caddr_t) &mg_size[1]},
  320. {"-mgs3",    "magnifierSize3",SepArg, NumberArg, 1,    (caddr_t) &mg_size[2]},
  321. #ifndef X10
  322. {"-mgs4",    "magnifierSize4",SepArg, NumberArg, 1,    (caddr_t) &mg_size[3]},
  323. {"-mgs5",    "magnifierSize5",SepArg, NumberArg, 1,    (caddr_t) &mg_size[4]},
  324. #endif
  325. };
  326. X
  327. /*
  328. X *    Process the option table.  This is not guaranteed for all possible
  329. X *    option tables, but at least it works for this one.
  330. X */
  331. X
  332. static    void
  333. parse_options(argc, argv)
  334. X    int argc;
  335. X    char **argv;
  336. {
  337. X    char    **arg;
  338. X    char    **argvend = argv + argc;
  339. X    char    *optstring;
  340. X    caddr_t    addr;
  341. X    struct option *opt, *lastopt, *candidate;
  342. X    int    len1, len2, matchlen;
  343. X
  344. X    /*
  345. X     * Step 1.  Process command line options.
  346. X     */
  347. X    for (arg = argv + 1; arg < argvend; ++arg) {
  348. X        len1 = strlen(*arg);
  349. X        candidate = NULL;
  350. X        matchlen = 0;
  351. X        for (opt = options; opt < options + XtNumber(options); ++opt) {
  352. X        len2 = strlen(opt->name);
  353. X        if (opt->argclass == StickyArg) {
  354. X            if (matchlen <= len2 && !strncmp(*arg, opt->name, len2)) {
  355. X            candidate = opt;
  356. X            matchlen = len2;
  357. X            }
  358. X        }
  359. X        else if (len1 <= len2 && matchlen <= len1 &&
  360. X            !strncmp(*arg, opt->name, len1)) {
  361. X            if (len1 == len2) {
  362. X            candidate = opt;
  363. X            break;
  364. X            }
  365. X            if (matchlen < len1) candidate = opt;
  366. X            else if (candidate && candidate->argclass != StickyArg)
  367. X            candidate = NULL;
  368. X            matchlen = len1;
  369. X        }
  370. X        }
  371. X        if (candidate == NULL) {
  372. #ifdef    X10
  373. X        if (**arg == '-') usage();
  374. X        if (index(*arg, ':') != NULL) {    /* display */
  375. X            --arg;
  376. X            candidate = options;
  377. X        }
  378. X        else if (dvi_name) usage();
  379. #else
  380. X        if (**arg == '-' || dvi_name) usage();
  381. #endif
  382. X        else {
  383. X            dvi_name = *arg;
  384. X            continue;
  385. X        }
  386. X        }
  387. X        /* flag it for subsequent processing */
  388. X        candidate->resource = (char *) candidate;
  389. X        /* store the value */
  390. X        addr = candidate->address;
  391. X        switch (candidate->argclass) {
  392. X        case FalseArg:    *((Boolean *) addr) = False; continue;
  393. X        case TrueArg:    *((Boolean *) addr) = True; continue;
  394. X        case StickyArg:    optstring = *arg + strlen(candidate->name);
  395. X            break;
  396. X        case SepArg:
  397. X            ++arg;
  398. X            if (arg >= argvend) usage();
  399. X            optstring = *arg;
  400. X            break;
  401. X        }
  402. X        switch (candidate->argtype) {
  403. X        case StringArg:    *((char **) addr) = optstring; break;
  404. X        case NumberArg:    *((int *) addr) = atoi(optstring); break;
  405. X        default:  ;
  406. X        }
  407. X    }
  408. X    /*
  409. X     * Step 2.  Propagate classes for command line arguments.  Backwards.
  410. X     */
  411. X    for (opt = options + XtNumber(options) - 1; opt >= options; --opt)
  412. X        if (opt->resource == (char *) opt) {
  413. X        addr = opt->address;
  414. X        lastopt = opt + opt->classcount;
  415. X        for (candidate = opt; candidate < lastopt; ++candidate) {
  416. X            if (candidate->resource != NULL) {
  417. X            switch (opt->argtype) {
  418. X                case BooleanArg:
  419. X                *((Boolean *) candidate->address) =
  420. X                    *((Boolean *) addr);
  421. X                break;
  422. X                case StringArg:
  423. X                *((char **) candidate->address) =
  424. X                    *((char **) addr);
  425. X                break;
  426. X                case NumberArg:
  427. X                *((int *) candidate->address) = *((int *) addr);
  428. X                break;
  429. X            }
  430. X            candidate->resource = NULL;
  431. X            }
  432. X        }
  433. X        }
  434. X
  435. #ifndef X10
  436. X    if ((DISP = XOpenDisplay(display)) == NULL)
  437. X        oops("Can't open display");
  438. X    SCRN = DefaultScreenOfDisplay(DISP);
  439. #else
  440. X    if (XOpenDisplay(display) == NULL)
  441. X        oops("Can't open display");
  442. #endif
  443. X    /*
  444. X     * Step 3.  Handle resources (including classes).
  445. X     */
  446. X    for (opt = options; opt < options + XtNumber(options); ++opt)
  447. X        if (opt->resource &&
  448. #ifndef X10
  449. X            ((optstring = XGetDefault(DISP, prog, opt->resource)) ||
  450. X            (optstring = XGetDefault(DISP, "XDvi", opt->resource))))
  451. #else
  452. X            (optstring = XGetDefault(DPY prog, opt->resource)))
  453. #endif
  454. X        {
  455. X            lastopt = opt + opt->classcount;
  456. X            for (candidate = opt; candidate < lastopt; ++candidate)
  457. X            if (candidate->resource != NULL) switch (opt->argtype) {
  458. X                case StringArg:
  459. X                *((char **) candidate->address) = optstring;
  460. X                break;
  461. X                case NumberArg:
  462. X                *((int *) candidate->address) = atoi(optstring);
  463. X                break;
  464. X                case BooleanArg:
  465. X                *((Boolean *) candidate->address) =
  466. X                    (strcmp(optstring, "on") == 0);
  467. X            }
  468. X        }
  469. }
  470. X
  471. #endif    /* TOOLKIT */
  472. X
  473. static    _Xconst    char    *paper_types[] = {
  474. X    "us",        "8.5x11",
  475. X    "usr",        "11x8.5",
  476. X    "legal",    "8.5x14",
  477. X    "foolscap",    "13.5x17.0",    /* ??? */
  478. X
  479. X    /* ISO `A' formats, Portrait */
  480. X    "a1",        "59.4x84.0cm",
  481. X    "a2",        "42.0x59.4cm",
  482. X    "a3",        "29.7x42.0cm",
  483. X    "a4",        "21.0x29.7cm",
  484. X    "a5",        "14.85x21.0cm",
  485. X    "a6",        "10.5x14.85cm",
  486. X    "a7",        "7.42x10.5cm",
  487. X
  488. X    /* ISO `A' formats, Landscape */
  489. X    "a1r",        "84.0x59.4cm",
  490. X    "a2r",        "59.4x42.0cm",
  491. X    "a3r",        "42.0x29.7cm",
  492. X    "a4r",        "29.7x21.0cm",
  493. X    "a5r",        "21.0x14.85cm",
  494. X    "a6r",        "14.85x10.5cm",
  495. X    "a7r",        "10.5x7.42cm",
  496. X
  497. X    /* ISO `B' formats, Portrait */
  498. X    "b1",        "70.6x100.0cm",
  499. X    "b2",        "50.0x70.6cm",
  500. X    "b3",        "35.3x50.0cm",
  501. X    "b4",        "25.0x35.3cm",
  502. X    "b5",        "17.6x25.0cm",
  503. X    "b6",        "13.5x17.6cm",
  504. X    "b7",        "8.8x13.5cm",
  505. X
  506. X    /* ISO `B' formats, Landscape */
  507. X    "b1r",        "100.0x70.6cm",
  508. X    "b2r",        "70.6x50.0cm",
  509. X    "b3r",        "50.0x35.3cm",
  510. X    "b4r",        "35.3x25.0cm",
  511. X    "b5r",        "25.0x17.6cm",
  512. X    "b6r",        "17.6x13.5cm",
  513. X    "b7r",        "13.5x8.8cm",
  514. X
  515. X    /* ISO `C' formats, Portrait */
  516. X    "c1",        "64.8x91.6cm",
  517. X    "c2",        "45.8x64.8cm",
  518. X    "c3",        "32.4x45.8cm",
  519. X    "c4",        "22.9x32.4cm",
  520. X    "c5",        "16.2x22.9cm",
  521. X    "c6",        "11.46x16.2cm",
  522. X    "c7",        "8.1x11.46cm",
  523. X
  524. X    /* ISO `C' formats, Landscape */
  525. X    "c1r",        "91.6x64.8cm",
  526. X    "c2r",        "64.8x45.8cm",
  527. X    "c3r",        "45.8x32.4cm",
  528. X    "c4r",        "32.4x22.9cm",
  529. X    "c5r",        "22.9x16.2cm",
  530. X    "c6r",        "16.2x11.46cm",
  531. X    "c7r",        "11.46x8.1cm",
  532. };
  533. X
  534. static    Boolean
  535. set_paper_type() {
  536. X    _Xconst    char    *arg, *arg1;
  537. X    char    temp[21];
  538. X    _Xconst    char    **p;
  539. X    char    *q;
  540. X
  541. X    if (strlen(paper) > sizeof(temp) - 1) return False;
  542. X    arg = paper;
  543. X    q = temp;
  544. X    for (;;) {    /* convert to lower case */
  545. X        char c = *arg++;
  546. X        if (c >= 'A' && c <= 'Z') c ^= ('a' ^ 'A');
  547. X        *q++ = c;
  548. X        if (c == '\0') break;
  549. X    }
  550. X    arg = temp;
  551. X    /* perform substitutions */
  552. X    for (p = paper_types; p < paper_types + XtNumber(paper_types); p += 2)
  553. X        if (strcmp(temp, *p) == 0) {
  554. X        arg = p[1];
  555. X        break;
  556. X        }
  557. X    arg1 = index(arg, 'x');
  558. X    if (arg1 == NULL) return False;
  559. X    unshrunk_paper_w = atopix(arg);
  560. X    unshrunk_paper_h = atopix(arg1 + 1);
  561. X    return (unshrunk_paper_w != 0 && unshrunk_paper_h != 0);
  562. }
  563. X
  564. /*
  565. X *    main program
  566. X */
  567. X
  568. int
  569. main(argc, argv)
  570. X    int argc;
  571. X    char **argv;
  572. {
  573. X
  574. #ifndef    TOOLKIT
  575. #ifndef X10
  576. X    XSizeHints    size_hints;
  577. X    XWMHints    wmhints;
  578. #else
  579. X    OpaqueFrame frame;
  580. X    char    def[32];
  581. X    int    mouspix;
  582. X    Color    cdef;
  583. X    int    x_thick, y_thick;
  584. #endif
  585. #endif    /* TOOLKIT */
  586. X    int    screen_w, screen_h;
  587. X
  588. #ifndef    VMS
  589. X    prog = rindex(*argv, '/');
  590. #else
  591. X    prog = rindex(*argv, ']');
  592. #endif
  593. X    if (prog != NULL) ++prog; else prog = *argv;
  594. X
  595. #ifdef    VMS
  596. X    if (index(prog, '.') != NULL) *index(prog, '.') = '\0';
  597. #endif
  598. X
  599. #ifdef    TOOLKIT
  600. X    top_level = XtInitialize(prog, "XDvi", options, XtNumber(options),
  601. X        &argc, argv);
  602. X    while (--argc > 0) {
  603. X        if (*(*++argv) == '+')
  604. X        if (curr_page != NULL) usage();
  605. X        else curr_page = *argv + 1;
  606. X        else if (dvi_name != NULL) usage();
  607. X        else dvi_name = *argv;
  608. X    }
  609. X
  610. X    XtGetApplicationResources(top_level, (caddr_t) NULL, resources,
  611. X        XtNumber(resources), NULL, 0);
  612. X    DISP = XtDisplay(top_level);
  613. X    SCRN = XtScreen(top_level);
  614. X
  615. #else    /* !TOOLKIT */
  616. X
  617. X    parse_options(argc, argv);
  618. #ifndef X10
  619. X    if (fore_color) fore_Pixel = string_to_pixel(&fore_color);
  620. X    if (back_color) back_Pixel = string_to_pixel(&back_color);
  621. X    if (brdr_color) brdr_Pixel = string_to_pixel(&brdr_color);
  622. X    if (high_color) hl_Pixel = string_to_pixel(&high_color);
  623. X    if (curs_color) cr_Pixel = string_to_pixel(&curs_color);
  624. #endif
  625. X
  626. #endif    /* TOOLKIT */
  627. X
  628. X    if (shrink_factor <= 0 || density <= 0 || pixels_per_inch <= 0 ||
  629. X        dvi_name == NULL) usage();
  630. X    if (shrink_factor != 1) bak_shrink = shrink_factor;
  631. X    mane.shrinkfactor = shrink_factor;
  632. X    if (debug_arg != NULL)
  633. X        debug = isdigit(*debug_arg) ? atoi(debug_arg) : DBG_ALL;
  634. X    if (sidemargin) home_x = atopix(sidemargin);
  635. X    if (topmargin) home_y = atopix(topmargin);
  636. X    offset_x = xoffset ? atopix(xoffset) : pixels_per_inch;
  637. X    offset_y = yoffset ? atopix(yoffset) : pixels_per_inch;
  638. X    if (!set_paper_type()) oops("Don't recognize paper type %s", paper);
  639. X
  640. X    init_font_open();
  641. X    open_dvi_file();
  642. X    if (curr_page) {
  643. X        current_page = (*curr_page ? atoi(curr_page) : total_pages) - 1;
  644. X        if (current_page < 0 || current_page >= total_pages) usage();
  645. X    }
  646. X
  647. #ifndef X10
  648. X
  649. X    /*
  650. X     *    X11 colors
  651. X     */
  652. X
  653. X    if (reverse) {
  654. X        if (!fore_color) fore_Pixel = WhitePixelOfScreen(SCRN);
  655. X        if (!back_color) back_Pixel = BlackPixelOfScreen(SCRN);
  656. X        fore_color = back_color = (char *) &fore_color;    /* nonzero */
  657. X    } else {
  658. X        if (!fore_color) fore_Pixel = BlackPixelOfScreen(SCRN);
  659. X        if (!back_color) back_Pixel = WhitePixelOfScreen(SCRN);
  660. X    }
  661. X    if (!brdr_color) brdr_Pixel = fore_Pixel;
  662. X    {
  663. X        XGCValues    values;
  664. X        Pixel    set_bits = (Pixel) (fore_Pixel & ~back_Pixel);
  665. X        Pixel    clr_bits = (Pixel) (back_Pixel & ~fore_Pixel);
  666. #define    MakeGC(fcn, fg, bg)    (values.function = fcn, values.foreground=fg,\
  667. X        values.background=bg,\
  668. X        XCreateGC(DISP, RootWindowOfScreen(SCRN),\
  669. X            GCFunction|GCForeground|GCBackground, &values))
  670. X
  671. X        if (copy == 2) copy = (PlanesOfScreen(SCRN) > 1);
  672. X        if (copy || (set_bits && clr_bits))
  673. X        ruleGC = MakeGC(GXcopy, fore_Pixel, back_Pixel);
  674. X        if (copy) foreGC = ruleGC;
  675. X        else if (!thorough && ruleGC) {
  676. X        foreGC = ruleGC;
  677. X        puts("Note:  overstrike characters may be incorrect.");
  678. X        }
  679. X        else {
  680. X        if (set_bits) foreGC = MakeGC(GXor, set_bits, 0);
  681. X        if (clr_bits)
  682. X            *(foreGC ? &foreGC2 : &foreGC) =
  683. X            MakeGC(GXandInverted, clr_bits, 0);
  684. X        if (!ruleGC) ruleGC = foreGC;
  685. X        }
  686. X        highGC = ruleGC;
  687. X        if (high_color)
  688. X        highGC = MakeGC(GXcopy, hl_Pixel, back_Pixel);
  689. X    }
  690. X
  691. #ifndef    VMS
  692. X    ready_cursor = XCreateFontCursor(DISP, XC_cross);
  693. X    redraw_cursor = XCreateFontCursor(DISP, XC_watch);
  694. #else
  695. X    DECWCursorFont = XLoadFont(DISP, "DECW$CURSOR");
  696. X    XSetFont(DISP, foreGC, DECWCursorFont);
  697. X    redraw_cursor = XCreateGlyphCursor(DISP, DECWCursorFont, DECWCursorFont,
  698. X        decw$c_wait_cursor, decw$c_wait_cursor + 1,
  699. X        &fore_color, &back_color);
  700. X    MagnifyPixmap = XCreateBitmapFromData (DISP, RootWindowOfScreen(SCRN),
  701. X        mag_glass_bits, mag_glass_width, mag_glass_height);
  702. X    ready_cursor = XCreatePixmapCursor(DISP, MagnifyPixmap, MagnifyPixmap,
  703. X        &back_color, &fore_color, mag_glass_x_hot, mag_glass_y_hot);
  704. #endif    /* VMS */
  705. X
  706. X    if (!curs_color)
  707. X        cr_Pixel = high_color ? hl_Pixel : fore_Pixel;
  708. X    {
  709. X        XColor bg_Color, cr_Color;
  710. X
  711. X        bg_Color.pixel = back_Pixel;
  712. X        XQueryColor(DISP, DefaultColormapOfScreen(SCRN), &bg_Color);
  713. X        cr_Color.pixel = cr_Pixel;
  714. X        XQueryColor(DISP, DefaultColormapOfScreen(SCRN), &cr_Color);
  715. X        XRecolorCursor(DISP, ready_cursor, &cr_Color, &bg_Color);
  716. X        XRecolorCursor(DISP, redraw_cursor, &cr_Color, &bg_Color);
  717. X    }
  718. X
  719. #ifdef    TOOLKIT
  720. X
  721. X    /*
  722. X     *    X11 windows (toolkit)
  723. X     */
  724. X
  725. X        /* The following code is lifted from Xterm */
  726. X    if (icon_geometry != NULL) {
  727. X        int scr, junk;
  728. X
  729. X        for(scr = 0;    /* yyuucchh */
  730. X        SCRN != ScreenOfDisplay(DISP, scr);
  731. X        scr++);
  732. X
  733. X        XGeometry(DISP, scr, icon_geometry, "", 0, 0, 0, 0, 0,
  734. X            (int *) &temp_args1[0].value,
  735. X            (int *) &temp_args1[1].value, &junk, &junk);
  736. X        XtSetValues(top_level, temp_args1, XtNumber(temp_args1));
  737. X    }
  738. X        /* Set icon pixmap */
  739. X    XtGetValues(top_level, temp_args3, XtNumber(temp_args3));
  740. X    if (icon_pm == NULL) {
  741. X        temp_args3[0].value = (XtArgVal) (XCreateBitmapFromData(DISP,
  742. X                RootWindowOfScreen(SCRN),
  743. X                xdvi_bits, xdvi_width, xdvi_height));
  744. X        XtSetValues(top_level, temp_args3, XtNumber(temp_args3));
  745. X    }
  746. X    temp_args4[0].value = (XtArgVal) dvi_name;
  747. X    XtSetValues(top_level, temp_args4, XtNumber(temp_args4));
  748. X
  749. #ifdef    BUTTONS
  750. X    form_widget = XtCreateManagedWidget("form", formWidgetClass,
  751. X        top_level, form_args, XtNumber(form_args));
  752. X
  753. X    line_args[0].value = (XtArgVal) high_color ? hl_Pixel : fore_Pixel;
  754. #else    /* !BUTTONS */
  755. #define    form_widget    top_level    /* for calls to XtAddEventHandler */
  756. #endif    /* BUTTONS */
  757. X    vport_widget = XtCreateManagedWidget("vport", viewportWidgetClass,
  758. X        form_widget, vport_args, XtNumber(vport_args));
  759. X    clip_widget = XtNameToWidget(vport_widget, "clip");
  760. X    draw_args[0].value = (XtArgVal) page_w;
  761. X    draw_args[1].value = (XtArgVal) page_h;
  762. X    draw_widget = XtCreateManagedWidget("drawing", drawWidgetClass,
  763. X        vport_widget, draw_args, XtNumber(draw_args));
  764. X    {    /* set default window size */
  765. #ifdef    BUTTONS
  766. X        int xtra_wid = expert ? 0 : XTRA_WID;
  767. #else
  768. #define    xtra_wid    0
  769. #endif
  770. X        XtWidgetGeometry constraints;
  771. X        XtWidgetGeometry reply;
  772. X
  773. X        XtGetValues(top_level, &temp_args2, 1);    /* get border width */
  774. X        screen_w = WidthOfScreen(SCRN) - 2 * bwidth - xtra_wid;
  775. X        screen_h = HeightOfScreen(SCRN) - 2 * bwidth;
  776. X        constraints.request_mode = reply.request_mode = 0;
  777. X        constraints.width = page_w;
  778. X        if (page_w > screen_w) {
  779. X        constraints.request_mode = CWWidth;
  780. X        constraints.width = screen_w;
  781. X        }
  782. X        constraints.height = page_h;
  783. X        if (page_h > screen_h) {
  784. X        constraints.request_mode = CWHeight;
  785. X        constraints.height = screen_h;
  786. X        }
  787. X        if (constraints.request_mode != 0
  788. X            && constraints.request_mode != (CWWidth | CWHeight))
  789. X        (void) XtQueryGeometry(vport_widget, &constraints, &reply);
  790. X        if (!(reply.request_mode & CWWidth))
  791. X        reply.width = constraints.width;
  792. X        set_wh_args[0].value = (XtArgVal) ((reply.width < screen_w
  793. X                ? reply.width : screen_w) + xtra_wid);
  794. X        if (!(reply.request_mode & CWHeight))
  795. X        reply.height = constraints.height;
  796. X        set_wh_args[1].value = (XtArgVal) (reply.height < screen_h
  797. X                    ? reply.height : screen_h);
  798. X        XtSetValues(top_level, set_wh_args, XtNumber(set_wh_args));
  799. #ifdef    BUTTONS
  800. X        set_wh_args[0].value -= xtra_wid;
  801. X        XtSetValues(vport_widget, set_wh_args, XtNumber(set_wh_args));
  802. X        if (!expert) create_buttons(set_wh_args[1].value);
  803. #endif    /* BUTTONS */
  804. X    }
  805. X    if (fore_color) XtSetValues(draw_widget, &fore_args, 1);
  806. X    if (back_color) {
  807. X        XtSetValues(draw_widget, &back_args, 1);
  808. X        XtSetValues(clip_widget, &back_args, 1);
  809. X    }
  810. X    XtAddEventHandler(form_widget, KeyPressMask, False, handle_key,
  811. X        (caddr_t) NULL);
  812. X    XtAddEventHandler(vport_widget, StructureNotifyMask, False,
  813. X        handle_resize, (caddr_t) NULL);
  814. X    XtAddEventHandler(draw_widget, ExposureMask, False, handle_exp,
  815. X        (caddr_t) &mane);
  816. X    XtAddEventHandler(draw_widget, ButtonPressMask, False, handle_button,
  817. X        (caddr_t) NULL);
  818. X    XtAddEventHandler(draw_widget, ButtonMotionMask, False, handle_motion,
  819. X        (caddr_t) NULL);
  820. X    XtAddEventHandler(draw_widget, ButtonReleaseMask, False, handle_release,
  821. X        (caddr_t) NULL);
  822. X    XtRealizeWidget(top_level);
  823. X
  824. X    currwin.win = mane.win = XtWindow(draw_widget);
  825. X
  826. #else    /* !TOOLKIT */
  827. X
  828. X    /*
  829. X     *    X11 windows (non toolkit)
  830. X     */
  831. X
  832. X    screen_w = WidthOfScreen(SCRN) - 2*bwidth;
  833. X    screen_h = HeightOfScreen(SCRN) - 2*bwidth;
  834. X    size_hints.flags = PMinSize;
  835. X    size_hints.min_width = size_hints.min_height = 50;
  836. X    size_hints.x = size_hints.y = 0;
  837. X    if (geometry != NULL) {
  838. X        int flag = XParseGeometry(geometry, &size_hints.x, &size_hints.y,
  839. X        &window_w, &window_h);
  840. X
  841. X        if (flag & (XValue | YValue))
  842. X        size_hints.flags |= USPosition;
  843. X        if (flag & (WidthValue | HeightValue))
  844. X        size_hints.flags |= USSize;
  845. X        if (flag & XNegative) size_hints.x += screen_w - window_w;
  846. X        if (flag & YNegative) size_hints.y += screen_h - window_h;
  847. X    }
  848. X    if (!(size_hints.flags & USSize)) {
  849. X        int x_thick = 0;
  850. X        int y_thick = 0;
  851. X        if (screen_w < page_w) x_thick = BAR_THICK;
  852. X        if (screen_h < page_h + x_thick) y_thick = BAR_THICK;
  853. X        window_w = page_w + y_thick;
  854. X        if (window_w > screen_w) {
  855. X        x_thick = BAR_THICK;
  856. X        window_w = screen_w;
  857. X        }
  858. X        window_h = page_h + x_thick;
  859. X        if (window_h > screen_h) window_h = screen_h;
  860. X        size_hints.flags |= PSize;
  861. X    }
  862. X    size_hints.width = window_w;
  863. X    size_hints.height = window_h;
  864. X    top_level = XCreateSimpleWindow(DISP, RootWindowOfScreen(SCRN),
  865. X        size_hints.x, size_hints.y, window_w, window_h, bwidth,
  866. X        brdr_Pixel, back_Pixel);
  867. X    XSetStandardProperties(DISP, top_level, dvi_name, prog, NULL,
  868. X        argv, argc, &size_hints);
  869. X
  870. X    wmhints.flags = InputHint | StateHint | IconPixmapHint;
  871. X    wmhints.input = True;    /* window manager must direct input */
  872. X    wmhints.initial_state = iconic ? IconicState : NormalState;
  873. X    wmhints.icon_pixmap = XCreateBitmapFromData(DISP,
  874. X                RootWindowOfScreen(SCRN),
  875. X                xdvi_bits, xdvi_width, xdvi_height);
  876. X    if (icon_geometry != NULL) {
  877. X        int junk;
  878. X
  879. X        wmhints.flags |= IconPositionHint;
  880. X        XGeometry(DISP, DefaultScreen(DISP), icon_geometry, "",
  881. X        0, 0, 0, 0, 0, &wmhints.icon_x, &wmhints.icon_y, &junk, &junk);
  882. X    }
  883. X    XSetWMHints(DISP, top_level, &wmhints);
  884. X
  885. X    XSelectInput(DISP, top_level, KeyPressMask | StructureNotifyMask);
  886. X    XMapWindow(DISP, top_level);
  887. X    Flush();
  888. X
  889. #endif    /* TOOLKIT */
  890. X
  891. X    XRebindKeysym(DISP, XK_Home, NULL, 0, (_Xconst ubyte *) "^", 1);
  892. X    XRebindKeysym(DISP, XK_Left, NULL, 0, (_Xconst ubyte *) "l", 1);
  893. X    XRebindKeysym(DISP, XK_Up, NULL, 0, (_Xconst ubyte *) "u", 1);
  894. X    XRebindKeysym(DISP, XK_Right, NULL, 0, (_Xconst ubyte *) "r", 1);
  895. X    XRebindKeysym(DISP, XK_Down, NULL, 0, (_Xconst ubyte *) "d", 1);
  896. X    XRebindKeysym(DISP, XK_Prior, NULL, 0, (_Xconst ubyte *) "b", 1);
  897. X    XRebindKeysym(DISP, XK_Next, NULL, 0, (_Xconst ubyte *) "f", 1);
  898. X
  899. X    image = XCreateImage(DISP, DefaultVisualOfScreen(SCRN), 1, XYBitmap, 0,
  900. X                 (char *)NULL, 0, 0, BITS_PER_BMUNIT, 0);
  901. X    image->bitmap_unit = BITS_PER_BMUNIT;
  902. #ifndef    MSBITFIRST
  903. X    image->bitmap_bit_order = LSBFirst;
  904. #else
  905. X    image->bitmap_bit_order = MSBFirst;
  906. #endif
  907. X    {
  908. X        short endian = MSBFirst << 8 | LSBFirst;
  909. X        image->byte_order = *((char *) &endian);
  910. X    }
  911. X
  912. #else    /* X10 */
  913. X
  914. X    /*
  915. X     *    X10 colors
  916. X     */
  917. X
  918. X    if (reverse) {
  919. X        foreGC = WhitePixel;
  920. X        highGC = WhitePixel;
  921. X        backpix = BlackPixel;
  922. X        backmap = BlackPixmap;
  923. X        bdrmap = WhitePixmap;
  924. X        mouspix = WhitePixel;
  925. X        GXfunc = GXor;
  926. X    } else {
  927. X        foreGC = BlackPixel;
  928. X        highGC = BlackPixel;
  929. X        backpix = WhitePixel;
  930. X        backmap = WhitePixmap;
  931. X        bdrmap = BlackPixmap;
  932. X        mouspix = BlackPixel;
  933. X        GXfunc = GXand;
  934. X    }
  935. X    if (DisplayCells() > 2) {
  936. X        if (fore_color && XParseColor(fore_color, &cdef) &&
  937. X            XGetHardwareColor(&cdef))
  938. X            foreGC = cdef.pixel;
  939. X        if (back_color && XParseColor(back_color, &cdef) &&
  940. X            XGetHardwareColor(&cdef)) {
  941. X            backpix = cdef.pixel;
  942. X            backmap = XMakeTile(backpix);
  943. X        }
  944. X        if (brdr_color && XParseColor(brdr_color, &cdef) &&
  945. X            XGetHardwareColor(&cdef))
  946. X            bdrmap = XMakeTile(cdef.pixel);
  947. X        if (high_color && XParseColor(high_color, &cdef) &&
  948. X            XGetHardwareColor(&cdef))
  949. X            highGC = cdef.pixel;
  950. X        if (curs_color && XParseColor(curs_color, &cdef) &&
  951. X            XGetHardwareColor(&cdef))
  952. X            mouspix = cdef.pixel;
  953. X    }
  954. X
  955. X    /*
  956. X     *    X10 windows
  957. X     */
  958. X
  959. X    frame.bdrwidth = bwidth;
  960. X    screen_w = DisplayWidth() - 2*bwidth;
  961. X    screen_h = DisplayHeight() - 2*bwidth;
  962. X    x_thick = y_thick = 0;
  963. X    if (screen_w < page_w) x_thick = BAR_THICK;
  964. X    if (screen_h < page_h + x_thick) y_thick = BAR_THICK;
  965. X    frame.width = page_w + y_thick;
  966. X    if (frame.width > screen_w) {
  967. X        x_thick = BAR_THICK;
  968. X        frame.width = screen_w;
  969. X    }
  970. X    frame.height = page_h + x_thick;
  971. X    if (frame.height > screen_h) frame.height = screen_h;
  972. X    frame.border = bdrmap;
  973. X    frame.background = backmap;
  974. X    frame.x = 0;
  975. X    frame.y = 0;
  976. X    Sprintf(def, "=%dx%d+0+0", frame.width, frame.height);
  977. X    top_level = XCreate("DVI Previewer", prog, geometry, def,
  978. X        &frame, 50, 50);
  979. X    XSelectInput(top_level, ExposeWindow | KeyPressed);
  980. X    XMapWindow(top_level);
  981. X    XDefineCursor(top_level,
  982. X        XCreateCursor(xdvi_width, xdvi_height, xdvi_bits, xdvi_mask_bits,
  983. X              xdvi_x_hot, xdvi_y_hot, mouspix, backpix, GXcopy));
  984. #endif    /* X10 */
  985. X
  986. X    do_pages();
  987. X    return 0;    /* do_pages() returns if DBG_BATCH is specified */
  988. }
  989. SHAR_EOF
  990. echo 'File xdvi.c is complete' &&
  991. chmod 0644 xdvi.c ||
  992. echo 'restore of xdvi.c failed'
  993. Wc_c="`wc -c < 'xdvi.c'`"
  994. test 79591 -eq "$Wc_c" ||
  995.     echo 'xdvi.c: original size 79591, current size' "$Wc_c"
  996. rm -f _shar_wnt_.tmp
  997. fi
  998. rm -f _shar_seq_.tmp
  999. echo You have unpacked the last part
  1000. exit 0
  1001. -- 
  1002. --
  1003. Molecular Simulations, Inc.            mail: dcmartin@msi.com
  1004. 796 N. Pastoria Avenue                uucp: uunet!dcmartin
  1005. Sunnyvale, California 94086            at&t: 408/522-9236
  1006.