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

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

通讯编程

开发平台：

Visual C++

dialog.c：源码内容
  1. /*
  2.  * Xgraph Dialog Boxes
  3.  *
  4.  * This file constructs the hardcopy and error dialog
  5.  * boxes used by xgraph.  It uses the mini-toolbox given
  6.  * in toolbox.c.
  7.  */
  9. #include "copyright.h"
  10. #include "xgout.h"
  11. #include "xgraph.h"
  12. #include "hard_devices.h"
  13. #include "xtb.h"
  14. #include "params.h"
  15. #include <stdio.h>
  16. #include <X11/Xutil.h>
  18. void    do_error();
  20. #define MAXCHBUF 1024
  22. #ifdef SHADOW
  23. #define gray_width 16
  24. #define gray_height 16
  25. static short gray_bits[] =
  26. {
  27.     0x5555, 0xaaaa, 0x5555, 0xaaaa,
  28.     0x5555, 0xaaaa, 0x5555, 0xaaaa,
  29.     0x5555, 0xaaaa, 0x5555, 0xaaaa,
  30.     0x5555, 0xaaaa, 0x5555, 0xaaaa};
  32. #endif
  34. static void make_msg_box();
  35. static void del_msg_box();
  38. #define D_VPAD 2
  39. #define D_HPAD 2
  40. #define D_INT 4
  41. #define D_BRDR 2
  42. #define D_INP 35
  43. #define D_DSP 10
  44. #define D_FS 10
  46. struct d_info {
  47.     char   *prog; /* Program name              */
  48.     xtb_data cookie; /* Info used by do_harcopy   */
  49.     Window  choices; /* Output device choices     */
  50.     Window  fod; /* File or device flag       */
  51.     Window  fodspec; /* File or device spec       */
  52.     Window  docu_p; /* Document predicate        */
  53.     Window  dimspec; /* Maximum dimension spec    */
  54.     Window  tf_family; /* Title font family spec    */
  55.     Window  tf_size; /* Title font size spec      */
  56.     Window  af_family; /* Axis font family spec     */
  57.     Window  af_size; /* Axis font size spec       */
  58. };
  60. #define BACKSPACE 0010
  61. #define DELETE 0177
  62. #define CONTROL_U 0025
  63. #define CONTROL_X 0030
  65. /*ARGSUSED*/
  66. static xtb_hret 
  67. df_fun(win, ch, text, val)
  68. Window  win; /* Widget window   */
  69. int     ch; /* Typed character */
  70. char   *text; /* Copy of text    */
  71. xtb_data val; /* User info       */
  73. /*
  74.  * This is the handler function for the text widget for
  75.  * specifing the file or device name.  It supports simple
  76.  * line editing operations.
  77.  */
  78. {
  79.     if ((ch == BACKSPACE) || (ch == DELETE)) {
  80. if (!xtb_ti_dch(win))
  81.     XBell(disp, 0);
  82.     }
  83.     else if ((ch == CONTROL_U) || (ch == CONTROL_X)) {
  84. (void) xtb_ti_set(win, "", (xtb_data) 0);
  85.     }
  86.     else {
  87. /* Insert if printable - ascii dependent */
  88. if ((ch < ' ') || (ch >= DELETE) || !xtb_ti_ins(win, ch)) {
  89.     XBell(disp, 0);
  90. }
  91.     }
  92.     return XTB_HANDLED;
  93. }
  95. /*ARGSUSED*/
  96. static xtb_hret 
  97. ok_fun(win, bval, info)
  98. Window  win; /* Button window     */
  99. int     bval; /* Button value      */
  100. xtb_data info; /* Local button info */
  102. /*
  103.  * This is the handler function for when the `Ok' button
  104.  * is hit.  It sets the button,  does the hardcopy output,
  105.  * and turns the button off.  It returns a status which
  106.  * deactivates the dialog.
  107.  */
  108. {
  109.     struct d_info *real_info = (struct d_info *) info;
  110.     int     val,
  111.             dev_p,
  112.             doc_p;
  113.     char    file_or_dev[MAXCHBUF],
  114.             dim_spec[MAXCHBUF],
  115.            *dev_spec;
  116.     char    tfam[MAXCHBUF],
  117.             afam[MAXCHBUF];
  118.     char    tsizstr[MAXCHBUF],
  119.             asizstr[MAXCHBUF];
  120.     double  centimeters,
  121.             tsize,
  122.             asize;
  123.     xtb_hret rtn;
  125.     (void) xtb_bt_set(win, 1, (xtb_data) 0, 0);
  126.     val = xtb_br_get(real_info->choices);
  127.     if ((val >= 0) && (val < hard_count)) {
  128. dev_p = xtb_br_get(real_info->fod);
  129. if ((dev_p == 0) || (dev_p == 1)) {
  130.     xtb_ti_get(real_info->fodspec, file_or_dev, (xtb_data *) 0);
  131.     doc_p = xtb_bt_get(real_info->docu_p, (xtb_data *) 0, (int *) 0);
  132.     xtb_ti_get(real_info->dimspec, dim_spec, (xtb_data *) 0);
  133.     if (sscanf(dim_spec, "%lf", &centimeters) == 1) {
  134. xtb_ti_get(real_info->tf_family, tfam, (xtb_data *) 0);
  135. xtb_ti_get(real_info->af_family, afam, (xtb_data *) 0);
  136. xtb_ti_get(real_info->tf_size, tsizstr, (xtb_data *) 0);
  137. if (sscanf(tsizstr, "%lf", &tsize) == 1) {
  138.     xtb_ti_get(real_info->af_size, asizstr, (xtb_data *) 0);
  139.     if (sscanf(asizstr, "%lf", &asize) == 1) {
  140. /* Got all the info */
  141. if (dev_p) {
  142.     dev_spec = (char *) 0;
  143. }
  144. else {
  145.     dev_spec = hard_devices[val].dev_spec;
  146. }
  147. do_hardcopy(real_info->prog, real_info->cookie,
  148.     hard_devices[val].dev_init, dev_spec,
  149.     file_or_dev, centimeters,
  150.     tfam, tsize, afam, asize, doc_p);
  151. rtn = XTB_STOP;
  152.     }
  153.     else {
  154. /* Bad axis size */
  155. do_error("Bad axis font sizen");
  156. rtn = XTB_HANDLED;
  157.     }
  158. }
  159. else {
  160.     /* Bad title size */
  161.     do_error("Bad title font sizen");
  162.     rtn = XTB_HANDLED;
  163. }
  164.     }
  165.     else {
  166. /* Bad max dimension */
  167. do_error("Bad maximum dimensionn");
  168. rtn = XTB_HANDLED;
  169.     }
  170. }
  171. else {
  172.     /* Bad device spec */
  173.     do_error("Must specify `To File' or `To Device'n");
  174.     rtn = XTB_HANDLED;
  175. }
  176.     }
  177.     else {
  178. /* Bad value spec */
  179. do_error("Must specify an output devicen");
  180. rtn = XTB_HANDLED;
  181.     }
  182.     (void) xtb_bt_set(win, 0, (xtb_data) 0, 0);
  183.     return rtn;
  184. }
  186. /*ARGSUSED*/
  187. static xtb_hret 
  188. can_fun(win, val, info)
  189. Window  win; /* Button window     */
  190. int     val; /* Button value      */
  191. xtb_data info; /* Local button info */
  193. /*
  194.  * This is the handler function for the cancel button.  It
  195.  * turns itself on and off and then exits with a status
  196.  * which kills the dialog.
  197.  */
  198. {
  199.     (void) xtb_bt_set(win, 1, (xtb_data) 0, 0);
  200.     (void) xtb_bt_set(win, 0, (xtb_data) 0, 0);
  201.     return XTB_STOP;
  202. }
  205. /*ARGSUSED*/
  206. static xtb_hret 
  207. docu_fun(win, val, info)
  208. Window  win; /* Button window     */
  209. int     val; /* Button value      */
  210. xtb_data info; /* Local button info */
  212. /*
  213.  * This is the handler function for the document button.  It
  214.  * toggles it's state.
  215.  */
  216. {
  217.     int     state;
  219.     state = xtb_bt_get(win, (xtb_data *) 0, (int *) 0);
  220.     xtb_bt_set(win, (state == 0), (xtb_data) 0, 0);
  221.     return XTB_HANDLED;
  222. }
  224. /*ARGSUSED*/
  225. static xtb_hret 
  226. dev_fun(win, old, new, info)
  227. Window  win; /* Button row window */
  228. int     old; /* Previous button   */
  229. int     new; /* Current button    */
  230. xtb_data info; /* User data         */
  232. /*
  233.  * This routine swaps the device specific information
  234.  * in the dialog based on what device is selected.  The
  235.  * information passed is the information for the whole
  236.  * dialog.
  237.  */
  238. {
  239.     struct d_info *data = (struct d_info *) info;
  240.     char    text[MAXCHBUF];
  241.     int     fod_spot,
  242.             inactive;
  244.     fod_spot = xtb_br_get(data->fod);
  245.     if ((old >= 0) && (old < hard_count)) {
  246. /* Save old info */
  247. xtb_ti_get(data->fodspec, text, (xtb_data *) 0);
  248. if (fod_spot == 1) {
  249.     strncpy(hard_devices[old].dev_file, text, MFNAME - 1);
  250. }
  251. else if (fod_spot == 0) {
  252.     strncpy(hard_devices[old].dev_printer, text, MFNAME - 1);
  253. }
  254. if (xtb_bt_get(data->docu_p, (xtb_data *) 0, &inactive)) {
  255.     if (inactive)
  256. hard_devices[old].dev_docu = NONE;
  257.     else
  258. hard_devices[old].dev_docu = YES;
  259. }
  260. else if (inactive)
  261.     hard_devices[old].dev_docu = NONE;
  262. else
  263.     hard_devices[old].dev_docu = NO;
  264. xtb_ti_get(data->dimspec, text, (xtb_data *) 0);
  265. if (sscanf(text, "%lf", &hard_devices[old].dev_max_dim) != 1) {
  266.     do_error("Warning: can't read maximum dimension");
  267. }
  268. xtb_ti_get(data->tf_family, text, (xtb_data *) 0);
  269. strncpy(hard_devices[old].dev_title_font, text, MFNAME - 1);
  270. xtb_ti_get(data->tf_size, text, (xtb_data *) 0);
  271. if (sscanf(text, "%lf", &hard_devices[old].dev_title_size) != 1) {
  272.     do_error("Warning: can't read title font size");
  273. }
  274. xtb_ti_get(data->af_family, text, (xtb_data *) 0);
  275. strncpy(hard_devices[old].dev_axis_font, text, MFNAME - 1);
  276. xtb_ti_get(data->af_size, text, (xtb_data *) 0);
  277. if (sscanf(text, "%lf", &hard_devices[old].dev_axis_size) != 1) {
  278.     do_error("Warning: can't read axis font size");
  279. }
  280.     }
  281.     /* Insert new info */
  282.     if ((new >= 0) && (new < hard_count)) {
  283. if (fod_spot == 1) {
  284.     xtb_ti_set(data->fodspec, hard_devices[new].dev_file, (xtb_data) 0);
  285. }
  286. else if (fod_spot == 0) {
  287.     xtb_ti_set(data->fodspec, hard_devices[new].dev_printer,
  288.        (xtb_data) 0);
  289. }
  290. else {
  291.     xtb_ti_set(data->fodspec, "", (xtb_data) 0);
  292. }
  293. switch (hard_devices[new].dev_docu) {
  294. case NONE:
  295.     (void) xtb_bt_set(data->docu_p, 0, (xtb_data) 0, 1);
  296.     break;
  297. case NO:
  298.     (void) xtb_bt_set(data->docu_p, 0, (xtb_data) 0, 0);
  299.     break;
  300. case YES:
  301.     (void) xtb_bt_set(data->docu_p, 1, (xtb_data) 0, 0);
  302.     break;
  303. }
  304. (void) sprintf(text, "%lg", hard_devices[new].dev_max_dim);
  305. xtb_ti_set(data->dimspec, text, (xtb_data) 0);
  306. xtb_ti_set(data->tf_family, hard_devices[new].dev_title_font,
  307.    (xtb_data) 0);
  308. (void) sprintf(text, "%lg", hard_devices[new].dev_title_size);
  309. xtb_ti_set(data->tf_size, text, (xtb_data) 0);
  310. xtb_ti_set(data->af_family, hard_devices[new].dev_axis_font,
  311.    (xtb_data) 0);
  312. (void) sprintf(text, "%lg", hard_devices[new].dev_axis_size);
  313. xtb_ti_set(data->af_size, text, (xtb_data) 0);
  314.     }
  315.     return XTB_HANDLED;
  316. }
  318. /*ARGSUSED*/
  319. static xtb_hret 
  320. fd_fun(win, old, new, info)
  321. Window  win; /* Button row window */
  322. int     old; /* Previous button   */
  323. int     new; /* Current button    */
  324. xtb_data info; /* User data         */
  326. /*
  327.  * This routine swaps the default file or device names
  328.  * based on the state of the file or device buttons.
  329.  * The information passed is the information for the whole
  330.  * dialog.
  331.  */
  332. {
  333.     struct d_info *data = (struct d_info *) info;
  334.     char    text[MAXCHBUF];
  335.     int     which_one;
  337.     which_one = xtb_br_get(data->choices);
  338.     if ((which_one >= 0) && (which_one < hard_count)) {
  339. if (old == 0) {
  340.     /* Save into device space */
  341.     xtb_ti_get(data->fodspec, text, (xtb_data *) 0);
  342.     strncpy(hard_devices[which_one].dev_printer, text, MFNAME - 1);
  343. }
  344. else if (old == 1) {
  345.     /* Save into file space */
  346.     xtb_ti_get(data->fodspec, text, (xtb_data *) 0);
  347.     which_one = xtb_br_get(data->choices);
  348.     strncpy(hard_devices[which_one].dev_file, text, MFNAME - 1);
  349. }
  350. if (new == 0) {
  351.     /* Restore into device */
  352.     xtb_ti_set(data->fodspec, hard_devices[which_one].dev_printer,
  353.        (xtb_data *) 0);
  354. }
  355. else if (new == 1) {
  356.     xtb_ti_set(data->fodspec, hard_devices[which_one].dev_file,
  357.        (xtb_data *) 0);
  358. }
  359.     }
  360.     return XTB_HANDLED;
  361. }
  364. /* Indices for frames made in make_dialog */
  365. enum d_frames_defn {
  366.     TITLE_F, ODEVLBL_F, ODEVROW_F, DISPLBL_F, DISPROW_F, FDLBL_F,
  367.     FDINP_F, OPTLBL_F, DOCU_F, MDIMLBL_F, MDIMI_F, TFLBL_F, TFFAMLBL_F, TFFAM_F,
  368.     TFSIZLBL_F, TFSIZ_F, AFLBL_F, AFFAMLBL_F, AFFAM_F, AFSIZLBL_F, AFSIZ_F,
  369.     OK_F, CAN_F, BAR_F, LAST_F
  370. }       d_frames;
  372. #define AF(ix) af[(int) (ix)]
  374. #define BAR_SLACK 10
  376. static void 
  377. make_dialog(win, spawned, prog, cookie, okbtn, frame)
  378. Window  win; /* Parent window          */
  379. Window  spawned; /* Spawned from window    */
  380. char   *prog; /* Program name           */
  381. xtb_data cookie; /* Info for do_hardcopy  */
  382. xtb_frame *okbtn; /* Frame for OK button    */
  383. xtb_frame *frame; /* Returned window/size   */
  385. /*
  386.  * This routine constructs a new dialog for asking the user about
  387.  * hardcopy devices.  The dialog and its size is returned in
  388.  * `frame'.  The window of the `ok' button is returned in `btnwin'.
  389.  * This can be used to reset some of the button state to reuse the dialog.
  390.  */
  391. {
  392.     Window  overall;
  393.     xtb_frame AF(LAST_F);
  394.     xtb_fmt *def,
  395.            *cntrl,
  396.            *mindim,
  397.            *tfarea,
  398.            *afarea;
  399.     Cursor  diag_cursor;
  400.     XColor  fg_color,
  401.             bg_color;
  402.     XSizeHints hints;
  403.     unsigned long wamask;
  404.     XSetWindowAttributes wattr;
  405.     struct d_info *info;
  406.     int     i,
  407.             found,
  408.             max_width,
  409.             which_one,
  410.             fodi;
  411.     char  **names;
  412.     static char *fodstrs[] =
  413.     {"To Device", "To File"};
  414.     XFontStruct *bigFont = PM_FONT("TitleFont");
  415.     XFontStruct *medFont = PM_FONT("LabelFont");
  416.     char   *Odevice = PM_STR("Device");
  417.     char   *Odisp = PM_STR("Disposition");
  418.     char   *OfileDev = PM_STR("FileOrDev");
  420.     wamask = CWBackPixel | CWBorderPixel | CWOverrideRedirect |
  421. CWSaveUnder | CWColormap;
  422.     wattr.background_pixel = PM_PIXEL("Background");
  423.     wattr.border_pixel = PM_PIXEL("Border");
  424.     wattr.override_redirect = True;
  425.     wattr.save_under = True;
  426.     wattr.colormap = cmap;
  427.     overall = XCreateWindow(disp, win, 0, 0, 1, 1, D_BRDR,
  428.     depth, InputOutput, vis,
  429.     wamask, &wattr);
  430.     frame->win = overall;
  431.     frame->width = frame->height = frame->x_loc = frame->y_loc = 0;
  432.     XStoreName(disp, overall, "Hardcopy Dialog");
  433.     XSetTransientForHint(disp, spawned, overall);
  434.     info = (struct d_info *) Malloc(sizeof(struct d_info));
  435.     info->prog = prog;
  436.     info->cookie = cookie;
  438.     /* Make all frames */
  439.     xtb_to_new(overall, "Hardcopy Options", bigFont, &AF(TITLE_F));
  440.     xtb_to_new(overall, "Output device:", medFont, &AF(ODEVLBL_F));
  441.     found = -1;
  442.     names = (char **) Malloc((unsigned) (sizeof(char *) * hard_count));
  443.     for (i = 0; i < hard_count; i++) {
  444. names[i] = hard_devices[i].dev_name;
  445. if (strcmp(Odevice, names[i]) == 0) {
  446.     found = i;
  447. }
  448.     }
  449.     xtb_br_new(overall, hard_count, names, found,
  450.        dev_fun, (xtb_data) info, &AF(ODEVROW_F));
  451.     info->choices = AF(ODEVROW_F).win;
  452.     xtb_to_new(overall, "Disposition:", medFont, &AF(DISPLBL_F));
  453.     found = -1;
  454.     for (i = 0; i < 2; i++) {
  455. if (strcmp(Odisp, fodstrs[i]) == 0) {
  456.     found = i;
  457. }
  458.     }
  459.     xtb_br_new(overall, 2, fodstrs, found,
  460.        fd_fun, (xtb_data) info, &AF(DISPROW_F));
  461.     info->fod = AF(DISPROW_F).win;
  462.     xtb_to_new(overall, "File or Device Name:", medFont, &AF(FDLBL_F));
  463.     xtb_ti_new(overall, "", D_INP, df_fun, (xtb_data) 0, &AF(FDINP_F));
  464.     if (OfileDev && strlen(OfileDev)) {
  465. which_one = xtb_br_get(info->choices);
  466. if ((which_one >= 0) && (which_one < hard_count)) {
  467.     fodi = xtb_br_get(info->fod);
  468.     if (fodi == 0) {
  469. strncpy(hard_devices[which_one].dev_printer, OfileDev, MFNAME - 1);
  470.     }
  471.     else if (fodi == 1) {
  472. strncpy(hard_devices[which_one].dev_file, OfileDev, MFNAME - 1);
  473.     }
  474. }
  475.     }
  476.     info->fodspec = AF(FDINP_F).win;
  477.     xtb_to_new(overall, "Optional Parameters", bigFont, &AF(OPTLBL_F));
  478.     xtb_bt_new(overall, "Include in Document", docu_fun, (xtb_data) 0, &AF(DOCU_F));
  479.     info->docu_p = AF(DOCU_F).win;
  480.     xtb_to_new(overall, "Maximum Dimension (cm):", medFont, &AF(MDIMLBL_F));
  481.     xtb_ti_new(overall, "", D_DSP, df_fun, (xtb_data) 0, &AF(MDIMI_F));
  482.     info->dimspec = AF(MDIMI_F).win;
  483.     xtb_to_new(overall, "Title Font", medFont, &AF(TFLBL_F));
  484.     xtb_to_new(overall, "Family:", medFont, &AF(TFFAMLBL_F));
  485.     xtb_ti_new(overall, "", MFNAME, df_fun, (xtb_data) 0, &AF(TFFAM_F));
  486.     info->tf_family = AF(TFFAM_F).win;
  487.     xtb_to_new(overall, "Size (pnts):", medFont, &AF(TFSIZLBL_F));
  488.     xtb_ti_new(overall, "", D_FS, df_fun, (xtb_data) 0, &AF(TFSIZ_F));
  489.     info->tf_size = AF(TFSIZ_F).win;
  490.     xtb_to_new(overall, "Axis Font", medFont, &AF(AFLBL_F));
  491.     xtb_to_new(overall, "Family:", medFont, &AF(AFFAMLBL_F));
  492.     xtb_ti_new(overall, "", MFNAME, df_fun, (xtb_data) 0, &AF(AFFAM_F));
  493.     info->af_family = AF(AFFAM_F).win;
  494.     xtb_to_new(overall, "Size (pnts):", medFont, &AF(AFSIZLBL_F));
  495.     xtb_ti_new(overall, "", D_FS, df_fun, (xtb_data) 0, &AF(AFSIZ_F));
  496.     info->af_size = AF(AFSIZ_F).win;
  497.     xtb_bt_new(overall, "  Ok  ", ok_fun, (xtb_data) info, &AF(OK_F));
  498.     xtb_bt_new(overall, "Cancel", can_fun, (xtb_data) 0, &AF(CAN_F));
  499.     /* Dividing bar */
  500.     max_width = 0;
  501.     for (i = 0; i < ((int) BAR_F); i++) {
  502. if (AF(i).width > max_width)
  503.     max_width = AF(i).width;
  504.     }
  505.     xtb_bk_new(overall, max_width - BAR_SLACK, 1, &AF(BAR_F));
  507.     /* Set device specific info */
  508.     (void) dev_fun(info->choices, -1, xtb_br_get(info->choices), (xtb_data) info);
  509.     (void) fd_fun(info->fod, -1, xtb_br_get(info->fod), (xtb_data) info);
  511.     /*
  512.      * Now place elements - could make this one expression but pcc is too
  513.      * wimpy.
  514.      */
  515.     cntrl = xtb_vert(XTB_LEFT, D_VPAD, D_INT,
  516.      xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  517.       xtb_w(&AF(ODEVLBL_F)),
  518.       xtb_w(&AF(ODEVROW_F)), NE),
  519.      xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  520.       xtb_w(&AF(DISPLBL_F)),
  521.       xtb_w(&AF(DISPROW_F)), NE),
  522.      xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  523.       xtb_w(&AF(FDLBL_F)),
  524.       xtb_w(&AF(FDINP_F)), NE),
  525.      NE);
  527.     mindim = xtb_vert(XTB_LEFT, D_VPAD, D_INT,
  528.       xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  529.        xtb_w(&AF(MDIMLBL_F)),
  530.        xtb_w(&AF(MDIMI_F)),
  531.        NE),
  532.       NE);
  534.     tfarea = xtb_vert(XTB_LEFT, D_VPAD, D_INT,
  535.       xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  536.        xtb_w(&AF(TFFAMLBL_F)),
  537.        xtb_w(&AF(TFFAM_F)),
  538.        xtb_w(&AF(TFSIZLBL_F)),
  539.        xtb_w(&AF(TFSIZ_F)), NE),
  540.       NE);
  542.     afarea = xtb_vert(XTB_LEFT, D_VPAD, D_INT,
  543.       xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  544.        xtb_w(&AF(AFFAMLBL_F)),
  545.        xtb_w(&AF(AFFAM_F)),
  546.        xtb_w(&AF(AFSIZLBL_F)),
  547.        xtb_w(&AF(AFSIZ_F)), NE),
  548.       NE);
  550.     def = xtb_fmt_do
  551. (xtb_vert(XTB_CENTER, D_VPAD, D_INT,
  552.   xtb_w(&AF(TITLE_F)),
  553.   cntrl,
  554.   xtb_w(&AF(BAR_F)),
  555.   xtb_w(&AF(OPTLBL_F)),
  556.   mindim,
  557.   xtb_w(&AF(DOCU_F)),
  558.   xtb_w(&AF(TFLBL_F)),
  559.   tfarea,
  560.   xtb_w(&AF(AFLBL_F)),
  561.   afarea,
  562.   xtb_hort(XTB_CENTER, D_HPAD, D_INT,
  563.    xtb_w(&AF(OK_F)), xtb_w(&AF(CAN_F)), NE),
  564.   NE),
  565.  &frame->width, &frame->height);
  566.     xtb_mv_frames(LAST_F, af);
  567.     xtb_fmt_free(def);
  569.     /* Make window large enough to contain the info */
  570.     XResizeWindow(disp, overall, frame->width, frame->height);
  571.     hints.flags = PSize;
  572.     hints.width = frame->width;
  573.     hints.height = frame->height;
  574.     XSetNormalHints(disp, overall, &hints);
  575.     diag_cursor = XCreateFontCursor(disp, XC_dotbox);
  576.     fg_color.pixel = PM_PIXEL("Foreground");
  577.     XQueryColor(disp, cmap, &fg_color);
  578.     bg_color.pixel = PM_PIXEL("Background");
  579.     XQueryColor(disp, cmap, &bg_color);
  580.     XRecolorCursor(disp, diag_cursor, &fg_color, &bg_color);
  581.     XDefineCursor(disp, overall, diag_cursor);
  582.     frame->width += (2 * D_BRDR);
  583.     frame->height += (2 * D_BRDR);
  584.     *okbtn = AF(OK_F);
  585. }
  589. #ifdef SHADOW
  590. Window 
  591. make_shadow(w, h)
  592. int     w,
  593.         h;
  595. /*
  596.  * Makes a shadow window for a pop-up window of the specified size.
  597.  * Needs hint work as well.  Try no background window.
  598.  */
  599. {
  600.     Window  shadow;
  601.     Bitmap  gray_bm;
  602.     Pixmap  gray_pm;
  604.     gray_bm = XStoreBitmap(gray_width, gray_height, gray_bits);
  605.     gray_pm = XMakePixmap(gray_bm, PM_PIXEL("Foreground"), PM_PIXEL("Background"));
  606.     shadow = XCreateWindow(RootWindow, 0, 0, w, h, 0, BlackPixmap, gray_pm);
  607.     XFreePixmap(gray_pm);
  608.     XFreeBitmap(gray_bm);
  609.     return shadow;
  610. }
  612. #endif
  616. #define SH_W 5
  617. #define SH_H 5
  619. void 
  620. ho_dialog(parent, prog, cookie)
  621. Window  parent; /* Parent window              */
  622. char   *prog; /* Program name               */
  623. xtb_data cookie; /* Info passed to do_hardcopy */
  625. /*
  626.  * Asks the user about hardcopy devices.  A table of hardcopy
  627.  * device names and function pointers to their initialization
  628.  * functions is assumed to be in the global `hard_devices' and
  629.  * `hard_count'.  Returns a non-zero status if the dialog was
  630.  * sucessfully posted.  Calls do_hardcopy in xgraph to actually
  631.  * output information.
  632.  */
  633. {
  634. #ifdef SHADOW
  635.     static Window shadow;
  637. #endif
  638.     static Window dummy;
  639.     static xtb_frame overall =
  640.     {(Window) 0, 0, 0, 0, 0};
  641.     static xtb_frame okbtn;
  642.     XEvent  evt;
  643.     XWindowAttributes winInfo;
  644.     XSizeHints hints;
  645.     struct d_info *info;
  647.     if (!overall.win) {
  648. make_dialog(RootWindow(disp, screen), parent, prog, cookie,
  649.     &okbtn, &overall);
  650. #ifdef SHADOW
  651. shadow = make_shadow(d_w, d_h);
  652. #endif
  653.     }
  654.     else {
  655. /* Change the button information */
  656. (void) xtb_bt_get(okbtn.win, (xtb_data *) & info, (int *) 0);
  657. info->prog = prog;
  658. info->cookie = cookie;
  659.     }
  660.     XGetWindowAttributes(disp, parent, &winInfo);
  661.     XTranslateCoordinates(disp, parent, RootWindow(disp, screen),
  662.   0, 0, &winInfo.x, &winInfo.y, &dummy);
  663.     XMoveWindow(disp, overall.win,
  664. (int) (winInfo.x + winInfo.width / 2 - overall.width / 2),
  665. (int) (winInfo.y + winInfo.height / 2 - overall.height / 2));
  666.     hints.flags = PPosition;
  667.     hints.x = winInfo.x + winInfo.width / 2 - overall.width / 2;
  668.     hints.y = winInfo.y + winInfo.height / 2 - overall.height / 2;
  669.     XSetNormalHints(disp, overall.win, &hints);
  670. #ifdef SHADOW
  671.     XMoveWindow(disp, shadow, winInfo.x + winInfo.width / 2 - d_w / 2 + SH_W,
  672. winInfo.y + winInfo.height / 2 - d_h / 2 + SH_H);
  673.     hints.flags = PPosition;
  674.     hints.x = winInfo.x + winInfo.width / 2 - d_w / 2 + SH_W;
  675.     hints.y = winInfo.y + winInfo.height / 2 - d_h / 2 + SH_H;
  676.     XSetNormalHints(disp, shadow, &hints);
  677.     XRaiseWindow(disp, shadow);
  678.     XMapWindow(disp, shadow);
  679. #endif
  680.     XRaiseWindow(disp, overall.win);
  681.     XMapWindow(disp, overall.win);
  682.     do {
  683. XNextEvent(disp, &evt);
  684.     } while (xtb_dispatch(&evt) != XTB_STOP);
  685.     XUnmapWindow(disp, overall.win);
  686. #ifdef SHADOW
  687.     XUnmapWindow(disp, shadow);
  688. #endif
  689. }
  693. /*ARGSUSED*/
  694. static xtb_hret 
  695. err_func(win, bval, info)
  696. Window  win; /* Button window     */
  697. int     bval; /* Button value      */
  698. xtb_data info; /* Local button info */
  700. /*
  701.  * Handler function for button in error box.  Simply stops dialog.
  702.  */
  703. {
  704.     (void) xtb_bt_set(win, 1, (xtb_data) 0, 0);
  705.     (void) xtb_bt_set(win, 0, (xtb_data) 0, 0);
  706.     return XTB_STOP;
  707. }
  710. struct err_info {
  711.     Window  title;
  712.     Window  contbtn;
  713.     int     num_lines;
  714.     int     alloc_lines;
  715.     Window *lines;
  716. };
  718. #define E_LINES 2
  719. #define E_VPAD 3
  720. #define E_HPAD 3
  721. #define E_INTER 1
  722. #define ML 256
  724. static void 
  725. make_msg_box(text, title, frame)
  726. char   *text; /* Error text    */
  727. char   *title; /* Title text    */
  728. xtb_frame *frame; /* Returned frame */
  730. /*
  731.  * Makes an error box with a title.
  732.  */
  733. {
  734.     XSizeHints hints;
  735.     struct err_info *new_info;
  736.     xtb_frame tf,
  737.             cf,
  738.             lf;
  739.     char   *lineptr,
  740.             line[ML];
  741.     int     y,
  742.             i;
  743.     unsigned long wamask;
  744.     XSetWindowAttributes wattr;
  745.     XFontStruct *bigFont = PM_FONT("TitleFont");
  746.     XFontStruct *medFont = PM_FONT("LabelFont");
  748.     wamask = CWBackPixel | CWBorderPixel | CWOverrideRedirect |
  749. CWSaveUnder | CWColormap;
  750.     wattr.background_pixel = PM_PIXEL("Background");
  751.     wattr.border_pixel = PM_PIXEL("Border");
  752.     wattr.override_redirect = True;
  753.     wattr.save_under = True;
  754.     wattr.colormap = cmap;
  755.     frame->win = XCreateWindow(disp, RootWindow(disp, screen),
  756.        0, 0, 1, 1, D_BRDR,
  757.        depth, InputOutput, vis,
  758.        wamask, &wattr);
  759.     frame->x_loc = frame->y_loc = frame->width = frame->height = 0;
  760.     XStoreName(disp, frame->win, "Error Dialog");
  761.     XSetTransientForHint(disp, RootWindow(disp, screen), frame->win);
  762.     new_info = (struct err_info *) Malloc((unsigned) sizeof(struct err_info));
  763.     xtb_to_new(frame->win, title, bigFont, &tf);
  764.     new_info->title = tf.win;
  765.     if (tf.width > frame->width)
  766. frame->width = tf.width;
  768.     xtb_bt_new(frame->win, "Dismiss", err_func, (xtb_data) 0, &cf);
  769.     new_info->contbtn = cf.win;
  770.     if (cf.width > frame->width)
  771. frame->width = cf.width;
  773.     new_info->alloc_lines = E_LINES;
  774.     new_info->num_lines = 0;
  775.     new_info->lines = (Window *) Malloc((unsigned) (sizeof(Window) * E_LINES));
  776.     /* zero the memory out of paranoia */
  777.     memset(new_info->lines, 0, sizeof(Window) * E_LINES);
  779.     lineptr = text;
  780.     while (getline(&lineptr, line)) {
  781. if (new_info->num_lines >= new_info->alloc_lines) {
  782.     int old_alloc_lines_size = new_info->alloc_lines * sizeof(Window);
  783.     new_info->alloc_lines *= 2;
  784.     new_info->lines = (Window *) Realloc((char *) new_info->lines,
  785.  (unsigned)
  786.  (new_info->alloc_lines *
  787.   sizeof(Window)));
  788.             memset(((char*)new_info->lines) + old_alloc_lines_size,
  789.    0, old_alloc_lines_size);
  790. }
  791. xtb_to_new(frame->win, line, medFont, &lf);
  792. new_info->lines[new_info->num_lines] = lf.win;
  793. new_info->num_lines += 1;
  794. if (lf.width > frame->width)
  795.     frame->width = lf.width;
  796.     }
  799.     /* Placement */
  800.     frame->width += (2 * E_HPAD);
  801.     y = E_VPAD;
  802.     /* Title */
  803.     XMoveWindow(disp, new_info->title, (int) (frame->width / 2 - tf.width / 2), y);
  804.     y += (tf.height + E_INTER);
  805.     /* All lines */
  806.     for (i = 0; i < new_info->num_lines; i++) {
  807. XMoveWindow(disp, new_info->lines[i], E_HPAD, y);
  808. y += (lf.height + E_INTER);
  809.     }
  810.     /* Button */
  811.     XMoveWindow(disp, new_info->contbtn, (int) (frame->width / 2 - cf.width / 2), y);
  812.     y += (cf.height + E_INTER);
  814.     /* Make dialog the right size */
  815.     y += (E_VPAD - E_INTER);
  816.     XResizeWindow(disp, frame->win, frame->width, (unsigned int) y);
  817.     hints.flags = PSize;
  818.     hints.width = frame->width;
  819.     hints.height = (unsigned int) y;
  820.     XSetNormalHints(disp, frame->win, &hints);
  821.     frame->width += (2 * D_BRDR);
  822.     frame->height = y + (2 * D_BRDR);
  823.     xtb_register(frame->win, (xtb_hret(*) ()) 0, (xtb_data) new_info);
  824. }
  826. void 
  827. msg_box(title, text)
  828. char   *title,
  829.        *text;
  831. /*
  832.  * This posts a dialog that contains lines of text and a continue
  833.  * button.  The text may be multiple lines.  The dialog is remade
  834.  * each time.
  835.  */
  836. {
  837. #ifdef SHADOW
  838.     Window  shadow;
  840. #endif
  841.     XWindowAttributes info;
  842.     XEvent  evt;
  843.     XSizeHints hints;
  844.     xtb_frame text_frame;
  846.     make_msg_box(text, title, &text_frame);
  847. #ifdef SHADOW
  848.     shadow = make_shadow(w, h);
  849. #endif
  850.     XGetWindowAttributes(disp, RootWindow(disp, screen), &info);
  851.     XMoveWindow(disp, text_frame.win, (int) (info.width / 2 - text_frame.width / 2),
  852. (int) (info.height / 2 - text_frame.height / 2));
  853.     hints.flags = PPosition;
  854.     hints.x = info.width / 2 - text_frame.width / 2;
  855.     hints.y = info.height / 2 - text_frame.height / 2;
  856.     XSetNormalHints(disp, text_frame.win, &hints);
  857. #ifdef SHADOW
  858.     XMoveWindow(disp, shadow, info.width / 2 - w / 2 + SH_W,
  859. info.height / 2 - h / 2 + SH_H);
  860.     hints.flags = PPosition;
  861.     hints.x = info.width / 2 - w / 2 + SH_W;
  862.     hints.y = info.height / 2 - h / 2 + SH_H;
  863.     XSetNormalHints(disp, text_frame.win, &hints);
  864.     XRaiseWindow(disp, shadow);
  865.     XMapWindow(disp, shadow);
  866. #endif
  867.     XRaiseWindow(disp, text_frame.win);
  868.     XMapWindow(disp, text_frame.win);
  869.     do {
  870. XNextEvent(disp, &evt);
  871.     } while (xtb_dispatch(&evt) != XTB_STOP);
  872. #ifdef SHADOW
  873.     XDestroyWindow(disp, shadow);
  874. #endif
  875.     del_msg_box(text_frame.win);
  876. }
  878. void 
  879. do_error(err_text)
  880. char   *err_text;
  881. {
  882.     if (PM_INT("Output Device") == D_XWINDOWS)
  883. msg_box("Xgraph Error", err_text);
  884.     else
  885. fputs(err_text, stderr);
  886. }
  890. int 
  891. getline(tptr, lptr)
  892. char  **tptr;
  893. char   *lptr;
  895. /*
  896.  * Returns next line from tptr.  Assumes `lptr' is large enough to
  897.  * accept the line.
  898.  */
  899. {
  900.     char   *start;
  902.     start = *tptr;
  903.     while (*tptr && **tptr && (**tptr != 'n')) {
  904. (*tptr)++;
  905.     }
  906.     if (*tptr > start) {
  907. (void) strncpy(lptr, start, (*tptr - start));
  908. lptr[*tptr - start] = '';
  909. if (**tptr == 'n')
  910.     (*tptr)++;
  911. return 1;
  912.     }
  913.     else {
  914. return 0;
  915.     }
  916. }
  920. static void 
  921. del_msg_box(msg)
  922. Window  msg;
  924. /*
  925.  * Deletes all components of an msg box
  926.  */
  927. {
  928.     struct err_info *info;
  929.     char   *dummy;
  930.     int     i;
  932.     if (xtb_unregister(msg, (xtb_data *) & info)) {
  933. xtb_to_del(info->title);
  934. xtb_bt_del(info->contbtn, (xtb_data *) & dummy);
  935. for (i = 0; i < info->num_lines; i++) {
  936.     xtb_to_del(info->lines[i]);
  937. }
  938. Free((char *) info->lines);
  939. Free((char *) info);
  940. XDestroyWindow(disp, msg);
  941.     }
  942. }