All the gadgets up until now have been mildly user interactive. In this post I finally tackle the biggest, and likely most useful, gadget – GInput(). This is the string input routine that allows type restricted (numeric, alphabetic, alpha-numeric, or any text) string input. The string editing size can be smaller than the string itself and the string will scroll left or right as the cursor is moved. There are some special keys tossed in to get to start of the string, end of the string, clearing the string, inserting and deleting characters. At the time of this writing, the C version hasn’t been fully tested for the last three cases mentioned, but will be by the time the library is published.

The code for GInput() is quite large in relation to the other gadgets, but it does quite a bit.

Here is a demo program showing how the gadget is called:

// ------------------------------------------------------------
// Program: ginput.c
// Desc...: A8 Library Input Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl ginput.c -o ginput.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoInput(void)
// Desc...: Displays input demo
// ------------------------------------------------------------
void DoInput(void)
{
    byte bW;
    unsigned char cA[41], cB[41], cC[41], cD[41];

    // Assign default string values
    strcpy(cA,  "-100.00                                 ");
    strcpy(cB,  "This string has something to edit in it!");
    strcpy(cC,  "                                        ");
    sprintf(cD, "%cAny character string!%c                 ", CHBALL, CHBALL);

    // Open window & draw form
    bW = WOpen(2, 6, 36, 10, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Input Test");

    WPrint(bW, 1, 1, WOFF, "Data Fields");
    WPrint(bW, 2, 3, WOFF, "Numer:");
    WPrint(bW, 2, 4, WOFF, "Alpha:");
    WPrint(bW, 2, 5, WOFF, "AlNum:");
    WPrint(bW, 2, 6, WOFF, "Any..:");

    // Display fields as is 
    // WPrint will truncate what doesn't fit (27 chars for this window).
    WPrint(bW, 8, 3, WOFF, cA);
    WPrint(bW, 8, 4, WOFF, cB);
    WPrint(bW, 8, 5, WOFF, cC);
    WPrint(bW, 8, 6, WOFF, cD);

    // Input each in succession
    // 27 is the maximum width to display of the 40 lengths
    GInput(bW, 8, 3, GNUMER, 27, cA);
    GInput(bW, 8, 4, GALPHA, 27, cB);
    GInput(bW, 8, 5, GALNUM, 27, cC);
    GInput(bW, 8, 6, GANY,   27, cD);

    // Wait for a key
    WPrint(bW, WPCNT, 8, WOFF, "press any key");
    WaitKCX(WOFF);

    // Close window
    WClose(bW);
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[9] =
      { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Spinner      ", " Input        ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 12, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 8, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: GAlert("Alert! menu option 2 selected!");
                    break;

            case 3: GAlert("Alert! menu option 3 selected!");
                    break;

            case 4: GAlert("Alert! menu option 4 selected!");
                    break;

            case 5: GAlert("Alert! menu option 5 selected!");
                    break;

            case 6: GAlert("Alert! menu option 6 selected!");
                    break;

            case 7: DoInput();
                    break;

            case 8: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot of it in use (the cursor is active on the s in the word has of the Alpha field):

This time I cover the conversion of the numeric spinner input. It allows for a number to be chosen where the user does not enter it directly, but rather changes the value by pressing keys representing increment and decrement. It only allows for value between 0 and 250. Values above 250 are reserved for form control, such as ESC and TAB. I feel like this is fine since no one will want to cycle up/down into thousands or more, and most likely this will be used from 0 to 100. I contemplated a top limit of 100, but decided to allow up to 250. This was also the last gadget I wrote for my Action! library.

In the demo program, the user is allowed to change the Value field from 5 to 100. Once accepted, the new value is displayed below in the New field.

Here is the demo program showing how its called:

// ------------------------------------------------------------
// Program: gspin.c
// Desc...: A8 Library Window Menu Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl gspin.c -o gspin.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoSpin(void)
// Desc...: Displays spinner demo
// ------------------------------------------------------------
void DoSpin(void)
{
    byte bW, bC, bV;
    unsigned char cL[4];

    // Set default value
    bV = 10;

    // Open window
    bW = WOpen(8, 7, 24, 9, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Spinner");
    WPrint(bW, 2, 2, WOFF, "Value:");
    WPrint(bW, 4, 4, WOFF,   "New:");

    // Display spinner and get returned value
    // Min value=5, max value=100
    bC = GSpin(bW, 8, 2, 5, 100, bV);

    // What was returned?
    if (bC == XESC)
    {
        GAlert(" Escaped Out! ");
    }
    else if (bC == XTAB)
    {
        GAlert(" Tabbed Out! ");
    }
    else
    {
        // Show the new value
        sprintf(cL, "%3d", bC);
        WPrint(bW, 8, 4, WOFF, cL);
    }

    // Wait for a key
    WPrint(bW, WPCNT, 6, WOFF, "Press any key.");
    WaitKCX(WOFF);

    // Close window
    WClose(bW);
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[8] =
      { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Spinner      ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 11, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 7, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: GAlert("Alert! menu option 2 selected!");
                    break;

            case 3: GAlert("Alert! menu option 3 selected!");
                    break;

            case 4: GAlert("Alert! menu option 4 selected!");
                    break;

            case 5: GAlert("Alert! menu option 5 selected!");
                    break;

            case 6: DoSpin();
                    break;

            case 7: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot of its use:

In this post I set out to convert the checkbox routine GCheck(). This displays a checkbox, and allows the user to check or uncheck it.

Here is the demo program showing how to call it:

// ------------------------------------------------------------
// Program: gcheck.c
// Desc...: A8 Library Gadget Checkbox Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl gcheck.c -o gcheck.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoCheck(void)
// Desc...: Displays checkbox demo
// ------------------------------------------------------------
void DoCheck(void)
{
    byte bW, bD, bF;
    // Vars used for selections and previous selections
    byte bca, bcb, bcc, bcap, bcbp, bccp;

    // Set defaults for previous selections (initial item status)
    bcap = GCOFF;
    bcbp = GCOFF;
    bccp = GCON;

    // Open window
    bW = WOpen(9, 10, 22, 6, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Checkboxes");
    WPrint(bW, 1, 1, WOFF, "Select your weapons:");
    WPrint(bW, 6, 2, WOFF, "Action!");
    WPrint(bW, 6, 3, WOFF, "BASIC");
    WPrint(bW, 6, 4, WOFF, "C");

    // Display only with previous/default/initial value
    bF = GCheck(bW, 2, 2, GDISP, bcap);
    bF = GCheck(bW, 2, 3, GDISP, bcbp);
    bF = GCheck(bW, 2, 4, GDISP, bccp);

    GAlert(" Check all and TAB to quit. ");

    // Continue until exited
    bF = FALSE;
    while (! bF)
    {
        // Stay on this check until ESC, TAB
        bD = FALSE;
        while (! bD)
        {
            // Call checkbox with edit and previous value
            bca = GCheck(bW, 2, 2, GEDIT, bcap);

            // Check returned value
            if ((bca == XESC) || (bca == XTAB))
            {
                // Allow exit of loop for this checkbox
                bD = TRUE;
            }
            else
            {
                // Set previous value to the current value
                bcap = bca;
            }
        }

        // Stay on this check until ESC, TAB
        bD = FALSE;
        while (! bD)
        {
            // Call checkbox with edit and previous value
            bcb = GCheck(bW, 2, 3, GEDIT, bcbp);

            // Check returned value
            if ((bcb == XESC) || (bcb == XTAB))
            {
                // Allow exit of loop for this checkbox
                bD = TRUE;
            }
            else
            {
                // Set previous value to the current value
                bcbp = bcb;
            }
        }

        // Stay on this check until ESC, TAB
        bD = FALSE;
        while (! bD)
        {
            // Call checkbox with edit and previous value
            bcc = GCheck(bW, 2, 4, GEDIT, bccp);

            // Check returned value
            if ((bcc == XESC) || (bcc == XTAB))
            {
                // Allow exit of loop for this checkbox
                bD = TRUE;
            }
            else
            {
                // Set previous value to the current value
                bccp = bcc;
            }
        }

        // Leave loop wonce all checked - DEMO
        if ((bcap == GCON) && (bcbp == GCON) && (bccp == GCON))
        {
            bF = TRUE;
        }
    }

    GAlert(" All options checked! ");

    // Close window
    WClose(bW);

    return;
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[7] = { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 10, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 6, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: GAlert("Alert! menu option 2 selected!");
                    break;

            case 3: GAlert("Alert! menu option 3 selected!");
                    break;

            case 4: DoCheck();
                    break;

            case 5: GAlert("Alert! menu option 5 selected!");
                    break;

            case 6: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot of it in use:

With a basic button set now working, I set my sights on converting my Action! library radio button routine. This is the GRadio() function. It displays a set of radio buttons either horizontally or vertically. I made a minor alteration in how navigation/selection is handled in the C version. In the Action! version, space would establish a button as selected but not exit until Enter was pressed. After using it a bit and never having been completely satisfied, I chose to have Space select and exit. Navigation feels smoother with this minor change.

To enable form drawing before activating any controls, it is necessary to call the function with a flag telling it to only display the choices and exit. You call it again with an edit flag when it is ready to be activated. After a radio button is edited, it should be called again with the display only flag to clean up – meaning to revert the selection if ESC was pressed, or show the new selection. There is no difference here in how it worked in my Action! library.

It’s noteworthy to mention that each of the interactive gadgets will return special values if ESC or TAB are pressed. This enables you to write a looping routing to process different input gadget elements as a form and allow the user to TAB through each control – much like modern GUI’s. In the demo program here you can see the handling of these keys which prevent the exit of the loop/form until both sets of radio buttons have the 3rd option selected.

Here is the demo program showing how the function is called for both orientations.

// ------------------------------------------------------------
// Program: gradio.c
// Desc...: A8 Library Gadget Radio Button Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl gradio.c -o gradio.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoRadio(void)
// Desc...: Displays radio button demo
// ------------------------------------------------------------
void DoRadio(void)
{
    byte bW, bra, brb, brap, brbp;
    unsigned char *rA[4] = { "One", "Two", "Three" };
    unsigned char *rB[4] = { "Choice A", "Choice B", "Choice C" };

    // Set defaults for selection and previous selection
    bra = 1;
    brb = 1;
    brap = bra;
    brbp = brb;

    // Open window
    bW = WOpen(2, 5, 36, 12, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Radio Button Test");

    // Show horizontal buttons
    WPrint(bW, 1, 2, WOFF, "Radio Buttons (horiz)");
    GRadio(bW, 2, 3, GHORZ, GDISP, brap, 3, rA);

    // Show veritcal buttons
    WPrint(bW, 1, 5, WOFF, "Radio Buttons (vert)");
    GRadio(bW, 2, 6, GVERT, GDISP, brbp, 3, rB);

    WPrint(bW, 1, 10, WOFF, "Pick 3rd choices to exit.");

    // Loop until accepted or cancelled
    while ((bra != 3) || (brb != 3))
    {
        // Display horiz buttons and get choice
        bra = GRadio(bW, 2, 3, GHORZ, GEDIT, brap, 3, rA);

        // If not bypass, set previous selected value
        if ((bra != XESC) && (bra != XTAB))
        {
            brap = bra;
        }

        // Redisplay buttons
        GRadio(bW, 2, 3, GHORZ, GDISP, brap, 3, rA);

        // Display vert buttons and get choice
        brb = GRadio(bW, 2, 6, GVERT, GEDIT, brbp, 3, rB);

        // If not bypass, set previous selected value
        if ((brb != XESC) && (brb != XTAB))
        {
            brbp = brb;
        }

        // Redisplay buttons
        GRadio(bW, 2, 6, GVERT, GDISP, brbp, 3, rB);
    }

    // Close window
    WClose(bW);
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[7] = { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 10, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 6, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: GAlert("Alert! menu option 2 selected!");
                    break;

            case 3: GAlert("Alert! menu option 3 selected!");
                    break;

            case 4: GAlert("Alert! menu option 4 selected!");
                    break;

            case 5: DoRadio();
                    break;

            case 6: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot of it in use:

In the previous post I converted the non-interactive gadget GProc(). In this post I move to the most basic of user interaction: buttons (like OK, Cancel) via function GButton(). The button labels and quantity are up to you, as well as the default button selection.

The programmer is required to specify any ornaments for the buttons, if so desired. As the user moves between buttons, the active one is displayed in inverse video. The implementation in C is actually quite simpler than an Action! due to C’s advanced handling of arrays of strings. The source code will be released once the entire library has been converted – at that point you can compare if you are so inclined.

Here is a program demonstrating its use:

// ------------------------------------------------------------
// Program: gbutton.c
// Desc...: A8 Library Gadget Button Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl gbutton.c -o gbutton.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoButt(void)
// Desc...: Displays button demo
// ------------------------------------------------------------
void DoButt(void)
{
    byte bC, bW;
    unsigned char *cS[3] = { "[ Ok ]", "[ Cancel ]" };

    // Open window
    bW = WOpen(9, 10, 22, 6, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Buttons");
    WPrint(bW, 2, 2, WOFF, "Select a button:");

    // Call the button handler with all buttons defined
    bC = GButton(bW, 5, 4, 2, 2, cS);

    // Close window
    WClose(bW);

    return;
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[7] = { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 10, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 6, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: GAlert("Alert! menu option 2 selected!");
                    break;

            case 3: DoButt();
                    break;

            case 4: GAlert("Alert! menu option 4 selected!");
                    break;

            case 5: GAlert("Alert! menu option 5 selected!");
                    break;

            case 6: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot of it running:

In the next set of posts I’ll be converting my Action! libraries Gadget routines. Gadgets are what I refer to as the widgets used in conjunction with the windowing library to create form based input. Think of a gadget as an input mechanism like a button (OK, Cancel, etc), a radio button (where only 1 over several choices can be selected), a checkbox, etc. The first one I converted is not so much as an input control, but a way to show progress to a user during a slow operation. This is the GProg() function.

This function is called with the placement location within an already opened window handle, and the value (0 to 100) to display.

Here is the code that demonstrates:

// ------------------------------------------------------------
// Program: gprog.c
// Desc...: A8 Library Progress Gadget Test
// Author.: Ripdubski
// Date...: 202208
// Notes..: cl65 -v [-O] -t atarixl gprog.c -o gprog.xex
// ------------------------------------------------------------

// Pull in include files
#include <stdio.h>
#include <conio.h>
#include <unistd.h>
#include <string.h>
#include <atari.h>

#include "a8defines.h"
#include "a8defwin.h"
#include "a8libmisc.c"
#include "a8libstr.c"
#include "a8libwin.c"
#include "a8libgadg.c"
#include "a8libmenu.c"


// ------------------------------------------------------------
// Func...: void DoProg(void)
// Desc...: Displays progress bar demo
// ------------------------------------------------------------
void DoProg(void)
{
    byte bL, bW;

    // Open window
    bW = WOpen(9, 10, 22, 4, WOFF);
    WOrn(bW, WPTOP, WPLFT, "Progress");

    // Loop through progress
    for (bL=1; bL <= 100; bL+=5)
    {
        // Display the progress bar and wait 1 second
        GProg(bW, 1, 2, bL);
        sleep(1);
    }

    // Close window
    WClose(bW);

    return;
}


// ------------------------------------------------------------
// Func...: void main(void)
// Desc...: Main routine
// ------------------------------------------------------------
void main(void)
{
    // Variables
    byte bW1, bW2, bC, bD;
    unsigned char *pcM[7] = { " Alert        ", " Progress     ", " Buttons      ", " Checkboxes   ", " Radio Button ", " Quit         " };

    // Setup screen
    WInit();
    WBack(14);

    // Open windows
    bW1 = WOpen(0, 0, 40, 3, WON);
    WPrint(bW1, WPCNT, 1, WOFF, "CC65 A8 Library Test");
    bW2 = WOpen(12, 6, 16, 10, WOFF);
    WOrn(bW2, WPTOP, WPCNT, "Menu");

    // Set done to false
    bD = FALSE;

    // Loop until done (Quit selected)
    while (! bD) {
        // Call menu
        bC = MenuV(bW2, 1, 2, WON, 1, 6, pcM);

        // Process choice
        switch (bC)
        {
            case 1: GAlert("Alert! menu option 1 selected!");
                    break;

            case 2: DoProg();
                    break;

            case 3: GAlert("Alert! menu option 3 selected!");
                    break;

            case 4: GAlert("Alert! menu option 4 selected!");
                    break;

            case 5: GAlert("Alert! menu option 5 selected!");
                    break;

            case 6: bD = TRUE;
                    break;
        }
    }

    // Wait for a keypress
    while (! kbhit()) { };

    // Close windows
    WClose(bW2);
    WClose(bW1);

    // Exit
    return;
}

Here is a screenshot showing what it looks like.