home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / XAP / XGAMES / SPIDER.TAR / spider / xaw_ui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-28  |  14.9 KB  |  563 lines
  1. /*
  2.  *    Spider
  3.  *
  4.  *    (c) Copyright 1989, Donald R. Woods and Sun Microsystems, Inc.
  5.  *    (c) Copyright 1990, David Lemke and Network Computing Devices Inc.
  6.  *
  7.  *    See copyright.h for the terms of the copyright.
  8.  *
  9.  *    @(#)xaw_ui.c    2.5    90/06/18
  10.  *
  11.  */
  12.  
  13. /*
  14.  * Athena Widget interface to Spider
  15.  */
  16.  
  17. #include    "defs.h"
  18. #include    "globals.h"
  19. #include    "xaw_ui.h"
  20.  
  21. #include    "spider.bm"
  22.  
  23. static XtAppContext    spider_con;
  24. Widget        toplevel;
  25. static Widget        table_w;
  26. static Widget        panel;
  27. static Widget        message;
  28. Widget        file;
  29. Widget        helptext = (Widget) 0;    /* catch un-created help 
  30.                      * widget in get_selection() */
  31. Widget        confirm_box;
  32. Widget        confirm_label;
  33.  
  34. extern int    replayTime;
  35. extern Bool    usebell;
  36. extern Bool    confirm;
  37. #ifdef ROUND_CARDS
  38. extern Bool    round_cards;
  39. #endif
  40. extern Bool    squish;
  41. extern int    deltamod;
  42. extern char    *helpDir;
  43.  
  44. extern char    helpfiles[6][256];
  45.  
  46. struct    _resources    {
  47.     Bool    confirm;
  48.     Bool    usebell;
  49. #ifdef ROUND_CARDS
  50.     Bool    round_cards;
  51. #endif
  52.     Bool    squish;
  53.     int    replayTime;
  54.     int    deltamod;
  55.     char    *helpDir;
  56. } app_resources;
  57.  
  58. #define    offset(field)    XtOffset (struct _resources *, field)
  59.  
  60. static XtResource    resources[] =    {
  61.     { "confirm", "Confirm", XtRBoolean, sizeof(Boolean),
  62.         offset(confirm), XtRString, "True" },
  63.     { "bell", "Bell", XtRBoolean, sizeof(Boolean),
  64.         offset(usebell), XtRString, "True" },
  65.     { "replayTime", "ReplayTime", XtRInt, sizeof(int),
  66.         offset(replayTime), XtRString, "200" },
  67. #ifdef    ROUND_CARDS
  68.     { "roundCards", "RoundCards", XtRBoolean, sizeof(Boolean),
  69.         offset(round_cards), XtRString, "True" },
  70. #endif
  71.     { "squish", "Squish", XtRBoolean, sizeof(Boolean),
  72.         offset(squish), XtRString, "False" },
  73.     { "deltaMod", "DeltaMod", XtRInt, sizeof(int),
  74.         offset(deltamod), XtRString, "1" },
  75.     { "helpDir", "HelpDir", XtRString, sizeof(char *),
  76.         offset(helpDir), XtRString, HELPDIR },
  77. };
  78. #undef    offset
  79.  
  80. /* make the input simple */
  81. static char    file_trans[] =
  82.   "Ctrl<Key>M:        no-op() \n\
  83.    Ctrl<Key>J:        no-op() \n\
  84.    Ctrl<Key>O:        no-op() \n\
  85.    Ctrl<Key>S:        no-op() \n\
  86.    Ctrl<Key>R:        no-op() \n\
  87.    Ctrl<Key>Z:        no-op() \n\
  88.    Meta<Key>I:        no-op() \n\
  89.    Meta<Key>Z:        no-op() \n\
  90.    <Key>Down:        no-op() \n\
  91.    <Key>Up:        no-op() \n\
  92.    <Key>Return:        no-op() \n\
  93.    <Key>Linefeed:    no-op() \n";
  94.  
  95.  
  96. static String    default_resources[] =     {
  97. #ifndef SMALL_CARDS
  98.     "*font:            *helvetica-bold-r-normal--14-140-*",
  99.     "*helptext*font:    *helvetica-bold-r-normal--12-120*",
  100. #else
  101.     "*font:            *helvetica-bold-r-normal--10-100-*",
  102.     "*helptext*font:    *helvetica-bold-r-normal--8-80*",
  103. #endif
  104.     "*input:        True",
  105.     "*newgame.Label:    New Game",
  106.     "*backupMenuButton.Label:    Backup",
  107.     "*onemove.Label:    One Move",
  108.     "*startover.Label:    Start Over",
  109.     "*replay.Label:        Replay",
  110.     "*expand.Label:        Expand",
  111.     "*locate.Label:        Locate",
  112.     "*score.Label:        Score",
  113.     "*help.Label:        Help...",
  114.     "*helpall.Label:    All",
  115.     "*helpintro.Label:    Introduction",
  116.     "*helprules.Label:    Rules",
  117.     "*helpcontrols.Label:    Controls",
  118.     "*helpexamples.Label:    Examples",
  119.     "*helpmisc.Label:    Extras",
  120.     "*helpsummary.Label:    Summary",
  121.     "*helpexit.Label:    Close",
  122.     "*fileMenuButton.Label:        File",
  123.     "*save.Label:        Save in File",
  124.     "*resumeFile.Label:    Resume from File",
  125.     "*resumeSelection.Label:    Resume from Selection",
  126.     "*name.Label:        Name:",
  127.     "*filename*editType:    edit",
  128.     "*confirmcancel.Label:    Cancel",
  129.     "*confirmok.Label:        Ok",
  130. /* this will only work with R4+ Xaw */
  131.     "*panel.MenuButton.leftBitmap:    menu12",
  132.     NULL,
  133. };
  134.  
  135. static void
  136. usage(arg)
  137. char    *arg;
  138. {
  139.         if (arg)
  140.                 (void) fprintf(stderr,"spider: illegal argument %s\n", arg);
  141.         (void) fprintf(stderr,
  142.         "usage: -display <display> -geometry < geometry> -save <save_file>\n");
  143. }
  144.  
  145. main(argc, argv)
  146. int    argc;
  147. char    **argv;
  148. {
  149. char    *save_file = NULL;
  150. int    i, nargs;
  151.  
  152.     nargs = xaw_init(argc, argv);
  153.  
  154.     /* argument processing */
  155.     for (i = 1; i < nargs; i++)      {
  156.         if (strncmp(argv[i], "-s", 2) == 0)      {
  157.             if (argv[i+1])  {
  158.                 save_file = argv[++i];
  159.             } else  {
  160.                 usage(NULL);
  161.                 exit(-1);
  162.             }
  163.         } else    {
  164.             usage(argv[1]);
  165.             exit(-1);
  166.         }
  167.     }
  168.  
  169.     XtRealizeWidget(toplevel);
  170.  
  171.     table_init(XtWindow(table_w));
  172.     card_init();
  173.  
  174.     if (save_file)
  175.         read_file(save_file);
  176.  
  177.     XtAppMainLoop(spider_con);
  178. }
  179.  
  180. #define    NUM_ARGS    15
  181.  
  182. xaw_init(argc, argv)
  183. int    argc;
  184. char    **argv;
  185. {
  186. XtTranslations translations;
  187. Widget    new_button, back_button, expand_button, 
  188.     locate_button, score_button, file_button, help_button;
  189. Widget    outerbox;
  190. Widget    file_menu, back_menu;
  191. Widget    entry;
  192. Arg    args[NUM_ARGS];
  193. int    n;
  194. int    mwin_h, bbox_height;
  195. Pixel    backcolor;
  196. Pixmap    icon_map;
  197. int    scr;
  198.  
  199.  
  200.     table_width = TABLE_WIDTH;
  201.     table_height = TABLE_HEIGHT;
  202.     mwin_h = 5;
  203.     bbox_height = 30;
  204.  
  205.     n = 0;
  206.     XtSetArg(args[n], XtNwidth, table_width);    n++;
  207.     XtSetArg(args[n], XtNheight, table_height + bbox_height + mwin_h); n++;
  208.  
  209.     toplevel = XtAppInitialize(&spider_con, "Spider",
  210.         NULL, 0,
  211.         &argc, argv, default_resources, args, n);
  212.  
  213.     XtGetApplicationResources(toplevel, (caddr_t) &app_resources,
  214.             resources, XtNumber(resources),
  215.             NULL, (Cardinal) 0);
  216.  
  217.     usebell = app_resources.usebell;
  218.     confirm = app_resources.confirm;
  219.     replayTime = app_resources.replayTime;
  220. #ifdef ROUND_CARDS
  221.     round_cards = app_resources.round_cards;
  222. #endif
  223.     squish = app_resources.squish;
  224.     deltamod = app_resources.deltamod;
  225.     helpDir = app_resources.helpDir;
  226.  
  227.     scr = XDefaultScreen(XtDisplay(toplevel));
  228.  
  229. #ifdef DEBUG
  230.     XSynchronize(XtDisplay(toplevel), True);
  231. #endif
  232.  
  233.     /* set the icon */
  234.     icon_map = XCreateBitmapFromData(XtDisplay(toplevel),
  235.         RootWindow(XtDisplay(toplevel), scr),
  236.         spider_bits, spider_width, spider_height);
  237.     n = 0;
  238.     XtSetArg(args[n], XtNiconPixmap, icon_map);    n++;
  239.     XtSetValues(toplevel, args, n);
  240.  
  241.  
  242.     /* get the pixel values, etc */
  243.     gfx_init(XtDisplay(toplevel), scr);
  244.  
  245.  
  246.     n = 0;
  247.     XtSetArg(args[n], XtNsensitive, True);    n++;
  248.     outerbox = XtCreateManagedWidget("outerbox", panedWidgetClass,
  249.         toplevel, args, n);
  250.  
  251.     XtSetArg(args[0], XtNbackground, &backcolor);
  252.     XtGetValues(outerbox, args, ONE);
  253.  
  254.     n = 0;
  255.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  256.     XtSetArg(args[n], XtNsensitive, True);    n++;
  257.     XtSetArg(args[n], XtNinternalBorderWidth, 10);    n++;
  258.     XtSetArg(args[n], XtNinternalBorderColor, backcolor);    n++;
  259.     XtSetArg(args[n], XtNorientation, XtorientHorizontal); n++;
  260.     panel = XtCreateManagedWidget("panel", panedWidgetClass, outerbox,
  261.         args, n);
  262.  
  263.     /* add the buttons */
  264.  
  265.     /* newgame */
  266.     n = 0;
  267.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  268.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  269.     new_button = XtCreateManagedWidget("newgame", commandWidgetClass,
  270.         panel, args, n);
  271.     
  272.     XtAddCallback(new_button, XtNcallback, newgame_handler, NULL);
  273.  
  274.     /* backup menu */
  275.     n = 0;
  276.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  277.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  278.     XtSetArg(args[n], XtNmenuName, "backupMenu");    n++;
  279.     back_button = XtCreateManagedWidget("backupMenuButton", 
  280.         menuButtonWidgetClass, panel, args, n);
  281.  
  282.     back_menu = XtCreatePopupShell("backupMenu", simpleMenuWidgetClass, 
  283.         back_button, NULL, ZERO);
  284.  
  285.     entry = XtCreateManagedWidget("onemove", smeBSBObjectClass, back_menu,
  286.         NULL, ZERO);
  287.     XtAddCallback(entry, XtNcallback, backup_handler, (XtPointer) 0);
  288.     entry = XtCreateManagedWidget("startover", smeBSBObjectClass, back_menu,
  289.         NULL, ZERO);
  290.     XtAddCallback(entry, XtNcallback, backup_handler, (XtPointer) 1);
  291.     entry = XtCreateManagedWidget("replay", smeBSBObjectClass, back_menu,
  292.         NULL, ZERO);
  293.     XtAddCallback(entry, XtNcallback, backup_handler, (XtPointer) 2);
  294.     
  295.  
  296.     /* Expand button */
  297.     n = 0;
  298.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  299.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  300.     expand_button = XtCreateManagedWidget("expand", commandWidgetClass,
  301.         panel, args, n);
  302.     
  303.     XtAddCallback(expand_button, XtNcallback, expand_handler, NULL);
  304.  
  305.     /* Locate button */
  306.     n = 0;
  307.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  308.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  309.     locate_button = XtCreateManagedWidget("locate", commandWidgetClass,
  310.         panel, args, n);
  311.     
  312.     XtAddCallback(locate_button, XtNcallback, locate_handler, NULL);
  313.  
  314.     /* Score button */
  315.     n = 0;
  316.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  317.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  318.     score_button = XtCreateManagedWidget("score", commandWidgetClass,
  319.         panel, args, n);
  320.  
  321.     XtAddCallback(score_button, XtNcallback, score_handler, NULL);
  322.  
  323.     /* Help button */
  324.     n = 0;
  325.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  326.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  327.     if (!can_get_help_files(helpfiles))    {
  328.         XtSetArg(args[n], XtNsensitive, False);    n++;
  329.     }
  330.     help_button = XtCreateManagedWidget("help", commandWidgetClass,
  331.         panel, args, n);
  332.  
  333.     XtAddCallback(help_button, XtNcallback, help_handler, NULL);
  334.  
  335.     /* File menu */
  336.     n = 0;
  337.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  338.     XtSetArg(args[n], XtNmenuName, "fileMenu");    n++;
  339.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  340.     file_button = XtCreateManagedWidget("fileMenuButton", 
  341.         menuButtonWidgetClass, panel, args, n);
  342.  
  343.     file_menu = XtCreatePopupShell("fileMenu", simpleMenuWidgetClass, 
  344.         file_button, NULL, ZERO);
  345.  
  346.     entry = XtCreateManagedWidget("save", smeBSBObjectClass, file_menu,
  347.         NULL, ZERO);
  348.     XtAddCallback(entry, XtNcallback, file_handler, (XtPointer) 0);
  349.     entry = XtCreateManagedWidget("resumeFile", smeBSBObjectClass, 
  350.         file_menu, NULL, ZERO);
  351.     XtAddCallback(entry, XtNcallback, file_handler, (XtPointer) 1);
  352.     entry = XtCreateManagedWidget("resumeSelection", smeBSBObjectClass,
  353.         file_menu, NULL, ZERO);
  354.     XtAddCallback(entry, XtNcallback, file_handler, (XtPointer) 2);
  355.  
  356.     /* File label */
  357.     n = 0;
  358.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  359.     XtSetArg(args[n], XtNborderWidth, 0);    n++;
  360.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  361.     file_button = XtCreateManagedWidget("name", 
  362.         labelWidgetClass, panel, args, n);
  363.     
  364.     /* file name entry field */
  365.     n = 0;
  366.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  367.     XtSetArg(args[n], XtNborderWidth, 0);    n++;
  368.     XtSetArg(args[n], XtNskipAdjust, False);    n++;
  369.     assert (n <= NUM_ARGS);
  370.     file = XtCreateManagedWidget("filename", asciiTextWidgetClass,
  371.         panel, args, n);
  372.     translations = XtParseTranslationTable(file_trans);
  373.     XtOverrideTranslations(file, translations);
  374.  
  375.     /* build the table itself */
  376.     n = 0;
  377.     XtSetArg(args[n], XtNx, 0);    n++;
  378.     XtSetArg(args[n], XtNy, bbox_height);    n++;
  379.     XtSetArg(args[n], XtNwidth, table_width - 2 * TABLE_BW);    n++;
  380.     XtSetArg(args[n], XtNheight, table_height);    n++;
  381.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  382.     XtSetArg(args[n], XtNskipAdjust, False);    n++;
  383.     assert (n <= NUM_ARGS);
  384.     if (is_color)    {
  385.         XtSetArg(args[n], XtNbackground, greenpixel);    n++;
  386.     } else    {
  387.         XtSetArg(args[n], XtNbackgroundPixmap, greenmap);    n++;
  388.     }
  389.     table_w = XtCreateManagedWidget("table", simpleWidgetClass, outerbox,
  390.         args, n);
  391.     XtAddEventHandler(table_w, ExposureMask, False, xaw_redraw_table, 
  392.                     NULL);
  393.     XtAddEventHandler(table_w, ButtonPressMask, False, xaw_button_press, 
  394.                     NULL);
  395.     XtAddEventHandler(table_w, ButtonReleaseMask, False, xaw_button_release,
  396.                     NULL);
  397.     XtAddEventHandler(table_w, KeyPressMask, False, xaw_key_press,
  398.                     NULL);
  399.     XtAddEventHandler(table_w, StructureNotifyMask, False, xaw_resize,
  400.                     NULL);
  401.  
  402.     n = 0;
  403.     XtSetArg(args[n], XtNx, 0);    n++;
  404.     XtSetArg(args[n], XtNy, table_height - 2 * TABLE_BW - mwin_h); n++;
  405.     XtSetArg(args[n], XtNwidth, table_width - 2 * TABLE_BW);    n++;
  406.     XtSetArg(args[n], XtNheight, mwin_h);    n++;
  407.     XtSetArg(args[n], XtNjustify, XtJustifyLeft);    n++;
  408.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  409.     XtSetArg(args[n], XtNskipAdjust, True);    n++;
  410.     assert (n <= NUM_ARGS);
  411.     message = XtCreateManagedWidget("message", labelWidgetClass,
  412.         outerbox, args, n);
  413.     /* set initial contents to version */
  414.     print_version();
  415.  
  416.     create_confirmer();
  417.  
  418.     return argc;
  419. }
  420.  
  421. create_confirmer()
  422. {
  423. Arg    args[NUM_ARGS];
  424. int    n = 0;
  425. Widget    confirmbox, confirmpane;
  426. Widget    button;
  427.  
  428.     /* create the confirmer box */
  429.     confirm_box = XtCreatePopupShell("prompt", transientShellWidgetClass,
  430.         toplevel, args, n);
  431.  
  432.     n = 0;
  433.     confirmpane = XtCreateManagedWidget("confirmbox", panedWidgetClass,
  434.         confirm_box, args, n);
  435.  
  436.     n = 0;
  437.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  438.     confirm_label = XtCreateManagedWidget("confirmlabel", labelWidgetClass,
  439.         confirmpane, args, n);
  440.  
  441.     n = 0;
  442.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  443.     XtSetArg(args[n], XtNorientation, XtorientHorizontal);    n++;
  444.     confirmbox = XtCreateManagedWidget("confirmbox", boxWidgetClass,
  445.         confirmpane, args, n);
  446.  
  447.     n = 0;
  448.     button = XtCreateManagedWidget("confirmok", commandWidgetClass,
  449.         confirmbox, args, n);
  450.     XtAddCallback(button, XtNcallback, confirm_callback, 1);
  451.  
  452.     n = 0;
  453.     button = XtCreateManagedWidget("confirmcancel", commandWidgetClass,
  454.         confirmbox, args, n);
  455.     XtAddCallback(button, XtNcallback, confirm_callback, 2);
  456. }
  457.  
  458.  
  459. void
  460. show_message(buf)
  461. char    *buf;
  462. {
  463. Arg    args[1];
  464.  
  465.     XtSetArg(args[0], XtNlabel, buf);
  466.     XtSetValues(message, args, ONE);
  467. }
  468.  
  469. /*
  470.  * since the Label needs to get events to update, it doesn't update until
  471.  * we hit the event loop.  this forces it out when we have to
  472.  * have it immediatly, like with the Expand feature.
  473.  */
  474. flush_message()
  475. {
  476. XEvent    event;
  477.  
  478.     /* force the result to be seen immediately */
  479.     while ( !XCheckTypedWindowEvent(XtDisplay(toplevel),
  480.                   XtWindow(message),
  481.                   Expose, &event) );
  482.     XtDispatchEvent( &event );
  483.     XFlush(XtDisplay(toplevel));
  484. }
  485.  
  486. Widget
  487. create_help_popup(fname)
  488. char    *fname;
  489. {
  490. Widget    help, helpbox, helpform, helpview;
  491. Widget    button;
  492. int    n;
  493. Arg    args[10];
  494.  
  495.     n = 0;
  496.     help = XtCreatePopupShell("Spider Help", topLevelShellWidgetClass,
  497.         toplevel, args, n);
  498.  
  499.     n = 0;
  500.     helpbox = XtCreateManagedWidget("helpbox", panedWidgetClass,
  501.         help, args, n);
  502.  
  503.     n = 0;
  504.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  505.     XtSetArg(args[n], XtNorientation, XtorientHorizontal);    n++;
  506.     helpform = XtCreateManagedWidget("helpform", boxWidgetClass,
  507.         helpbox, args, n);
  508.  
  509.     n = 0;
  510.     button = XtCreateManagedWidget("helpintro", commandWidgetClass,
  511.         helpform, args, n);
  512.     XtAddCallback(button, XtNcallback, change_help, 1);
  513.  
  514.     n = 0;
  515.     button = XtCreateManagedWidget("helprules", commandWidgetClass,
  516.         helpform, args, n);
  517.     XtAddCallback(button, XtNcallback, change_help, 2);
  518.  
  519.     n = 0;
  520.     button = XtCreateManagedWidget("helpcontrols", commandWidgetClass,
  521.         helpform, args, n);
  522.     XtAddCallback(button, XtNcallback, change_help, 3);
  523.  
  524.     n = 0;
  525.     button = XtCreateManagedWidget("helpexamples", commandWidgetClass,
  526.         helpform, args, n);
  527.     XtAddCallback(button, XtNcallback, change_help, 4);
  528.  
  529.     n = 0;
  530.     button = XtCreateManagedWidget("helpmisc", commandWidgetClass,
  531.         helpform, args, n);
  532.     XtAddCallback(button, XtNcallback, change_help, 5);
  533.  
  534.     n = 0;
  535.     button = XtCreateManagedWidget("helpsummary", commandWidgetClass,
  536.         helpform, args, n);
  537.     XtAddCallback(button, XtNcallback, change_help, 6);
  538.  
  539.     n = 0;
  540.     button = XtCreateManagedWidget("helpexit", commandWidgetClass,
  541.         helpform, args, n);
  542.     XtAddCallback(button, XtNcallback, change_help, 7);
  543.  
  544.     n = 0;
  545.     XtSetArg(args[n], XtNshowGrip, False);    n++;
  546.     XtSetArg(args[n], XtNallowHoriz, True);    n++;
  547.     XtSetArg(args[n], XtNallowVert, True);    n++;
  548.     helpview = XtCreateManagedWidget("helpview", viewportWidgetClass,
  549.         helpbox, args, n);
  550.  
  551.     n = 0;
  552.     XtSetArg(args[n], XtNheight, 300);    n++;
  553.     XtSetArg(args[n], XtNwidth, 550);    n++;
  554.     XtSetArg(args[n], XtNtype, XawAsciiFile);    n++;
  555.     XtSetArg(args[n], XtNstring, fname);    n++;
  556.     XtSetArg(args[n], XtNwrap, XawtextWrapLine);    n++;
  557.     XtSetArg(args[n], XtNscrollVertical, XawtextScrollWhenNeeded);    n++;
  558.     helptext = XtCreateManagedWidget("helptext", asciiTextWidgetClass,
  559.         helpview, args, n);
  560.  
  561.     return help;
  562. }
  563.