开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
www.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：61k
源码类别：

浏览器

开发平台：

Unix_Linux

www.c：源码内容
  1. #include <stdlib.h>
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include <signal.h>
  5. #include <sys/types.h>
  6. #include <sys/time.h>
  8. #if 0
  9. #include <X11/Xlib.h>
  10. #include <X11/Xutil.h>
  11. #include <X11/Xos.h>
  12. #include <X11/Xatom.h>
  13. #include <X11/keysym.h>
  14. #include <X11/cursorfont.h>
  16. #ifdef __hpux
  17. #include <X11/HPkeysym.h>
  18. #endif
  20. #endif
  22. #ifndef NFDBITS
  23. #define NFDBITS 0
  24. #endif
  26. #include "www.h"
  27. #include "popup.h"
  28. #include "style.h"
  29. #include "neweditor.h"
  31. #ifndef XK_DeleteChar
  32. #define XK_DeleteChar XK_Delete
  33. #endif
  35. #define BITMAPDEPTH 1
  37. /* values for window_size in main, is window big enough to be useful */
  39. #define SMALL 1
  40. #define OK 0
  42. extern int statusHeight;
  43. extern int sbar_width;
  44. extern int ToolBarHeight;
  45. extern long PixelOffset;
  46. extern long buf_height;
  47. extern int PixelIndent;
  48. extern int buf_width;
  49. extern char *buffer;
  50. extern int hdrlen;
  51. extern int Authorize;
  52. extern int OpenURL;
  53. extern int IsIndex;
  54. extern int SaveFile;
  55. extern int FindStr;
  56. extern char *FindStrVal, *FindNextStr;
  57. extern int font;
  58. extern Field *focus;
  59. extern Frame background;
  60. extern Byte *paint;
  61. extern Bool TextFieldFocus;
  62. extern double lens_factor;
  63. extern GC disp_gc, gc_fill;
  65. int debug = 0;        /* used to control reporting of errors */
  66. int initialised = 0;  /* avoid X output until this is true! */
  67. int busy = 0;         /* blocks hypertext links etc while receiving data */
  68. int UseHTTP2 = 1;     /* use new HTRQ/HTTP protocol */
  69. int OpenSubnet = 0;   /* if true host is on OpenSubnet */
  70. int UsePaper = 1; 
  71. int fontsize = 0;
  72. int NoTerminal = 0; /* howcome 5/11/94: can we ask for passwd? */
  73. char *CacheRoot = "/tmp"; /* howcome 5/10/94: command line option to turn caching on */
  74. char *Printer = NULL; /* howcome 5/10/94: command line option enables printing */
  75. char *Editor = NULL; /* howcome 5/10/94: command line option turns the editor on */
  76. int  Badflags = 5; /* howcome 5/10/94: how many badflags do we want in the output */
  77. char *Icon = NULL; /* howcome 5/10/94: command line option turns the use of icon */
  78. double Gamma = 2.2; /* howcome 7/11/94: made into command line option */
  79. int NoMailcap = 0; /* howcome 7/11/94 */
  80. BOOL NoStyle = FALSE; /* howcome 2/3/95 */
  81. BOOL Quiet = FALSE; /* howcome 10/8/95 */
  82. BOOL OwnColorMap = FALSE; /* howcome 10/8/95 */
  83. Atom ARENA_LOCATION; 
  84. Atom ARENA_COMMAND;
  86. long main_stack[256];
  87. long *stack;
  89. int library_trace = 0; /* howcome 20/11/94 */
  91. Doc *CurrentDoc;
  92. Context *context;
  95. /* Display and screen are used as arguments to nearly every Xlib
  96.  * routine, so it simplifies routine calls to declare them global.
  97.  * If there were additional source files, these variables would be
  98.  * declared `extern' in them.
  99.  */
  101. Display *display;
  102. Visual *visual;
  103. Colormap colormap;
  104. int screen;
  105. int depth;
  106. Window win;
  107. int ExposeCount;   /* used to monitor GraphicsExpose events during scrolling */
  108. char *prog;        /* name of invoking program */
  109. int default_pixmap_width, default_pixmap_height;
  110. Pixmap background_pixmap, default_pixmap;
  111. Pixmap icon_pixmap;
  113. Cursor hourglass;
  114. int shape;
  116. unsigned long textColor, labelColor, windowColor, strikeColor, statusColor,
  117.        transparent, windowTopShadow, windowBottomShadow, windowShadow;
  119. #ifdef SELECTION
  120. unsigned long statusSelectColor; /* howcome */
  121. static char *selectStr=NULL; /* howcome 2/8/94 */
  122. #endif
  124. int charWidth, charHeight, charAscent, lineHeight;
  125. unsigned int win_width, win_height, tileWidth, tileHeight;
  126. unsigned char *tileData;
  128. /*int document;*/
  129. int gadget;
  130. int gatewayport = 3000; /* GATEWAYPORT; */
  131. char *gateway;      /* gateway if can't access server directly */
  132. char *help;
  133. /* char *printer; */ /* howcome 16/10/94 */
  134. char *startwith;    /* default initial document */
  135. char *user;
  137. int RepeatButtonDown = 0;
  139. XFontStruct *fixed_font;
  140. XFontStruct *Fonts[FONTS];  /* array of fonts */
  141. char *FontsName[FONTS];
  142. int LineSpacing[FONTS];
  143. int BaseLine[FONTS];
  144. int StrikeLine[FONTS];
  145. int LineThickness[FONTS];
  147. int ListIndent1, ListIndent2;
  149. GC gc_fill;
  150. static GC gc_scrollbar, gc_status, gc_text;
  151. static char *display_name = NULL;
  152. static int window_size = 0;    /* OK or SMALL to display contents */
  153. static int button_x, button_y;
  154. static XSizeHints size_hints;
  155. int ColorStyle;
  157. unsigned int display_width, display_height;
  158. double display_pt2px;
  160. struct itimerval itimer, old_itimer;
  163. void ShowBusy()
  164. {
  165.     XDefineCursor(display, win, hourglass);
  166.     XFlush(display);
  167.     busy = 1;
  168. }
  170. void HideBusy()
  171. {
  172.     XUndefineCursor(display, win);
  173.     XFlush(display);
  174.     busy = 0;
  175. }
  179. /* From Scott Nelson <snelson@canopus.llnl.gov> 24 bit color  1/12/94 */
  180. /* these are here for speed reasons */
  181. int RPixelShift=16, GPixelShift=8, BPixelShift=0;
  182. int RPixelMask=0xff, GPixelMask=0xff, BPixelMask=0xff;
  185. /* pause for delay milliseconds */
  186. /* howcome moved this from tcp.c 20/9/94 */
  188. void Pause(int delay)
  189. {
  190.     struct timeval timer;
  192.     timer.tv_sec = 0;
  193.     timer.tv_usec = delay * 1000;
  195.     select(NFDBITS, 0, 0, 0, &timer);
  196. }
  199. void CatchCore()
  200. {
  201.     fprintf(stderr,"CATCH_CORE %d%cn",(int)getpid(),7);
  202.     Exit(1);
  203. }
  205. void CatchQuit()
  206. {
  207.     fprintf(stderr,"CATCH_QUITn");
  208.     Exit(1);
  209. }
  211. void CatchX(Display * err_dpy_p, XErrorEvent *err_event)
  212. {
  213.     fprintf(stderr,"catchX pid %dn", (int)getpid());
  214. }
  216. /* howcome 4/10/94: need to clean the library cache.. */
  217. int Exit(int i)
  218. {
  219.     if (VERBOSE_TRACE)
  220.         printf("bridge.c: Exitn");
  221.     libExit(0);
  222.     printf("nThanks for using %s %s. The authors -- Dave, Hakon, Henrik nand Yves -- can be reached at arena@w3.org. nPlease check %s nbefore reporting bugs.n", BANNER, VERSION, HELP_URL);
  223.     exit(i);
  224. }
  228. /* find best visual for specified visual class */
  229. Visual *BestVisual(int class, int *depth)
  230. {
  231.     long visual_info_mask;
  232.     int number_visuals, i, best_depth;
  233.     XVisualInfo *visual_array, visual_info_template;
  234.     Visual *best_visual;
  236.     visual_info_template.class = class;
  237.     visual_info_template.screen = DefaultScreen(display);
  238.     visual_info_mask = VisualClassMask | VisualScreenMask;
  240.     visual_array = XGetVisualInfo(display, visual_info_mask,
  241.                         &visual_info_template,
  242.                         &number_visuals);
  244.     *depth = 0;
  245.     best_depth = 0; /* *depth */
  246.     best_visual = 0;
  247.  
  248.     for (i = 0; i < number_visuals; ++i)
  249.     {
  250.         if (visual_array[i].depth > *depth)
  251.         {
  252.             best_visual = visual_array[i].visual;
  253.             *depth = visual_array[i].depth;
  254.         }
  256.         if (*depth == best_depth)
  257.             break;
  258.     }
  260.     XFree((void *)visual_array);
  261.     return best_visual;
  262. }
  265. #ifdef SELECTION
  267. void SetSelection(char *s) /* howcome 2/8/94 */
  268. {
  269.   Free(selectStr);
  270.   selectStr = strdup(s);
  271.   XSetSelectionOwner(display, XA_PRIMARY, win, CurrentTime);
  272.   XStoreBytes(display, selectStr, strlen(selectStr));
  273. }
  275. #endif
  278. /* send myself an expose event to force redrawing of give rectangle */
  280. void Redraw(int x, int y, int w, int h)
  281. {
  282.     XExposeEvent event;
  284.     event.type = Expose;
  285.     event.serial = 0;
  286.     event.send_event = 1;
  287.     event.display = display;
  288.     event.window = win;
  289.     event.x = x;
  290.     event.y = y;
  291.     event.width = w;
  292.     event.height = h;
  293.     event.count = 0;
  295.     if (X_TRACE)
  296. fprintf(stderr,"Redrawn");
  297.     XSendEvent(display, win, 0, ExposureMask, (XEvent *)&event);
  298. }
  300. void SetBanner(char *title)
  301. {
  302.     XTextProperty textprop;
  304.      /* Support multiple <TITLE>s in a document */
  305.     if(CurrentDoc->title)
  306. free(CurrentDoc->title);
  308.     CurrentDoc->title = strdup(title);
  309.     XStoreName(display, win, title);
  310.     if(CurrentDoc->url)
  311.     {
  312. char *v;
  313. int v_size;
  314. v_size = strlen(title)+strlen(CurrentDoc->url)+13; /* 13: 'URL='(string)'TITLE='(string)  */ 
  315. v = (char *)calloc(v_size, sizeof(char));
  316. sprintf(v, "URL=%s%cTITLE=%s",CurrentDoc->url,0,title);
  317. XChangeProperty(display, win, ARENA_LOCATION, XA_STRING, 8, PropModeReplace,
  318. v, v_size);
  319. free(v);
  320.     }
  321. /*
  322.     if (strlen(title) > 8 && (p = strrchr(title, '/')))
  323.     {
  324.             if (p[1] != '')
  325.                 ++p;
  327.             title = p;
  328.     }
  329. */
  330.     textprop.value = (unsigned char *)title;
  331.     textprop.encoding = XA_STRING;
  332.     textprop.format = 8;
  333.     textprop.nitems = strlen(title);
  335.     XSetWMIconName(display, win, &textprop);
  336. }
  338. void LoadFont(int idx, char *font_name, char *fall_back)
  339. {
  340.     int direction_hint, font_ascent, font_descent;
  341.     XFontStruct *font;
  342.     XCharStruct overall;
  343.     char *test = "Testing";
  345.     if ((Fonts[idx] = XLoadQueryFont(display, font_name)) == NULL)
  346.     {
  347.         (void) fprintf(stderr, "Cannot open %s fontn", font_name);
  349.         if ((Fonts[idx] = XLoadQueryFont(display, fall_back)) == NULL)
  350.         {
  351.             (void) fprintf(stderr, "Cannot open alternate font: %sn", fall_back);
  352.             Exit(1);
  353.         }
  355.         fprintf(stderr, "Using alternate font: %sn", fall_back);
  356.     }
  358.     font = Fonts[idx];
  360.     XTextExtents(font, test, strlen(test),
  361.                     &direction_hint,
  362.                     &font_ascent,
  363.                     &font_descent,
  364.                     &overall);
  366.     charWidth = overall.width/strlen(test);
  367.     charHeight = overall.ascent + overall.descent;
  368.     charAscent = overall.ascent;
  369.     lineHeight = charHeight + overall.ascent/4 + 2;
  371.     LineSpacing[idx] = SPACING(font);
  372.     BaseLine[idx] = BASELINE(font);
  373.     StrikeLine[idx] = STRIKELINE(font);
  374. }
  377. #if 0
  378. janet 21/07/95: commented, function not used at all
  380. static int hex(char *s)
  381. {
  382.     int n, c;
  384.     n = toupper((unsigned char *)*s++) - '0';
  385.     n = toupper((int)*s++) - '0'; /* howcome changing cast 22/8/94  */
  387.     if (n > 9)
  388. n += '0' - 'A' + 10;
  389.     
  390.     c = toupper((unsigned char *)*s) - '0';
  391.     c = toupper((int)*s) - '0'; /* howcome changing cast 22/8/94 */
  393.     if (c > 9)
  394. c += '0' - 'A' + 10;
  396.     return c + (n << 4);
  397. }
  398. #endif
  401. /* From Scott Nelson <snelson@canopus.llnl.gov> 24bit color  1/12/94  Dec 1 1994 */
  402. /*
  403.    For efficiency, these should be computed after the visual is
  404. changed and then stored and reused, or stored in each routine
  405. as a static variable, or as a global variable.
  406. */
  407. /*
  408. int RPixelShift(){
  409.    int i = 0;
  410.    long int maskval;
  412. maskval = (*visual).red_mask;
  414. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  416. return i;
  417. }
  418. int GPixelShift(){
  419.    int i = 0;
  420.    long int maskval;
  422. maskval = (*visual).green_mask;
  424. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  426. return i;
  427. }
  428. int BPixelShift(){
  429.    int i = 0;
  430.    long int maskval;
  432. maskval = (*visual).blue_mask;
  434. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  436. return i;
  437. }
  438. */
  440. void CalcPixelShift(){
  441. /* this needs to be called after the visual has changed */
  443.    int i = 0;
  444.    long int maskval;
  446. maskval = (*visual).red_mask;
  448. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  450. RPixelShift = i;
  453.    i = 0;
  455. maskval = (*visual).green_mask;
  457. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  459. GPixelShift = i;
  462. i = 0;
  464. maskval = (*visual).blue_mask;
  466. while ((maskval & 1) == 0) { i++; maskval = maskval >> 1; }
  468. BPixelShift = i;
  469. }
  472. int Pixel4Color(XColor *color, unsigned long *pixel)
  473. {
  474.     unsigned long r, g, b;
  476.     r = color->red >> 8;
  477.     g = color->green >> 8;
  478.     b = color->blue >> 8;
  480. /*    *pixel = (b | g << 8 | r << 16); */ /* From Scott Nelson <snelson@canopus.llnl.gov> 24bit color  1/12/94  Dec 1 1994 */
  481. /*    *pixel = (r | g << 8 | b << 16);*/  /* some systems use RGB masks, others use BGR masks */
  482.     *pixel = (b << BPixelShift | g << GPixelShift | r << RPixelShift ); 
  483.  
  484.     return 1;
  485. }
  487. int Pixel2Color(XColor *color, unsigned long *pixel)
  488. {
  489.     unsigned long r, g, b;
  491.     r = (color->red * (long)(RPixelMask+1)) >> 16;
  492.     g = (color->green *(long)(GPixelMask+1)) >> 16;
  493.     b = (color->blue *(long)(BPixelMask+1)) >> 16;
  495.     *pixel = (b << BPixelShift | g << GPixelShift | r << RPixelShift );
  496.     return 1;
  497. }
  499. int GetNamedColor(char *name, unsigned long *pix)
  500. {
  501.     XColor color;
  503.     if (depth == 24)
  504.     {
  505.         if (XParseColor(display, colormap, name, &color) == 0)
  506.         {
  507.             if (X_TRACE)
  508.                 fprintf(stderr, "www: can't allocate named color `%s'n", name);
  510.             return 0;
  511.         }
  513.         return Pixel4Color(&color, pix);
  514.     }
  515.     if (depth == 16)
  516.     {
  517.         if (XParseColor(display, colormap, name, &color) == 0)
  518.         {
  519.             if (X_TRACE)
  520.                 fprintf(stderr, "www: can't allocate named color `%s'n", name);
  522.             return 0;
  523.         }
  524.         return Pixel2Color(&color, pix);
  525.     }
  526.     else if (XParseColor(display, colormap, name, &color) == 0 ||
  527.                      XAllocColor(display, colormap, &color) == 0)
  528.     {
  529.         if (X_TRACE)
  530.             fprintf(stderr, "www: can't allocate named color `%s'n", name);
  532.         return 0;
  533.     }
  535.     *pix = color.pixel;
  536.     return 1;
  537. }
  539. int GetColor(int red, int green, int blue, unsigned long *pix)
  540. {
  541.     XColor color;
  542. /*
  543.     if (red == 255 && green == 255 && blue == 255)
  544.     {
  545.         *pix = WhitePixel(display, screen);
  546.         return 1;
  547.     }
  549.     if (red == 0 && green == 0 && blue == 0)
  550.     {
  551.         *pix = BlackPixel(display, screen);
  552.         return 1;
  553.     }
  554. */
  555.     color.red = red << 8;
  556.     color.green = green << 8;
  557.     color.blue = blue  << 8;
  559.     if (depth == 24)
  560.         return Pixel4Color(&color, pix);
  561.     else if (depth == 16)
  562. return Pixel2Color(&color, pix);
  563.     else if (XAllocColor(display, colormap, &color) == 0)
  564.     {
  565. /*        if (X_TRACE)*/
  566.             fprintf(stderr, "www: can't allocate color %d:%d:%dn", red, green, blue);
  567. *pix = BlackPixel(display, screen);
  568.         return 0;
  569.     }
  571.     *pix = color.pixel;
  572.     return 1;
  573. }
  575. char *DetermineValue(char *prog, char *param, char *def)
  576. {
  577.     char *value;
  579.     if ((value = XGetDefault(display, prog, param)) == NULL)
  580.         value = def;
  582.     return value;
  583. }
  585. int DetermineColor(char *prog, char *param,
  586.         int r, int g, int b,
  587.         unsigned long *pix)
  588. {
  589.     char *colorname, *p1, *p2;
  591.     colorname = XGetDefault(display, prog, param);
  593.     if (colorname)  /* parse and GetColor() or GetNamedColor() */
  594.     {
  595.         /* "red:green:blue" e.g."205:184:157" or named color */
  597.         p1 = strchr(colorname, ':');
  598.         p2 = strrchr(colorname, ':');
  600.         if (p1 && p2 && p1 != p2)
  601.         {
  602.             sscanf(colorname, "%d:", &r);
  603.             sscanf(p1+1, "%d:", &g);
  604.             sscanf(p2+1, "%d", &b);
  606.             return GetColor(r, g, b, pix);
  607.         }
  609.         return GetNamedColor(colorname, pix);
  610.     }
  612.     return GetColor(r, g, b, pix);
  613. }
  615. void ButtonDown(unsigned int button, unsigned int state, int x, int y, int x_root, int y_root)
  616. {
  617.     if (X_TRACE)
  618.         fprintf(stderr, "ButtonDown %d %dn",x,y);
  621.     if (y < WinTop){
  622.         if (y < StatusTop)
  623.             gadget = ToolBarButtonDown(x, y);
  624.         else 
  625.             gadget = StatusButtonDown(button, x, y);
  626.     }
  627.     else if (x < WinRight && y < WinBottom)
  628. #ifdef POPUP
  629.         if (button == Button3)
  630.         {            
  631.             Popup(x_root, y_root);   
  632.         }
  633.         else
  634. #endif
  635.     if (button == Button2)   /* spif -> button2 shows URL */
  636.     {
  637. ShowLink(x, y);
  638.     }
  639.     else
  640. gadget = WindowButtonDown(x, y);
  641.     else if ( (x >= WinRight && y < WinBottom) ||
  642.               (x <= WinRight && y >= WinBottom) )
  643.     {
  644.         button_x = x;
  645.         button_y = y;
  646.         gadget = ScrollButtonDown(x, y);
  647.     }
  648.     else
  649.         gadget = VOID;
  650. }
  652. void ButtonUp(unsigned int button, unsigned int state, int x, int y)
  653. {
  654.     int shifted;
  656.     RepeatButtonDown = 0;
  657.     shifted = ShiftMask & state;
  659.     if (gadget == WINDOW)
  660.         WindowButtonUp(shifted, x, y);
  661.     else if (gadget == SCROLLBAR)
  662.         ScrollButtonUp(x, y);
  663.     else if (gadget == TOOLBAR)
  664.         ToolBarButtonUp(x, y);
  665.     else if (gadget == STATUS)
  666.         StatusButtonUp(x, y);
  667. }
  670. int GuiEvents(int s, HTRequest * rq, int f)
  671. {
  672.     char keybuf[20];
  673.     int keybufsize = 20;
  674.     int count;
  675.     KeySym key;
  676.     XEvent event;
  677.     XComposeStatus cs;
  678.     int block = 0;
  679.     int w, h;
  680.     
  681.     while (block || XEventsQueued(display, QueuedAfterReading) != 0)
  682.     {
  683. /*
  684. if (RepeatButtonDown) {
  685.     XButtonEvent e;
  687.     e.type = ButtonPress;
  688.     XSendEvent(event.xselectionrequest.display, event.xselectionrequest.requestor, False, 0, (XEvent *) &selEv);
  689. */
  691. /*
  692.         if (RepeatButtonDown && !ExposeCount &&
  693.                 XEventsQueued(display, QueuedAfterReading) == 0)
  694.         {
  695.             XFlush(display);
  696.             ButtonDown(event.xbutton.button, event.xbutton.state, button_x, button_y);
  697.             Pause(10);
  698.             continue;
  699.         }
  700. */
  702.         XNextEvent(display, &event);
  704.         switch(event.type)
  705.         {
  706.             case Expose:
  707.                     /* the following commented by janet: redrawing won't work, you get a trail  */
  708.                     /* get rid of all other Expose events on the queue */
  709.                     /*                 while (XCheckTypedEvent(display, Expose, &event)); */
  711.                 if (event.xexpose.y < WinTop) /* janet: added check for whether to draw or not */
  712.                 {
  713.                     DisplayToolBar();
  714.                     DisplayStatusBar();
  715.                     DisplayIcon();
  716.                 }
  717.                 
  718.                 w = event.xexpose.x + event.xexpose.width; /* the real coordinate */
  719.                 h = event.xexpose.y + event.xexpose.height; /* the real coordinate  */
  721. /*                 DisplayIcon(); */
  722. /*                 DisplayDoc(WinLeft, WinTop, WinWidth, WinHeight); */
  723.                 if ((h > WinTop && event.xexpose.x < WinWidth &&   /* checking whether to draw.. */
  724.                      event.xexpose.y < (WinHeight+WinTop)))
  725.                 {
  726.                     
  727.                         /* only redraw pieces that were exposed */
  728.                     DisplayDoc(event.xexpose.x, event.xexpose.y, 
  729.                                event.xexpose.width, event.xexpose.height);
  730.                 }
  731.                     /* we do the scrollbar last, to make sure DisplayDoc is not drawing on top of it */
  732.                 if ((w > WinWidth || h > WinHeight + WinTop))
  733.                     DisplayScrollBar();
  734.                 
  735.                 break;
  737.             case GraphicsExpose:
  738. /* if (event.xexpose.y < WinTop)
  739. {*/
  740.     SetToolBarWin(win);
  741.     SetToolBarGC(gc_status);
  742.     DisplayToolBar();
  743.     
  744.     SetStatusWin(win);
  745.     SetStatusGC(gc_status);
  746.     DisplayStatusBar();
  747.     
  748.     SetIconWin(win);
  749.     SetIconGC(gc_status);
  750.     DisplayIcon();
  751.     /* };*/
  753. SetScrollBarWin(win);
  754. SetScrollBarGC(gc_scrollbar);
  755. DisplayScrollBar();
  757. SetDisplayGC(gc_text);
  758. DisplayDoc(event.xgraphicsexpose.x,
  759.    event.xgraphicsexpose.y,
  760.    event.xgraphicsexpose.width,
  761.    event.xgraphicsexpose.height);
  763. ExposeCount = event.xgraphicsexpose.count;
  764. break;
  766.             case NoExpose:
  767.                 ExposeCount = 0;
  768.                 break;
  770.             case ConfigureNotify:
  771.                 if (win_width == event.xconfigure.width &&
  772.                         win_height == event.xconfigure.height)
  773.                     break;
  775.                 win_width = event.xconfigure.width;
  776.                 win_height = event.xconfigure.height;
  778.                 if ((win_width < size_hints.min_width) ||
  779.                         (win_height < size_hints.min_height))
  780.                     window_size = SMALL;
  781.                 else
  782.                     window_size = OK;
  784.                 if (focus && focus->flags & CHECKED)
  785.                 {
  786.                     focus->flags &= ~CHECKED;
  787.                     focus = NULL;
  788.                 }
  790.                 DisplaySizeChanged(1);
  792. #ifdef RESIZE_BUG
  793. /* 
  794.    howcome 26/7/94: need to expose after redraw 
  795.    this appears to be the case on suu4-sol2, and decstations??
  796.  */
  797.                 Redraw(0,0,WinWidth,WinHeight + WinTop); /* janet: changed height argument */
  798. #endif
  799.                 break;
  801.             case KeyPress:
  802.                 if (X_TRACE)
  803.                     fprintf(stderr, "KeyPressn");
  805.                 count = XLookupString((XKeyEvent*)&event, keybuf, keybufsize, &key, &cs);
  806.                 keybuf[count] = 0;
  808.                 if (key == XK_F8)
  809.                 {
  810.                     XCloseDisplay(display);
  811.                     Exit(1);
  812.                 }
  813.                 else if (key == XK_F2)
  814.                     count = 1;
  815. /*                else if (key == XK_F4)
  816.                     ShowPaint(background.top-paint, 14); */
  817.                 else if (key == XK_F6)
  818.                     ReportVisuals();
  819.                 else if (key == XK_F7)
  820.                 {
  821.                     ReportStandardColorMaps(XA_RGB_DEFAULT_MAP);
  822.                     ReportStandardColorMaps(XA_RGB_BEST_MAP);
  823.                 }
  824. /*
  825. else if (TextFieldFocus && key !=XK_Begin && key !=XK_End && key != XK_Prior && key != XK_Next) {
  826.     if (IsEditChar(*keybuf))
  827. FormEditChar(*keybuf);
  828.     else
  829. FormMoveCursor(key);
  830. }
  831. */
  832. else if (key == XK_v && (event.xkey.state & ControlMask))
  833.     MoveDownPage();
  834. else if (key == XK_v && (event.xkey.state & Mod1Mask))
  835.     MoveUpPage();
  836. /* 28-Nov-95 starting to play with the editor --Spif */
  837. else if ((CurrentDoc->field_editor) && (key == XK_Left))
  838. {
  839.     if(CurrentDoc->field_editor->pos)
  840.     {
  841. CurrentDoc->field_editor->pos--;
  842. PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  843. PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  844.     };
  845.                       /* afficher le curseur */
  846. }
  847. else if ((CurrentDoc->field_editor) && (key == XK_Right))
  848. {
  849.     if(CurrentDoc->field_editor->pos < CurrentDoc->field_editor->size)
  850.     {
  851. CurrentDoc->field_editor->pos++;
  852. PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  853. PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  854.     };
  855.                         /* afficher le curseur */
  856. }
  857. else if ((CurrentDoc->field_editor) && (key == XK_Delete || key == XK_DeleteChar))
  858. {
  859.     DeleteChar(CurrentDoc->field_editor, CurrentDoc->field_editor->pos);
  860.     free(CurrentDoc->edited_field->value);
  861.     CurrentDoc->edited_field->value = Buffer2Str(CurrentDoc->field_editor);
  862.     CurrentDoc->edited_field->buflen = CurrentDoc->field_editor->size;
  863.     PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  864.     PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  865.     /* Afficher tout */
  866. }
  867. else if ((CurrentDoc->field_editor) && ((key < 255)||(key == XK_Return))) /* normal keypress... adding */
  868. {
  869.     /* printf("adding [%c] [%d]n",key, key); */
  870.     if(key == XK_Return)
  871. InsertChar(CurrentDoc->field_editor, CurrentDoc->field_editor->pos , 'n');
  872.     else
  873. InsertChar(CurrentDoc->field_editor, CurrentDoc->field_editor->pos , key);
  874.     CurrentDoc->field_editor->pos++;
  875.     free(CurrentDoc->edited_field->value);
  876.     CurrentDoc->edited_field->value = Buffer2Str(CurrentDoc->field_editor);
  877.     CurrentDoc->edited_field->buflen = CurrentDoc->field_editor->size;
  878.     PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  879.     PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  880.                     /* Afficher tout */
  881. }
  882. else if ((CurrentDoc->field_editor) && (key == XK_Up))
  883. {
  884.     PrevLine(CurrentDoc->field_editor);
  885.     PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  886.     PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  887. }
  888. else if ((CurrentDoc->field_editor) && (key == XK_Down))
  889. {
  890.     NextLine(CurrentDoc->field_editor);
  891.     PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field );
  892.     PaintFieldCursorBuffer(disp_gc, strikeColor, CurrentDoc->field_editor, CurrentDoc->edited_field);
  893. }
  894.                 else if ((Authorize|OpenURL|IsIndex|SaveFile|FindStr) && IsEditChar(*keybuf))
  895.                     EditChar(*keybuf);
  896.                 else if ((Authorize|OpenURL|IsIndex|SaveFile|FindStr) && (key == XK_Left || key == XK_Right))
  897.                     MoveStatusCursor(key);
  898.                 else if ((Authorize|OpenURL|IsIndex|SaveFile|FindStr) && (key == XK_Delete || key == XK_DeleteChar))
  899.                     EditChar(127);
  900. #ifdef _HPUX_SOURCE
  901.                 else if ((Authorize|OpenURL|IsIndex|SaveFile|FindStr) && (key == XK_ClearLine || key == XK_DeleteLine))
  902.                 {
  903.                     ClearStatus();
  904.                     SetStatusString(0); /* force refresh */
  905.                 }
  906. #endif
  907.                 else if (key == XK_Up && !ExposeCount)
  908.                 {
  909.     if (event.xkey.state & ControlMask)
  910. MoveUpPage();
  911.     else
  912. MoveUpLine();
  913.                     XFlush(display);   /* to avoid scrollbar flashing */
  914.                 }
  915.                 else if (key == XK_Down && !ExposeCount)
  916.                 {
  917.     if (event.xkey.state & ControlMask)
  918. MoveDownPage();
  919.     else
  920. MoveDownLine();
  921.                     XFlush(display);   /* to avoid scrollbar flashing */
  922.                 }
  923.                 else if (key == XK_Left && !ExposeCount)
  924.                 {
  925.     if (event.xkey.state & (Mod4Mask | ControlMask))
  926. BackDoc();
  927.     else
  928. MoveLeftLine();
  929.                     XFlush(display);   /* to avoid scrollbar flashing */
  930.                 }
  931.                 else if (key == XK_Right && !ExposeCount)
  932.                 {
  933.     if (event.xkey.state & (Mod4Mask | ControlMask))
  934. ForwardDoc();
  935.     else
  936. MoveRightLine();
  937.                     XFlush(display);   /* to avoid scrollbar flashing */
  938.                 }
  939.                 else if (key == XK_Prior && !ExposeCount)
  940.                     MoveUpPage();
  941.                 else if (key == XK_Next && !ExposeCount)
  942.                     MoveDownPage();
  943.                 else if ((key == XK_Begin || key == XK_Home) && !ExposeCount)
  944.                 {
  945.                     if (event.xkey.state & ShiftMask)
  946.                         MoveToEnd();
  947.                     else
  948.                         MoveToStart();
  949.                 }
  950.                 else if (key == XK_End && !ExposeCount)
  951.                     MoveToEnd();
  952.                 else if (key == XK_Escape)
  953.                 {
  954.                     if (Authorize)
  955.                         HideAuthorizeWidget();
  956.                     else if (busy)
  957.                         Beep();
  958.                     else if (OpenURL)
  959.                     {
  960.                         OpenURL = 0;
  961.                         SetStatusString("");
  962.                     }
  963.                     else if (SaveFile)
  964.                     {
  965.                         SaveFile = 0;
  966.                         SetStatusString("");
  967.                     }
  968.                     else if (FindStr)
  969.                     {
  970.                         FindStr = 0;
  971.                         SetStatusString("");
  972.                     }
  973.                 }
  974.                 else if (busy)
  975.                     Beep();
  976.                 else if (key == XK_F2)
  977.                     BackDoc();
  978.                 else if (key == XK_F3 && FindStrVal)
  979.                     FindString(FindStrVal, &FindNextStr);
  980.                 break;
  982.             case KeyRelease:
  983.                 count = XLookupString((XKeyEvent*)&event, keybuf, keybufsize, &key, &cs);
  984.                 keybuf[count] = 0;
  985.                 break;
  987.             case ButtonRelease:
  988.                 ButtonUp(event.xbutton.button, event.xbutton.state, event.xbutton.x, event.xbutton.y);
  989.                 break;
  991.             case ButtonPress:
  992.                 if (X_TRACE)
  993.                     fprintf(stderr, "ButtonPress %d %dn",event.xbutton.x, event.xbutton.y);
  994. if(CurrentDoc->edited_field)
  995. {
  996.     free(CurrentDoc->edited_field->value);
  997.     CurrentDoc->edited_field->value = Buffer2Str(CurrentDoc->field_editor);
  998.     CurrentDoc->edited_field->flags &= ~CHECKED;
  999.     TextFieldFocus = FALSE;
  1000.     PaintField(disp_gc, -1, Abs2Win(CurrentDoc->edited_field->baseline),CurrentDoc->edited_field);
  1001.     CurrentDoc->edited_field = NULL;
  1002.     FreeBuffer(CurrentDoc->field_editor);
  1003.     CurrentDoc->field_editor = NULL;
  1004. };
  1005.                 ButtonDown(event.xbutton.button, event.xbutton.state, event.xbutton.x, event.xbutton.y, event.xbutton.x_root, event.xbutton.y_root);
  1006.                 break;
  1008.             case MotionNotify:  /* only sent when Button1 is down! */
  1009.               /* ignore event if still repairing holes from earlier copy operation*/
  1010.                 if (ExposeCount)
  1011.                     break;
  1013.                 /* get rid of all other MotionNotify events on the queue */
  1014.                 while (XCheckTypedEvent(display, MotionNotify, &event));
  1016. #ifdef SELECTION
  1017. SelectStatus(event.xbutton.x, event.xbutton.y);
  1018. #endif
  1019. ScrollButtonDrag(event.xbutton.x, event.xbutton.y);
  1020.                 break;
  1022.            /* the following is a failed attempt to exit tidily when the user
  1023.                 forces an exit through the system menu - I need to do better ! */
  1025.             case DestroyNotify:
  1026. if (event.xdestroywindow.window == win) {
  1027.     if (X_TRACE)
  1028.                 fprintf(stderr, "DestroyNotify event receivedn");
  1029.     /* XCloseDisplay(display); */
  1030.     Exit(1);
  1031. }
  1033.             case MapNotify:
  1034.                 initialised = 1;   /* allow status display now its safe */
  1035.                 break;
  1037.             case UnmapNotify:
  1038.                 if (X_TRACE) /* howcome 31/10/94 */
  1039.                     fprintf(stderr, "UnmapNotifyn");
  1040.                 break;
  1042.             case ReparentNotify:
  1043.                 break;
  1046.     case PropertyNotify:
  1047.     {
  1049. /* thanks to Colas Nahaboo */
  1051. Atom            actual_type;
  1052. int             actual_format;
  1053. unsigned long   nitems;
  1054. unsigned long   bytes_after;
  1055. unsigned char  *buffer = 0;
  1057. if (Success == XGetWindowProperty(display, win, ARENA_COMMAND, 0, 8000, TRUE,
  1058.   AnyPropertyType, &actual_type,
  1059.   &actual_format, &nitems, &bytes_after,
  1060.   &buffer))
  1061. {
  1062.     if(buffer)
  1063.     {
  1064. buffer[nitems] = '';
  1065. if (!(actual_type == XA_STRING && ((signed long)nitems >= 0))) 
  1066. {
  1067.     XFree(buffer);
  1068.     buffer = 0;
  1069. } /* else ok */
  1070.     } else {
  1071. if (buffer) XFree(buffer);
  1072. buffer = 0;
  1073.     }
  1074. }
  1076. if(buffer)
  1077. {
  1078.     ParseCommandLine(buffer, nitems);
  1079. }
  1080.     }
  1081.     break;
  1083. #ifdef SELECTION
  1085. /* selection event handling added by howcome 2/8/94 */
  1087.     case SelectionClear:
  1088. ClearStatusSelection();
  1089. DisplayStatusBar();
  1090. break;
  1091.     case SelectionNotify:
  1092. fprintf(stderr,"notifyn");
  1093. break;
  1094.     case SelectionRequest:
  1095. {
  1096.   XSelectionEvent selEv; 
  1098.   if (event.xselectionrequest.target != XA_STRING) {
  1099.     selEv.property = None;
  1100.   }
  1101.   else {
  1102.     selEv.property = event.xselectionrequest.property;
  1103.     XChangeProperty(event.xselectionrequest.display,
  1104.   event.xselectionrequest.requestor,
  1105.   event.xselectionrequest.property,
  1106.   event.xselectionrequest.target,
  1107.   8, PropModeReplace, selectStr,
  1108.   strlen(selectStr));
  1109.   }
  1111.   selEv.type = SelectionNotify;
  1112.   selEv.display = event.xselectionrequest.display;
  1113.   selEv.requestor = event.xselectionrequest.requestor;
  1114.   selEv.selection = event.xselectionrequest.selection;
  1115.   selEv.target = event.xselectionrequest.target;
  1116.   selEv.time = event.xselectionrequest.time;
  1119.   XSendEvent(event.xselectionrequest.display, event.xselectionrequest.requestor, False, 0, (XEvent *) &selEv);
  1120. }
  1121. break;
  1123. #endif /* SELECTION */
  1126.             default:  /* handle all other events */
  1127.                 if (X_TRACE) 
  1128.     fprintf(stderr, "Unexpected Event: %dn", event.type);
  1129.                 break;
  1130.         }
  1131. XFlush(display);
  1132.     }
  1134.     busy = 0;
  1135.     return HT_WOULD_BLOCK; /* howcome 24/7/95: must do this to not insult library */
  1136. }
  1141. /* get font/colour resources */
  1143. void GetResources(void)
  1144. {
  1145.     if (fontsize == 0)
  1146.     {
  1147.         LoadFont(IDX_H1FONT, DetermineValue(prog, "h1font", H1FONT), "variable");
  1148.         LoadFont(IDX_H2FONT, DetermineValue(prog, "h2font", H2FONT), "variable");
  1149.         LoadFont(IDX_H3FONT, DetermineValue(prog, "h3font", H3FONT), "variable");
  1150.         LoadFont(IDX_H4FONT, DetermineValue(prog, "h4font", H4FONT), "variable");
  1151.         LoadFont(IDX_LABELFONT, DetermineValue(prog, "labelfont", LABELFONT), "fixed");
  1152.         LoadFont(IDX_NORMALFONT, DetermineValue(prog, "normalfont", NORMALFONT), "fixed");
  1153.         LoadFont(IDX_INORMALFONT, DetermineValue(prog, "italicfont", ITALICFONT), "fixed");
  1154.         LoadFont(IDX_BNORMALFONT, DetermineValue(prog, "boldfont", BOLDFONT), "fixed");
  1155.         LoadFont(IDX_BINORMALFONT, DetermineValue(prog, "bolditalicfont", BINORMFONT), "fixed");
  1156.         LoadFont(IDX_FIXEDFONT, DetermineValue(prog, "fixedfont", RFIXEDFONT), "fixed");
  1157.         LoadFont(IDX_IFIXEDFONT, DetermineValue(prog, "ifixedfont", IFIXEDFONT), "fixed");
  1158.         LoadFont(IDX_BFIXEDFONT, DetermineValue(prog, "bfixedfont", BFIXEDFONT), "fixed");
  1159.         LoadFont(IDX_BIFIXEDFONT, DetermineValue(prog, "bifixedfont", BIFIXEDFONT), "fixed");
  1160.         LoadFont(IDX_SYMBOLFONT, DetermineValue(prog, "symbolfont", SYMFONT), "grk-s30");
  1161.         LoadFont(IDX_SUBSYMFONT, DetermineValue(prog, "subsymbolfont", SUBSYMFONT), "grk-s25");
  1162.         LoadFont(IDX_SMALLFONT, DetermineValue(prog, "smallfont", SUBSCRFONT), "micro");
  1163.     }
  1164.     else if (fontsize == 1)
  1165.     {
  1166.         LoadFont(IDX_H1FONT, DetermineValue(prog, "h1font", H1FONTL), "vg-20");
  1167.         LoadFont(IDX_H2FONT, DetermineValue(prog, "h2font", H2FONTL), "fg-16");
  1168.         LoadFont(IDX_H3FONT, DetermineValue(prog, "h3font", H3FONTL), "variable");
  1169.         LoadFont(IDX_H4FONT, DetermineValue(prog, "h4font", H4FONTL), "variable");
  1170.         LoadFont(IDX_LABELFONT, DetermineValue(prog, "labelfont", LABELFONT), "fixed");
  1171.         LoadFont(IDX_NORMALFONT, DetermineValue(prog, "normalfont", NORMALFONTL), "fixed");
  1172.         LoadFont(IDX_INORMALFONT, DetermineValue(prog, "italicfont", ITALICFONTL), "fixed");
  1173.         LoadFont(IDX_BNORMALFONT, DetermineValue(prog, "boldfont", BOLDFONTL), "fixed");
  1174.         LoadFont(IDX_BINORMALFONT, DetermineValue(prog, "bolditalicfont", BINORMFONTL), "fixed");
  1175.         LoadFont(IDX_FIXEDFONT, DetermineValue(prog, "fixedfont", RFIXEDFONTL), "fixed");
  1176.         LoadFont(IDX_IFIXEDFONT, DetermineValue(prog, "ifixedfont", IFIXEDFONTL), "fixed");
  1177.         LoadFont(IDX_BFIXEDFONT, DetermineValue(prog, "bfixedfont", BFIXEDFONTL), "fixed");
  1178.         LoadFont(IDX_BIFIXEDFONT, DetermineValue(prog, "bifixedfont", BIFIXEDFONTL), "fixed");
  1179.         LoadFont(IDX_SYMBOLFONT, DetermineValue(prog, "symbolfont", SYMFONTL), "grk-s30");
  1180.         LoadFont(IDX_SUBSYMFONT, DetermineValue(prog, "subsymbolfont", SUBSYMFONTL), "grk-s25");
  1181.         LoadFont(IDX_SMALLFONT, DetermineValue(prog, "smallfont", SUBSCRFONTL), "micro");
  1182.     }
  1183.     else if (fontsize >= 2)
  1184.     {
  1185.         LoadFont(IDX_H1FONT, DetermineValue(prog, "h1font", H1FONTG), "vg-20");
  1186.         LoadFont(IDX_H2FONT, DetermineValue(prog, "h2font", H2FONTG), "fg-16");
  1187.         LoadFont(IDX_H3FONT, DetermineValue(prog, "h3font", H3FONTG), "variable");
  1188.         LoadFont(IDX_H4FONT, DetermineValue(prog, "h4font", H4FONTG), "variable");
  1189.         LoadFont(IDX_LABELFONT, DetermineValue(prog, "labelfont", LABELFONT), "fixed");
  1190.         LoadFont(IDX_NORMALFONT, DetermineValue(prog, "normalfont", NORMALFONTG), "fixed");
  1191.         LoadFont(IDX_INORMALFONT, DetermineValue(prog, "italicfont", ITALICFONTG), "fixed");
  1192.         LoadFont(IDX_BNORMALFONT, DetermineValue(prog, "boldfont", BOLDFONTG), "fixed");
  1193.         LoadFont(IDX_BINORMALFONT, DetermineValue(prog, "bolditalicfont", BINORMFONTG), "fixed");
  1194.         LoadFont(IDX_FIXEDFONT, DetermineValue(prog, "fixedfont", RFIXEDFONTG), "fixed");
  1195.         LoadFont(IDX_IFIXEDFONT, DetermineValue(prog, "ifixedfont", IFIXEDFONTG), "fixed");
  1196.         LoadFont(IDX_BFIXEDFONT, DetermineValue(prog, "bfixedfont", BFIXEDFONTG), "fixed");
  1197.         LoadFont(IDX_BIFIXEDFONT, DetermineValue(prog, "bifixedfont", BIFIXEDFONTG), "fixed");
  1198.         LoadFont(IDX_SYMBOLFONT, DetermineValue(prog, "symbolfont", SYMFONTG), "grk30s25");
  1199.         LoadFont(IDX_SUBSYMFONT, DetermineValue(prog, "subsymbolfont", SUBSYMFONTG), "grk-s25");
  1200.         LoadFont(IDX_SMALLFONT, DetermineValue(prog, "smallfont", SUBSCRFONTG), "micro");
  1201.     }
  1203.     fixed_font = Fonts[IDX_FIXEDFONT];
  1205.     /* list indents for ordered/unordered lists */
  1207.     ListIndent1 = XTextWidth(Fonts[IDX_NORMALFONT], "ABCabc", 6)/6;
  1208.     ListIndent2 = ListIndent1;
  1209.     ListIndent1 = 2 * ListIndent1;
  1211.     /* check for monchrome displays */
  1213.     if (DefaultDepth(display, screen) == 1)
  1214.     {
  1215.         strikeColor = labelColor = textColor = BlackPixel(display, screen);
  1216.         transparent = statusColor = windowColor = WhitePixel(display, screen);
  1217.         windowShadow = windowTopShadow = windowBottomShadow = textColor;
  1218.     }
  1219.     else   /* try for color but degrade as sensibly as possible */
  1220.     {
  1221.         if (!DetermineColor(prog, "windowColor", 220, 209, 186, &windowColor))
  1222.         {
  1223.             if (GetNamedColor("gray", &windowColor))
  1224.             {
  1225.                 windowBottomShadow = BlackPixel(display, screen);
  1227.                 if (!GetNamedColor("dim gray", &windowShadow))
  1228.                     windowShadow = windowColor;
  1230.                 if (!GetNamedColor("light gray", &windowTopShadow))
  1231.                     windowTopShadow = WhitePixel(display, screen);
  1233.                 strikeColor = textColor = labelColor = WhitePixel(display, screen);
  1234.             }
  1235.             else
  1236.             {
  1237.                 labelColor = strikeColor = textColor = BlackPixel(display, screen);
  1238.                 windowShadow = windowColor = WhitePixel(display, screen);
  1239.                 windowShadow = windowTopShadow = windowBottomShadow = textColor;
  1240.             }
  1241.         }
  1242.         else
  1243.         {
  1244.             DetermineColor(prog, "textColor", 0, 0, 100, &textColor);
  1245.             DetermineColor(prog, "labelColor", 0, 100, 100, &labelColor);
  1246.             DetermineColor(prog, "strikeColor", 170, 0, 0, &strikeColor);
  1248.             DetermineColor(prog, "windowShadow", 200, 188, 169, &windowShadow);
  1249.             DetermineColor(prog, "windowTopShadow", 255, 242, 216, &windowTopShadow);
  1250.             DetermineColor(prog, "windowBottomShadow", 180, 170, 152, &windowBottomShadow);
  1252.             if (windowTopShadow == windowColor)
  1253.                 windowTopShadow = WhitePixel(display, screen);
  1255.             if (windowBottomShadow == windowColor)
  1256.                 windowBottomShadow = BlackPixel(display, screen);
  1258.             if (windowColor == textColor)
  1259.             {
  1260.                 windowShadow = windowColor = BlackPixel(display, screen);
  1261.                 strikeColor = windowTopShadow = windowBottomShadow = textColor;
  1262.             }
  1263.         }
  1265.         transparent = windowColor;
  1266.         statusColor = windowShadow;
  1267.     }
  1268. }
  1270. void MakePaper()
  1271. {
  1272.     XGCValues values;
  1273.     unsigned int valuemask;
  1274.     Pixmap pixmap;
  1275.     XImage *image;
  1276.     GC drawGC;
  1278.     gc_fill = XCreateGC(display, win, 0, 0);
  1279.     XSetFunction(display, gc_fill, GXcopy);
  1281.     InitPaperRGB ();
  1283.     if (! (UsePaper && (depth == 8 || depth == 16 || depth == 24)))
  1284.     {
  1285.         UsePaper = 0;
  1286.         XSetForeground(display, gc_fill, windowColor);
  1287.     }
  1288.     else
  1289.     {
  1290.         tileWidth = tileHeight = 64;
  1292. /* howcome 15/3/95: commented out XQueryTile since it on some
  1293.            platforms set tile* to 0. On other servers it returns a low
  1294.            number which dosn't look good */
  1296. /*        XQueryBestTile(display, win, tileWidth, tileHeight, &tileWidth, &tileHeight); */
  1298.         tileData = CreateBackground(tileWidth, tileHeight, depth);
  1300.         if (!tileData)
  1301.         {
  1302.             UsePaper = 0;
  1303.             XSetForeground(display, gc_fill, windowColor);
  1304.             return;
  1305.         }
  1307.         if ((pixmap = XCreatePixmap(display, win, tileWidth, tileHeight, depth)) == 0)
  1308.         {
  1309.             fprintf(stderr, "Failed to create Pixmap for background!n");
  1310.             Exit(1);
  1311.         }
  1313.         if ((image = XCreateImage(display, DefaultVisual(display, screen),
  1314.   depth, ZPixmap, 0, (char *)tileData,
  1315.   tileWidth, tileHeight, (depth == 24 ? 32 : (depth == 16 ? 16 : 8)), 0)) == 0)
  1316.         {
  1317.             /* Free(tileData); keep for transparent backgrounds */
  1318.             XFreePixmap(display, pixmap);
  1319.             fprintf(stderr, "Failed to create X Image for background!n");
  1320.             Exit(1);
  1321.         }
  1323. /* howcome 22/2/95: do we need to set these?? */
  1325. image->byte_order = MSBFirst;
  1326. image->bitmap_bit_order = BitmapBitOrder(display); /* was MSBFirst*/ ;
  1328.         drawGC = XCreateGC(display, pixmap, 0, 0);
  1329.         XSetFunction(display, drawGC, GXcopy);
  1330.         XPutImage(display, pixmap, drawGC, image, 0, 0, 0, 0, tileWidth, tileHeight);
  1331.         XFreeGC(display, drawGC);
  1332.         image->data = NULL;   /* we don't want to free image data */
  1333.         XDestroyImage(image); /* normally frees image data */
  1335.         valuemask = GCTile|GCFillStyle;
  1336.         values.tile = pixmap;
  1337.         values.fill_style = FillTiled;
  1338.         XChangeGC(display, gc_fill, valuemask, &values);
  1339.     }
  1340. }
  1342. /* create clone of self by forking and duplicating resources
  1344.     creates duplicate of history file and closes
  1345.     all open files, then duplicates stdio ...
  1347.     returns 0 for parent, and 1 for clone
  1348. */
  1350. int CloneSelf(void)
  1351. {
  1353. #if 0
  1355.     int childpid, tty;
  1356.     int x = 0, y = 0;               /* window position */
  1357.     unsigned int border_width = 4;  /* border four pixels wide */
  1358. /*    unsigned int display_width, display_height;*/
  1359.     char *window_name = BANNER;
  1360.     char *icon_name = BANNER;
  1361.     int i, fh, depth;
  1362.     unsigned int class;
  1363.     Visual *visual;
  1364.     unsigned long valuemask, where;
  1365.     XSetWindowAttributes attributes;
  1366.     Pixmap icon_pixmap;
  1368.     if ((tty = open("/dev/tty", 2)) == -1 && (tty = open("/dev/null", 2)) == -1)
  1369.     {
  1370.         Warn("Can't open /dev/tty");
  1371.         return 0;
  1372.     }
  1374.     /* ensure that children won't become zombies */
  1376. #ifdef SIGCHLD
  1377.     signal(SIGCHLD, SIG_IGN);
  1378. #else
  1379.     signal(SIGCLD, SIG_IGN);
  1380. #endif
  1382.     if ((childpid = fork()) < 0)
  1383.     {
  1384.         close(tty);
  1385.         Warn("Can't fork new process");
  1386.         return 0;
  1387.     }
  1389.     if (childpid != 0)
  1390.     {
  1391.         close(tty);
  1392.         return 0;
  1393.     }
  1395.     /* ok child process - so dup stdio  - this leaves other files open! */
  1397.     fprintf(stderr,"CloneSelf: childn");
  1399.     close(0); dup(tty);
  1400.     close(1); dup(tty);
  1401.     close(2); dup(tty);
  1402.     close(tty);
  1404.     close(ConnectionNumber(display));  /* close TCP connection to X server */
  1406.     /* now clone history file and close original */
  1408.     initialised = 0;  /* avoid X output until this is true! */
  1410. /*    XCloseDisplay(display); */ /* close connection for parent display */
  1412.     /* connect to X server */
  1414.     if ( (display = XOpenDisplay(display_name)) == NULL )
  1415.     {
  1416.         (void) fprintf(stderr, "www: cannot connect to X server %sn",
  1417.                         XDisplayName(display_name));
  1418.         exit(-1);
  1419.     }
  1421.     /* free memory but not pixmaps which we no longer own! */
  1422.     FreeImages(1);
  1423.     FreeForms();   /* is this right? */
  1424.                      
  1425.   /* try to allocate 128 fixed colors + 16 grey scales */
  1426.     if (InitImaging(ColorStyle) == MONO)
  1427.         UsePaper = 0;
  1429. /*    GetResources();  *//* load font and colour resources */
  1431.     if (ColorStyle == MONO)
  1432.         statusColor = windowColor;
  1434.     /* get screen size from display structure macro */
  1436.     screen = DefaultScreen(display);
  1438.     depth = DisplayPlanes(display, screen);
  1439.     class = InputOutput;    /* window class*/
  1440.     visual = DefaultVisual(display, screen);
  1441.     valuemask = CWColormap | CWBorderPixel | CWBitGravity |
  1442.              CWBackingStore | CWBackingPlanes;
  1443.     attributes.colormap = colormap;
  1444.     attributes.bit_gravity = ForgetGravity;
  1445.     attributes.backing_planes = 0;
  1446.     attributes.backing_store = NotUseful;
  1448.     win = XCreateWindow(display, RootWindow(display, screen),
  1449.             x,y, win_width, win_height, border_width,
  1450.             depth, class, visual, valuemask, &attributes);
  1452.     XSetWindowBackground(display, win, windowColor);
  1454.     /* Create pixmap of depth 1 (bitmap) for icon */
  1456.     icon_pixmap = XCreateBitmapFromData(display, win, www_bits,
  1457.                                     www_width, www_height);
  1459.     /* Create default pixmap for use when we can't load images */
  1461.     default_pixmap = XCreatePixmapFromBitmapData(display, win, www_bits,
  1462.                       www_width, www_height, textColor, transparent, depth);
  1464.     default_pixmap_width = www_width;
  1465.     default_pixmap_height = www_height;
  1467.     /* initialize size hint property for window manager */
  1469.     size_hints.flags = PPosition | PSize | PMinSize;
  1470.     size_hints.x = x;
  1471.     size_hints.y = y;
  1472.     size_hints.width = win_width;
  1473.     size_hints.height = win_height;
  1474.     size_hints.min_width = 440;
  1475.     size_hints.min_height = 250;
  1477.     /* set properties for window manager (always before mapping) */
  1479.     XSetStandardProperties(display, win, window_name, icon_name,
  1480.         icon_pixmap, (char **)0, 0, &size_hints);
  1482.     /* select events wanted */
  1484.     XSelectInput(display, win, ExposureMask | KeyPressMask | KeyReleaseMask |
  1485.        Button1MotionMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask |PropertyChangeMask);
  1487.     /* create hourglass cursor */
  1489.     hourglass = XCreateFontCursor(display, XC_watch);
  1491.     /* create GCs for text and drawing: gc_scrollbar, gc_status, gc_text */
  1493.     gc_scrollbar = XCreateGC(display, win, 0, 0);
  1494.     gc_status = XCreateGC(display, win, 0, 0);
  1495.     gc_text = XCreateGC(display, win, 0, 0);
  1496.     MakePaper();
  1497.     font = -1;
  1499.     if (DocHTML(CurrentDoc))
  1500.         SetBanner(CurrentDoc->url);
  1502.     /* refresh paint buffer to ensure that images resources are created */
  1504.     where = PixelOffset;
  1505.     PixelOffset = 0;
  1506.     ParseHTML(&i);
  1508.     if (where > 0)
  1509.         DeltaHTMLPosition(where);
  1511.     /* Map Display Window */
  1513.     XMapWindow(display, win);
  1515.     return 1;
  1517. #endif
  1518.     return 1;
  1520. }
  1522. Context *NewContext()
  1523. {
  1524.     return ((Context *) calloc (sizeof(Context), 1));
  1525. }
  1528. void myAlarm()
  1529. {
  1530.     fprintf(stderr,"myAlarmn");
  1532. }
  1534. void Push(void *item)
  1535. {
  1536.     *stack = (long)item;
  1537.     stack += sizeof(long);
  1538. }
  1540. void *Pop()
  1541. {
  1542.     if(stack == main_stack)
  1543. return NULL;
  1544.     
  1545.     stack -= sizeof(long);
  1546.     return((void *)*stack);
  1547. }
  1549. void main(int argc, char **argv)
  1550. {
  1551.     int x = 0, y = 0;               /* window position */
  1552.     unsigned int border_width = 2;  /* border four pixels wide */
  1553.     char *window_name = BANNER;
  1554.     char *icon_name = BANNER;
  1555.     int best_depth;    
  1556.     /*    unsigned long *pixels;  janet 21/07/95:  not used */
  1557.     unsigned int class;
  1558.     unsigned long valuemask;
  1559.     XSetWindowAttributes attributes;
  1560.     XClassHint class_hints;
  1561.     mode_t cmask;
  1562.  
  1564. #ifdef SIGWAITING_IGN
  1565.     signal(SIGWAITING, SIG_IGN);           /* howcome: solaris binaries receive this signal, but why? */
  1566. #endif
  1567.     signal(SIGABRT, SIG_IGN);
  1568.     signal(SIGPIPE, SIG_IGN);
  1569. #if !defined __QNX__ 
  1570.     signal(SIGINT, Exit);   /* howcome 4/10/94: trap C-C so that we can delete cache */
  1571. #endif
  1572.     signal(SIGIOT, CatchCore);
  1573. /*    signal(SIGSEGV, CatchCore); */
  1574.     cmask = umask(0000);
  1576.     stack = main_stack;
  1578.     UseHTTP2 = 1;
  1579.     UsePaper = 1;
  1581.     ColorStyle = COLOR888;
  1583.     Editor = getenv("EDITOR"); /* howcome 16/10/94: has to do it before command line arg processing */
  1585.     prog = argv[0];
  1587.     while (argc > 1)
  1588.     {
  1589. if (!strcasecmp(argv[1], "-help")||!strcasecmp(argv[1], "-h"))
  1590. {
  1591.     printf("Usage: arena [-large][-giant][-mono][-grey][-color][-color8]n");
  1592.     printf("             [-plain][-nocache][-noterminal][-nomailcap][-nostyle]n");
  1593.     printf("             [-cm][-quiet][-display display][-editor editor]n");
  1594.     printf("             [-cache dir][-geometry geom] [URL]n");
  1595.     Exit(1);
  1596. }
  1598. if (strcmp(argv[1], "-large") == 0)
  1599.         {
  1600.             fontsize = 1;
  1601.             --argc;
  1602.             ++argv;
  1603.         }
  1604.         else if (strcmp(argv[1], "-giant") == 0)
  1605.         {
  1606.             fontsize = 2;
  1607.             --argc;
  1608.             ++argv;
  1609.         }
  1610.         else if (strcmp(argv[1], "-mono") == 0)
  1611.         {
  1612.             ColorStyle = MONO;
  1613.             --argc;
  1614.             ++argv;
  1615.         }
  1616.         else if (strcmp(argv[1], "-grey") == 0 ||
  1617.                      strcmp(argv[1], "-gray") == 0)
  1618.         {
  1619.             ColorStyle = GREY4;
  1620.             --argc;
  1621.             ++argv;
  1622.         }
  1623.         else if (strcmp(argv[1], "-color") == 0)
  1624.         {
  1625.             ColorStyle = COLOR888;
  1626.             --argc;
  1627.             ++argv;
  1628.         }
  1629.         else if (strcmp(argv[1], "-color8") == 0)
  1630.         {
  1631.             ColorStyle = COLOR232;
  1632.             --argc;
  1633.             ++argv;
  1634.         }
  1635.         else if (strcmp(argv[1], "-plain") == 0)
  1636.         {
  1637.             UsePaper = 0;
  1638.             --argc;
  1639.             ++argv;
  1640.         }
  1641.         else if (strcmp(argv[1], "-nocache") == 0)
  1642.         {
  1643.             CacheRoot = NULL;
  1644.             --argc;
  1645.             ++argv;
  1646.         }
  1647.         else if (strcmp(argv[1], "-noterminal") == 0)
  1648.         {
  1649.             NoTerminal = 1;
  1650.             --argc;
  1651.             ++argv;
  1652.         }
  1654.         else if (strcmp(argv[1], "-nomailcap") == 0)
  1655.         {
  1656.             NoMailcap = 1;
  1657.             --argc;
  1658.             ++argv;
  1659.         }
  1661.         else if (strcmp(argv[1], "-nostyle") == 0)
  1662.         {
  1663.             NoStyle = 1;
  1664.             --argc;
  1665.             ++argv;
  1666.         }
  1668.         else if (strcmp(argv[1], "-cm") == 0)
  1669.         {
  1670.             OwnColorMap = 1;
  1671.             --argc;
  1672.             ++argv;
  1673.         }
  1675.         else if (strcmp(argv[1], "-quiet") == 0)
  1676.         {
  1677.             Quiet = 1;
  1678.             --argc;
  1679.             ++argv;
  1680.         }
  1682.         else if (strcmp(argv[1], "-display") == 0)
  1683.         {
  1684.             --argc;
  1685.             ++argv;
  1686.     if (argc > 1) {
  1687.                 --argc;
  1688.                 ++argv;
  1689.                 display_name = *argv;
  1690.                 if (OPTION_TRACE)
  1691.     printf("cache dir = %sn", CacheRoot);
  1692.             }
  1693.         }
  1695.         /* howcome 5/10/94: added cache command line option */
  1696.         else if (strcmp(argv[1], "-cache") == 0)
  1697.         {
  1698.             --argc;
  1699.             ++argv;
  1700.             if (argc > 1) {
  1701.                 --argc;
  1702.                 ++argv;
  1703.                 CacheRoot = *argv;
  1704.                 if (OPTION_TRACE)
  1705.     printf("cache dir = %sn", CacheRoot);
  1706.             }
  1707.         }
  1709.         /* howcome 10/10/94: added editor command line option */
  1710.         else if (strncmp(argv[1], "-editor",5) == 0)
  1711.         {
  1712.             --argc;
  1713.             ++argv;
  1714.             if (argc > 1) {
  1715.                 --argc;
  1716.                 ++argv;
  1717.                 Editor = *argv;
  1718.                 if (OPTION_TRACE) 
  1719.     printf("Editor = %sn", Editor);
  1720.             }
  1721.         }
  1723.         /* howcome 10/10/94: added badflags command line option */
  1724.         else if (strcmp(argv[1], "-badflags") == 0)
  1725.         {
  1726.             --argc;
  1727.             ++argv;
  1728.             if (argc > 1) {
  1729.                 --argc;
  1730.                 ++argv;
  1731.                 Badflags = atoi(*argv);
  1732.                 if (OPTION_TRACE) 
  1733.     printf("Editor = %sn", Editor);
  1734.             }
  1735.         }
  1737.         /* howcome 13/10/94: added icon command line option */
  1738.         else if (strcmp(argv[1], "-icon") == 0)
  1739.         {
  1740.             --argc;
  1741.             ++argv;
  1742.             if (argc > 1) {
  1743.                 --argc;
  1744.                 ++argv;
  1745.                 Icon = *argv;
  1746.                 if (OPTION_TRACE) 
  1747.     printf("Icon = %sn", Icon);
  1748.             }
  1749.         }
  1751.         /* howcome 10/10/94: added command line option */
  1752.         else if (strncmp(argv[1], "-printer",6) == 0)
  1753.         {
  1754.             --argc;
  1755.             ++argv;
  1756.             if (argc > 1) {
  1757.                 --argc;
  1758.                 ++argv;
  1759.                 Printer = *argv;
  1760.                 if (OPTION_TRACE) 
  1761.     printf("Printer = %sn", Printer);
  1762.             }
  1763.         }
  1765.         /* howcome 7/11/94: added command line option */
  1766.         else if (strncmp(argv[1], "-gamma",6) == 0)
  1767.         {
  1768.             --argc;
  1769.             ++argv;
  1770.             if (argc > 1) {
  1771.                 --argc;
  1772.                 ++argv;
  1773.                 Gamma = (double) atof (*argv);
  1774.                 if (OPTION_TRACE) 
  1775.     printf("Gamma = %fn", Gamma);
  1776.             }
  1777.         }
  1779.         else if (strcmp(argv[1], "-debug") == 0)
  1780.         {
  1781.             debug = 255;
  1782.     library_trace = 255;
  1783.             --argc;
  1784.             ++argv;
  1785.         }
  1787.         /* howcome 7/11/94: added command line option */
  1788.         else if (strncmp(argv[1], "-ct",3) == 0)
  1789.         {
  1790.             --argc;
  1791.             ++argv;
  1792.             if (argc > 1) {
  1793.                 --argc;
  1794.                 ++argv;
  1795.                 debug = (int) atoi(*argv);
  1796. /*                if (debug) */
  1797.     printf("Client trace = %dn", debug);
  1798.             }
  1799.         }
  1801.         /* howcome 9/5/95: added command line option */
  1802.         else if (strncmp(argv[1], "-lens",5) == 0)
  1803.         {
  1804.             --argc;
  1805.             ++argv;
  1806.             if (argc > 1) {
  1807.                 --argc;
  1808.                 ++argv;
  1809.                 lens_factor = (int) atof(*argv);
  1810. fontsize = (int) (lens_factor + 0.5);
  1811. /*                if (debug) */
  1812.     printf("Client trace = %dn", debug);
  1813.             }
  1814.         }
  1817.         /* howcome 7/11/94: added command line option */
  1818.         else if (strncmp(argv[1], "-lt",3) == 0)
  1819.         {
  1820.             --argc;
  1821.             ++argv;
  1822.             if (argc > 1) {
  1823.                 --argc;
  1824.                 ++argv;
  1826. {
  1827.     char *p = *argv;
  1828.     library_trace = 0;
  1829.     for(; *p; p++) {
  1830. switch (*p) {
  1831.     case 'a': library_trace |= SHOW_ANCHOR_TRACE; break;
  1832.     case 'b': library_trace |= SHOW_BIND_TRACE; break;
  1833.     case 'c': library_trace |= SHOW_CACHE_TRACE; break;
  1834.     case 'g': library_trace |= SHOW_SGML_TRACE; break;
  1835.     case 'p': library_trace |= SHOW_PROTOCOL_TRACE; break;
  1836.     case 's': library_trace |= SHOW_STREAM_TRACE; break;
  1837.     case 't': library_trace |= SHOW_THREAD_TRACE; break;
  1838.     case 'u': library_trace |= SHOW_URI_TRACE; break;
  1839.      case 'v': library_trace = SHOW_ALL_TRACE; break;
  1840. }
  1841.     }
  1842. }
  1844. /*                library_trace = (int) atoi(*argv);*/
  1845. /*                if (debug) */
  1846.     printf("Library trace = %dn", library_trace);
  1847.             }
  1848.         }
  1849.        /* pdd 31/10/95: added crippled window position option */
  1850.         else if (strcmp(argv[1], "-geometry") == 0)
  1851.         {
  1852.            --argc;
  1853.            ++argv;
  1854.            if (argc > 1) {
  1855.               --argc;
  1856.               ++argv;
  1857.       sscanf(*argv,"+%d+%d", &x, &y);
  1858.               /* this part may not be necessary... but can't hurt */
  1859.       if (x < 0 || x >= 2048 || y < 0 || y >= 1536) {
  1860. fprintf(stderr,"-geometry: only supports +X+Yn");
  1861. x = 0;
  1862. y = 0;
  1863.       }
  1864.             }
  1865.          }
  1867.         /* pdd 31/10/95: added option to force end of option parsing */
  1868.         else if (strcmp(argv[1],"--") == 0)
  1869.         {
  1870.           --argc;
  1871.           ++argv;
  1872.           break;
  1873.         }
  1875.         /* pdd 31/10/95: silently bypass invalid arguments */
  1876.         else if (strncmp(argv[1],"-",1) == 0)
  1877.         {
  1878.           --argc;
  1879.           ++argv;
  1880.         }
  1883.         /* pdd 31/10/95: treat first argument not starting with a "-"
  1884.            as a new starting URL */
  1885.         else if (strncmp(argv[1],"-",1) != 0)
  1886.         {
  1887.           break;
  1888.         }
  1889.       } /* end of command line option parsing */
  1892.     /* initialise ISO character entity definitions */
  1894.     InitEntities();
  1896.     /* connect to X server */
  1898.     if ( (display=XOpenDisplay(display_name)) == NULL )
  1899.     {
  1900.         (void) fprintf(stderr, "www: cannot connect to X server %sn",
  1901.                         XDisplayName(display_name));
  1902.         Exit(-1);
  1903.     }
  1905. /*    XSetErrorHandler(CatchX);*/
  1908. /* for debuging  - disable buffering of output queue */
  1910. /*    XSynchronize(display, 0); */ /* 0 enable, 1 disable */
  1912. /*    gateway = DetermineValue(prog, "gateway", GATEWAY_HOST); */
  1913.     help = DetermineValue(prog, "help", HELP_URL);
  1915. /*    printer = DetermineValue(prog, "printer", PRINTER);*/ /* howcome 16/10/94: best not to set this */
  1917.     startwith = getenv("WWW_HOME");
  1918.     if (!startwith)
  1919. startwith = DetermineValue(prog, "startwith", DEFAULT_URL);
  1921.     /* get screen size from display structure macro */
  1923.     screen = DefaultScreen(display);
  1924.     depth = DisplayPlanes(display, screen);
  1926.     if (depth == 1)
  1927.       ColorStyle = MONO;
  1928.     
  1929.     visual = BestVisual(TrueColor, &best_depth);
  1930.     if (best_depth == 24){
  1932. /* From Scott Nelson <snelson@canopus.llnl.gov> 24bit color: 12/5/94 */
  1933. /* visual = BestVisual(DirectColor, &best_depth); */ 
  1934. visual=BestVisual(TrueColor, &best_depth); 
  1935. CalcPixelShift();
  1936.     } else {
  1937. visual = BestVisual(DirectColor, &best_depth);
  1938.     }
  1940.     if (ColorStyle != COLOR888 || best_depth <= depth)
  1941.     {
  1942.         colormap = DefaultColormap(display, screen);
  1943.         visual = DefaultVisual(display, screen);
  1945.         if ((ColorStyle = InitImaging(ColorStyle)) == MONO)
  1946.             UsePaper = 0;
  1947.     }
  1948.     else
  1949.     {
  1950.         InitImaging(ColorStyle);
  1951.         depth = best_depth;
  1952.         colormap = XCreateColormap(display, RootWindow(display, screen),
  1953.                                                     visual, AllocNone);
  1954.     }
  1956.     display_width = DisplayWidth(display, screen);
  1957.     display_height = DisplayHeight(display, screen);
  1958.     display_pt2px =  (25.4 / 72.0) * 
  1959. (((double) DisplayWidth(display,screen)) / ((double) DisplayWidthMM(display, screen)));
  1961.     GetResources();  /* load font and colour resources */
  1963.     if (ColorStyle == MONO)
  1964.         statusColor = windowColor;
  1966.     /* size widow with enough room for text */
  1968.     charWidth = XTextWidth(Fonts[IDX_NORMALFONT], "ABCabc", 6)/6; 
  1969.     charHeight = SPACING(Fonts[IDX_NORMALFONT]);
  1971.     win_width = min ( (92 * charWidth), (display_width * 0.9) );
  1972.     win_height = min ( (35 * charHeight + 7), (display_height) );
  1974.     class = InputOutput;    /* window class*/
  1975.     valuemask = CWColormap | CWBorderPixel | CWBitGravity |
  1976.              CWBackingStore | CWBackingPlanes;
  1977.     attributes.colormap = colormap;
  1978.     attributes.bit_gravity = ForgetGravity;
  1979.     attributes.backing_planes = 0;
  1980.     attributes.backing_store = NotUseful;
  1982.     /* create opaque window */
  1984.     win = XCreateWindow(display, RootWindow(display, screen),
  1985.             x,y, win_width, win_height, border_width,
  1986.             depth, class, visual, valuemask, &attributes);
  1988.     class_hints.res_name = (char *)calloc(strlen("Browser")+1, sizeof(char));
  1989.     strcpy(class_hints.res_name, "Browser");
  1990.     class_hints.res_class = (char *)calloc(strlen(BANNER)+1, sizeof(char));
  1991.     strcpy(class_hints.res_class, BANNER);
  1992.     XSetClassHint(display, win, &class_hints);
  1994.     ARENA_LOCATION = XInternAtom(display, "ARENA_LOCATION", False); /* inter client comm */
  1995.     ARENA_COMMAND  = XInternAtom(display, "ARENA_COMMAND" , False);
  1997.     /* Create pixmap of depth 1 (bitmap) for icon */
  1998. /*
  1999.     icon_pixmap = XCreateBitmapFromData(display, win, www_bits,
  2000.                                     www_width, www_height);
  2001. */
  2003. #if 0
  2004.     /* Create default pixmap for use when we can't load images */
  2006.     default_pixmap = XCreatePixmapFromBitmapData(display, win, www_bits,
  2007.                       www_width, www_height, textColor, transparent, depth);
  2009.     default_pixmap_width = www_width;
  2010.     default_pixmap_height = www_height;
  2012.     default_image->pixmap = default_pixmap;
  2013.     default_image->width = default_pixmap_width;
  2014.     default_image->height = default_pixmap_height;
  2015. #endif
  2017.     /* initialize size hint property for window manager */
  2019.     size_hints.flags = PPosition | PSize | PMinSize;
  2020.     size_hints.x = x;
  2021.     size_hints.y = y;
  2022.     size_hints.width = win_width;
  2023.     size_hints.height = win_height;
  2025.     size_hints.min_width = 100;
  2026.     size_hints.min_height = 150;
  2027. /*
  2028.     size_hints.min_width = 440;
  2029.     size_hints.min_height = 350;
  2030. */
  2031.     /* before we can call XSetStandardProperties we need the
  2032.        icon. Befor we can get the icon, we need to initialize the
  2033.        library */
  2035.     context = NewContext();
  2036.     context->registered_anchors = HTList_new();
  2037. /*    context->pending_docs = HTList_new();
  2038.     context->pending_anchors = HTList_new(); */
  2039.     context->style = StyleGetInit();
  2040.     context->history = HTList_new();
  2041.     context->conversions = HTList_new();
  2042.     context->memory_leaks = HTList_new();
  2045.     libEntry(); /* howcome: library init */
  2046.     LoadIcon(); /* howcome 14/10/94 */
  2048.     /* set properties for window manager (always before mapping) */
  2050.     XSetStandardProperties(display, win, window_name, icon_name,
  2051.         icon_pixmap, argv, argc, &size_hints);
  2053.     /* select events wanted */
  2055.     XSelectInput(display, win, ExposureMask | KeyPressMask | KeyReleaseMask |
  2056.        Button1MotionMask | ButtonPressMask | ButtonReleaseMask |
  2057.        StructureNotifyMask | SubstructureNotifyMask| PropertyChangeMask);
  2059.     /* create hourglass cursor */
  2061.     hourglass = XCreateFontCursor(display, XC_watch);
  2063.     /* create GCs for text and drawing: gc_scrollbar, gc_status, gc_text */
  2065.     gc_scrollbar = XCreateGC(display, win, 0, 0);
  2066.     gc_status = XCreateGC(display, win, 0, 0);
  2067.     gc_text = XCreateGC(display, win, 0, 0);
  2069.     /* find user's name */
  2071.      user = getenv("USER");     /* shell variable for user name */
  2074. /*    InitCurrent(CurrentDirectory()); */  /* set current host to self etc. */
  2075.     SetToolBarFont(Fonts[IDX_LABELFONT]);
  2076.     SetStatusFont(Fonts[IDX_LABELFONT]);
  2078.     SetToolBarWin(win);
  2079.     SetToolBarGC(gc_status);
  2080.     SetStatusWin(win);
  2081.     SetStatusGC(gc_status);
  2082.     SetScrollBarWin(win);
  2083.     SetScrollBarGC(gc_scrollbar);
  2084.     SetIconWin(win);
  2085.     SetIconGC(gc_status);
  2086.     SetToolBarGC(gc_status);
  2087.     SetDisplayGC(gc_text);
  2088. #ifdef POPUP
  2089.     initPopup(Fonts[IDX_LABELFONT]);
  2090. #endif    
  2091.     MakePaper();  /* create gc_fill for textured paper */
  2092.     MakeIcons(depth);     /* create images for icons */
  2094.     /* create pixmap for testing initial <img> implementation */
  2096.     /* Map Display Window */
  2098.     XMapWindow(display, win);
  2100.     /* get buffer with named file in it */
  2102.     hdrlen = 0;
  2103.     buffer = NULL;
  2106.     if (argc != 1)
  2107.         startwith = argv[1];
  2109. #if 0
  2110.     signal(SIGALRM, myAlarm);
  2112.     itimer.it_value.tv_sec     = 10;
  2113.     itimer.it_value.tv_usec    = 0;
  2114.     itimer.it_interval.tv_sec  = 0;
  2115.     itimer.it_interval.tv_usec = 500000;
  2117.     setitimer (ITIMER_REAL, &itimer, &old_itimer);
  2118. #endif
  2120.     libEventLoop(ConnectionNumber(display), startwith);
  2121. }