## Visual Basic in 12 Easy Lessons velp10.htm

- Stop & Type
  - The Program's Description
  - Needed: Program Randomness
- The Help Menu
  - Descriptions
  - Studying the Rest of the Code
  - Descriptions
  - Close the Application

#
Project 10

##
Making Programs "Real World"

###
Stop & Type

This lesson taught you how to design and add menus to your Visual Basic applications. The Menu Design window enables you to specify the property values for menu bar commands and pull-down menu items. By using the Menu Design window, you can add shortcut access keystrokes and menu separator bars, and specify special menu features such as checkmarked menu items. Generating program code that responds to menu events is no more difficult than writing event procedures that respond to command button clicks.

In addition to creating menus, you also learned how to work with the timer control. As you saw in the previous unit, the timer control is a control that triggers its own events. Depending on the value of the timer control's Interval property, the timer control generates an event every few milliseconds. The code that you add to the timer's event procedure determines how to handle the event. You can set alarms and perform certain screen and control update actions every time that the timer generates an event, if you want.

In this lesson, you saw the following:

- How to create menus for your Visual Basic applications
- Why the Menu Design window is so much more appropriate for specifying menu property values than the Property window
- How to right justify menu items if you want to change the menu bar a bit
- What the timer control does to generate events
- When to respond to a timer's event and when to ignore the event

####
The Program's Description

Figure P10.1 shows the PROJEC10.MAK opening Form window. This project presents a simple number- and letter-guessing that contains a menu bar with three items. The program contains three event procedures that are tied to the menu's commands.

Figure P10.1. Project 10's application begins with a simple form.

The Menu Design window is nothing more than an advanced Property window for the menu. The menu events to which your code will respond are click events. Therefore, there is nothing really new with the code used in this program. The program generates a random number or letter when the user selects File New Game. If the Option Use Alphabetic Letters menu option is checked, the program will generate a random letter from A through Z. If the Option Use Alphabetic Letters menu option isn't checked, the program will generate a random number from 1 to 100. A small label at the bottom of the guess screen reminds the user to guess a number or letter when the guessing begins.

####
Needed: Program Randomness

Because there is nothing new required for code that responds to menu events, this lesson's project introduces a new command and function to generate the random value and make the project more interesting. The random number generator is the only part of Visual Basic's powerful language that does not do the same thing every time you execute the same code.

