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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
xtb.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：37k
源码类别：

通讯编程

开发平台：

Visual C++

xtb.c：源码内容
  1. /*LINTLIBRARY*/
  2. /*
  3.  * Mini-Toolbox
  4.  *
  5.  * David Harrison
  6.  * University of California, Berkeley
  7.  * 1988, 1989
  8.  *
  9.  * This file contains routines which implement simple display widgets
  10.  * which can be used to construct simple dialog boxes.
  11.  * A mini-toolbox has been written here (overkill but I didn't
  12.  * want to use any of the standards yet -- they are too unstable).
  13.  */
  15. #include <X11/Xos.h>
  16. #include <X11/Xlib.h>
  17. #include <X11/Xutil.h>
  18. #include <string.h>  /* for strcpy */
  19. #include "xtb.h"
  21. extern void abort();
  23. #define MAXKEYS 10
  25. #ifdef __STDC__
  26. #define FNPTR(fname, rtn, args) rtn (*fname)args
  27. #include <stdarg.h>
  28. #define VARARGS(func, rtn, args) rtn func args
  29. #else
  30. #define FNPTR(fname, rtn, args) rtn (*fname)()
  31. #include <varargs.h>
  32. #define VARARGS(func, rtn, args) /*VARARGS1*/ rtn func(va_alist) va_dcl
  33. #endif
  35. struct h_info {
  36.     FNPTR(func, xtb_hret, (XEvent * evt, xtb_data info)); /* Function to call */
  37.     xtb_data info; /* Additional info  */
  38. };
  40. static Display *t_disp; /* Display          */
  41. static int t_scrn; /* Screen           */
  43. static unsigned long norm_pix; /* Foreground color */
  44. static unsigned long back_pix; /* Background color */
  46. static XFontStruct *norm_font; /* Normal font      */
  48. extern char *Malloc();
  50. #define STRDUP(str) (strcpy(Malloc((unsigned) (strlen(str)+1)), (str)))
  51. extern void Free();
  55. void
  56. xtb_init(disp, scrn, foreground, background, font)
  57. Display *disp; /* Display          */
  58. int     scrn; /* Screen number    */
  59. unsigned long foreground; /* Foreground color */
  60. unsigned long background; /* Background color */
  61. XFontStruct *font; /* Normal font      */
  63. /*
  64.  * Sets default parameters used by the mini-toolbox.
  65.  */
  66. {
  67.     t_disp = disp;
  68.     t_scrn = scrn;
  69.     norm_pix = foreground;
  70.     back_pix = background;
  71.     norm_font = font;
  72. }
  75. #define gray_width 32
  76. #define gray_height 32
  77. static char gray_bits[] =
  78. {
  79.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
  80.     0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
  81.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
  82.     0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
  83.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
  84.     0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
  85.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
  86.     0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
  87.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
  88.     0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
  89.     0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa};
  91. static  Pixmap
  92. make_stipple(disp, able, bits, width, height)
  93. Display *disp;
  94. Drawable able;
  95. char   *bits;
  96. unsigned int     width,
  97.         height;
  98. {
  99.     unsigned int     w,
  100.             h;
  101.     Pixmap  stipple;
  102.     int     bitmap_pad;
  103.     GC      image_gc;
  104.     XGCValues image_vals;
  105.     XImage *stip_image;
  107.     if (!XQueryBestStipple(disp, able, width, height, &w, &h)) {
  108. /* Can't query best stipple */
  109. return (Pixmap) 0;
  110.     }
  111.     if ((w > width) || (h > height)) {
  112. /* Given pattern is too small */
  113. return (Pixmap) 0;
  114.     }
  115.     if (!(stipple = XCreatePixmap(disp, able, w, h, 1))) {
  116. /* Can't create pixmap image */
  117. return (Pixmap) 0;
  118.     }
  119.     bitmap_pad = 8;
  120.     stip_image = XCreateImage(disp, DefaultVisual(disp, DefaultScreen(disp)),
  121.       1, XYPixmap, 0, bits, width, height,
  122.       bitmap_pad, 0);
  123.     if (!stip_image)
  124. return (Pixmap) 0;
  125.     image_gc = XCreateGC(disp, stipple, (unsigned long) 0, &image_vals);
  126.     XPutImage(disp, stipple, image_gc, stip_image, 0, 0, 0, 0, w, h);
  127.     return stipple;
  128. }
  131. static  Pixmap
  132. gray_map(win)
  133. Window  win;
  135. /*
  136.  * Returns a gray pixmap suitable for stipple fill.
  137.  */
  138. {
  139.     static Pixmap map = (Pixmap) 0;
  141.     if (!map) {
  142. map = make_stipple(t_disp, win, gray_bits, gray_width, gray_height);
  143.     }
  144.     return map;
  145. }
  147. static  GC
  148. set_gc(win, fg, bg, font, gray_p)
  149. Window  win; /* For creating GC  */
  150. unsigned long fg; /* Foreground pixel */
  151. unsigned long bg; /* Background pixel */
  152. Font    font; /* Font             */
  153. int     gray_p; /* Gray if set      */
  155. /*
  156.  * Sets and returns the fields listed above in a global graphics context.
  157.  * If graphics context does not exist,  it is created.
  158.  */
  159. {
  160.     static GC t_gc = (GC) 0;
  161.     XGCValues gcvals;
  162.     unsigned long gcmask;
  164.     gcvals.foreground = fg;
  165.     gcvals.background = bg;
  166.     gcvals.font = font;
  167.     gcvals.stipple = gray_map(win);
  168.     gcvals.fill_style = (gray_p ? FillStippled : FillSolid);
  169.     gcmask = GCForeground | GCBackground | GCFont | GCFillStyle | GCStipple;
  170.     if (t_gc == (GC) 0) {
  171. t_gc = XCreateGC(t_disp, win, gcmask, &gcvals);
  172.     }
  173.     else {
  174. XChangeGC(t_disp, t_gc, gcmask, &gcvals);
  175.     }
  176.     return t_gc;
  177. }
  181. static XContext h_context = (XContext) 0;
  183. void
  184. xtb_register(win, func, info)
  185. Window  win;
  187. FNPTR(func, xtb_hret, (XEvent * evt, xtb_data info));
  188. xtb_data info;
  190. /*
  191.  * Associates the event handling function `func' with the window
  192.  * `win'.  Additional information `info' will be passed to `func'.
  193.  * The routine should return one of the return codes given above.
  194.  */
  195. {
  196.     struct h_info *new_info;
  198.     if (h_context == (XContext) 0) {
  199. h_context = XUniqueContext();
  200.     }
  201.     new_info = (struct h_info *) Malloc(sizeof(struct h_info));
  202.     new_info->func = func;
  203.     new_info->info = info;
  204.     XSaveContext(t_disp, win, h_context, (caddr_t) new_info);
  205. }
  207. xtb_data
  208. xtb_lookup(win)
  209. Window  win;
  211. /*
  212.  * Returns the associated data with window `win'.
  213.  */
  214. {
  215.     xtb_data data;
  217.     if (!XFindContext(t_disp, win, h_context, (XPointer*) &data)) {
  218. return ((struct h_info *) data)->info;
  219.     }
  220.     else {
  221. return (xtb_data) 0;
  222.     }
  223. }
  225. xtb_hret
  226. xtb_dispatch(evt)
  227. XEvent *evt;
  229. /*
  230.  * Dispatches an event to a handler if its ours.  Returns one of
  231.  * the return codes given above (XTB_NOTDEF, XTB_HANDLED, or XTB_STOP).
  232.  */
  233. {
  234.     struct h_info *info;
  236.     if (!XFindContext(t_disp, evt->xany.window, h_context, (caddr_t *) & info)) {
  237. if (info->func)
  238.     return (*info->func) (evt, info->info);
  239. else
  240.     return XTB_NOTDEF;
  241.     }
  242.     else
  243. return XTB_NOTDEF;
  244. }
  246. int
  247. xtb_unregister(win, info)
  248. Window  win;
  249. xtb_data *info;
  251. /*
  252.  * Removes `win' from the dialog association table.  `info' is
  253.  * returned to allow the user to delete it (if desired).  Returns
  254.  * a non-zero status if the association was found and properly deleted.
  255.  */
  256. {
  257.     struct h_info *hi;
  259.     if (!XFindContext(t_disp, win, h_context, (caddr_t *) & hi)) {
  260. (void) XDeleteContext(t_disp, win, h_context);
  261. *info = hi->info;
  262. Free((char *) hi);
  263. return 1;
  264.     }
  265.     else
  266. return 0;
  267. }
  271. #define BT_HPAD 3
  272. #define BT_VPAD 2
  273. #define BT_LPAD 3
  274. #define BT_BRDR 1
  276. struct b_info {
  277.     FNPTR(func, xtb_hret, (Window win, int state, xtb_data val));
  278.     /* Function to call */
  279.     char   *text; /* Text of button   */
  280.     int     flag; /* State of button  */
  281.     int     na; /* Non-zero if not active */
  282.     int     line_y,
  283.             line_w; /* Entry/Exit line  */
  284.     xtb_data val; /* User defined info */
  285. };
  287. static void
  288. bt_draw(win, ri)
  289. Window  win;
  290. struct b_info *ri;
  292. /*
  293.  * Draws a button window
  294.  */
  295. {
  296.     if (ri->flag) {
  297. XDrawImageString(t_disp, win,
  298.  set_gc(win, back_pix, norm_pix, norm_font->fid, 0),
  299.  BT_HPAD, BT_VPAD + norm_font->ascent,
  300.  ri->text, strlen(ri->text));
  301.     }
  302.     else {
  303. XDrawImageString(t_disp, win,
  304.  set_gc(win, norm_pix, back_pix, norm_font->fid, 0),
  305.  BT_HPAD, BT_VPAD + norm_font->ascent,
  306.  ri->text, strlen(ri->text));
  307.     }
  308.     if (ri->na) {
  309. Window  root;
  310. int     x,
  311.         y;
  312. unsigned int w,
  313.         h,
  314.         b,
  315.         d;
  317. XGetGeometry(t_disp, win, &root, &x, &y, &w, &h, &b, &d);
  318. XFillRectangle(t_disp, win,
  319.        set_gc(win, (ri->flag ? norm_pix : back_pix),
  320.       back_pix, norm_font->fid, 1),
  321.        0, 0, w, h);
  322.     }
  323. }
  325. static void
  326. bt_line(win, ri, pix)
  327. Window  win;
  328. struct b_info *ri;
  329. unsigned long pix;
  331. /*
  332.  * Draws a status line beneath the text to indicate the
  333.  * user has moved into the button.
  334.  */
  335. {
  336.     XDrawLine(t_disp, win,
  337.       set_gc(win, pix, back_pix, norm_font->fid, ri->na),
  338.       BT_HPAD, ri->line_y, BT_HPAD + ri->line_w, ri->line_y);
  339. }
  341. static  xtb_hret
  342. bt_h(evt, info)
  343. XEvent *evt;
  344. xtb_data info;
  346. /*
  347.  * Handles button events.
  348.  */
  349. {
  350.     Window  win = evt->xany.window;
  351.     struct b_info *ri = (struct b_info *) info;
  352.     xtb_hret rtn = 0;
  354.     switch (evt->type) {
  355.     case Expose:
  356. bt_draw(win, ri);
  357. rtn = XTB_HANDLED;
  358. break;
  359.     case EnterNotify:
  360. if (!ri->na)
  361.     bt_line(win, ri, norm_pix);
  362. rtn = XTB_HANDLED;
  363. break;
  364.     case LeaveNotify:
  365. if (!ri->na)
  366.     bt_line(win, ri, back_pix);
  367. rtn = XTB_HANDLED;
  368. break;
  369.     case ButtonPress:
  370. /* Nothing - just wait for button up */
  371. rtn = XTB_HANDLED;
  372. break;
  373.     case ButtonRelease:
  374. if (!ri->na)
  375.     rtn = (*ri->func) (win, ri->flag, ri->val);
  376. break;
  377.     default:
  378. rtn = XTB_NOTDEF;
  379.     }
  380.     return rtn;
  381. }
  383. void
  384. xtb_bt_new(win, text, func, val, frame)
  385. Window  win; /* Parent window     */
  386. char   *text; /* Text in button    */
  388. FNPTR(func, xtb_hret, (Window, int, xtb_data)); /* Callback */
  389. xtb_data val; /* User data         */
  390. xtb_frame *frame; /* Size (RETURN)     */
  392. /*
  393.  * Makes a new button under `win' with the text `text'.  The
  394.  * window, size, and position of the button are returned in `frame'.
  395.  * The initial position is always (0, 0).  When the
  396.  * button is pressed,  `func' will be called with the button
  397.  * window,  the current state of the button,  and `val'.
  398.  * It is up to `func' to change the state of the button (if desired).
  399.  * The routine should return XTB_HANDLED normally and XTB_STOP if the
  400.  * dialog should stop.  The window will be automatically mapped.
  401.  */
  402. {
  403.     XCharStruct bb;
  404.     struct b_info *info;
  405.     int     dir,
  406.             ascent,
  407.             descent;
  409.     XTextExtents(norm_font, text, strlen(text), &dir, &ascent, &descent, &bb);
  410.     frame->width = bb.width + 2 * BT_HPAD;
  411.     frame->height = norm_font->ascent + norm_font->descent + BT_VPAD + BT_LPAD;
  412.     frame->x_loc = frame->y_loc = 0;
  413.     frame->win = XCreateSimpleWindow(t_disp, win,
  414.      frame->x_loc, frame->y_loc,
  415.      frame->width, frame->height,
  416.      BT_BRDR, norm_pix, back_pix);
  417.     XSelectInput(t_disp, frame->win, ExposureMask |
  418.  ButtonPressMask | ButtonReleaseMask |
  419.  EnterWindowMask | LeaveWindowMask);
  420.     info = (struct b_info *) Malloc(sizeof(struct b_info));
  421.     info->func = func;
  422.     info->text = STRDUP(text);
  423.     info->flag = 0;
  424.     info->na = 0;
  425.     info->val = val;
  426.     info->line_y = frame->height - 2;
  427.     info->line_w = frame->width - 2 * BT_HPAD;
  428.     xtb_register(frame->win, bt_h, (xtb_data) info);
  429.     XMapWindow(t_disp, frame->win);
  430.     frame->width += (2 * BT_BRDR);
  431.     frame->height += (2 * BT_BRDR);
  432. }
  434. int
  435. xtb_bt_get(win, stuff, na)
  436. Window  win;
  437. xtb_data *stuff;
  438. int    *na;
  440. /*
  441.  * Returns the state of button `win'.  If provided,  the button
  442.  * specific info is returned in `info' and the active state
  443.  * of the button is returned in `na'.
  444.  */
  445. {
  446.     struct b_info *info = (struct b_info *) xtb_lookup(win);
  448.     if (stuff)
  449. *stuff = info->val;
  450.     if (na)
  451. *na = info->na;
  452.     return info->flag;
  453. }
  455. int
  456. xtb_bt_set(win, val, stuff, na)
  457. Window  win;
  458. int     val;
  459. xtb_data stuff;
  460. int     na;
  462. /*
  463.  * Changes the value of a button and returns the new state.
  464.  * The button is drawn.  If set,  the button specific info
  465.  * will be set to `info'.  This doesn't allow you to set
  466.  * the state to zero, but that may not be important.  If
  467.  * `na' is non-zero,  the button will be deactivated (no
  468.  * activity will be allowed). The change in button appearance
  469.  * will be immediate.
  470.  */
  471. {
  472.     struct b_info *info = (struct b_info *) xtb_lookup(win);
  474.     info->flag = (val != 0);
  475.     info->na = (na != 0);
  476.     if (stuff)
  477. info->val = stuff;
  478.     bt_draw(win, info);
  479.     XFlush(t_disp);
  480.     return info->flag;
  481. }
  483. void
  484. xtb_bt_del(win, info)
  485. Window  win;
  486. xtb_data *info;
  488. /*
  489.  * Deletes the button `win' and returns the user defined information
  490.  * in `info' for destruction.
  491.  */
  492. {
  493.     struct b_info *bi;
  495.     if (xtb_unregister(win, (xtb_data *) & bi)) {
  496. *info = bi->val;
  497. Free((char *) bi->text);
  498. Free((char *) bi);
  499. XDestroyWindow(t_disp, win);
  500.     }
  501. }
  505. #define BR_XPAD 2
  506. #define BR_YPAD 2
  507. #define BR_INTER 2
  509. struct br_info {
  510.     Window  main_win; /* Main button row    */
  511.     int     which_one; /* Which button is on */
  512.     int     btn_cnt; /* How many buttons   */
  513.             FNPTR(func, xtb_hret, (Window win, int prev, int this, xtb_data val));
  514.     xtb_data val; /* User data          */
  515.     Window *btns; /* Button windows     */
  516. };
  518. /*ARGSUSED*/
  519. static  xtb_hret
  520. br_h(win, val, info)
  521. Window  win;
  522. int     val;
  523. xtb_data info;
  525. /*
  526.  * This handles events for button rows.  When a button is pressed,
  527.  * it turns off the button selected in `which_one' and turns itself
  528.  * on.
  529.  */
  530. {
  531.     struct br_info *real_info = (struct br_info *) info;
  532.     int     i,
  533.             prev;
  535.     prev = real_info->which_one;
  536.     if ((prev >= 0) && (prev < real_info->btn_cnt)) {
  537. (void) xtb_bt_set(real_info->btns[prev], 0, (xtb_data) 0, 0);
  538.     }
  539.     for (i = 0; i < real_info->btn_cnt; i++) {
  540. if (win == real_info->btns[i]) {
  541.     real_info->which_one = i;
  542.     break;
  543. }
  544.     }
  545.     (void) xtb_bt_set(win, 1, (xtb_data) 0, 0);
  546.     /* Callback */
  547.     if (real_info->func) {
  548. return (*real_info->func) (real_info->main_win,
  549.    prev, real_info->which_one,
  550.    real_info->val);
  551.     }
  552.     else {
  553. return XTB_HANDLED;
  554.     }
  555. }
  558. void
  559. xtb_br_new(win, cnt, lbls, init, func, val, frame)
  560. Window  win; /* Parent window    */
  561. int     cnt; /* Count of buttons */
  562. char   *lbls[]; /* Button labels    */
  563. int     init; /* Initial button   */
  565. FNPTR(func, xtb_hret, (Window, int, int, xtb_data)); /* Callback */
  566. xtb_data val; /* User data        */
  567. xtb_frame *frame; /* Returned size    */
  569. /*
  570.  * This routine makes a new row of buttons in the window `win'
  571.  * and returns a frame containing all of these buttons.  These
  572.  * buttons are designed so that only one of them will be active
  573.  * at a time.  Initially,  button `init' will be activated (if
  574.  * init is less than zero,  none will be initially activated).
  575.  * Whenever a button is pushed, `func' will be called with the
  576.  * button row window,  the index of the previous button (-1 if
  577.  * none),  the index of the current button,  and the user data, `val'.
  578.  * The function is optional (if zero,  no function will be called).
  579.  * The size of the row is returned in `frame'.  The window
  580.  * will be automatically mapped.  Initially,  the window containing
  581.  * the buttons will be placed at 0,0 in the parent window.
  582.  */
  583. {
  584.     struct br_info *info;
  585.     xtb_frame sub_frame;
  586.     int     i,
  587.             x,
  588.             y;
  590.     frame->width = frame->height = 0;
  591.     frame->x_loc = frame->y_loc = 0;
  592.     frame->win = XCreateSimpleWindow(t_disp, win, 0, 0, 1, 1,
  593.      0, back_pix, back_pix);
  594.     info = (struct br_info *) Malloc(sizeof(struct br_info));
  595.     info->main_win = frame->win;
  596.     info->btns = (Window *) Malloc((unsigned) (sizeof(Window) * cnt));
  597.     info->btn_cnt = cnt;
  598.     info->which_one = init;
  599.     info->func = func;
  600.     info->val = val;
  601.     /* the handler is used simply to get information out */
  602.     xtb_register(frame->win, (xtb_hret(*) ()) 0, (xtb_data) info);
  603.     x = BR_XPAD;
  604.     y = BR_YPAD;
  605.     for (i = 0; i < cnt; i++) {
  606. xtb_bt_new(frame->win, lbls[i], br_h, (xtb_data) info, &sub_frame);
  607. info->btns[i] = sub_frame.win;
  608. XMoveWindow(t_disp, info->btns[i], x, y);
  609. x += (BR_INTER + sub_frame.width);
  610. if (sub_frame.height > frame->height)
  611.     frame->height = sub_frame.height;
  612. if (i == init)
  613.     (void) xtb_bt_set(info->btns[i], 1, (xtb_data) 0, 0);
  614.     }
  615.     frame->width = x - BR_INTER + BR_XPAD;
  616.     frame->height += (2 * BR_YPAD);
  617.     XResizeWindow(t_disp, frame->win, frame->width, frame->height);
  618.     XMapWindow(t_disp, frame->win);
  619. }
  621. int
  622. xtb_br_get(win)
  623. Window  win;
  625. /*
  626.  * This routine returns the index of the currently selected item of
  627.  * the button row given by the window `win'.  Note:  no checking
  628.  * is done to make sure `win' is a button row.
  629.  */
  630. {
  631.     struct br_info *info = (struct br_info *) xtb_lookup(win);
  633.     return info->which_one;
  634. }
  636. void
  637. xtb_br_del(win)
  638. Window  win;
  640. /*
  641.  * Deletes a button row.  All resources are reclaimed.
  642.  */
  643. {
  644.     struct br_info *info;
  645.     int     i;
  647.     if (xtb_unregister(win, (xtb_data *) & info)) {
  648. for (i = 0; i < info->btn_cnt; i++) {
  649.     xtb_bt_del(info->btns[i], (xtb_data *) & info);
  650. }
  651. Free((char *) info->btns);
  652. Free((char *) info);
  653. XDestroyWindow(t_disp, win);
  654.     }
  655. }
  659. /* Text widget */
  661. #define TO_HPAD 1
  662. #define TO_VPAD 1
  664. struct to_info {
  665.     char   *text; /* Text to display */
  666.     XFontStruct *ft; /* Font to use     */
  667. };
  669. static void
  670. to_draw(win, ri)
  671. Window  win;
  672. struct to_info *ri;
  674. /*
  675.  * Draws the text for a widget
  676.  */
  677. {
  678.     XDrawImageString(t_disp, win,
  679.      set_gc(win, norm_pix, back_pix, ri->ft->fid, 0),
  680.      TO_HPAD, TO_VPAD + ri->ft->ascent,
  681.      ri->text, strlen(ri->text));
  682. }
  684. static  xtb_hret
  685. to_h(evt, info)
  686. XEvent *evt;
  687. xtb_data info;
  689. /*
  690.  * Handles text widget events
  691.  */
  692. {
  693.     Window  win = evt->xany.window;
  694.     struct to_info *ri = (struct to_info *) info;
  696.     switch (evt->type) {
  697.     case Expose:
  698. to_draw(win, ri);
  699. return XTB_HANDLED;
  700.     default:
  701. return XTB_NOTDEF;
  702.     }
  703. }
  705. void
  706. xtb_to_new(win, text, ft, frame)
  707. Window  win; /* Parent window */
  708. char   *text; /* Text          */
  709. XFontStruct *ft; /* Font to use   */
  710. xtb_frame *frame; /* Returned size */
  712. /*
  713.  * Makes a new text widget under `win' with the text `text'.
  714.  * The size of the widget is returned in `w' and `h'.  The
  715.  * window is created and mapped at 0,0 in `win'.  The font
  716.  * used for the text is given in `ft'.
  717.  */
  718. {
  719.     struct to_info *info;
  721.     frame->width = XTextWidth(ft, text, strlen(text)) + 2 * TO_HPAD;
  722.     frame->height = ft->ascent + ft->descent + 2 * TO_VPAD;
  723.     frame->x_loc = frame->y_loc = 0;
  724.     frame->win = XCreateSimpleWindow(t_disp, win, 0, 0,
  725.      frame->width, frame->height, 0,
  726.      back_pix, back_pix);
  727.     XSelectInput(t_disp, frame->win, ExposureMask);
  728.     info = (struct to_info *) Malloc(sizeof(struct to_info));
  729.     info->text = STRDUP(text);
  730.     info->ft = ft;
  731.     xtb_register(frame->win, to_h, (xtb_data) info);
  732.     XMapWindow(t_disp, frame->win);
  733. }
  735. void
  736. xtb_to_del(win)
  737. Window  win;
  739. /*
  740.  * Deletes an output only text widget.
  741.  */
  742. {
  743.     struct to_info *info;
  745.     if (xtb_unregister(win, (xtb_data *) & info)) {
  746. if (info->text)
  747.     Free((char *) info->text);
  748. Free((char *) info);
  749. XDestroyWindow(t_disp, win);
  750.     }
  751. }
  754. /*
  755.  * Input text widget
  756.  */
  758. #define TI_HPAD 2
  759. #define TI_VPAD 2
  760. #define TI_LPAD 3
  761. #define TI_BRDR 2
  762. #define TI_CRSP 1
  764. struct ti_info {
  765.     FNPTR(func, xtb_hret, (Window win, int ch, char *textcopy, xtb_data * val));
  766.     /* Function to call   */
  767.     int     maxlen; /* Maximum characters */
  768.     int     curidx; /* Current index pos  */
  769.     int     curxval; /* Current draw loc   */
  770.     char    text[MAXCHBUF]; /* Current text array */
  771.     int     line_y,
  772.             line_w; /* Entry/Exit line    */
  773.     int     focus_flag; /* If on, we have focus */
  774.     xtb_data val; /* User info          */
  775. };
  777. static int
  778. text_width(font, str, len)
  779. XFontStruct *font; /* What font       */
  780. char   *str; /* Character array */
  781. int     len; /* Length of array */
  783. /*
  784.  * Returns the width of a string using XTextExtents.
  785.  */
  786. {
  787.     XCharStruct bb;
  788.     int     dir,
  789.             ascent,
  790.             descent;
  792.     XTextExtents(font, str, len, &dir, &ascent, &descent, &bb);
  793.     return bb.width;
  794. }
  796. static void
  797. ti_cursor_on(win, ri)
  798. Window  win;
  799. struct ti_info *ri;
  801. /*
  802.  * Draws the cursor for the window.  Uses pixel `pix'.
  803.  */
  804. {
  805.     XFillRectangle(t_disp, win,
  806.    set_gc(win, norm_pix, back_pix, norm_font->fid, 0),
  807.    ri->curxval + TI_HPAD + TI_CRSP, TI_VPAD,
  808.    (ri->focus_flag ? 2 : 1),
  809.    norm_font->ascent + norm_font->descent - 1);
  810. }
  812. static void
  813. ti_cursor_off(win, ri)
  814. Window  win;
  815. struct ti_info *ri;
  817. /*
  818.  * Draws the cursor for the window.  Uses pixel `pix'.
  819.  */
  820. {
  821.     XFillRectangle(t_disp, win,
  822.    set_gc(win, back_pix, back_pix, norm_font->fid, 0),
  823.    ri->curxval + TI_HPAD + TI_CRSP, TI_VPAD,
  824.    (ri->focus_flag ? 2 : 1),
  825.    norm_font->ascent + norm_font->descent - 1);
  826. }
  828. static void
  829. ti_draw(win, ri, c_flag)
  830. Window  win;
  831. struct ti_info *ri;
  832. int     c_flag;
  834. /*
  835.  * Draws the indicated text widget.  This includes drawing the
  836.  * text and cursor.  If `c_flag' is set,  the window will
  837.  * be cleared first.
  838.  */
  839. {
  840.     if (c_flag)
  841. XClearWindow(t_disp, win);
  842.     /* Text */
  843.     XDrawImageString(t_disp, win,
  844.      set_gc(win, norm_pix, back_pix, norm_font->fid, 0),
  845.      TI_HPAD, TI_VPAD + norm_font->ascent,
  846.      ri->text, strlen(ri->text));
  847.     /* Cursor */
  848.     ti_cursor_on(win, ri);
  849. }
  851. static void
  852. ti_line(win, ri, pix)
  853. Window  win;
  854. struct ti_info *ri;
  855. unsigned long pix;
  857. /*
  858.  * Draws a status line beneath the text in a text widget to indicate
  859.  * the user has moved into the text field.
  860.  */
  861. {
  862.     XDrawLine(t_disp, win,
  863.       set_gc(win, pix, back_pix, norm_font->fid, 0),
  864.       TI_HPAD, ri->line_y, TI_HPAD + ri->line_w, ri->line_y);
  865. }
  867. /* For debugging */
  868. focus_evt(evt)
  869. XEvent *evt;
  870. {
  871.     switch (evt->xfocus.mode) {
  872.     case NotifyNormal:
  873. printf("NotifyNormal");
  874. break;
  875.     case NotifyGrab:
  876. printf("NotifyGrab");
  877. break;
  878.     case NotifyUngrab:
  879. printf("NotifyUngrab");
  880. break;
  881.     }
  882.     printf(", detail = ");
  883.     switch (evt->xfocus.detail) {
  884.     case NotifyAncestor:
  885. printf("NotifyAncestor");
  886. break;
  887.     case NotifyVirtual:
  888. printf("NotifyVirtual");
  889. break;
  890.     case NotifyInferior:
  891. printf("NotifyInferior");
  892. break;
  893.     case NotifyNonlinear:
  894. printf("NotifyNonLinear");
  895. break;
  896.     case NotifyNonlinearVirtual:
  897. printf("NotifyNonLinearVirtual");
  898. break;
  899.     case NotifyPointer:
  900. printf("NotifyPointer");
  901. break;
  902.     case NotifyPointerRoot:
  903. printf("NotifyPointerRoot");
  904. break;
  905.     case NotifyDetailNone:
  906. printf("NotifyDetailNone");
  907. break;
  908.     }
  909.     printf("n");
  910. }
  914. static  xtb_hret
  915. ti_h(evt, info)
  916. XEvent *evt;
  917. xtb_data info;
  919. /*
  920.  * Handles text input events.
  921.  */
  922. {
  923.     Window  win = evt->xany.window;
  924.     struct ti_info *ri = (struct ti_info *) info;
  925.     char    keys[MAXKEYS],
  926.             textcopy[MAXCHBUF];
  927.     xtb_hret rtn = 0;
  928.     int     nbytes,
  929.             i;
  931.     switch (evt->type) {
  932.     case Expose:
  933. ti_draw(win, ri, 0);
  934. rtn = XTB_HANDLED;
  935. break;
  936.     case KeyPress:
  937. nbytes = XLookupString(&evt->xkey, keys, MAXKEYS,
  938.        (KeySym *) 0, (XComposeStatus *) 0);
  939. for (i = 0; i < nbytes; i++) {
  940.     (void) strcpy(textcopy, ri->text);
  941.     if ((rtn = (*ri->func) (win, (int) keys[i],
  942.     textcopy, ri->val)) == XTB_STOP)
  943. break;
  944. }
  945. break;
  946.     case FocusIn:
  947. focus_evt(evt);
  948. if (evt->xfocus.detail != NotifyPointer) {
  949.     ti_cursor_off(win, ri);
  950.     ri->focus_flag = 1;
  951.     ti_cursor_on(win, ri);
  952. }
  953. break;
  954.     case FocusOut:
  955. focus_evt(evt);
  956. if (evt->xfocus.detail != NotifyPointer) {
  957.     ti_cursor_off(win, ri);
  958.     ri->focus_flag = 0;
  959.     ti_cursor_on(win, ri);
  960. }
  961. break;
  962.     case EnterNotify:
  963. ti_line(win, ri, norm_pix);
  964. rtn = XTB_HANDLED;
  965. break;
  966.     case LeaveNotify:
  967. ti_line(win, ri, back_pix);
  968. rtn = XTB_HANDLED;
  969. break;
  970.     case ButtonPress:
  971. /* Wait for release */
  972. break;
  973.     case ButtonRelease:
  974. /* Set input focus */
  975. XSetInputFocus(t_disp, win, RevertToParent, CurrentTime);
  976. break;
  977.     default:
  978. rtn = XTB_NOTDEF;
  979. break;
  980.     }
  981.     return rtn;
  982. }
  984. void
  985. xtb_ti_new(win, text, maxchar, func, val, frame)
  986. Window  win; /* Parent window      */
  987. char   *text; /* Initial text       */
  988. int     maxchar; /* Maximum characters */
  990. FNPTR(func, xtb_hret, (Window, int, char *, xtb_data *)); /* Callback */
  991. xtb_data val; /* User data          */
  992. xtb_frame *frame; /* Returned size      */
  994. /*
  995.  * This routine creates a new editable text widget under `win'
  996.  * with the initial text `text'.  The widget contains only
  997.  * one line of text which cannot exceed `maxchar' characters.
  998.  * The size of the widget is returned in `frame'.  Each
  999.  * time a key is pressed in the window,  `func' will be called
  1000.  * with the window, the character, a copy of the text, and `val'.
  1001.  * The state of the widget can be changed by the routines below.
  1002.  * May set window to zero if the maximum overall character width
  1003.  * (MAXCHBUF) is exceeded.
  1004.  */
  1005. {
  1006.     struct ti_info *info;
  1008.     if (maxchar >= MAXCHBUF) {
  1009. frame->win = (Window) 0;
  1010. return;
  1011.     }
  1012.     frame->width = XTextWidth(norm_font, "8", 1) * maxchar + 2 * TI_HPAD;
  1013.     frame->height = norm_font->ascent + norm_font->descent + TI_VPAD + TI_LPAD;
  1014.     frame->x_loc = frame->y_loc = 0;
  1015.     frame->win = XCreateSimpleWindow(t_disp, win, 0, 0,
  1016.      frame->width, frame->height, TI_BRDR,
  1017.      norm_pix, back_pix);
  1018.     XSelectInput(t_disp, frame->win, ExposureMask | KeyPressMask |
  1019.  EnterWindowMask | LeaveWindowMask |
  1020.  FocusChangeMask | ButtonPressMask |
  1021.  ButtonReleaseMask);
  1022.     info = (struct ti_info *) Malloc(sizeof(struct ti_info));
  1023.     info->func = func;
  1024.     info->val = val;
  1025.     info->maxlen = maxchar;
  1026.     if (text)
  1027. (void) strcpy(info->text, text);
  1028.     else
  1029. info->text[0] = '';
  1030.     info->curidx = strlen(info->text);
  1031.     info->curxval = text_width(norm_font, info->text, info->curidx);
  1032.     info->line_y = frame->height - 2;
  1033.     info->line_w = frame->width - 2 * TI_HPAD;
  1034.     info->focus_flag = 0;
  1035.     xtb_register(frame->win, ti_h, (xtb_data) info);
  1036.     XMapWindow(t_disp, frame->win);
  1037.     frame->width += (2 * TI_BRDR);
  1038.     frame->height += (2 * TI_BRDR);
  1039. }
  1041. void
  1042. xtb_ti_get(win, text, val)
  1043. Window  win; /* Widget widnow  */
  1044. char    text[MAXCHBUF]; /* Filled in text */
  1045. xtb_data *val; /* User info      */
  1047. /*
  1048.  * This routine returns the information associated with text
  1049.  * widget `win'.  The text is filled into the passed buffer
  1050.  * `text' which should be MAXCHBUF characters in size.  If
  1051.  * `val' is non-zero,  the user supplied info is returned there.
  1052.  */
  1053. {
  1054.     struct ti_info *info = (struct ti_info *) xtb_lookup(win);
  1056.     if (val)
  1057. *val = info->val;
  1058.     (void) strcpy(text, info->text);
  1059. }
  1061. int
  1062. xtb_ti_set(win, text, val)
  1063. Window  win; /* Widget window    */
  1064. char   *text; /* Replacement text */
  1065. xtb_data val; /* User info        */
  1067. /*
  1068.  * This routine sets the text of a text widget.  The widget
  1069.  * will be redrawn.  Note:  for incremental changes,  ti_ins and
  1070.  * ti_dch should be used.  If `val' is non-zero,  it will replace
  1071.  * the user information for the widget.  The widget is redrawn.
  1072.  * Will return zero if `text' is too long.
  1073.  */
  1074. {
  1075.     struct ti_info *info = (struct ti_info *) xtb_lookup(win);
  1076.     int     newlen;
  1078.     if (text) {
  1079. if ((newlen = strlen(text)) >= info->maxlen)
  1080.     return 0;
  1081.     }
  1082.     else {
  1083. newlen = 0;
  1084.     }
  1085.     info->curidx = newlen;
  1086.     if (text)
  1087. (void) strcpy(info->text, text);
  1088.     else
  1089. info->text[0] = '';
  1090.     info->curxval = text_width(norm_font, info->text, info->curidx);
  1091.     if (val)
  1092. info->val = val;
  1093.     ti_draw(win, info, 1);
  1094.     return 1;
  1095. }
  1097. int
  1098. xtb_ti_ins(win, ch)
  1099. Window  win; /* Widget window */
  1100. int     ch; /* Character     */
  1102. /*
  1103.  * Inserts the character `ch' onto the end of the text for `win'.
  1104.  * Will return zero if there isn't any more room left.  Does
  1105.  * all appropriate display updates.
  1106.  */
  1107. {
  1108.     struct ti_info *info = (struct ti_info *) xtb_lookup(win);
  1109.     char    lstr[1];
  1111.     if (info->curidx >= info->maxlen - 1)
  1112. return 0;
  1113.     info->text[info->curidx] = ch;
  1114.     info->text[info->curidx + 1] = '';
  1115.     /* Turn off cursor */
  1116.     ti_cursor_off(win, info);
  1117.     /* Text */
  1118.     lstr[0] = (char) ch;
  1119.     XDrawImageString(t_disp, win,
  1120.      set_gc(win, norm_pix, back_pix, norm_font->fid, 0),
  1121.      info->curxval + TI_HPAD, TI_VPAD + norm_font->ascent,
  1122.      lstr, 1);
  1123.     info->curidx += 1;
  1124.     info->curxval += text_width(norm_font, lstr, 1);
  1125.     ti_cursor_on(win, info);
  1126.     return 1;
  1127. }
  1129. int
  1130. xtb_ti_dch(win)
  1131. Window  win; /* Widget window */
  1133. /*
  1134.  * Deletes the character at the end of the text for `win'.  Will
  1135.  * return zero if there aren't any characters to delete.  Does
  1136.  * all appropriate display updates.
  1137.  */
  1138. {
  1139.     struct ti_info *info = (struct ti_info *) xtb_lookup(win);
  1140.     int     chw;
  1142.     if (info->curidx == 0)
  1143. return 0;
  1144.     /* Wipe out cursor */
  1145.     ti_cursor_off(win, info);
  1146.     info->curidx -= 1;
  1147.     chw = text_width(norm_font, &(info->text[info->curidx]), 1);
  1148.     info->curxval -= chw;
  1149.     /* Wipe out character */
  1150.     XClearArea(t_disp, win, info->curxval + TI_HPAD, TI_VPAD,
  1151.        (unsigned int) chw + 1,
  1152.        (unsigned int) norm_font->ascent + norm_font->descent,
  1153.        False);
  1154.     info->text[info->curidx] = '';
  1155.     ti_cursor_on(win, info);
  1156.     return 1;
  1157. }
  1159. void
  1160. xtb_ti_del(win, info)
  1161. Window  win;
  1162. xtb_data *info;
  1164. /*
  1165.  * Deletes an input text widget.  User defined data is returned in `info'.
  1166.  */
  1167. {
  1168.     struct ti_info *ti;
  1170.     if (xtb_unregister(win, (xtb_data *) & ti)) {
  1171. *info = ti->val;
  1172. Free((char *) ti);
  1173. XDestroyWindow(t_disp, win);
  1174.     }
  1175. }
  1178. /*
  1179.  * Simple colored output frame - usually used for drawing lines
  1180.  */
  1182. void
  1183. xtb_bk_new(win, width, height, frame)
  1184. Window  win; /* Parent window */
  1185. unsigned width,
  1186.         height; /* Size          */
  1187. xtb_frame *frame; /* Returned size */
  1189. /*
  1190.  * This routine creates a new frame that displays a block
  1191.  * of color whose size is given by `width' and `height'.
  1192.  * It is usually used to draw lines.  No user interaction
  1193.  * is defined for the frame.  The color used is the default
  1194.  * foreground color set in xtb_init().
  1195.  */
  1196. {
  1197.     frame->x_loc = frame->y_loc = 0;
  1198.     frame->width = width;
  1199.     frame->height = height;
  1200.     frame->win = XCreateSimpleWindow(t_disp, win,
  1201.      frame->x_loc, frame->y_loc,
  1202.      frame->width, frame->height,
  1203.      0, norm_pix, norm_pix);
  1204.     XMapWindow(t_disp, frame->win);
  1205. }
  1208. void
  1209. xtb_bk_del(win)
  1210. Window  win;
  1212. /*
  1213.  * Deletes a block frame.
  1214.  */
  1215. {
  1216.     XDestroyWindow(t_disp, win);
  1217. }
  1222. /*
  1223.  * Formatting support
  1224.  */
  1226. #define ERROR(msg) printf("%sn", msg); abort();
  1228. xtb_fmt *
  1229. xtb_w(w)
  1230. xtb_frame *w;
  1232. /*
  1233.  * Returns formatting structure for a widget.
  1234.  */
  1235. {
  1236.     xtb_fmt *ret;
  1238.     ret = (xtb_fmt *) Malloc((unsigned) sizeof(xtb_fmt));
  1239.     ret->wid.type = W_TYPE;
  1240.     ret->wid.w = w;
  1241.     return ret;
  1242. }
  1244. VARARGS(xtb_hort, xtb_fmt *, (xtb_just just, int padding, int interspace,...))
  1245. /*
  1246.  * Builds a horizontal structure
  1247.  */
  1248. {
  1249.     va_list ap;
  1250.     xtb_fmt *ret,
  1251.            *val;
  1253. #ifdef __STDC__
  1254.     va_start(ap, interspace);
  1255. #else
  1256.     xtb_just just;
  1257.     int     padding,
  1258.             interspace;
  1260.     va_start(ap);
  1261.     just = va_arg(ap, xtb_just);
  1262.     padding = va_arg(ap, int);
  1263.     interspace = va_arg(ap, int);
  1264. #endif
  1265.     ret = (xtb_fmt *) Malloc((unsigned) sizeof(xtb_fmt));
  1266.     ret->align.type = A_TYPE;
  1267.     ret->align.dir = HORIZONTAL;
  1268.     ret->align.just = just;
  1269.     ret->align.padding = padding;
  1270.     ret->align.interspace = interspace;
  1271.     /* Build array of incoming xtb_fmt structures */
  1272.     ret->align.ni = 0;
  1273.     while ((val = va_arg(ap, xtb_fmt *)) != (xtb_fmt *) 0) {
  1274. if (ret->align.ni < MAX_BRANCH) {
  1275.     ret->align.items[ret->align.ni] = val;
  1276.     ret->align.ni++;
  1277. }
  1278. else {
  1279.     ERROR("too many branchesn");
  1280. }
  1281.     }
  1282.     return ret;
  1283. }
  1286. VARARGS(xtb_vert, xtb_fmt *, (xtb_just just, int padding, int interspace,...))
  1287. /*
  1288.  * Builds a vertical structure
  1289.  */
  1290. {
  1291.     va_list ap;
  1292.     xtb_fmt *ret,
  1293.            *val;
  1295. #ifdef __STDC__
  1296.     va_start(ap, interspace);
  1297. #else
  1298.     xtb_just just;
  1299.     int     padding,
  1300.             interspace;
  1302.     va_start(ap);
  1303.     just = va_arg(ap, xtb_just);
  1304.     padding = va_arg(ap, int);
  1305.     interspace = va_arg(ap, int);
  1306. #endif
  1307.     ret = (xtb_fmt *) Malloc((unsigned) sizeof(xtb_fmt));
  1308.     ret->align.type = A_TYPE;
  1309.     ret->align.dir = VERTICAL;
  1310.     ret->align.just = just;
  1311.     ret->align.padding = padding;
  1312.     ret->align.interspace = interspace;
  1313.     /* Build array of incoming xtb_fmt structures */
  1314.     ret->align.ni = 0;
  1315.     while ((val = va_arg(ap, xtb_fmt *)) != (xtb_fmt *) 0) {
  1316. if (ret->align.ni < MAX_BRANCH) {
  1317.     ret->align.items[ret->align.ni] = val;
  1318.     ret->align.ni++;
  1319. }
  1320. else {
  1321.     ERROR("too many branchesn");
  1322. }
  1323.     }
  1324.     return ret;
  1325. }
  1328. static void
  1329. xtb_fmt_setpos(def, x, y)
  1330. xtb_fmt *def;
  1331. int     x,
  1332.         y;
  1334. /*
  1335.  * Sets all position fields of widgets in `def' to x,y.
  1336.  */
  1337. {
  1338.     int     i;
  1340.     switch (def->type) {
  1341.     case W_TYPE:
  1342. def->wid.w->x_loc = x;
  1343. def->wid.w->y_loc = y;
  1344. break;
  1345.     case A_TYPE:
  1346. for (i = 0; i < def->align.ni; i++) {
  1347.     xtb_fmt_setpos(def->align.items[i], x, y);
  1348. }
  1349. break;
  1350.     default:
  1351. ERROR("bad type");
  1352.     }
  1353. }
  1356. static void
  1357. xtb_fmt_addpos(def, x, y)
  1358. xtb_fmt *def;
  1359. int     x,
  1360.         y;
  1362. /*
  1363.  * Adds the offset specified to all position fields of widgets in `def'.
  1364.  */
  1365. {
  1366.     int     i;
  1368.     switch (def->type) {
  1369.     case W_TYPE:
  1370. def->wid.w->x_loc += x;
  1371. def->wid.w->y_loc += y;
  1372. break;
  1373.     case A_TYPE:
  1374. for (i = 0; i < def->align.ni; i++) {
  1375.     xtb_fmt_addpos(def->align.items[i], x, y);
  1376. }
  1377. break;
  1378.     default:
  1379. ERROR("bad type");
  1380.     }
  1381. }
  1383. static void
  1384. xtb_fmt_hort(nd, defs, widths, heights, just, pad, inter, rw, rh)
  1385. int     nd; /* Number of children     */
  1386. xtb_fmt *defs[]; /* Definitions themselves */
  1387. unsigned int     widths[]; /* Widths of children     */
  1388. unsigned int     heights[]; /* Heights of children    */
  1389. xtb_just just; /* Justification          */
  1390. int     pad,
  1391.         inter; /* Padding and interspace */
  1392. unsigned int    *rw,
  1393.        *rh; /* Returned size          */
  1395. /*
  1396.  * Formats items horizontally subject to the widths and heights
  1397.  * of the items passed.
  1398.  */
  1399. {
  1400.     int     i;
  1401.     int     max_height = 0;
  1402.     int     tot_width = 0;
  1403.     int     xspot;
  1405.     /* Find parameters */
  1406.     for (i = 0; i < nd; i++) {
  1407. if (heights[i] > max_height)
  1408.     max_height = heights[i];
  1409. tot_width += widths[i];
  1410.     }
  1411.     /* Place items -- assumes center justification */
  1412.     xspot = pad;
  1413.     for (i = 0; i < nd; i++) {
  1414. switch (just) {
  1415. case XTB_TOP:
  1416.     xtb_fmt_addpos(defs[i], xspot, pad);
  1417.     break;
  1418. case XTB_BOTTOM:
  1419.     xtb_fmt_addpos(defs[i], xspot, max_height - heights[i] + pad);
  1420.     break;
  1421. case XTB_CENTER:
  1422. default:
  1423.     /* Everyone else center */
  1424.     xtb_fmt_addpos(defs[i], xspot, (max_height - heights[i]) / 2 + pad);
  1425.     break;
  1426. }
  1427. xspot += (widths[i] + inter);
  1428.     }
  1429.     /* Figure out resulting size */
  1430.     *rw = tot_width + (nd - 1) * inter + (2 * pad);
  1431.     *rh = max_height + (2 * pad);
  1432. }
  1435. static void
  1436. xtb_fmt_vert(nd, defs, widths, heights, just, pad, inter, rw, rh)
  1437. int     nd; /* Number of children     */
  1438. xtb_fmt *defs[]; /* Definitions themselves */
  1439. unsigned int     widths[]; /* Widths of children     */
  1440. unsigned int     heights[]; /* Heights of children    */
  1441. xtb_just just; /* Justification          */
  1442. int     pad,
  1443.         inter; /* Padding and interspace */
  1444. unsigned int    *rw,
  1445.        *rh; /* Returned size          */
  1447. /*
  1448.  * Formats items vertically subject to the widths and heights
  1449.  * of the items passed.
  1450.  */
  1451. {
  1452.     int     i;
  1453.     int     max_width = 0;
  1454.     int     tot_height = 0;
  1455.     int     yspot;
  1457.     /* Find parameters */
  1458.     for (i = 0; i < nd; i++) {
  1459. if (widths[i] > max_width)
  1460.     max_width = widths[i];
  1461. tot_height += heights[i];
  1462.     }
  1463.     /* Place items -- assumes center justification */
  1464.     yspot = pad;
  1465.     for (i = 0; i < nd; i++) {
  1466. switch (just) {
  1467. case XTB_LEFT:
  1468.     xtb_fmt_addpos(defs[i], pad, yspot);
  1469.     break;
  1470. case XTB_RIGHT:
  1471.     xtb_fmt_addpos(defs[i], max_width - widths[i] + pad, yspot);
  1472.     break;
  1473. case XTB_CENTER:
  1474. default:
  1475.     /* Everyone else center */
  1476.     xtb_fmt_addpos(defs[i], (max_width - widths[i]) / 2 + pad, yspot);
  1477.     break;
  1478. }
  1479. yspot += (heights[i] + inter);
  1480.     }
  1481.     /* Figure out resulting size */
  1482.     *rw = max_width + (2 * pad);
  1483.     *rh = tot_height + (nd - 1) * inter + (2 * pad);
  1484. }
  1486. static void
  1487. xtb_fmt_top(def, w, h)
  1488. xtb_fmt *def;
  1489. unsigned *w,
  1490.        *h;
  1492. /*
  1493.  * Recursive portion of formatter
  1494.  */
  1495. {
  1496.     unsigned widths[MAX_BRANCH];
  1497.     unsigned heights[MAX_BRANCH];
  1498.     int     i;
  1500.     switch (def->type) {
  1501.     case A_TYPE:
  1502. /* Formatting directive */
  1503. /* place children and determine sizes */
  1504. for (i = 0; i < def->align.ni; i++) {
  1505.     xtb_fmt_top(def->align.items[i], &(widths[i]), &(heights[i]));
  1506. }
  1507. /* now format based on direction */
  1508. switch (def->align.dir) {
  1509. case HORIZONTAL:
  1510.     xtb_fmt_hort(def->align.ni, def->align.items, widths, heights,
  1511.  def->align.just, def->align.padding,
  1512.  def->align.interspace, w, h);
  1513.     break;
  1514. case VERTICAL:
  1515.     xtb_fmt_vert(def->align.ni, def->align.items, widths, heights,
  1516.  def->align.just, def->align.padding,
  1517.  def->align.interspace, w, h);
  1518.     break;
  1519. default:
  1520.     ERROR("bad direction");
  1521. }
  1522. break;
  1523.     case W_TYPE:
  1524. /* Simple widget - return size */
  1525. *w = def->wid.w->width;
  1526. *h = def->wid.w->height;
  1527. break;
  1528.     default:
  1529. ERROR("bad type");
  1530.     }
  1531. }
  1533. #ifdef DEBUG
  1534. static void
  1535. xtb_fmt_debug(def)
  1536. xtb_fmt *def;
  1538. /*
  1539.  * Dumps formatting structure for debugging purposes.
  1540.  */
  1541. {
  1542.     int     i;
  1544.     switch (def->type) {
  1545.     case W_TYPE:
  1546. printf("%d %d %d %dn",
  1547.        def->wid.w->x_loc, def->wid.w->y_loc,
  1548.        def->wid.w->width, def->wid.w->height);
  1549. break;
  1550.     case A_TYPE:
  1551. for (i = 0; i < def->align.ni; i++) {
  1552.     xtb_fmt_debug(def->align.items[i]);
  1553. }
  1554. break;
  1555.     default:
  1556. ERROR("bad type");
  1557.     }
  1558. }
  1560. #endif
  1562. xtb_fmt *
  1563. xtb_fmt_do(def, w, h)
  1564. xtb_fmt *def;
  1565. unsigned *w,
  1566.        *h;
  1568. /*
  1569.  * Actually does formatting
  1570.  */
  1571. {
  1572.     /* First zero out all positions */
  1573.     xtb_fmt_setpos(def, 0, 0);
  1575.     /* Now call recursive portion */
  1576.     xtb_fmt_top(def, w, h);
  1578. #ifdef DEBUG
  1579.     xtb_fmt_debug(def);
  1580. #endif
  1581.     return def;
  1582. }
  1584. void
  1585. xtb_fmt_free(def)
  1586. xtb_fmt *def;
  1588. /*
  1589.  * Frees resources associated with formatting routines
  1590.  */
  1591. {
  1592.     int     i;
  1594.     if (def->type == A_TYPE) {
  1595. for (i = 0; i < def->align.ni; i++) {
  1596.     xtb_fmt_free(def->align.items[i]);
  1597. }
  1598.     }
  1599.     Free((char *) def);
  1600. }
  1602. void
  1603. xtb_mv_frames(nf, frames)
  1604. int     nf; /* Number of frames */
  1605. xtb_frame frames[]; /* Array of frames  */
  1607. /*
  1608.  * Moves frames to the location indicated in the frame
  1609.  * structure for each item.
  1610.  */
  1611. {
  1612.     int     i;
  1614.     for (i = 0; i < nf; i++) {
  1615. XMoveWindow(t_disp, frames[i].win, frames[i].x_loc, frames[i].y_loc);
  1616.     }
  1617. }