home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 281_01 / dem_menu.c < prev    next >
C/C++ Source or Header  |  1988-10-06  |  38KB  |  1,030 lines
  1. /*  dem_menu.c
  2.  *
  3.  *  Demo program for menu functions
  4.  *    This program will also spawn the window, data entry and general
  5.  *    library demo programs from a menu.
  6.  *
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <process.h>
  11.  
  12.  
  13. #include "uc_defs.h"
  14. #include "uc_glob.h"
  15. #include "uc_proto.h"
  16.  
  17. #include "wn_defs.h"
  18. #include "wn_glob.h"
  19. #include "wn_proto.h"
  20.  
  21. #include  "mn_defs.h"
  22. #include  "mn_glob.h"
  23.  
  24.  
  25. #include "uc_key.h"
  26.  
  27.  
  28.  
  29. MNUPTR        make_mnu();
  30.  
  31. MNU_ITEMPTR make_item();
  32.  
  33.  
  34.  
  35. void main( void )
  36. {
  37.    MNU_ITEMPTR    mnu_item;
  38.    MNUPTR    mnu_ptr;
  39.    WINDOWPTR    wn_mnu;
  40.    WINDOWPTR    wn_main;
  41.    int        dummy();
  42.    int        bye_bye();
  43.    int        unicorn();
  44.    int        demos();
  45.    int        registration();
  46.    int        future();
  47.    int        notes();
  48.    int        uclib51();
  49.    int        i;
  50.  
  51.    uc_init();    /* This function checks the current video mode and    */
  52.         /* sets up the window system accordingly.          */
  53.         /* At present you must define attributes for either a */
  54.         /* color or a monochrome system.  A future release    */
  55.         /* add a universal attribute system used in a past    */
  56.         /* Unicorn release.  This system allows the user to   */
  57.         /* predefine a set of attributes for both systems and */
  58.         /* to use the appropriate ones determined on a run    */
  59.         /* time check of the video mode.  This means a single */
  60.         /* program may be written that will run correctly on  */
  61.         /* both color and monochrome systems.              */
  62.    if ( mouse_exist )
  63.       m_flagdec();
  64.  
  65.  
  66.    cur_save();    /* Save the users current cursor location and shape.  */
  67.  
  68.  
  69.         /*  Make a full screen window.    This will be popped up*/
  70.         /*  to save the users screen so that it may be          */
  71.         /*  restored on exiting this demo program.          */
  72.    wn_main = wn_make( 0, 0, 24, 80 );
  73.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  74.    wn_bclr( wn_main, mk_att( BLUE,  WHITE + BRIGHT ) );
  75.    wn_clear( wn_main );
  76.    wn_margin( wn_main, 1 );
  77.  
  78.  
  79.         /* A future release will contain a function to build a*/
  80.         /* title so the user will not have to do this messy   */
  81.         /* stuff.  It will be hidden behind a function call.  */
  82.  
  83.    wn_main->title = ( TITLEPTR ) malloc( sizeof( TITLE ) );
  84.    wn_main->title->title = ( char * ) malloc( 100 );
  85.    strcpy( wn_main->title->title,
  86. " Unicorn Software P.O. Box 3214 Kirkland, WA 98034-3214 (206) 823-4656" );
  87.    wn_main->title->position = 4;
  88.                     /* Set the title color          */
  89.    wn_main->clr->title = mk_att( WHITE, BLUE + BRIGHT );
  90.  
  91.  
  92.    wn_mkbdr( wn_main, BDR_LNP );
  93.  
  94.         /* position the cursor in the window and write some   */
  95.         /* text for the user to read.                  */
  96.  
  97.    wn_csr( wn_main, 4, 21 );
  98.    wn_printf( wn_main, "Unicorn Menu System Version 1.0\n" );
  99.  
  100.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  101.    wn_printf( wn_main, "\n                                     " );
  102.    wn_printf( wn_main, "Welcome to the " );
  103.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  104.    wn_printf( wn_main, "Unicorn Menu System\n" );
  105.  
  106.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  107.    wn_printf( wn_main, "                                     " );
  108.    wn_printf( wn_main, "Version 1.0.   This is included as\n" );
  109.  
  110.    wn_printf( wn_main, "                                     " );
  111.    wn_printf( wn_main, "a part of the Unicorn Library.     \n" );
  112.  
  113.    wn_printf( wn_main, "                                     " );
  114.    wn_printf( wn_main, "We hope you enjoy the menu Demo and\n" );
  115.  
  116.    wn_printf( wn_main, "                                     " );
  117.    wn_printf( wn_main, "the other demo programs it will run.\n\n" );
  118.  
  119.    wn_printf( wn_main, "                                     " );
  120.    wn_printf( wn_main, "Not all features are demonstrated but\n" );
  121.  
  122.    wn_printf( wn_main, "                                     " );
  123.    wn_printf( wn_main, "with the source code for this program\n" );
  124.  
  125.    wn_printf( wn_main, "                                     " );
  126.    wn_printf( wn_main, "and the other demos along with the\n" );
  127.  
  128.    wn_printf( wn_main, "                                     " );
  129.    wn_printf( wn_main, "reference guide there should be more\n" );
  130.  
  131.    wn_printf( wn_main, "                                     " );
  132.    wn_printf( wn_main, "than enough to allow you to write\n" );
  133.  
  134.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  135.    wn_printf( wn_main, "    If you have a mouse driver       " );
  136.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  137.    wn_printf( wn_main, "your own programs.  " );
  138.  
  139.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  140.    wn_printf( wn_main, "Registered users \n" );
  141.  
  142.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  143.    wn_printf( wn_main, "    installed, you may use the       " );
  144.    wn_printf( wn_main, "will recieve a " );
  145.  
  146.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  147.    wn_printf( wn_main, "6 disk set " );
  148.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  149.    wn_printf( wn_main, "including\n" );
  150.  
  151.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  152.    wn_printf( wn_main, "    mouse to point and shoot         " );
  153.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  154.    wn_printf( wn_main, "full source code" );
  155.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  156.    wn_printf( wn_main, " for all of the over\n" );
  157.  
  158.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  159.    wn_printf( wn_main, "    with the menus and may use       " );
  160.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  161.    wn_printf( wn_main, "300 functions " );
  162.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  163.    wn_printf( wn_main, "contained in this version\n" );
  164.  
  165.    wn_printf( wn_main, "    the buttons to move through      " );
  166.    wn_printf( wn_main, "of the Unicorn Library.  " );
  167.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  168.    wn_printf( wn_main, "Thanks for\n" );
  169.  
  170.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  171.    wn_printf( wn_main, "    the display instead of           " );
  172.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  173.    wn_printf( wn_main, "looking at the library and considering\n" );
  174.  
  175.    wn_wnclr( wn_main, mk_att( BLUE, WHITE + BRIGHT ) );
  176.    wn_printf( wn_main, "    pressing a key.                  " );
  177.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  178.    wn_printf( wn_main, "registration.        " );
  179.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  180.    wn_printf( wn_main, " Dave Miller\n" );
  181.    wn_wnclr( wn_main, mk_att( BLUE, CYAN ) );
  182.  
  183.  
  184.              /* Time to make a window for the menu.  It will  */
  185.              /* be attached to a menu structure.          */
  186.    wn_mnu = wn_make( 4, 2, 11, 32 );
  187.    wn_wnclr( wn_mnu, mk_att( CYAN, BLACK + BRIGHT ) );
  188.    wn_bclr( wn_mnu, mk_att( CYAN,  BROWN + BRIGHT ) );
  189.    wn_clear( wn_mnu );
  190.    wn_margin( wn_mnu, 2 );
  191.    wn_mkbdr( wn_mnu, BDR_DLNP );
  192.  
  193.              /* Make the menu structure now.              */
  194.    mnu_ptr = make_mnu( wn_mnu );
  195.  
  196.    wn_printf( mnu_ptr->mnu_window, "        Main Menu\n" );
  197.  
  198.  
  199.              /* Now we will make the actual menu items.  Each */
  200.              /* item call is passed several parameters.  You  */
  201.              /* may easily experiment with changing them to   */
  202.              /* get a better feel for the system.  One very   */
  203.              /* important one is the pointer to a function to */
  204.              /* be called if this item is selected.  For the  */
  205.              /* first item the pointer is 'unicorn'.          */
  206.  
  207.    mnu_item = make_item( 3, 4, mk_att( CYAN, BLUE ),
  208.         mk_att( BLUE, CYAN + BRIGHT ), " Unicorn Software ", unicorn,
  209.             'U', mk_att( CYAN, RED ), mnu_ptr );
  210.  
  211.    mnu_item = make_item( 4, 4, mk_att( CYAN, BLUE ),
  212.         mk_att( BLUE, CYAN + BRIGHT ), " Demo Programs    ", demos,
  213.             'D', mk_att( CYAN, RED ), mnu_ptr );
  214.  
  215.    mnu_item = make_item( 5, 4, mk_att( CYAN, BLUE ),
  216.         mk_att( BLUE, CYAN + BRIGHT ), " Registration    ", registration,
  217.              'R', mk_att( CYAN, RED ), mnu_ptr );
  218.  
  219.    mnu_item = make_item( 6, 4, mk_att( CYAN, BLUE ),
  220.         mk_att( BLUE, CYAN + BRIGHT ), " Future Updates  ", future,
  221.               'F', mk_att( CYAN, RED ), mnu_ptr );
  222.  
  223.    mnu_item = make_item( 7, 4, mk_att( CYAN, BLUE ),
  224.         mk_att( BLUE, CYAN + BRIGHT ), " Library Notes   ", notes,
  225.               'L', mk_att( CYAN, RED ), mnu_ptr );
  226.  
  227.    mnu_item = make_item( 8, 4, mk_att( CYAN, BLUE ),
  228.         mk_att( BLUE, CYAN + BRIGHT ), " Uclib 5.1 Update", uclib51,
  229.               'i', mk_att( CYAN, RED ), mnu_ptr );
  230.  
  231.    mnu_item = make_item( 9, 4, mk_att( CYAN, BLUE ),
  232.         mk_att( BLUE, CYAN + BRIGHT ), " Exit to DOS     ", bye_bye,
  233.               'x', mk_att( CYAN, RED ), mnu_ptr );
  234.  
  235.              /* Display the full screen window on the screen  */
  236.    wn_dsply( wn_main );
  237.  
  238.              /* Go process the menu.                  */
  239.    mnu_proc( mnu_ptr, 1 );
  240.  
  241.              /* Now that the menu is processed and the program*/
  242.              /* is over lets bring down the windows and       */
  243.              /* restore the users screen and cursor.          */
  244.    wn_hide( mnu_ptr->mnu_window );
  245.    wn_hide( wn_main );
  246.    cur_restore();
  247. }
  248.  
  249.  
  250.  
  251. /*--------------------------------------------------------------------*/
  252. /*  This function, called from the main menu will spawn the window    */
  253. /*  demo program.                              */
  254. /*  Notice that all menu item functions are passed a pointer to the   */
  255. /*  menu and the choice from the menu.    This allows the called          */
  256. /*  function access to the menu information and thus to be smart      */
  257. /*  enough to position any windows according to the menu item selected*/
  258. /*  among other things.                           */
  259. /*--------------------------------------------------------------------*/
  260.  
  261. int window( MNUPTR mnu_ptr, int choice )
  262. {
  263.    WINDOWPTR     wn1;
  264.    MNU_ITEMPTR     tmp;
  265.    int         i;
  266.    MNUPTR     mn_ptr;
  267.    MNU_ITEMPTR     mn_item;
  268.    int         general();
  269.    int         window();
  270.    int         data_entry();
  271.    int         ret;
  272.  
  273.                  /* This uses the passed information to   */
  274.                  /* reset the menu's border type and      */
  275.                  /* attribute.                  */
  276.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BLUE ) );
  277.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  278.    wn_bdr( mnu_ptr->mnu_window );
  279.  
  280.    ret = spawnl( P_WAIT, "window.exe", "window", NULL );
  281.    if ( ret == -1 )
  282.    {
  283.       printf( "\n\nSpawn failed\n" );
  284.       exit( -1 );
  285.    }
  286.  
  287.                  /* This sets the calling menu's border   */
  288.                  /* type and attribute back to the          */
  289.                  /* original values.              */
  290.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BROWN +BRIGHT ) );
  291.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  292.    wn_bdr( mnu_ptr->mnu_window );
  293.  
  294.    return( 1 );   /* A return of 1 tells the menu processor to          */
  295.           /* continue processing the menu.  A return of 0     */
  296.           /* informs the processor an exit is desired and thus*/
  297.           /* the processor will imediately exit.          */
  298. }
  299.  
  300.  
  301.  
  302. int general_no( MNUPTR mnu_ptr, int choice )
  303. {
  304.    WINDOWPTR     wn1;
  305.    MNU_ITEMPTR     tmp;
  306.    int         i;
  307.    MNUPTR     mn_ptr;
  308.    MNU_ITEMPTR     mn_item;
  309.    int         general();
  310.    int         window();
  311.    int         data_entry();
  312.    int         ret;
  313.    WINDOWPTR     wn_main;
  314.  
  315.  
  316.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BLUE ) );
  317.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  318.    wn_bdr( mnu_ptr->mnu_window );
  319.  
  320.    cur_on();
  321.         /*  Make a full screen window.    This will be popped up*/
  322.         /*  to save the users screen so that it may be          */
  323.         /*  restored on exiting this demo program.          */
  324.    wn_main = wn_make( 0, 0, 24, 80 );
  325.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  326.    wn_bclr( wn_main, mk_att( BLUE,  WHITE + BRIGHT ) );
  327.    wn_clear( wn_main );
  328.    wn_margin( wn_main, 1 );
  329.  
  330.    wn_main->title = ( TITLEPTR ) malloc( sizeof( TITLE ) );
  331.    wn_main->title->title = ( char * ) malloc( 100 );
  332.    strcpy( wn_main->title->title,
  333. " Unicorn Software P.O. Box 3214 Kirkland, WA 98034-3214 (206) 823-4656" );
  334.    wn_main->title->position = 4;
  335.                     /* Set the title color          */
  336.    wn_main->clr->title = mk_att( WHITE, BLUE + BRIGHT );
  337.  
  338.  
  339.    wn_mkbdr( wn_main, BDR_LNP );
  340.  
  341.    wn_dsply( wn_main );
  342.  
  343.  
  344.    ret = spawnl( P_WAIT, "lib_demo.exe", "lib_demo", "1", "2", "3", "4", NULL );
  345.    if ( ret == -1 )
  346.    {
  347.       printf( "\n\nSpawn failed\n" );
  348.       exit( -1 );
  349.    }
  350.  
  351.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BROWN +BRIGHT ) );
  352.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  353.    wn_bdr( mnu_ptr->mnu_window );
  354.  
  355.    wn_hide( wn_main );
  356.    cur_off();
  357.    return( 1 );
  358. }
  359.  
  360.  
  361.  
  362.  
  363. int general( MNUPTR mnu_ptr, int choice )
  364. {
  365.    WINDOWPTR     wn1;
  366.    MNU_ITEMPTR     tmp;
  367.    int         i;
  368.    MNUPTR     mn_ptr;
  369.    MNU_ITEMPTR     mn_item;
  370.    int         general();
  371.    int         window();
  372.    int         data_entry();
  373.    int         ret;
  374.    WINDOWPTR     wn_main;
  375.  
  376.  
  377.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BLUE ) );
  378.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  379.    wn_bdr( mnu_ptr->mnu_window );
  380.  
  381.    cur_on();
  382.         /*  Make a full screen window.    This will be popped up*/
  383.         /*  to save the users screen so that it may be          */
  384.         /*  restored on exiting this demo program.          */
  385.    wn_main = wn_make( 0, 0, 24, 80 );
  386.    wn_wnclr( wn_main, mk_att( BLUE, BROWN + BRIGHT ) );
  387.    wn_bclr( wn_main, mk_att( BLUE,  WHITE + BRIGHT ) );
  388.    wn_clear( wn_main );
  389.    wn_margin( wn_main, 1 );
  390.  
  391.    wn_main->title = ( TITLEPTR ) malloc( sizeof( TITLE ) );
  392.    wn_main->title->title = ( char * ) malloc( 100 );
  393.    strcpy( wn_main->title->title,
  394. " Unicorn Software P.O. Box 3214 Kirkland, WA 98034-3214 (206) 823-4656" );
  395.    wn_main->title->position = 4;
  396.                     /* Set the title color          */
  397.    wn_main->clr->title = mk_att( WHITE, BLUE + BRIGHT );
  398.  
  399.  
  400.    wn_mkbdr( wn_main, BDR_LNP );
  401.  
  402.    wn_dsply( wn_main );
  403.  
  404.  
  405.    ret = spawnl( P_WAIT, "lib_demo.exe", "lib_demo", NULL );
  406.    if ( ret == -1 )
  407.    {
  408.       printf( "\n\nSpawn failed\n" );
  409.       exit( -1 );
  410.    }
  411.  
  412.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BROWN +BRIGHT ) );
  413.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  414.    wn_bdr( mnu_ptr->mnu_window );
  415.  
  416.    wn_hide( wn_main );
  417.    cur_off();
  418.    return( 1 );
  419. }
  420.  
  421.  
  422.  
  423. int data_entry( MNUPTR mnu_ptr, int choice )
  424. {
  425.    WINDOWPTR     wn1;
  426.    MNU_ITEMPTR     tmp;
  427.    int         i;
  428.    MNUPTR     mn_ptr;
  429.    MNU_ITEMPTR     mn_item;
  430.    int         general();
  431.    int         window();
  432.    int         data_entry();
  433.    int         ret;
  434.  
  435.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BLUE ) );
  436.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  437.    wn_bdr( mnu_ptr->mnu_window );
  438.  
  439.    ret = spawnl( P_WAIT, "tdata.exe", "tdata", NULL );
  440.    if ( ret == -1 )
  441.    {
  442.       printf( "\n\nSpawn failed\n" );
  443.       exit( -1 );
  444.    }
  445.  
  446.    wn_bclr( mnu_ptr->mnu_window, mk_att( RED, BROWN +BRIGHT ) );
  447.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  448.    wn_bdr( mnu_ptr->mnu_window );
  449.  
  450.    return( 1 );
  451. }
  452.  
  453.  
  454.  
  455. /*--------------------------------------------------------------------*/
  456. /* This function sets up a sub menu using the passed information to   */
  457. /* place it on the screen in correct relationship to the calling menu.*/
  458. /* This menu will then call fucntions that are capable of spawing the */
  459. /* demo programs for the library.                      */
  460. /* As many sub menus as you need or want may be built in the same     */
  461. /* manner creating as complicated a menu system as you desire or need */
  462. /*--------------------------------------------------------------------*/
  463.  
  464. int demos( MNUPTR mnu_ptr, int choice )
  465. {
  466.    WINDOWPTR     wn1;
  467.    MNU_ITEMPTR     tmp;
  468.    int         i;
  469.    MNUPTR     mn_ptr;
  470.    MNU_ITEMPTR     mn_item;
  471.    int         general();
  472.    int         gereral_no();
  473.    int         window();
  474.    int         data_entry();
  475.  
  476.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  477.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  478.    wn_bdr( mnu_ptr->mnu_window );
  479.  
  480.    tmp = mnu_ptr->mnu_item;
  481.    for( i = 1; i < choice; i++ )
  482.       tmp = tmp->next;
  483.  
  484.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  485.           mnu_ptr->mnu_window->col + tmp->col + 1, 9, 32 );
  486.  
  487.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  488.    wn_bclr( wn1,  mk_att( RED, BROWN + BRIGHT ) );
  489.    wn_clear( wn1 );
  490.    wn_margin( wn1, 4 );
  491.    wn_mkbdr( wn1, BDR_DLNP );
  492.    wn_dsply( wn1 );
  493.  
  494.    mn_ptr = make_mnu( wn1 );
  495.  
  496.    wn_printf( mn_ptr->mnu_window, "    Demo Programs\n" );
  497.  
  498.    mn_item = make_item( 3, 4, mk_att( RED, WHITE ),
  499.            mk_att( WHITE, RED ),  " General ( w/sound)", general,
  500.             'w', mk_att( RED, BROWN + BRIGHT ), mn_ptr );
  501.  
  502.    mn_item = make_item( 4, 4, mk_att( RED, WHITE ),
  503.            mk_att( WHITE, RED ),  " General (no sound)", general_no,
  504.             'n', mk_att( RED, BROWN + BRIGHT ), mn_ptr );
  505.  
  506.    mn_item = make_item( 5, 4, mk_att( RED, WHITE ),
  507.            mk_att( WHITE, RED ),  " Window System     ", window,
  508.             'W', mk_att( RED, BROWN + BRIGHT ), mn_ptr );
  509.  
  510.    mn_item = make_item( 6, 4, mk_att( RED, WHITE ),
  511.             mk_att( WHITE, RED ), " Data Entry System ", data_entry,
  512.              'D', mk_att( RED, BROWN + BRIGHT ), mn_ptr );
  513.  
  514.    mn_item = make_item( 7, 4, mk_att( RED, WHITE ),
  515.             mk_att( WHITE, RED ), " Exit              ", bye_bye,
  516.               'x', mk_att( RED, BROWN + BRIGHT ), mn_ptr );
  517.  
  518.  
  519.    mnu_proc( mn_ptr, 1 );
  520.  
  521.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN +BRIGHT ) );
  522.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  523.    wn_bdr( mnu_ptr->mnu_window );
  524.  
  525.    wn_hide( mn_ptr->mnu_window );
  526.    return( 1 );
  527. }
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534.  
  535. int uclib51( MNUPTR mnu_ptr, int choice )
  536. {
  537.    WINDOWPTR  wn1;
  538.    MNU_ITEMPTR     tmp;
  539.    int         i;
  540.  
  541.  
  542.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  543.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  544.    wn_bdr( mnu_ptr->mnu_window );
  545.  
  546.    tmp = mnu_ptr->mnu_item;
  547.    for( i = 1; i < choice; i++ )
  548.       tmp = tmp->next;
  549.  
  550.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  551.           mnu_ptr->mnu_window->col + tmp->col + 1, 11, 63 );
  552.  
  553.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  554.    wn_bclr( wn1,  mk_att( RED, WHITE + BRIGHT ) );
  555.    wn_clear( wn1 );
  556.    wn_margin( wn1, 3 );
  557.    wn_mkbdr( wn1, BDR_12LNP );
  558.    wn_dsply( wn1 );
  559.    wn_printf( wn1, "     Unicorn Library Updates for version 5.1" );
  560.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  561.    wn_printf( wn1, "\n\n   This release of the Unicorn Library is    \n" );
  562.    wn_printf( wn1, "version 5.1 occuring in October of 1988.  Version\n" );
  563.    wn_printf( wn1, "5.0 occurred in September of 1988.  This version \n" );
  564.    wn_printf( wn1, "is comming so rapidly since the menu system was  \n" );
  565.  
  566.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  567.    wn_printf( wn1, "\n              Press a key to continue\n" );
  568.    uc_key();
  569.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  570.  
  571.    wn_printf( wn1, "completed sooner than the author anticipated.    \n" );
  572.    wn_printf( wn1, "   This new version adds the first portion of the\n" );
  573.    wn_printf( wn1, "planned menus to the library along with mouse    \n" );
  574.    wn_printf( wn1, "support.  The inititalization function 'uc_init()'\n" );
  575.    wn_printf( wn1, "will now look for a mouse and if found it will   \n" );
  576.    wn_printf( wn1, "turn on the mouse cursor ( default is a reverse  \n" );
  577.  
  578.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  579.    wn_printf( wn1, "\n              Press a key to continue\n" );
  580.    uc_key();
  581.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  582.  
  583.    wn_printf( wn1, "video block ).  This cursor may be turned off by \n" );
  584.    wn_printf( wn1, "a call to 'm_flagdec()' following the call to    \n" );
  585.    wn_printf( wn1, "'uc_init().  The demos illustrate this.          \n" );
  586.    wn_printf( wn1, "  The menus may be accessed by the mouse using   \n" );
  587.    wn_printf( wn1, "the 'point and shoot approach.  In addition any   \n" );
  588.    wn_printf( wn1, "time a key stroke is called for in the demos a   \n" );
  589.  
  590.  
  591.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  592.    wn_printf( wn1, "\n               Press a key to continue\n" );
  593.    uc_key();
  594.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  595.  
  596.    wn_printf( wn1, "mouse button may be pressed instead.             \n" );
  597.    wn_printf( wn1, "  At the present time the next update is planned \n" );
  598.    wn_printf( wn1, "for about the end of 1988.  Look for it on the   \n" );
  599.    wn_printf( wn1, "boards and in particular the Seattle area boards \n" );
  600.    wn_printf( wn1, "mentioned elsewhere in the documentation.         \n" );
  601.  
  602.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  603.    wn_printf( wn1, "\n               Press a key to continue\n" );
  604.    uc_key();
  605.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  606.  
  607.    wn_hide( wn1 );
  608.  
  609.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN +BRIGHT ) );
  610.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  611.    wn_bdr( mnu_ptr->mnu_window );
  612.  
  613.    return( 1 );
  614.  
  615. }
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622. int future( MNUPTR mnu_ptr, int choice )
  623. {
  624.    WINDOWPTR  wn1;
  625.    MNU_ITEMPTR     tmp;
  626.    int         i;
  627.  
  628.  
  629.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  630.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  631.    wn_bdr( mnu_ptr->mnu_window );
  632.  
  633.    tmp = mnu_ptr->mnu_item;
  634.    for( i = 1; i < choice; i++ )
  635.       tmp = tmp->next;
  636.  
  637.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  638.           mnu_ptr->mnu_window->col + tmp->col + 1, 14, 63 );
  639.  
  640.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  641.    wn_bclr( wn1,  mk_att( RED, WHITE + BRIGHT ) );
  642.    wn_clear( wn1 );
  643.    wn_margin( wn1, 3 );
  644.    wn_mkbdr( wn1, BDR_12LNP );
  645.    wn_dsply( wn1 );
  646.    wn_printf( wn1, "                     The Future" );
  647.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  648.    wn_printf( wn1, "\n\n   In large part the future is up to you, the\n" );
  649.    wn_printf( wn1, "user.  Most of the our releases have been heavily\n" );
  650.    wn_printf( wn1, "influenced by user input while others are the    \n" );
  651.    wn_printf( wn1, "direct result of user requests.  Feel free to    \n" );
  652.    wn_printf( wn1, "provide your input on features or other tools you\n" );
  653.    wn_printf( wn1, "would like to see.                               \n" );
  654.  
  655.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  656.    wn_printf( wn1, "\n              Press a key to continue\n" );
  657.    uc_key();
  658.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  659.  
  660.    wn_printf( wn1, "   Currently there are many enhancements planned \n" );
  661.    wn_printf( wn1, "for this library.  New features are planned in   \n" );
  662.    wn_printf( wn1, "particular for the window, data entry form and   \n" );
  663.    wn_printf( wn1, "the menu sections of the library.  There are a   \n" );
  664.    wn_printf( wn1, "large number of mouse functions available in the \n" );
  665.    wn_printf( wn1, "library which will be utilized in these areas.   \n" );
  666.    wn_printf( wn1, "Also planned are enhancements to the sound       \n" );
  667.    wn_printf( wn1, "functions in the library.                        \n" );
  668.  
  669.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  670.    wn_printf( wn1, "\n              Press a key to continue\n" );
  671.    uc_key();
  672.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  673.  
  674.    wn_printf( wn1, "  In addition upgrades of several other releases \n" );
  675.    wn_printf( wn1, "are being planned.  All Unicorn releases except   \n" );
  676.    wn_printf( wn1, "for one may be found by looking for UC????? on a \n" );
  677.    wn_printf( wn1, "board since they all start with the letters 'UC' \n" );
  678.    wn_printf( wn1, "except for the 'C Tool Box' which was released as\n" );
  679.    wn_printf( wn1, "'CTB100.ARC'.                                    \n" );
  680.    wn_printf( wn1, "   Again, let us know what YOU would like to see.\n" );
  681.    wn_printf( wn1, "You may contact us directly or through the Journey\n" );
  682.    wn_printf( wn1, "to Mars Board in the Seattle Area, (206) 486-3136.\n" );
  683.    wn_printf( wn1, "Leave a message for Dave Miller.                 \n" );
  684.  
  685.  
  686.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  687.    wn_printf( wn1, "\n               Press a key to continue" );
  688.    uc_key();
  689.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  690.  
  691.    wn_hide( wn1 );
  692.  
  693.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN +BRIGHT ) );
  694.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  695.    wn_bdr( mnu_ptr->mnu_window );
  696.  
  697.    return( 1 );
  698.  
  699. }
  700.  
  701.  
  702.  
  703.  
  704.  
  705.  
  706. int notes( MNUPTR mnu_ptr, int choice )
  707. {
  708.    WINDOWPTR  wn1;
  709.    MNU_ITEMPTR     tmp;
  710.    int         i;
  711.  
  712.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  713.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  714.    wn_bdr( mnu_ptr->mnu_window );
  715.  
  716.  
  717.    tmp = mnu_ptr->mnu_item;
  718.    for( i = 1; i < choice; i++ )
  719.       tmp = tmp->next;
  720.  
  721.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  722.           mnu_ptr->mnu_window->col + tmp->col + 1, 12, 63 );
  723.  
  724.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  725.    wn_bclr( wn1,  mk_att( RED, WHITE + BRIGHT ) );
  726.    wn_clear( wn1 );
  727.    wn_margin( wn1, 2 );
  728.    wn_mkbdr( wn1, BDR_12LNP );
  729.    wn_dsply( wn1 );
  730.    wn_printf( wn1, "                    Library Notes\n" );
  731.  
  732.    wn_printf( wn1, "   Documentation is found in the reference guide \n" );
  733.    wn_printf( wn1, "file.  At present there is no full manual in the \n" );
  734.    wn_printf( wn1, "true sense.  The reference guide coupled with the \n" );
  735.    wn_printf( wn1, "source code for the demo programs should be more  \n" );
  736.    wn_printf( wn1, "enough to get you started writing programs using  \n" );
  737.    wn_printf( wn1, "the library.  Not all functions, unfortunately are\n" );
  738.  
  739.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  740.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  741.    uc_key();
  742.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  743.  
  744.    wn_printf( wn1, "\nincluded in the demos due to size considerations. \n" );
  745.    wn_printf( wn1, "In addition all registered users will recieve a \n" );
  746.    wn_printf( wn1, "disk containing all the test programs used in the\n" );
  747.    wn_printf( wn1, "development of the library.  These obviously show\n" );
  748.    wn_printf( wn1, "how the functions are called.                    \n" );
  749.  
  750.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  751.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  752.    uc_key();
  753.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  754.  
  755.    wn_printf( wn1, "\nA function call attached to a menu selection is   \n" );
  756.    wn_printf( wn1, "passed a pointer to the menu structure and the  \n" );
  757.    wn_printf( wn1, "currently selected item number.  This allows great\n" );
  758.    wn_printf( wn1, "versitility in many ways.  In this demo the info \n" );
  759.    wn_printf( wn1, "is used to position the function windows or  \n" );
  760.  
  761.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  762.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  763.    uc_key();
  764.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  765.  
  766.  
  767.    wn_printf( wn1, "\nsub menus to just below the selected item on the  \n" );
  768.    wn_printf( wn1, "menu.  However you chose to use the information  is\n" );
  769.    wn_printf( wn1, "up to you but it will allow you to do quite a bit \n" );
  770.    wn_printf( wn1, "with a little thought.                           \n" );
  771.  
  772.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  773.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  774.    uc_key();
  775.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  776.  
  777.    wn_printf( wn1, "\n   It is also possible to execute another program \n" );
  778.    wn_printf( wn1, "from a menu.  The demos selection will spawn the two\n" );
  779.    wn_printf( wn1, "other demos found with the menu demo.  This allows\n" );
  780.    wn_printf( wn1, "a great deal of versitility in your programming. \n" );
  781.    wn_printf( wn1, "   A utility ( uc_chk.exe ) is included in this  \n" );
  782.  
  783.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  784.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  785.    uc_key();
  786.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  787.  
  788.    wn_printf( wn1, "package for your use.  If run against the library \n" );
  789.    wn_printf( wn1, "or any executables it produces it will list any and \n" );
  790.    wn_printf( wn1, "all library functions included.  For example type:\n\n" );
  791.  
  792.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  793.    wn_printf( wn1, "          uc_chk uclib.lib          \n" );
  794.    wn_printf( wn1, "or        uc_chk dem_menu.exe       \n" );
  795.  
  796.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  797.    wn_printf( wn1, "\n                 Press a key to continue\n" );
  798.    uc_key();
  799.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  800.  
  801.    wn_printf( wn1, "The output of this utility is redirectable to the \n" );
  802.    wn_printf( wn1, "printer or to a file.  For example:  \n\n" );
  803.  
  804.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  805.    wn_printf( wn1, "          uc_chk uclib.lib > prn         \n" );
  806.    wn_printf( wn1, "or        uc_chk dem_menu.exe > listing.txt \n\n" );
  807.  
  808.    wn_wnclr( wn1, mk_att( RED, MAGENTA + BRIGHT ) );
  809.    wn_printf( wn1, "               1 October 1988 Dave Miller        \n\n" );
  810.  
  811.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  812.    wn_printf( wn1, "                 Press a key to continue\n" );
  813.    uc_key();
  814.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  815.  
  816.    wn_hide( wn1 );
  817.  
  818.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN +BRIGHT ) );
  819.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  820.    wn_bdr( mnu_ptr->mnu_window );
  821.  
  822.    return( 1 );
  823. }
  824.  
  825.  
  826.  
  827.  
  828.  
  829. int registration( MNUPTR mnu_ptr, int choice )
  830. {
  831.    WINDOWPTR  wn1;
  832.    MNU_ITEMPTR     tmp;
  833.    int         i;
  834.  
  835.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  836.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  837.    wn_bdr( mnu_ptr->mnu_window );
  838.  
  839.  
  840.    tmp = mnu_ptr->mnu_item;
  841.    for( i = 1; i < choice; i++ )
  842.       tmp = tmp->next;
  843.  
  844.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  845.           mnu_ptr->mnu_window->col + tmp->col + 1, 15, 63 );
  846.  
  847.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  848.    wn_bclr( wn1,  mk_att( RED, WHITE + BRIGHT ) );
  849.    wn_clear( wn1 );
  850.    wn_margin( wn1, 2 );
  851.    wn_mkbdr( wn1, BDR_12LNP );
  852.    wn_dsply( wn1 );
  853.    wn_printf( wn1, "               Library Registration\n" );
  854.  
  855.    wn_printf( wn1, "   Registration of your copy of the library couldn't\n" );
  856.    wn_printf( wn1, "be easier.  Simply look at the file register.doc and\n" );
  857.    wn_printf( wn1, "follow the instructions.                             \n" );
  858.    wn_printf( wn1, "This will cause 6 ( " );
  859.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  860.    wn_printf( wn1, "yes 6!" );
  861.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  862.    wn_printf( wn1, " ) disks to appear in your\n" );
  863.    wn_printf( wn1, "mailbox shortly thereafter.  Two of these will contain\n" );
  864.    wn_printf( wn1, "the library release files, three will contain ALL\n" );
  865.    wn_printf( wn1, "source code to the library and the last will    \n" );
  866.  
  867.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  868.    wn_printf( wn1, "\n              Press a key to continue\n\n" );
  869.    uc_key();
  870.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  871.  
  872.    wn_printf( wn1, "contain all the author's test programs used in  \n" );
  873.    wn_printf( wn1, "developing and testing the library.  These programs\n" );
  874.    wn_printf( wn1, "will of course illustrate further the correct call  \n" );
  875.    wn_printf( wn1, "for the functions and the source code should clear up\n" );
  876.    wn_printf( wn1, "any remaining questions you might have.  Remember   \n" );
  877.    wn_printf( wn1, "that's " );
  878.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  879.    wn_printf( wn1, "6 disks " );
  880.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  881.    wn_printf( wn1, "for the registered user with all the\n" );
  882.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  883.    wn_printf( wn1, "source code " );
  884.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  885.    wn_printf( wn1, "to " );
  886.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  887.    wn_printf( wn1, "over 300 " );
  888.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  889.    wn_printf( wn1, "( and growing ) " );
  890.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  891.    wn_printf( wn1, "functions. \n" );
  892.    wn_printf( wn1, "\n              Press a key to continue\n" );
  893.    uc_key();
  894.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  895.  
  896.  
  897.    wn_printf( wn1, "Registration is NOT required for evaluation of  \n" );
  898.    wn_printf( wn1, "the library, you are free to use it for this purpose\n" );
  899.    wn_printf( wn1, "however, " );
  900.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  901.    wn_printf( wn1, "any commercial use or use for profit of this\n" );
  902.    wn_printf( wn1, "library requires registration with the author.       \n" );
  903.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  904.    wn_printf( wn1, "If you decide you like the library and use it you   \n" );
  905.    wn_printf( wn1, "should register your copy.  You may give the public\n" );
  906.    wn_printf( wn1, "files to a third party however the source code you \n" );
  907.    wn_printf( wn1, "receive upon registration may NOT be transfered to \n" );
  908.    wn_printf( wn1, "any third party.  Executables created with the code\n" );
  909.    wn_printf( wn1, "may be transfered to third parties.                \n" );
  910.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  911.    wn_printf( wn1, "\n              Press a key to continue\n" );
  912.    uc_key();
  913.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  914.  
  915.    wn_printf( wn1, "Please respect the author's work and effort in  \n" );
  916.    wn_printf( wn1, "protecting the source code when you register.       \n" );
  917.    wn_printf( wn1, "   Development of this library took over a year of \n" );
  918.    wn_printf( wn1, "of the author's spare time ( about 25 hrs a week ).\n" );
  919.  
  920.    wn_wnclr( wn1, mk_att( RED, WHITE + BRIGHT ) );
  921.    wn_printf( wn1, "\n              Press a key to continue\n" );
  922.    uc_key();
  923.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  924.  
  925.  
  926.    wn_hide( wn1 );
  927.  
  928.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN +BRIGHT ) );
  929.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  930.    wn_bdr( mnu_ptr->mnu_window );
  931.  
  932.    return( 1 );
  933. }
  934.  
  935.  
  936.  
  937.  
  938. int unicorn( MNUPTR mnu_ptr, int choice )
  939. {
  940.    WINDOWPTR  wn1;
  941.    MNU_ITEMPTR     tmp;
  942.    int         i;
  943.  
  944.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BLUE ) );
  945.    wn_mkbdr( mnu_ptr->mnu_window, BDR_LNP );
  946.    wn_bdr( mnu_ptr->mnu_window );
  947.  
  948.  
  949.    tmp = mnu_ptr->mnu_item;
  950.    for( i = 1; i < choice; i++ )
  951.       tmp = tmp->next;
  952.  
  953.    wn1 = wn_make( mnu_ptr->mnu_window->row + tmp->row + 1,
  954.           mnu_ptr->mnu_window->col + tmp->col + 1, 15, 63 );
  955.  
  956.    wn_wnclr( wn1, mk_att( RED, BROWN + BRIGHT ) );
  957.    wn_bclr( wn1,  mk_att( RED, WHITE + BRIGHT ) );
  958.    wn_clear( wn1 );
  959.    wn_margin( wn1, 2 );
  960.    wn_mkbdr( wn1, BDR_12LNP );
  961.    wn_dsply( wn1 );
  962.    wn_printf( wn1, "                Unicorn Software\n\n" );
  963.  
  964.    wn_printf( wn1, "   Unicorn Software is the spare time project of a  \n" );
  965.    wn_printf( wn1, "single author.  Originally begun as a way to learn C,\n" );
  966.    wn_printf( wn1, "the author soon found the process was at least as    \n" );
  967.    wn_printf( wn1, "enjoyable as the end result.  Thus the process of    \n" );
  968.    wn_printf( wn1, "developing tools for C programmers continues and will  \n" );
  969.    wn_printf( wn1, "for the foreseeable future, consistant with user    \n" );
  970.    wn_printf( wn1, "support and interest.                               \n" );
  971.  
  972.    wn_printf( wn1, "\n              Press a key to continue\n\n" );
  973.    uc_key();
  974.  
  975.    wn_printf( wn1, "   Unicorn Software has been releasing shareware for\n" );
  976.    wn_printf( wn1, "over two years.  This library is the latest release\n" );
  977.    wn_printf( wn1, "and plans for expansion and enhancement continue. The\n" );
  978.    wn_printf( wn1, "library was originally released in September 1988 and\n" );
  979.    wn_printf( wn1, "this update, which added menus, was released in October\n" );
  980.    wn_printf( wn1, "of 1988.  Plans continue for this library well into \n" );
  981.    wn_printf( wn1, "1989 with several new features planned.             \n" );
  982.  
  983.    wn_printf( wn1, "\n              Press a key to continue\n\n" );
  984.    uc_key();
  985.  
  986.    wn_printf( wn1, "   Watch for our releases on your favorite board or \n" );
  987.    wn_printf( wn1, "contact Journey to Mars ( 206 ) 486-3136 or College \n" );
  988.    wn_printf( wn1, "Corner at ( 206 ) 643-0804.  Both are fine boards   \n" );
  989.    wn_printf( wn1, "run by excellent sysops in the Seattle area.  Unicorn\n" );
  990.    wn_printf( wn1, "Software releases are usually placed on these two   \n" );
  991.    wn_printf( wn1, "boards as soon as released so they should contain the\n" );
  992.    wn_printf( wn1, "latest versions at all times.                       \n" );
  993.  
  994.    wn_printf( wn1, "\n              Press a key to continue\n\n" );
  995.    uc_key();
  996.  
  997.    wn_printf( wn1, "   The author may be contacted on one of the above  \n" );
  998.    wn_printf( wn1, "boards, leave a message for Dave Miller, or try     \n" );
  999.    wn_printf( wn1, "directly by phone.  The current number is           \n" );
  1000.    wn_printf( wn1, "( 206 ) 823-4656.  Please call after 6PM weeknights \n" );
  1001.    wn_printf( wn1, "and sorry but no collect calls please.  Since the   \n" );
  1002.    wn_printf( wn1, "the author tends to move a bit, a post office box has\n" );
  1003.    wn_printf( wn1, "been established to provide a constant address.     \n" );
  1004.    wn_printf( wn1, "Unicorn Software may always be reached at that box. \n" );
  1005.  
  1006.    wn_printf( wn1, "\n              Press a key to continue\n" );
  1007.    uc_key();
  1008.  
  1009.    wn_hide( wn1 );
  1010.  
  1011.    wn_bclr( mnu_ptr->mnu_window, mk_att( CYAN, BROWN + BRIGHT ) );
  1012.    wn_mkbdr( mnu_ptr->mnu_window, BDR_DLNP );
  1013.    wn_bdr( mnu_ptr->mnu_window );
  1014.  
  1015.    return( 1 );
  1016. }
  1017.  
  1018.  
  1019.  
  1020.  
  1021. int bye_bye( MNUPTR mnu_ptr, int choice )
  1022. {
  1023.    WINDOWPTR  wn1;
  1024.    MNU_ITEMPTR     tmp;
  1025.    int         i;
  1026.  
  1027.    return( 0 );         /* A return of Zero ( 0 ) causes the */
  1028.                 /* menu processor to exit the menu     */
  1029. }
  1030.