home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 1 / Meeting Pearls Vol 1 (1994).iso / installed_progs / gfx / lise2.1 / mdl / src / mdllibux.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-31  |  18.5 KB  |  710 lines
  1. /* {(rm mdllib.o ; cc -DUNIX -c -s -n -O -Wc,-Nd4000 -Wc,-Ns4000 -Wc,-Nt50000 -DSYSV -DNLS16 -Dhp9000s300 -o mdllib.o mdllib.c)& } */
  2. /**---------------------------------------------------------------------
  3. ***    
  4. ***    file:        mdl.c
  5. ***
  6. ***    project:    Menu Description Language
  7. ***                     General purpose Menu generator.
  8. ***
  9. ***            (c) 1990 Rainer Kowallik
  10. ***
  11. ***-------------------------------------------------------------------*/
  12.  
  13.  
  14. /*  include files  */
  15. #include <stdio.h>
  16. #include <setjmp.h>
  17.  
  18. #include <X11/Intrinsic.h>
  19. #include <X11/IntrinsicP.h>
  20. #include <X11/CoreP.h>
  21. #include <X11/Shell.h>
  22. #include <Xm/Xm.h>
  23. #include <Xm/BulletinB.h>
  24. #include <Xm/CascadeB.h>
  25. #include <Xm/Frame.h>
  26. #include <Xm/Label.h>
  27. #include <Xm/MainW.h>
  28. #include <Xm/MessageB.h>
  29. #include <Xm/PushB.h>
  30. #include <Xm/PushBG.h>
  31. #include <Xm/RowColumn.h>
  32. #include <Xm/ScrollBar.h>
  33. #include <Xm/ScrolledW.h>
  34. #include <Xm/ToggleBG.h>
  35. #include <Xm/Scale.h>
  36. #include <Xm/SelectioB.h>
  37.  
  38.  
  39. #define    PUSH         1
  40. #define    TOGGLE       2
  41. #define    SCALEX       3
  42. #define SCALEY       4
  43. #define    DIALOG       5
  44. #define    MENU         6
  45. #define    NEW_MENU     7
  46. #define    FILE_SELECT  8
  47. #define    BOARD         9
  48. #define BULLETIN    10
  49. #define    SELECTION   11
  50. #define    MESSAGE     12
  51. #define    RADIO       13
  52. #define    ROWCOL      14
  53. #define    SCALEX11    15
  54. #define SCALEY11    16
  55. #define STRING      17
  56. #define INTEGER     18
  57. #define FLOAT       19
  58.  
  59.  
  60. /*  functions defined in this program  */
  61. /* void main(); */
  62. void activateCB(); /* Callback for the PushButton */
  63.  
  64.  
  65. /*  global variables  */
  66.  
  67. Display        *display    = NULL; /*  dsplay        */
  68. XtAppContext    app_context     = NULL; /*  Application Context */
  69. Widget        app_shell    = NULL;    /*  shell widget    */
  70. Widget        main_window    = NULL;    /*  MainWindow        */
  71. Widget        menu_bar    = NULL;    /*  MenuBar        */
  72. Widget        menu_pane    = NULL;    /*  MenuPane        */
  73. Widget        cascade        = NULL;    /*  CascadeButton    */
  74. Widget        frame        = NULL;    /*  Frame        */
  75. Widget        swindow        = NULL;    /*  ScrolledWindow    */
  76. Widget        row_column    = NULL;    /*  RowColumn        */
  77. Widget        button        = NULL;    /*  PushButtonGadget    */
  78. Widget        hsb        = NULL;
  79. Widget         vsb        = NULL;    /*  ScrollBars        */
  80. Widget        radio        = NULL;    /*  Radio button Widget */
  81. Widget        dialog_box    = NULL;
  82.  
  83. int     last_gadgetid = 0;
  84. int     fn_number = 0;
  85. void    (*fn_command[160])();
  86. int     *var_value[160];
  87. int     var_funct[160];
  88. Widget     Wstring[160];
  89. int    string_var[160];
  90. int     string_ptr = 0;
  91. Widget     Wtoggle[160];
  92. int    toggle_var[160];
  93. int     toggle_ptr = 0;
  94. Widget    Wscale[160];
  95. int    scale_var[160];
  96. int    scale_ptr = 0;
  97. int    selector[160];
  98. int    selector_ptr = 0;
  99. int    acc_x = 0;        /* accumulated x  */
  100. int    acc_y = 0;        /* accumulated y  */
  101. int    bas_y = 5;        /* base scale for y-increment */
  102. char    menu_name[80];            /* store menu bar name */
  103. char    return_string[80];        /* string returned from dialog box */
  104. char    resource[80];
  105. jmp_buf    ugly;
  106.  
  107. /* -------------------------------------------------------------
  108.    The following variables and functions are declared for AMIGA
  109.    compatibility. They should get more usefull in future releases
  110.    ------------------------------------------------------------- */
  111.  
  112. int    propdwn;
  113. int    menu_line;
  114. int    menu_column;
  115. int    top_slider;
  116. int    scale_var0[160];
  117. int    scale_var1[160];
  118. int    fin_flg;               /* tells the MainLoop to termitate */
  119.  
  120. read_dir(s1,s2)
  121. char *s1, *s2;
  122. {
  123.    return(0);
  124. }
  125.  
  126. /* -------------------------------------------------------------- 
  127.     Create default application windows and widgets
  128.    -------------------------------------------------------------- */
  129. Widget CreateApplication (parent) 
  130. Widget        parent;        /*  parent widget    */
  131. {
  132. Arg        args[10];    /*  arg list        */
  133. register int    n;        /*  arg count        */
  134.  
  135.  
  136.     /*    Create MainWindow.
  137.     */
  138.     n = 0;
  139.     main_window = XmCreateMainWindow (parent, "main1", args, n);
  140.     XtManageChild (main_window);
  141.  
  142.     /*    Create MenuBar in MainWindow.
  143.     */
  144.     n = 0;
  145.     menu_bar = XmCreateMenuBar (main_window, "menu_bar", args, n); 
  146.     XtManageChild (menu_bar);
  147.  
  148.     /*    Create Frame MainWindow and ScrolledWindow in Frame.
  149.     */
  150.     n = 0;
  151.     XtSetArg (args[n], XmNmarginWidth, 2);  n++;
  152.     XtSetArg (args[n], XmNmarginHeight, 2);  n++;
  153.     XtSetArg (args[n], XmNshadowThickness, 1);  n++;
  154.     XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);  n++;
  155.     frame = XmCreateFrame (main_window, "frame", args, n);
  156.     XtManageChild (frame);
  157.  
  158.     n = 0;
  159.     XtSetArg (args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED);  n++;
  160.     XtSetArg (args[n], XmNscrollingPolicy, XmAUTOMATIC);  n++;
  161.     swindow = XmCreateScrolledWindow (frame, "swindow", args, n);
  162.     XtManageChild (swindow);
  163.  
  164.     n = 0;
  165.     XtSetArg (args[n], XmNpacking, XmPACK_NONE);  n++;
  166.     XtSetArg (args[n], XmNorientation, XmVERTICAL);  n++; 
  167.     row_column = XmCreateRowColumn (swindow, "row_column", args, n);
  168.     XtManageChild (row_column);
  169.  
  170.     /*    Set MainWindow areas and add tab groups
  171.     */
  172.     XmMainWindowSetAreas (main_window, menu_bar, NULL, NULL, NULL,
  173.             frame);
  174.     n = 0;
  175.     XtSetArg (args[n], XmNhorizontalScrollBar, &hsb);  n++;
  176.     XtSetArg (args[n], XmNverticalScrollBar, &vsb);  n++;
  177.     XtGetValues (main_window, args, n);
  178.     if (hsb) XmAddTabGroup (hsb);
  179.     if (vsb) XmAddTabGroup (vsb);
  180.     XmAddTabGroup (row_column);
  181.     return(main_window);
  182. }
  183.  
  184.  
  185. /* -------------------------------------------------------------
  186.      Dialog Box Creation Functions:
  187.         Help(char message[]);
  188.         FileSelect(char dir[]);
  189.         StringBox(char title[]);
  190.    ------------------------------------------------------------- */
  191. /*-------------------------------------------------------------
  192. **    CreateHelp        - create help window
  193. */
  194. Widget    CreateHelp (message) 
  195.     char message[];
  196. {
  197.     Widget        knopf;
  198.     Widget        message_box;    /*  Message Dialog     */
  199.     Arg        args[20];    /*  arg list        */
  200.     register int    n;        /*  arg count           */
  201.     XmString    title_string = NULL;
  202.     XmString    message_string = NULL;
  203.     XmString    knopf_string = NULL;
  204.  
  205.  
  206.     message_string = XmStringCreateLtoR (message, XmSTRING_DEFAULT_CHARSET);
  207.     knopf_string = XmStringCreateLtoR ("Close", XmSTRING_DEFAULT_CHARSET);
  208.     title_string = XmStringCreateLtoR ("Message:", XmSTRING_DEFAULT_CHARSET);
  209.  
  210.     /*    Create MessageBox dialog.
  211.     */
  212.     n = 0;
  213.     XtSetArg (args[n], XmNdialogTitle, title_string);  n++;
  214.     XtSetArg (args[n], XmNokLabelString, knopf_string);  n++;
  215.     XtSetArg (args[n], XmNmessageString, message_string);  n++;
  216.     message_box = XmCreateMessageDialog (main_window, "helpbox", args, n);
  217.  
  218.     knopf = XmMessageBoxGetChild (message_box, XmDIALOG_CANCEL_BUTTON);
  219.     XtUnmanageChild (knopf);
  220.     knopf = XmMessageBoxGetChild (message_box, XmDIALOG_HELP_BUTTON);
  221.     XtUnmanageChild (knopf);
  222.  
  223.  
  224.     /*    Free strings and return MessageBox.
  225.     */
  226.     if (title_string) XtFree (title_string);
  227.     if (message_string) XtFree (message_string);
  228.     if (knopf_string) XtFree (knopf_string);
  229.     return (message_box);
  230. }
  231.  
  232. Help(message)
  233. char message[];
  234. {
  235. Widget w;
  236. w = CreateHelp(message);
  237. XtManageChild(w);
  238. }
  239.  
  240. /*-------------------------------------------------------------
  241. **    CreateStringBox        - create string input window
  242. */
  243. Widget    CreateStringBox (title) 
  244.     char title[];
  245. {
  246.     Widget        knopf;
  247.     Arg        args[20];    /*  arg list        */
  248.     register int    n;        /*  arg count        */
  249.  
  250.     XmString    title_string = NULL;
  251.  
  252.  
  253.     title_string = XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET);
  254.  
  255.     /*    Create MessageBox dialog.
  256.     */
  257.     n = 0;
  258.     XtSetArg (args[n], XmNdialogTitle, title_string);  n++;
  259.     dialog_box = (Widget) XmCreatePromptDialog (main_window, "stringbox", args, n);
  260.  
  261.     XtAddCallback (dialog_box, XmNokCallback,activateCB, -1);
  262.  
  263.     /*    Free strings and return MessageBox.
  264.     */
  265.     if (title_string) XtFree (title_string);
  266.     return (dialog_box);
  267. }
  268.  
  269. /* TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK
  270.  
  271.    Since Xwindows only works from within the XtMainloop (building boxes,
  272.    watching mouse actions ...) it seemd to be impossible to write
  273.    JUST a function, which returns anything from a box, and then continues
  274.    with the program. The only way around this is a very dirty trick:
  275.    we store the address of our function with setjmp before giving controll
  276.    to XtMainloop, and after processing in our callback routine, longjmp
  277.    goes back to were we started.
  278.  
  279.    TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK TRICK */
  280.  
  281. StringBox(message,rtstr)
  282. char message[],rtstr[];
  283. {
  284. Widget w;
  285. w = CreateStringBox(message);
  286. if(setjmp(ugly)==0) {
  287.    XtManageChild(w);
  288.    XtAppMainLoop (app_context);
  289. } else {
  290.    strcpy(rtstr,return_string);
  291. }
  292. }
  293.  
  294. /*-------------------------------------------------------------
  295. **    CreateFileSelect    - create file selection window
  296. */
  297. Widget    CreateFileSelect (dir) 
  298.     char dir[];
  299. {
  300.     Widget        knopf;
  301.     Arg        args[10];    /*  arg list        */
  302.     register int    n;        /*  arg count        */
  303.  
  304.     XmString    title_string = NULL;
  305.  
  306.  
  307.     title_string = XmStringCreateLtoR (dir, XmSTRING_DEFAULT_CHARSET);
  308.  
  309.     /*    Create MessageBox dialog.
  310.     */
  311.     n = 0;
  312.     XtSetArg (args[n], XmNdialogTitle, title_string);  n++;
  313.     dialog_box = (Widget) XmCreateFileSelectionDialog (main_window,
  314.              "fsel_box", args, n);
  315.  
  316.     XtAddCallback (dialog_box, XmNokCallback,activateCB, -1);
  317.  
  318.     knopf = (Widget) XmFileSelectionBoxGetChild (dialog_box, XmDIALOG_HELP_BUTTON);
  319.     XtUnmanageChild (knopf);
  320.  
  321.  
  322.     /*    Free strings and return MessageBox.
  323.     */
  324.     if (title_string) XtFree (title_string);
  325.     return (dialog_box);
  326. }
  327.  
  328. FileSelect(message,rtstr)
  329. char message[],rtstr[];
  330. {
  331. Widget w;
  332. w = CreateFileSelect(message);
  333. if(setjmp(ugly)==0) {
  334.    XtManageChild(w);
  335.    XtAppMainLoop (app_context);
  336. } else {
  337.    strcpy(rtstr,return_string);
  338. }
  339. }
  340.  
  341. /* -------------------------------------------------------------------
  342.  
  343.    look for altered variables and assotiated gadgets, Update Gadgets
  344.    (Writes back altered wariables to Gadgets)
  345.  
  346.    ------------------------------------------------------------------- */
  347.  
  348. UpdateGadgets()            /* NEW! */
  349. {
  350. int    n,m,i;
  351.  
  352. /* first set all toggle buttons */
  353.    for(n=0;n<toggle_ptr;n++) {
  354.       m=toggle_var[n];
  355.       i = *var_value[m];
  356.       XmToggleButtonGadgetSetState(Wtoggle[n],i);
  357.    }
  358.       
  359. /* now set all sliders */
  360.    for(n=0;n<scale_ptr;n++) {
  361.       m=scale_var[n];
  362.       i = *var_value[m];
  363.       XmScaleSetValue(Wscale[n],i);
  364.    }
  365.  
  366. /* now set all strings */
  367.    for(n=0;n<string_ptr;n++) {
  368.       m=string_var[n];
  369.       XmTextSetString(Wstring[n],var_value[m]);
  370.    }
  371. }
  372.  
  373.  
  374. /* -------------------------------------------------------------
  375.     add an item to the menu list
  376.    ------------------------------------------------------------- */
  377. add_item(x,y,type,text,p1,p2)
  378. int x,y,type,p1,p2;
  379. char text[];
  380. {
  381. int i,m;
  382. Widget button;
  383. Widget knopf;
  384. XmString label_string;
  385. Arg    args[10]; /*  arg list        */
  386. register int n;    /*  arg count        */
  387. char s1[80];
  388. XmString item[80];
  389.  
  390.    var_funct[fn_number] = type;
  391.  
  392. /* check, if position has to be adjusted */
  393.    if(x != -1) acc_x = x;
  394.    if(y != -1) acc_y = y;
  395.  
  396. /* do string parsing for SELECTION box */
  397.    extract_str(s1,text,0,',');
  398.     label_string = 
  399.            XmStringCreateLtoR(s1, XmSTRING_DEFAULT_CHARSET);
  400.     n = 0;
  401.     XtSetArg (args[n], XmNlabelString, label_string);  n++;
  402.    i=1; m=1;
  403.    while(m>0) {
  404.       m = extract_str(s1,text,i,',');
  405.       if(strlen(s1)==0) break;
  406.       item[i-1] = XmStringCreateLtoR(s1,XmSTRING_DEFAULT_CHARSET);
  407.       i++;
  408.    }
  409.    item[i-1] = NULL;
  410.  
  411. /* set position */
  412.     XtSetArg (args[n], XmNx,acc_x); n++;
  413.     XtSetArg (args[n], XmNy,acc_y); n++;
  414.  
  415.    switch(type) {
  416.  
  417.    case PUSH:
  418.     XtSetArg (args[n], XmNlabelType, XmSTRING);  n++; 
  419.     button = XmCreatePushButtonGadget(row_column,text , args, n);
  420.     XtAddCallback (button, XmNactivateCallback, 
  421.           activateCB, (caddr_t)fn_number);
  422.     acc_y = acc_y + (8 * bas_y);
  423.     break;
  424.  
  425.    case TOGGLE:
  426.     if(radio==NULL) radio = row_column;
  427.     button = XmCreateToggleButtonGadget(radio,text , args, n);
  428.     toggle_var[toggle_ptr] = fn_number;
  429.     Wtoggle[toggle_ptr++] = button;
  430.     acc_y = acc_y + (5 * bas_y);
  431.     break;
  432.  
  433.    case SCALEX:
  434.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  435.     XtSetArg (args[n], XmNorientation, XmHORIZONTAL);  n++;
  436.     XtSetArg (args[n], XmNshowValue, True);  n++;
  437.     XtSetArg (args[n], XmNminimum,p1);  n++;
  438.     XtSetArg (args[n], XmNmaximum,p2);  n++;
  439.     button = XmCreateScale(row_column,text , args, n);
  440.     scale_var[scale_ptr] = fn_number;
  441.     Wscale[scale_ptr++] = button;
  442.     acc_y = acc_y + (15 * bas_y);
  443.     break;
  444.  
  445.    case SCALEY:
  446.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  447.     XtSetArg (args[n], XmNorientation, XmVERTICAL);  n++;
  448.     XtSetArg (args[n], XmNshowValue, True);  n++;
  449.     XtSetArg (args[n], XmNminimum,p1);  n++;
  450.     XtSetArg (args[n], XmNmaximum,p2);  n++;
  451.     button = XmCreateScale(row_column,text , args, n);
  452.     scale_var[scale_ptr] = fn_number;
  453.     Wscale[scale_ptr++] = button;
  454.     acc_y = acc_y + (30 * bas_y);
  455.     break;
  456.  
  457.    case SCALEY11:
  458.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  459.     XtSetArg (args[n], XmNorientation, XmVERTICAL);  n++;
  460.     XtSetArg (args[n], XmNshowValue, True);  n++;
  461.     XtSetArg (args[n], XmNminimum,p1);  n++;
  462.     XtSetArg (args[n], XmNmaximum,p2);  n++;
  463.     XtSetArg (args[n], XmNheight,(p2-p1));  n++;
  464.     button = XmCreateScale(row_column,text , args, n);
  465.     scale_var[scale_ptr] = fn_number;
  466.     Wscale[scale_ptr++] = button;
  467.     acc_y = acc_y + (30 * bas_y);
  468.     break;
  469.  
  470.    case SCALEX11:
  471.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  472.     XtSetArg (args[n], XmNorientation, XmHORIZONTAL);  n++;
  473.     XtSetArg (args[n], XmNshowValue, True);  n++;
  474.     XtSetArg (args[n], XmNminimum,p1);  n++;
  475.     XtSetArg (args[n], XmNmaximum,p2);  n++;
  476.     XtSetArg (args[n], XmNwidth,(p2-p1));  n++;
  477.     button = XmCreateScale(row_column,text , args, n);
  478.     scale_var[scale_ptr] = fn_number;
  479.     Wscale[scale_ptr++] = button;
  480.     acc_y = acc_y + (15 * bas_y);
  481.     break;
  482.  
  483.    case SELECTION:
  484.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  485.     XtSetArg (args[n], XmNlistLabelString, label_string);  n++;
  486.     XtSetArg (args[n], XmNminimizeButtons,True);  n++;
  487.     XtSetArg (args[n], XmNlistItemCount,i-1);  n++;
  488.     XtSetArg (args[n], XmNlistItems,item); n++;
  489.     button = XmCreateSelectionBox(row_column,text , args, n);
  490.     knopf = XmMessageBoxGetChild (button, XmDIALOG_CANCEL_BUTTON);
  491.     XtUnmanageChild (knopf); /* get rid of unneeded buttons */
  492.     XtAddCallback (button, XmNokCallback, 
  493.           activateCB, (caddr_t)fn_number);
  494.     selector[selector_ptr++] = fn_number;
  495.     acc_y = acc_y + (75 * bas_y);
  496.     break;
  497.  
  498.    case RADIO:
  499.     radio = (Widget) XmCreateRadioBox(row_column,text, args, n);
  500.     XtManageChild (radio);
  501.     return(0);
  502.     break;
  503.  
  504.    case FILE_SELECT:
  505.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  506.     XtSetArg (args[n], XmNlistLabelString, label_string);  n++;
  507.     button = (Widget) XmCreateFileSelectionBox(row_column,text , args, n);
  508.     knopf = (Widget) XmFileSelectionBoxGetChild (button, XmDIALOG_CANCEL_BUTTON);
  509.     XtUnmanageChild (knopf); /* get rid of unneeded buttons */
  510.     knopf = (Widget) XmFileSelectionBoxGetChild (button, XmDIALOG_HELP_BUTTON);
  511.     XtUnmanageChild (knopf);
  512.     XtAddCallback (button, XmNokCallback, 
  513.           activateCB, (caddr_t)fn_number);
  514.     selector[selector_ptr++] = fn_number;
  515.     acc_y = acc_y + (90 * bas_y);
  516.     break;
  517.  
  518.    case STRING:
  519.     XtSetArg (args[n], XmNtitleString, label_string);  n++;
  520.         XtSetArg (args[n], XmNeditable, True); n++;
  521.         XtSetArg (args[n], XmNeditMode, XmSINGLE_LINE_EDIT); n++;
  522.         XtSetArg (args[n], XmNscrollVertical, False); n++;
  523.         XtSetArg (args[n], XmNscrollHorizontal, False); n++;
  524.     button = (Widget) XmCreateScrolledText(row_column,text , args, n);
  525.     XtAddCallback (button, XmNactivateCallback, 
  526.           activateCB, (caddr_t)fn_number);
  527.     string_var[string_ptr] = fn_number;
  528.     Wstring[string_ptr++] = button;
  529.     acc_y = acc_y + (15 * bas_y);
  530.     break;
  531.  
  532.    case MENU:
  533.     button = XmCreatePushButton (menu_pane, label_string, args, n);
  534.     XtAddCallback (button, XmNactivateCallback, 
  535.          activateCB, (caddr_t)fn_number);
  536.     break;
  537.  
  538.    case NEW_MENU:
  539.     n = 0;
  540.     label_string = 
  541.            XmStringCreateLtoR(menu_name, XmSTRING_DEFAULT_CHARSET);
  542.     XtSetArg (args[n], XmNlabelString, label_string);  n++;
  543.     XtSetArg (args[n], XmNsubMenuId, menu_pane);  n++;
  544.     XtSetArg(args[n], XmNlabelString,
  545.         label_string);
  546.     cascade = XmCreateCascadeButton (menu_bar,label_string,args,n);
  547.     XtManageChild (cascade);
  548.     n = 0;
  549.     menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane", args, n);
  550.     strcpy(menu_name,text);
  551.     return(0);
  552.     break;
  553.    default:
  554.     return(0);
  555.     break;
  556.    }
  557.    
  558. /*  start managing button */
  559.       XtManageChild(button);
  560. }
  561.  
  562.  
  563. /*-------------------------------------------------------------
  564. **    activateCB - callback for button
  565. */
  566. void activateCB (w, client_data, call_data) 
  567. Widget    w;        /*  widget id        */
  568. caddr_t    client_data;    /*  data from application   */
  569. caddr_t    call_data;    /*  data from widget class  */
  570. {
  571. int    fn;
  572. int    n,m,i;
  573. char    *cbstr;
  574. char    rtstr[80];
  575.  
  576. /* first read all toggle buttons */
  577.    for(n=0;n<toggle_ptr;n++) {
  578.       i=XmToggleButtonGadgetGetState(Wtoggle[n]);
  579.       m=toggle_var[n];
  580.       *var_value[m] = i;
  581.    }
  582.       
  583. /* now read all sliders */
  584.    for(n=0;n<scale_ptr;n++) {
  585.       XmScaleGetValue(Wscale[n],&i);
  586.       m=scale_var[n];
  587.       *var_value[m] = i;
  588.    }
  589.  
  590. /* now read all strings */
  591.    for(n=0;n<string_ptr;n++) {
  592.       m=string_var[n];
  593.       cbstr = (char *) XmTextGetString(Wstring[n]);
  594.       strcpy(var_value[m],cbstr);
  595.       XtFree(cbstr);
  596.    }
  597.  
  598.  
  599.    fn = (int) client_data;
  600.    last_gadgetid = fn;
  601.  
  602. /* process callback from dialog box */
  603.    if(fn<0) {
  604.           {
  605.              XmSelectionBoxCallbackStruct *scb =
  606.                 (XmSelectionBoxCallbackStruct *) call_data;
  607.              XmStringGetLtoR(scb->value, XmSTRING_DEFAULT_CHARSET, &cbstr);
  608.           }
  609.           strcpy(return_string,cbstr);
  610.       XtUnmanageChild(dialog_box);
  611.           longjmp(ugly,1);
  612.    }
  613.  
  614.  
  615.  
  616. /* if call from selection box, the catch string */
  617.    for(n=0;n<selector_ptr;n++) {
  618.       if(selector[n] == fn) {
  619.           {
  620.              XmSelectionBoxCallbackStruct *scb =
  621.                 (XmSelectionBoxCallbackStruct *) call_data;
  622.              XmStringGetLtoR(scb->value, XmSTRING_DEFAULT_CHARSET, &cbstr);
  623.              strcpy(var_value[fn],cbstr);
  624.           }
  625.       }
  626.    }
  627.    (*fn_command[fn])();
  628.    UpdateGadgets();
  629. }
  630.  
  631.  
  632. dummy()
  633. {
  634. return(0);
  635. }
  636.  
  637. /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  638.       Dummy functions for amiga compatibility
  639.    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
  640.  
  641. Refresh1Gadget(i)
  642. int i;
  643. {
  644.    return;
  645. }
  646.  
  647.  
  648. DrawAllPropBorders(i)
  649. int i;
  650. {
  651.    return;
  652. }
  653.  
  654. set_new_pointer()
  655. {
  656.    return;
  657. }
  658.  
  659. set_old_pointer()
  660. {
  661.    return;
  662. }
  663.  
  664. RequestYesNo(s)
  665. char *s;
  666. {
  667.    return(0);
  668. }
  669.  
  670. /* ********************************************************************
  671.  
  672.    S T R I N G H A N D L I N G
  673.  
  674.    ******************************************************************** */
  675.  
  676. /* --------------------------------------------------
  677.    reurns in s1 s2 from nth occurence of c up to c
  678.    -------------------------------------------------- */
  679.  
  680. extract_str(s1,s2,n,c)
  681. char s1[],s2[],c;
  682. int n;
  683. {
  684. int m,i,l;
  685. char c1;
  686.  
  687.    m=0; l=strlen(s2);
  688.    i = 0;
  689.    if(n > 0) {
  690.       for(i=0;i<l;i++) {
  691.           c1=s2[i];
  692.           if(c1 == c) m++;
  693.           if(m == n) break;
  694.       }
  695.       s1[0] = 0;
  696.       if(c1 != c) return(-1);
  697.       i++;
  698.    }
  699.    m=0;
  700.    while(i<l) {
  701.       c1 = s2[i++];
  702.       if(c1 == c) break;
  703.       s1[m++] = c1;
  704.    }
  705.    s1[m] = 0;
  706.    if(strlen(s1)==0) return(-1);
  707.    return(1);
  708. }
  709.  
  710.