The Rnd() function, when used without an argument, generates a random number between 0 and 1. If the user wants to guess a number, however, the program needs a random number from 1 to 100, and if the user wants to guess a letter, the program needs a random number from 65 to 90 to represent Chr$() arguments for the letters A through Z. The program uses the following formula to generate a random number from a low value to a high value:

    Int((LowValue + HighValue + 1) * Rnd + LowValue

Therefore, here is the assignment statement that generates a random number from 65 to 90, and stores the character value of that generated ASCII number in a variable named Letter:

    Letter = Chr$(Int(26) * Rnd + 65) ' A through Z

There is only one problem with the Rnd function. The function generates the same set of random values every time you run a program that uses Rnd, unless you first execute the following statement:

    Randomize Timer

The Randomize command requires a single value. That value seeds the random number generator by providing a value for the first generated random number. If you were to use the same seed value, Rnd wouldn't change from program run to program run. A guessing game that always produced the same set of values to guess wouldn't remain interesting. By using Timer to seed the internal random number generator, you can ensure that Randomize rarely works with the same value twice, because the randomizing seed value is the internal clock setting at the time that the Randomize statement executes.

###
The Help Menu

You'll notice that the Help menu is right justified. The Form_Load() event procedure concatenates a Chr$(8) backspace character to the menu bar's Help command. As you learned in Unit 19, the backspace character right justifies menu bar commands.

Figure P10.1 shows the help message and command button that appear when the user selects the Help command. The Help command's event procedure, shown in Listing P10.1, sets the Visible property of the command button and help label to True so that the user can see the help message. When the user clicks the command button, the cmdHelp_Click() event procedure (also shown in Listing P10.1) executes to hide the help label and command button.

Figure P10.2. The Help menu command produces a program overview for the user.

Listing P10.1. Respond to the Help command and turn off help when requested.

    1: Sub mnuHelp_Click ()

    2: ' Show the help message and the help command button

    3: lblHelp.Visible = True

    4: cmdHelp.Visible = True

    5: End Sub

    6:

    7: Sub cmdHelp_Click ()

    8: ' Hide the help message and the help command button

    9: lblHelp.Visible = False

    10: cmdHelp.Visible = False

    12: End Sub

####
Descriptions

1: The code for the event procedure that responds to the Help menu bar command must be a click procedure.

2: A remark that explains the procedure.

3: Turn on the large label that appears in the center of the screen.

> > 3: The help is a label that normally remains invisible.

4: Turn on the command button that the user can use to hide the help information.

5: Terminate the procedure.

6: A blank line separates the procedures.

7: The code for the event procedure that responds to the command button that turns off Help's information.

8: A remark that explains the procedure.

9: Turn off the large label that appears in the center of the screen.

10: Turn off the command button that the user can use to hide the help information.

11: Terminate the procedure.

####
Studying the Rest of the Code

Listing P10.2 contains the rest of the program, including the Form_Load() event procedure that right justifies the Help command and seeds the random number generator so that subsequent calls to Rnd will produce a different set of values between program runs. Figure P10.3 shows the running program during the user's guessing of a letter. Notice that a label appears at the bottom of the screen during the progress of the game that tells the user whether letters or numbers are to be guessed.

Figure P10.3. The user must guess a letter from A to Z.

Listing P10.2. The code for the guessing-game project listing.

    1: Sub Form_Load ()

    2: ' Begin with a number-guessing game

    3: ' Turn off the checkmark
    from the

    4: ' Options Use Alphabetic Characters menu

    5: mnuOptionUseAlpha.Checked = False

    6: ' Right-justify the Help menu command

    7: mnuHelp.Caption = Chr$(8) + mnuHelp.Caption

    8: ' Spin the internal randomizing wheel

    9: Randomize Timer

    10: End Sub

    11:

    12: Sub mnuFileExit_Click ()

    13: End

    14: End Sub

    15:

    16: Sub mnuFileNewGame_Click ()

    17: ' Call appropriate subroutine procedure depending

    18: ' on value of Option Use Alphabetic Characters

    19:

    20: ' Turn off opening label if it's still
    visible

    21: If (lblOpening.Visible = True) Then

    22: lblOpening.Visible = False

    23: End If

    24:

    25: If (mnuOptionUseAlpha.Checked) Then

    26: Call GuessLetter

    27: Else

    28: Call GuessNumber

    29: End If

    30: ' Turn back on opening label

    31:
    lblOpening.Visible = True

    32: End Sub

    33:

    34: Sub mnuOptionUseAlpha_Click ()

    35: ' Reverse the state of the checkmark

    36: mnuOptionUseAlpha.Checked = Not (mnuOptionUseAlpha.Checked)

    37: End Sub

    38:

    39: Sub GuessNumber ()

    40: ' User guesses a
    number

    41: Dim Guess As Variant

    42: Dim Number, GuessNum As Integer

    43:

    44: ' Update the instruction label

    45: lblInstruct.Caption = "Guess a number from 1 to 100"

    46: lblInstruct.Visible = True

    47: ' Find value from 1 to 100

    48: Number =
    Int(100 * Rnd + 1)

    49:

    50: Do

    51: Guess = InputBox("What's your guess?", "Guess")

    52: If (Guess = "") Then ' Check for Cancel

    53: ' Turn off instruction label

    54: lblInstruct.Visible = False

    55: Exit Sub ' User pressed
    Cancel

    56: End If

    57: GuessNum = Guess ' Convert to number

    58: If (GuessNum > Number) Then

    59: MsgBox "Your number is too high...", , "Wrong"

    60: Else

    61: If (GuessNum < Number) Then

    62: MsgBox "Your number is too
    low...", , "Wrong"

    63: End If

    64: End If

    65: Loop Until (GuessNum = Number)

    66: Beep

    67: MsgBox "You guessed " & Guess & "! Correct!!!", , "Lucky"

    68: ' Turn off instruction label

    69:
    lblInstruct.Visible = False

    70: End Sub

    71:

    72: Sub GuessLetter ()

    73: ' User guesses a letter

    74: Dim Letter, GuessLet As String

    75:

    76: ' Update the instruction label

    77: lblInstruct.Caption = "Guess a letter from A to Z"

    78:
    lblInstruct.Visible = True

    79: ' Find value from ASCII 65 - 90 ('A' to 'Z')

    80: Letter = Chr$(Int(26) * Rnd + 65) ' A through Z

    81: Do

    82: GuessLet = InputBox("What's your guess?", "Guess")

    83: If (GuessLet = "") Then '
    Check for Cancel

    84: ' Turn off instruction label

    85: lblInstruct.Visible = False

    86: Exit Sub ' User pressed Cancel

    87: End If

    88: ' Convert user's letter to uppercase

    89: GuessLet = UCase(GuessLet)

    90: If (GuessLet > Letter) Then

    91: MsgBox
    "Your letter is too high...", , "Wrong"

    92: Else

    93: If (GuessLet < Letter) Then

    94: MsgBox "Your letter is too low...", , "Wrong"

    95: End If

    96: End If

    97: Loop Until (GuessLet = Letter)

    98:

    99: ' Here is
    user guessed number

    100: Beep

    101: MsgBox "You guessed " & GuessLet & "! Correct!!!", , "Lucky"

    102:

    103: ' Turn off instruction label

    104: lblInstruct.Visible = False

    105: End Sub

####
Descriptions

1: The code for the opening event procedure that executes right before the user sees the form.

2: A remark explains the procedure.

3: The remark continues.

4: The remark continues.

5: Set the guess to letters.

6: A remark explains the code.

7: Right justify the Help menu option.

8: A remark explains the code.

9: Use the internal clock to seed the random number generator.

> > 9: Be sure to seed the random number generator so that truly random values appear.

10: Terminate the procedure.

11: A blank line separates the procedures.

12: The code for the File Exit menu command.

13: Terminate the program's execution.

14: Terminate the procedure.

15: A blank line separates the procedure.

16: The code for the File New Game menu command.

17: A remark explains the procedure.

18: The remark continues.

19: A blank line helps separate parts of the program.

20: A remark that explains the procedure.

21: Turn off the display of the Press File New Game label if it's on.

22: Hide the label.

23: Terminate the If.

24: A blank line helps separate parts of the program.

25: See whether the user wants to guess a letter.

26: Execute the subroutine procedure that enables the user to guess a letter.

27: If the user wants to guess a number...

28: Execute the subroutine procedure that enables the user to guess a number.

29: Terminate the If.

30: A remark explains the code.

31: Now that the user has finished the game, turn the Select File New Game label.

32: Terminate the procedure.

33: A blank line helps separate parts of the program.

34: The code for the Option use Alphabetic Letters menu command.

35: A remark helps explain the procedure.

> > 35: Check or uncheck the menu command when clicked.

36: Turn the menu command's check mark either on or off.

37: Terminate the procedure.

38: A blank line helps separate the procedures.

39: The subroutine procedure called when the user wants to guess a number.

40: A remark explains the procedure.

41: Define a variable to hold the InputBox() function's return value.

42: Define variables to hold the user's guess and the random number generated for the guessing game.

43: A blank line helps separate parts of the procedure.

44: A remark explains the code.

45: Change the label that appears at the bottom of the screen during the user's guessing.

46: Displays the guessing label.

47: A remark explains the code.

48: Generate a random number from 1 to 100.

> > 48: Unless you convert the value fall within a different range, Visual Basic generates a number from 0 to 1.

49: A blank line helps separate parts of the code.

50: Begin the guessing loop.

51: Get the user's guess.

52: Check to see whether the user pressed the Cancel command button at the display of the input box.

53: A remark explains the code.

54: Turn off the guessing label.

55: Terminate the guessing subroutine early.

56: Terminate the If.

57: Convert the user's Variant answer to an Integer.

58: Check whether the user's guess was too high.

59: If the user's guess was too high, tells the user.

60: The user's guess was not too high.

61: Check whether the user's guess was too low.

62: If the user's guess was too low, tells the user.

63: Terminate the If.

64: Terminate the If.

65: Keep asking the user for a guess until the user guesses the correct answer.

66: Audibly tells the user that the guess was correct.

67: Show the user that the guess was correct.

68: A remark helps explain the code.

69: Hide the guessing instructional label.

70: Terminate the procedure.

71: A blank line helps separate procedures.

72: The subroutine procedure called when the user wants to guess a letter.

73: A remark explains the procedure.

74: Define a variable to hold the user's guess and the random letter.

75: A blank line helps separate parts of the procedure.

76: A remark explains the code.

77: Change the label that appears at the bottom of the screen during the user's guessing.

78: Display the guessing label.

79: A remark explains the code.

80: Generate a random letter from A to Z.

81: Begin the guessing loop.

82: Get the user's guess.

83: Check to see whether the user pressed the Cancel command button at the display of the input box.

84: A remark explains the code.

85: Turn off the guessing label.

86: Terminate the guessing subroutine early.

87: Terminate the If.

88: A remark explains the code.

89: Convert the user's guess to uppercase if the letter is not already uppercase.

> > 89: The UCase$() function keeps the user's guessing range within the uppercase letters.

90: Check whether the user's guess was too high.

91: If the user's guess was too high, tells the user.

92: The user's guess was not too high.

93: Check whether the user's guess was too low.

94: If the user's guess was too low, tells the user.

95: Terminate the If.

96: Terminate the If.

97: Keep asking the user for a guess until the user guesses the correct answer.

98: A blank line helps separate parts of the code.

99: A remark helps explain the code.

100: Audibly tells the user that the guess was correct.

101: Show the user that the guess was correct.

102: A blank line helps separate parts of the code.

103: A remark helps explain the code.

104: Hide the guessing instructional label.

105: Terminate the procedure.

####
Close the Application

You can now exit the application and exit Visual Basic. The next lesson teaches you how to send text to the printer and really have fun by drawing graphics on the user's form.