Chapter One: An Introduction to Programming and Visual Basic

Chapter One: An Introduction to Programming and Visual Basic
Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Learning Objectives Understand the importance of information systems in organizations. Discuss the role of computer programs and programming in information systems. List and discuss the six computer operations. Describe the difference between modern Windows-based computer languages and older procedural languages. Discuss the difference between compiled and interpreted languages. List and discuss the steps in the object-oriented, event-driven programming process. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Data and Information Data are raw facts
Examples of data include transactions, dates, amounts, etc. Information are data that have been processed into a usable form Information includes tables, documents, charts, etc. Goal of computer applications is to process data into information Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Six Basic Computer Operations
1. A computer can receive (input) data 2. A computer can store data in memory 3. A computer can perform arithmetic and manipulate text strings 4. A computer can compare the contents of two memory locations and select one of two alternatives 5. A computer can repeat a group of operations 6. A computer can output information (processed data) We will use pseudocode statements to demonstrate these six operations. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Computer Operations Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Programs and Programming
A program is a very specific set of rules that tell the computer which switches should be "ON" or "OFF". The process of creating a program is called programming. The computer only knows what it is told through programs, so they must be accurate and very specific. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

What is Programming? Deciding if there is a task to be accomplished or problem to be solved using a computer, e.g., is there a need for a program? Determining the nature of the task or problem, e.g., what must the program do? Developing a plan that will accomplish the task or solve the problem, e.g., generating the step-by-step process that the program will follow (algorithm). Converting the plan into a computer language program Testing the program to ensure it accomplishes task or solves problem defined earlier. Implementing the program to accomplish the task or solve the problem. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Types of Computer Languages
Procedural: Monolithic programs that run from start to finish with no intervention from user other than input Basic, QBasic, QuickBasic COBOL FORTRAN C Object Oriented/Event Driven (OOED): Programs that use objects which respond to events; use small segments to code for each object Visual Basic Visual C++ Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Levels of Computer Languages
Low Level: at the level of the computer, i.e., in binary (0-1) format Computer can only execute a binary form of a program Intermediate Level: close to the computer but uses English words or mnemonics, e.g., Assembler, that is converted directly into binary High Level: at the level of the programmer using English words and clearly defined syntax; must be converted or translated into binary for computer to implement it, e.g., Visual Basic Need a software program to handle the conversion of high-level into binary Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Translating from High-level Language to Binary
Interpreted: each statement translated as it is executed--slow but easy to use Compiled: entire program is converted to binary--executes faster, but more difficult to use (.exe files are compiled programs) VB is interpreted during creation and testing but can then be compiled into an .exe file Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Introduction to Programming with Visual Basic 6

Object-Oriented Event-driven Programming (OOED)
OOED uses objects, or self contained modules that combine data and program code which pass strictly defined messages to one another. OOED is easier to work with, because it is more intuitive than traditional programming methods. Visual Basic is an OOED language. Users can combine the objects with relative ease to create new systems or extend existing ones. Properties of objects are attributes associated with an object. Methods of objects are those activities that the object can carry out. Objects respond to events. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

OOED Programming Process
A six step process for writing an OOED computer program: 1. Define problem. 2. Create interface 3. Develop logic for action objects 4. Write and test code for action objects 5. Test overall project 6. Document project in writing No matter how well a program is written, the objective is not achieved if the program solves the wrong problem. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Step One: Define Problem
Before you can create a computer application to solve a problem, you must first clearly define it. This may involve a study of the problem to understand the inputs and outputs. Must identify the data to be input to the program and the results to be output from it. Sketching an interface is a good way to understand the problem and to communicate your understanding to other people. Denote input and output objects as well as action objects--those for which code (instructions) are needed. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Sketch of Vintage Video Interface

Step Two: Create Interface
Once you have defined problem and sketched interface, you are ready to create interface. Doing this with VB is quite easy--select objects and place them on VB form following sketch. For Vintage Video, only need three objects: buttons for action textboxes for input and output labels for descriptors Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Vintage Video Interface

Step Three: Develop Logic for Action Objects
Need to think about what each action object should do in response to an event This is the logic for each object Use Input/Processing/Output (IPO) Tables and Pseudocode to develop the logic IPO Tables show the inputs, outputs, and the processing to convert inputs into outputs Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

IPO Table for Calculate Button

Using Pseudocode An important part of the developing the logic for action objects is generating corresponding pseudocode. Pseudocode involves actually writing a program in English rather than in a computer language. When the actual computer program is written, the pseudocode is translated into computer language. A pseudocode program is useful for two reasons: The programmer may use it to structure the algorithm's logic in writing. It provides a relatively direct link between the algorithm and the computer program Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Pseudocode for Calculate Button
Begin procedure Input Video Price Taxes = 0.07 x Video Price Amount Due = Video Price + Taxes Output Taxes and Amount Due End procedure Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Step Four: Write and Test Code of Action Objects
Once you learn the vocabulary and syntax of a language, you should be able to convert the logic embodied in the pseudocode into a computer language. In our case, we use VB. You need to test each code for each action object as they are created. Once the object code is written, the programmer must test and correct it. This stage is referred to as debugging, since it involves removing "bugs". Use test data for which you know the correct answer to test the object code. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

VB Code for Calculate Button
Private Sub cmdCalc_Click() ‘ This object calculates the Taxes and Amount ‘ Due given the Video Price Dim curPrice as Currency, curTaxes as Currency Dim curAmountDue as Currency curPrice = Val(txtVideoPrice.Text ) curTaxes = 0.07* curPrice curAmountDue = curPrice + curTaxes txtTaxes.Text = Str(curTaxes) txtAmountDue.Text = Str(curAmountDue) End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Step Five: Test Overall Project
Even with extensive testing, some bugs can often be found in most commercial software. With computer software, each program instruction must be absolutely correct. Otherwise, the whole program might fail. BE SURE to test your program in the actual environment and on the actual data on which it will be used (just ask IBM at the Olympics). Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Step Six: Document Project in Writing
Documentation includes the pictorial and written descriptions of the software. It contains internal descriptions of programming commands and external descriptions and instructions. Documentation is necessary since, sooner or later, the program will need to be maintained (correct bugs, add new features, handle problems not thought of previously, etc. This is NOT possible without documentation. Written documentation includes books, manuals, and pamphlets that give instructions on software use and discuss the objectives and logic of the software. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter Two: Creating a First Project in Visual Basic

Learning Objectives Point out the elements of the Visual Basic development environment, including the title bar, menu bar, toolbar, initial form window, Toolbox, Project Explorer window, Properties window, and Form Layout window. Discuss the use of the form in creating a Visual Basic project. Understand controls and their properties. Use the label, command button, and image controls from the Toolbox to create an interface on the form. Use a message box for output from the project. Use the Code window to write the event procedure for a command button. List the different types of files that make up a Visual Basic project and be able to save a project to disk. Use the various Visual Basic help facilities to answer questions or solve problems encountered when creating a project. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Getting Started with Visual Basic
Double-click VB icon on Desktop or use Start|Programs|Visual Basic to bring up opening dialog box Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

VB Development Environment
You should start in the default MDI environment Project Window should have a white background Form should be displayed in Project Window Maximize Project Window Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

VB Development Environment
Toolbar Form Size Project Explorer Initial Form Window Toolbox Properties Window Project Window Form Layout Window Sizing Handles Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Toolbox Used to select a control to place on form. Label Control
Textbox control Used to select a control to place on form. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Project Explorer Window
View code View Object Change Folders Used to select the code or object or to change folders. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Properties Window Used to change the properties of controls at
Window Name Object Box Properties List Tabs Scrollable list of properties Description Pane Used to change the properties of controls at design time. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Important Properties Name property: identifies the control
Should start with three letter prefix lbl for label txt for text box frm for form Can include letters, numbers, and underscore Caption property for labels--what you see on screen Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Adding a Control Double-click to add control to center of form
Can be moved around from there Use sizing handles to change size Single Click and draw on form Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Controls to Add to Form Label control: provides description of other controls Image control: holds a graphic image Stretch property should be set to True Picture property is set to graphic file Command button control: can be clicked to provide action Caption property Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Adding Code to Project Code goes in Code Window in event procedure
Event procedure begins with “Private Sub…” and ends with “End Sub” Use Msgbox command to display dialog box with message Msgbox “Welcome to Vintage Videos” Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Design Time and Run Time
You are in “Design Time” when you are designing the project and adding code You are in “Run Time” when you click the VCR Run icon You can stop the project and exit Run time by clicking the VCR Stop Icon. You can go to “Break Mode” by clicking the VCR Pause Icon. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Toolbar and Menu System
The VB menu system provides access to all commands. The Toolbar uses icons for more commonly used menu commands. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Files in Visual Basic All projects in VB have a .vbp (project) file and at least one .frm (form file) file. Always save .frm files first and then save project files. Use File|Save or File|Save as… commands for this purpose or click Disk icon on toolbar. Projects with graphics also have .frx (binary form) files. They are saved automatically. Module files have a .bas extension and are pure code files. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Visual Basic Help There are three types of Help:
Help menu option context-sensitive help and Auto Help In VB 6, Help uses the familiar Internet Explorer browser interface for the first two types of help. You can seek help by selecting Contents, Index, or Search from the Help menu item Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Context-Sensitive and Auto Help
With context-sensitive help, pressing the F1 key provides help on whatever item the cursor is located. With Auto Help, VB tries to help you with a code statement by providing: A list of items to complete the statement Info on the statement you have started Tips on the type of data you are working with Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 3: Variables, Assignment Statements, and Arithmetic

Learning Objectives Declare and use different types of variables in your project. Use text boxes for event-driven input and output. Use a four-step process to write code for event procedures Write Visual Basic instructions to carry out arithmetic operations. Describe the hierarchy of operations for arithmetic. Understand how to store the result of arithmetic operations in variables using assignment statements. Use comments to explain the purpose of program statements. Discuss using Visual Basic functions to carry out commonly used operations. Use command buttons to clear text boxes, print a form with the PrintForm method, and exit the project. Describe the types of errors that commonly occur in a Visual Basic project and their causes. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Variables Variables are named locations in memory (memory cells) in which we store data that will change at run time Variable names in VB: Must begin with letter can’t include period can’t be over 255 characters are not case-sensitive Example variable names: VideoPrice for Video Rental Price Taxes for taxes on this price AmountDue for sum of price and taxes YTDEarnings for year to date earnings EmpLastName for employee’s last name

Data Types Two primary types of data: numeric and string
Numeric data can be used in arithmetic operations 3.154; 2300; -34; are all numeric constants String data should not be used in arithmetic “Dogs”; “ ”; “Dr. Brown” are all string constants Numeric data types can be subdivided into specific types: - currency $55, integer 255 - single long (integer) 35,455 - double Boolean True or False

Declaring Variables Declare ALL variables with the DIM statement
General form: Dim Variable1 as type1, variable2 as type2, etc. For example, Dim strMyName as String, sngMyValue as Single Dim curTaxes as Currency, curPrice as Currency Dim curAmountDue as Currency Two or more variables can be declared with same Dim statement but you must include the variable type If you fail to declare a variable after the Option Explicit statement has been entered, an error occurs at Run time Use variables rather than objects in processing since all textboxes are strings

The Option Explicit Statement
Begin ALL Forms with the Option Explicit command in the declarations procedure of the general object. This forces all variables to be declared To automatically include Option Explicit, go to the Tools|Options|Editor menu selection and check the box for “Require variable declaration”

Event-driven Input In VB, we often use event-driven input where data is transferred from text boxes to variables by an event Use an assignment statement to do this: Control property or variable = value, variable, or property Only variables or control properties can be on left of assignment statement Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Assignment Statements
Must convert strings in text boxes to numeric with Val function, e.g., Price = Val(txtPrice.Text) Convert numeric variables to strings before assigning to text box, e.g., txtAmountDue.Text = Str(curAmountDue) Carry out calculations with assignment statements, e.g., curTaxes = 0.07*curPrice curAmountDue = curPrice + curTaxes

Using Functions Sometimes we want to convert a string to a number or vice versa or to compute a single value To do this, we use a function that is nothing more than an operation that takes a multiple arguments and generates a single value variable = functionName(arg1, arg2, …) Example functions for converting data: Val to convert a string to a number Str to convert a number to a string CCur to convert a string to a currency data type

Using Assignment Statements for Calculations
Sometimes, an expression will be on right of assignment statement An expression is a combination of one or more variables and/or constants with operators Operators are symbols used for carrying out processing Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Arithmetic Operators () for grouping + for addition
^ for exponentiation - for subtraction - for negation * for multiplication / for division \ for integer division mod for modulus Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Hierarchy of Operations
Operations within parentheses ( ) Exponentiation (^) Negation (-) Multiplication and division (*, /) Integer division (\) Modulo arithmetic (Mod) Addition and subtraction (+, -) String concatenation (&)

Arithmetic Example 3 1 2 5 4 Order 1 Subtract Taxes from Salary
3 * (curSalary - curTaxes)^2 - curBonus/curMonths Order 1 Subtract Taxes from Salary 2 Square the result 3 Multiply this result by 3 4 Divide Bonus by Months 5 Subtract result from first expression

Symbolic Constants We can assign a name to a constant with the Const statement const constant name as variable type = value Example Const sngRate As Single = 0.07 Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Comments To explain the purpose of a statement, a comment statement is added Any statement beginning with an apostrophe or REM is a comment Comments can be added to end of statements using apostrophe Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Formatting Data To display information in a pleasant form, we can use the Format function: variable or control = Format(variable, format expression) Where the format expressions are in quotes and include; Currency Fixed Standard Percent Scientific Example: txtTaxes.Text = Format(curTaxes, “currency”)

Print Form, Clearing Entries and Setting Focus
To print the form, use the PrintForm command To clear a text box, set it equal to the null string ”” (no space) To set the focus to a text box, use the Setfocus method For example, txtCustName.SetFocus sets focus to this textbox Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using Other Arithmetic Functions
Other useful functions include Abs for absolute value Sqr for square root FV for future value PV for present value IRR for internal rate of return Pmt for payment Ucase/Lcase to convert to upper/lower case Len for length of a string Date for the system date DateValue for the date corresponding to string argument We will use Pmt to compute the monthly payment curMonPay = Pmt(sngRate, curNper, -curLoanAmt) Pmt(.08/12,60,-10000) = $256.03

Creating a Monthly Payment Calculator
Assume you wanted to determine the monthly payment necessary to pay off a loan at a given interest rate in some number of months Use PMT function PMT(rate, nper, pv) where rate = monthly interest rate nper = number of months pv = negative value of loan amount

The Monthly Payment Form

Compute Button Click event
Dim curAmount As Currency, intMonths As Integer Dim sngRate As Single, curPayment As Currency curAmount = CCur(txtAmount) intMonths = CInt(txtMonths.Text) sngRate = CSng(txtRate.Text) curPayment = Pmt(sngRate, intMonths, -curAmount) txtPayment.Text = Format(curPayment, “Currency”) txtAmount.Text = Format(curAmount, “Currency”) txtRate.Text = Format(sngRate, “Percent”)

Visual Basic Errors Syntax errors: caused by incorrect grammar, vocabulary, or spelling. Also caused by using a keyword. Usually caught as you enter the statement. These are pointed out by VB and are usually easy to find and correct. Run time errors: errors not caught at entry but which involve an incorrect statement or bad data, e.g., dividing by zero. The presence of an error is detected by VB when you run the program, but you still have to find the source of the error. More difficult to correct than syntax errors. Logic errors: those that VB does not catch as being “wrong”, but which involve erroneous logic, say, only having a program include 11 months of data instead of 12. These are the hardest to find! Debugging is the art and science of finding errors. VB has debugging tools to be discussed later.

Chapter 4: The Selection Process in Visual Basic

Learning Objectives Understand the importance of the selection process in programming. Describe the various types of decisions that can be made in a computer program. Discuss the statements used in Visual Basic to make decisions. Understand the various comparison operators used in implementing decisions in Visual Basic. Use the If-Then-Else, If-Then-ElseIf, and Case decision structures. Use the list box control to select from a list of alternatives. Work with complex comparison structures and nested decisions to handle more sophisticated selection processes. Use the scroll bar to input integer values. Use the Form_Load event to execute a procedure when a form is loaded. Work with the debugging toolbar to find program errors. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Selection Process One of the key operations of a computer is to select between two or more alternatives to make a decision. Every decision involves a comparison between a variable and a constant, variable, or expression using logical operators. Decisions can involve two-alternatives or multiple alternatives. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The If-Then-Else Decision Structure
For two alternative decisions, the If-Then-Else decision structure should be used In pseudocode, this is: If condition is true then implement true alternative Else implement false alternative End Decision Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Multiple Alternatives
For multiple alternatives, the general form in pseudocode is: Select one: Condition 1 is true; implement alternative 1 Condition 2 is true: implement alternative 2 Condition 3 is true; implement alternative 3 End Selection. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Two Alternative Decision Structure
The If-Then-Else statement is: If condition is true Then statements for true alternative Else statements for false alternative End if The If-Then condition test expression1 comparison operator test expression2 where comparison operator is one of these six operators: Equal to: = Not equal to: <> Less then: < Greater than: > Less than or equal to: <= Greater than or equal to: >= Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The If-Then-Else Decision Structure (cont.)

Example of If-Then-Else Decision to Compute Payroll
sngPayRate = CCur(txtPayRate.text) intHours = CSng(txtHours.text) If intHours >= 40 Then curPay = sngPayRate * * _ sngPayRate * (intHours - 40) Else curPay = intHours * sngPayRate Endif txtPay.Text = Format(curPay, _ ”currency”) Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

One-Alternative Decision
If there is only a true alternative, then this is a special case of the two-alternative decision structure If condition is true Then true alternative is implemented End If One-alternative decision can be combined with InputBox used to validate user input, e.g., to test that Customer Name textbox has something in it: If txtCustName.Text = “” then txtCustName.Text = InputBox(“Enter _ Name and try again”) Exit Sub Where the Exit Sub statement exits the event procedure Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

If-Then-ElseIf Decision Structure
One way to implement a multiple alter-native decision structure is through the If-Then-ElseIf decision structure: If condition1 true Then first set of statements ElseIf condition2 true Then second set of statements ElseIf condition3 true Then third set of statements Else last set of statements End If Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

If-Then-ElseIf Decision Structure (Assume condition3 is True)

Example of If-Then-ElseIf for Letter Grade Determination
Dim intAverage as Integer Dim strLetterGrade as String intAverage = CInt(txtAverage.Text) If intAverage >= 90 then strLetterGrade = “A” ElseIf Average >= 80 then strLetterGrade = “B” ElseIf Average >= 70 then strLetterGrade = “C” ElseIf Average >= 60 then strLetterGrade = “D” Else strLetterGrade = “F” End if. txtLetter.Text = strLetterGrade Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the Select Case Decision Structure for Multiple Alternatives
General form: Select Case expression Case Condition1 is true First set of statements Case Condition2 is true Second set of statements Case Condition3 is true Third set of statements Case Else Last set of statements End Select Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Case Conditions Conditions for Case statement can be in 3 forms:
Test Condition Example Value or expression Case 91, 92, 93 Range of values Case 90 to 100 Comparison condition Case Is > 89 Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Example of Select Case to Determine LetterGrade
Dim intAverage as Integer Dim strLetterGrade as String intAverage = CInt(txtAverage.Text) Select Case intAverage Case Is >= 90 strLetterGrade = “A” Case Is >= 80 strLetterGrade = “B” Case Is >= 70 strLetterGrade = “C” Case Is >= 60 strLetterGrade = “D” Case Else strLetterGrade = “F” End Select Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the List Box The List box enables the
user to select from a list of items. lst is the prefix for name and the List property of the list box can be set at design time or run time. The Text property of the list box is equal to the selected item. We can test the Text property to determine which item was selected. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

More Complex Decisions
Decisions within decisions are know as nested decisions Interior decision must be an alternative of outer decision Decisions that combine two or more test conditions using logical operators are known as compound decisions And, Or, Not, and Xor are logical operators Both conditions must be able to stand alone Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Example of Nested Decisions
Need to check if employee is hourly before checking for overtime: If strPayType = “Hourly” then If intHours > 40 Then curPay = 40 * sngPayRate _ (intHours-40) * sngPayRate Else curPay = intHours * sngPayRate End If curPay = 40 * sngPayRate Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Example of Compound Decisions
Using compound condition to test for average AND number of absences If sngAverage >= 90 AND intAbsences < 3 then strLetterGrade = “A” ElseIf sngAverage >= 80 AND intAbsences < 5 then strLetterGrade = “B” etc. In this case, if a student has an average of 93 and 4 absences, he/she will receive a grade of “B” because he/she has more than 3 absences. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Example of Using List Box
Dim strVideoType as String Dim curPrice as Currency strVideoType = lstTypes.Text Select Case strVideoType Case “Kids” curPrice = 0.99 Case “Regular” curPrice = 1.99 Case “Classic” curPrice = 2.99 End Select txtVideoType.Text = Format(curPrice, _ ”currency”) End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the Form_Load Event
The Form_Load event occurs when the project is started and the form is loaded. Code from a command button can be cut (or copied) and then pasted into the form_load event Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the Debug ToolBar
To view the Debug Toolbar, Select View|Toolbars and click the Debug checkbox The Debug Toolbar Run Stop Step Into Step Out Immediate Window Quick Watch Break Toggle Step Over Locals Watch Window Call Stack Breakpoint Window Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Debugging With the Immediate Window
By clicking the Immediate Window icon on the debug toolbar, you can then print the current value of a textbox or variable Use the Print variable or textbox command to display its current value This can enable you to find errors in the code Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 5: The Repetition Process in Visual Basic

The Repetition Process
The capability to repeat one or more statements as many times as necessary is what really sets a computer apart from other devices All loops have two parts: the body of the loop (the statements being repeated) a termination condition that stops the loop Failure to have a valid termination condition can lead to an endless loop Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Types of Loops There are three types of loops
event-driven determinate indeterminate Event-driven loops are repeated by the user causing an event to occur Determinate loops repeat a known number of times Indeterminate loops repeat an unknown number of times Variables should be initialized before being used in a loop Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Event-Driven Loops Event-driven loops are repeated by user causing an event to occur Variable scope is important for loops; Variables in event procedures are local and are reset to zero when procedure terminates Variables defined at form level are known to all procedures and retain their value between events Form-level variables are declared in the Declarations procedure of the General object Static variables retain their value between events but are local to event procedure Declared with Static keyword Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Form-level Variables Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Use of AddItem and Clear Methods
The AddItem method is used to add items to a list box at run time Form of AddItem method list1.Additem string Always add a string to list box since it contains text The Clear method clears a list box list1.Clear Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Sum a Series of Numbers
Private Sub cmdCalc_Click() Dim intTheValue As Integer intTheValue = CInt(txtTheValue.Text) intSum = intSum + intTheValue ‘intSum is form level intNumValues = intNumValues + 1 ‘form level txtSum.Text = Str(intSum) txtNumValues.Text = Str(intNumValues) lstEntries.AddItem str(intTheValue) txtTheValue.Text = "” txtTheValue.SetFocus End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Determinate Loops Using For-Next Loop
Best way to create a determinate loop is to use a For-Next Loop Form of For-Next Loop: For variable = start value to end value Step change value statements that compose body of loop Next variable where variable = the counter variable in the loop start value = the beginning value of the counter variable end value = the ending value of the counter variable change value = the amount the counter variable changes each time through the loop Next variable = the end of the For loop Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Example of For-Next Loop
Ending Change Counter Beginning Value Value Variable Value For intCounter = 1 to 10 Step 1 Statement intSum = intSum + intCounter Next intCounter Body of Loop Next Statement Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code To Sum using For-Next Loop
Private Sub cmdCalc_Click() Dim intTheValue as Integer, intSum as Integer Dim intNumValues as Integer, intCounter as Integer intSum = 0 ‘Initialize Sum to Zero If txtNumValues.Text = "" Then ’Number not entered Msgbox "Please enter number of values to be summed“ Exit Sub ’Do not go into loop End if intNumValues = CInt(txtNumValues.Text) For intCounter = 1 to intNumValues intTheValue = CInt(InputBox("Enter next value")) intSum = intSum + intTheValue lstEntries.AddItem Str(intTheValue) ‘Add to list Next txtSum.Text = Str(intSum) lstEntries.AddItem "Sum is " & Str(intSum) End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Printing a List To print the contents of listbox, use the Listcount and List() properties of the list box Listcount is the number of items in list box but List() property runs from 0 to Listcount -1 List(intCounter) is equal to the contents of the corresponding list box Code to print contents of list box to Immediate Window: For intCounter = 0 to lstEntries.ListCount - 1 Debug.Print lstEntries.List(intCounter) Next Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Indeterminate Loops Indeterminate loops run for an unknown number of repetitions until a condition is true or while a condition is true Four types of indeterminate loops Until loop with termination condition before body of loop While loop with termination condition before body of loop Until loop with termination condition after body of loop While loop with termination condition after body of loop Pre-Test loops have termination condition before loop body Post-test loops have termination condition after loop body Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Form of Pre- and Post-Test Loops
The form of the pre-test loops is: Do Until (or While) condition body of loop Loop The form of the post-test loops is: Do Loop Until (or While) condition Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Pre and Post-Test Loops

Processing an Unknown Number of Values from a File
A data file is a collection of data stored on magnetic or optical secondary storage in the form of records. A record is a collection of one or more data items that are treated as a unit. Files are identified by the computer’s operating system with file names assigned by the user. Files are important to processing data into information because they provide a permanent method of storing large amounts of data that can be input whenever needed. Three types of files: sequential access, database, and direct access files We will use sequential access files as input. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using Sequential Access Files
Sequential access files must be read in same order as they are created so they replicate the action of entering data from a keyboard. The number of records on a sequential access file is often unknown, but there is an invisible binary marker at the end of the file called the EOF (end of file) marker. Use a Do While loop or a Do Until loop to input data from sequential access file. Loops can input data until the EOF marker is encountered (or while it has not been encountered). Create sequential access files by using a text editor such as Notepad. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Opening and Inputting Data from a File
Files must be opened with the Open statement: Open “filename" for Input as #n To input data from a file, use the Input #n, statement Input #n, list of variables Files must be closed at end of procedure Close #n Using an Until loop to input data from file Do Until EOF(n) Loop Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Input and Sum values from File
Private Sub cmdCalc_Click() Dim intTheValue As Integer, intSum As Integer Dim intNumValues As Integer Open "a:\SumData.txt" For Input As #10 intSum = 0 intNumValues = 0 Do Until EOF(10) ’Input to end of file Input #10, intTheValue intSum = intSum + intTheValue intNumValues = intNumValues + 1 lstEntries.AddItem Str(intTheValue) Loop txtNumValues.Text = Str(intNumValues) txtSum.Text = Str(intSum) lstEntries.AddItem "Sum is " & str(intSum) Close #10 End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Combo Box A combo box is a combination of a text box and a list box. It has a text box portion that is displayed at all times and a drop-down list of items that can be displayed by clicking on the down arrow. One property of note for the combo box is the Style property, which can be set at design time to Drop Down combo (the default), Simple Combo, or Drop Down list. Its prefix is cbo . The combo box has all the properties and methods of the list box including the AddItem, ListCount, and List() properties. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

More on Combo Boxes The default event for the Combo box is the Change event--to use the Click event, you must change to it. The Sorted property is a useful property for the combo and list boxes that arranges the items in the box alphabetically. Items can be removed from a combo or list box with the RemoveItem method which requires that number of the item to be remove be given. To remove a selected item, you can use the ListIndex property, eg, cboMembers.RemoveItem cboMembers.ListIndex Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Nested Loops A Nested loop is a loop within a loop. Must complete the inner loop within the outer loop. Nested For-Next loops have a For-Next loop within a For-Next loop. The inner loop will go through all its values for each value of the outer loop. Three key programming rules to remember about using nested For-Next loops: Always use different counter variables for the outer and inner For-Next loops. Always have the Next statement for the inner For- Next loop before the Next statement for the outer For- Next loop. Always include the counter variable in the Next statements to distinguish between the loops. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Creating an Executable File
An executable file is one that can be executed on any computer on which it is installed. Creating an executable file in VB is accomplished with the File|Make filename.exe menu selection. Once an executable file is created, a shortcut to it can be created by right-clicking the file name in Windows Explorer and selecting Create Shortcut. Drag the shortcut to the desktop. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Debugging Loops Debug a loop by inserting a debug.print command in the loop to print to the Immediate Window. Add a Quick Watch by locating the pointer on a variable and clicking the eyeglass icon on the Debug Toolbar. The values for this variable will be shown in the Watch Window. Use the Locals window to display the values of variables local to a procedure. Use the Toggle Breakpoint icon to pause execution at a designated line in the code and then use the various windows to view the values for variables. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 6: Using Arrays Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using Control Arrays 1. A control array is group of the same type control which is assigned a single name. 2. The individual controls are identified by the control array name and an index value. 3. The Case decision structure can be useful in working with a control array. 4. To create a control array, just enter the same name for more than one control and reply “yes” to the query. 5. The order in which the controls are entered determines the index values for the controls in the control array. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using List Arrays 1. Arrays are lists or tables of data which have a single name. Individual array elements are identified by the array name and one or more subscripts or index values. 2. To be used in Visual Basic, an array must be declared; arrays can be fixed size or dynamic size (we use only fixed arrays.) 3. The default lower limit on an array index is zero but this can be changed to one or any other value. 4. It is not possible to exceed the upper limit or go below the lower limit on the array index values. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Comparing Listboxes and Arrays
curPrices(0) curPrices(1) curPrices(3) curPrices(2) curPrices(4) curPrices(6) curPrices(5) curPrices(7) curPrices(8) curPrices(9) Array curPrices Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Entering Array Data 1. Arrays can be input with any of the three types of loops discussed earlier--event driven, for-next, or while/until loops. 2. Event-driven loops and For-Next loops are good for keyboard input; While or Until loops are good for input from a file. 3. In any case, each array element must be input using its subscript value. 4. With an event driven loop, each click of a button increments a counter and inputs the corresponding array element. 5. With a For-Next loop, you must input the number of array elements. The array values must be input with an Inputbox with the For-next counter variable matching the array index. 6. With an Until loop, you can input from a file. You must increment a counter that matches the index for the array element. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Input from For-Next and Until Loops
For-Next Loop Dim intCounter As Integer intNumPrices = CInt(InputBox("How many prices?")) For intCounter = 0 To intNumPrices - 1 curPrices(intCounter ) = CCur(InputBox("Next _ price:")) Next Until Loop Open "a:\prices.txt" For Input As #1 Do Until EOF(1) Input #1, curPrices(intNumPrices) intNumPrices = intNumPrices + 1 Loop Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Processing Arrays 1. Typical array operations include summing and averaging the array values and finding the largest or smallest value in the array. 2. Working with arrays usually involves a For-Next loop. 3. Summing curPrices array elements involves using a statement of the form: curSum = curSum + curPrices(intCounter) 4. Averaging curPrices array elements involves dividing the curSum by the number of elements. 5. Finding the largest or smallest value involves multiple comparisons of array elements. 6. To find the maximum Price, you must compare each array value to the current highest price; if it is higher, it becomes the highest price. Do this using For-Next loop and If-then If curMax < curPrice(intCounter) then curMax = curPrice(intCounter) End if Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Find MaximumValue in List
Private Sub cmdFindMax_Click() Dim intCounter As Integer Dim curLargest As Currency curLargest = curPrices(0) For intCounter = 1 To intNumPrices - 1 If curPrices(intCounter) > curLargest Then curLargest = curPrices(intCounter) End If Next txtMaxPrice.Text = Format(curLargest, _ "currency") End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Finding Items and Working With Multiple Lists
1. It is possible to work with multiple list arrays by matching the index values for the arrays. 2. Finding a specific array value involves comparing each array element to the desired value. A flag is often used to indicate whether a match was found. 3. The MsgBox can be used as a function by including multiple parameters within parentheses. 4. Parameters can be internal constants. 5. The MsgBox function returns a value which can be checked to determine which button was clicked. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Pseudocode to Find Price for Part Identifier
Begin procedure to find part identifier Input part identifier Set Flag to false Repeat for each part in parts list If part identifier = identifier on parts list then Flag = True Save index of part identifier on parts list End decision End repeat If Flag = true Use saved index to display part identifier and price Else Display message that part not on parts list End procedure Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Find Price for a Part Identifier
Private Sub cmdFind_Click() Dim intCounter As Integer, intResults As Integer Dim strFindID as String, blnFound As Boolean Dim intPriceIndex as Integer strFindID = InputBox("Input part identifier to find") blnFound = False For intCounter = 0 To intNumPrices – 1 If strFindID = strPartId(intCounter) Then blnFound = True intPriceIndex = intCounter Exit For End If Next If blnFound Then txtFound.Text = strPartId(intPriceIndex ) & " " & _ Format(curPrices(intPriceIndex ), "Currency") Else intResults = MsgBox("Part not found", VbExclamation, _ "Price Search") End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Save Index of Part with Highest Price
Private Sub cmdFindMax_Click() Dim intCounter As Integer Dim curLargest As Currency Dim intMaxIndex as Integer curLargest = curPrices(0) For intCounter = 1 To intNumPrices - 1 If curPrices(intCounter) > curLargest Then curLargest = curPrices(intCounter) intMaxIndex = intCounter End If Next txtMaxPrice.Text = strPartId(intMaxIndex) & _ " " & Format(curPrices(intMaxIndex), _ "Currency") End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Working with Multiple Forms
1. It is possible to have multiple forms in a project. To display a form, use Object.Show To hide the form, use Object.Hide 2. A new form can be added using the Project|New Form menu option or the New Form icon on the toolbar. 3. If a control on one form is referred to on another form, the form name must be included as a part of the control reference. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Searching in Strings * Searching for strings using a loop requires that you use UCase() or LCase() to convert all strings to the same case. * To search for a sub-string within a string, you use the function: (Instr(string to search, search string) For example, InStr(“Go Dogs”, “D “) returns 4 because “D” is in the 4th position. If the character does not exist, InStr() returns a zero. *NOTE: InStr() is case sensitive!!! Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Search for a Partial Video Name
Private Sub cmdSearch_Click() Dim strVideoName As String, intCounter As Integer Dim intNumMatches As Integer strVideoName = txtSearch.Text lstVideos.Clear lstVideos.AddItem "Video Name" For intCounter = 0 To intNumVideos If InStr(UCase(Videos(intCounter)), _ UCase(strVideoName)) > 0 Then intNumMatches = intNumMatches + 1 lstVideos.AddItem strVideos(intCounter) End If Next If intNumMatches = 0 Then MsgBox ("No matching videos found! Try again.") ElseIf intNumMatches <= 5 Then lstVideos.AddItem Str(intNumMatches) + " videos found" Else MsgBox ("Too many matching videos!") End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Code to Display Video Information
Private Sub lstVideos_Click() Dim strVideoName As String Dim intCounter As Integer strVideoName = lstVideos.Text lstVideos.Clear For intCounter = 0 To intNumVideos If strVideoName = strVideos(intCounter) Then lstVideos.AddItem strVideoName & " " & _ Format(strVideoPrice(intCounter), _ "currency") & " " & strVideoLoc(intCounter) Exit For End If Next End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Two-Dimensional Arrays
When you are working with a table instead of a list, you have a 2-dimensional array. 2-D arrays use two subscripts with the first subscript referring to the row value and the second subscript referring to the column value. Nested For-next loops are often used to work with 2-D arrays with the inner loop matching the columns and the outer loop matching the rows. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the Step Commands for Debugging
Step into Stepout of The Step Commands Step Over If you select Step Into, you can “step” through the code, line by line and note the result of the code in the various windows--Watch, Locals, or Immediate. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 7: Using Functions, Subs, and Modules

Plan for Revising Vintage Videos Application
Need a way of adding videos to system Need a better way of managing membership list Need capability to add late fees to customer’s bill Need a system to print alphabetical list of members or videos Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Design for Expanded Vintage Videos Project

Membership Management Form

Modified Videos Form Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using General Procedures
Event procedures are associated with a particular event and are not usually available to other forms. General procedures are used for specific tasks that are not associated with an event. General procedures are defined in the General Object of a form and then invoked elsewhere in the project. Two types of general procedures: subs (subroutines) functions Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Relationship Between General and Event Procedures

Subs and Functions A sub is a unit of code that performs a specific task but returns no value. A function is similar to the built in functions in that arguments are passed to it and processed to compute a single value returned by its name. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Primary Purposes of Subs and Functions

Working with General Procedures
General procedures must be created and then invoked. Invoking a function: variable = functionname(arg1, arg2, …, argn) Invoking a sub: subname arg1, arg2, …, argn Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Creating Subs and Functions
To create a sub or function you can Use the Tools|Add Procedure menu command and select the type of procedure to add or simply type the word Sub or Function and press Enter after any existing event or general procedure. In either case, then add the parameters. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Creating a Function The general form of the function definition statement is: Function FuncName(parameter1 as type, parameter2 as type, …) as type For example Function intFindMax(intNum1 as Integer, intNum2 as Integer) as Integer An important rule is that the name of the function must be assigned a value in the function. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Creating a Sub The general form of the sub definition statement is:
Sub SubName (parameter1 as type, parameter2 as type, …) Note that the sub name is not assigned a data type Example Sub Reverse(curFirst as Currency, curSecond as Currency) Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Relationship Between Sub Definition Statement and Statement Invoking the Sub

Relationship Between Function Definition Statement and the Statement Invoking the Function

Matching Arguments and Parameters
For both sub and functions, the number and type of arguments in the invoking statement must match the number and type of parameters in the procedure definition statement. In both the argument and parameter list, fixed-size arrays are referenced by the name of the array followed by parentheses. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Function to Compute Income Taxes
Public Function curComputeTaxes(intNumDep As Integer, _ curGrossIncome As Currency) as Currency Dim curTaxIncome As Currency curTaxIncome = curGrossIncome intNumDep * 2650 Select Case curTaxIncome Case Is <= 24650 curComputeTaxes = 0.15 * curTaxIncome Case Is <= 59750 curComputeTaxes = * (curTaxIncome ) Case Is <= curComputeTaxes = * (curTaxIncome ) Case Is < curComputeTaxes = * (curTaxIncome ) Case Else curComputeTaxes = * (curTaxIncome ) End Select End Function Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Sub to Reverse Two Values
Sub Reverse(curFirst as Currency, curSecond as _ Currency) Dim curTemp as Currency curTemp = curFirst curFirst = curSecond curSecond = curTemp End sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Sub to Sort Arrays Public Sub Sort(curFirstList() As Currency, _
curSecondList()As Currency, intNumList As Integer) Dim blnNoReversal As Boolean, intCounter As Integer blnNoReversal = False Do Until blnNoReversal blnNoReversal = True For intCounter = 0 To intNumList - 2 If curFirstList(intCounter ) > _ curFirstList(intCounter + 1) Then Reverse curFirstList(intCounter ), _ FirstList(intCounter + 1) StrReverse curSecondList(intCounter ), _ curSecondList(intCounter +1) End If Next Loop End Sub Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Global Declarations and the Code Module
In a global declaration, the scope of global variables, as compared to form-level variables or procedure-level variables, includes all parts of the project. The Code Module is the section of pure code that is known to all parts of the project. Use Public statement to declare variables Public varName1 as type, varName2 as type, ... Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Scope of Global Variables

Use of String Functions
Len(string) --returns number of characters in string. Left(string, N) or Right(string, N) --returns the leftmost or rightmost N characters in a string. Mid(String,P,N) --returns N characters in a string starting at Pth character. LTrim(string) or RTrim(string) --trims blank characters from left (right) end of string. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Passing by Value in Subs
If there is a two-way communication between arguments and parameters, then you have passing by reference. If there is a one-way communication between arguments and parameters, then you have passing by value. It is possible to force passing by value by adding the keyword ByVal prior to a variable in the procedure definition statement. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 8: Security, Menus, and Files

Security Passwords are often used to control access to a computer or software program. Passwords should be at least 6 characters in length and something that cannot be easily guessed. It should not be possible to move, resize, or bypass the password form in VB and it should be the Startup object. The Tag property for a textbox can be used for the password and the PasswordChar property can be used to disguise the password as it is entered. A user should be given a set number of “chances” to enter the correct password. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Menu Systems in VB A menu system for a form can be created using the Menu Editor. Menu bar options as well as submenus can be created with this editor. Menu and submenu items have caption and name properties (the prefix is mnu). Code is written for menu items just like for other event procedures. Menu options are always click events. Most menus contain File and Help menu bar options in addition to others specific to the application. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Menu Editor Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Creating a Memo Editor Creating a memo editor in VB involves using a textbox as the location of the text and a menu system for the various editor commands. The textbox should have its MultiLine property set to true and its ScrollBars property set to vertical. The Form_Resize event occurs when the user displays a textbox--it can be used to cause the memo text box to fill its form by setting the Height and Width properties to ScaleHeight and ScaleWidth. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Memo Editor File Menu
The File Menu should have options to begin a new memo, open an existing memo, save a memo under the current name or a new one, close the memo, print it, or exit the memo editor. Key to the File Menu is the use of the common dialog control which must be added to the Toolbar with the Project|Components VB menu option before being added to the form. The common dialog control (with dlg prefix) can be used to open or save files with the ShowOpen and ShowSave methods. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Plan for Vintage Videos

Saving a Memo The Filter property of the common dialog control is used to display a list of files. It has the form: dlgName.Filter = “description1|filter1|description2|filter2|etc” The FilterIndex property determines the default file type. When a file is selected or a filename entered, this becomes the Filename property for the dialog box. The FreeFile function returns an unused file number and the On Error Goto statement causes control to jump to a label when an error is encountered. Both are useful in working with files. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Other File Operations Input$(number, #filenumber)
A file can be opened from a common dialog box with the ShowOpen method. The contents of the file can be input using the Input$ function: Input$(number, #filenumber) where number = number of characters in file that is identified by #filenumber. The LOF(FileNumber) function can be used to determine the number of characters in a file. A memo can be saved by printing its contents to a file—it is common to query the user to save the file if it has been changed. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Memo Editing Submenu
Typical editing options are Cut, Copy, and Paste. All three use the Clipboard object to temporarily save information. The Clipboard SetText method transfers selected text to the clipboard and the GetText method retrieves text from clipboard. The Clipboard Clear method clears the Clipboard. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using the Clipboard Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Memo Format Submenu
Formatting of text in the memo involves changing the Font and Style of the text. Menu control arrays are used to display different types of fonts and styles. The FontName property of the memo textbox determines the font type. FontBold, FontItalics, FontUnderline properties of the textbox control the style of the text. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Chapter 9: Introduction to Working with Databases in Visual Basic

Database Concepts Database: the storage of different types of data in such a way that the data can be easily manipulated and retrieved by an end user. A database is composed of fields, records, and tables. Field: a single fact or data. It is the smallest use of named data that has meaning in a database. Fields are given field names to identify them. Record: A collection of related data that is treated as a unit. A collection of fields that pertain to a single person, place or thing. Table: A related collection of records, all having the same fields. Composed of rows and columns. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

A Database Table Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Relational Database A relational database is composed of multiple related tables. It is the most common form of database in use today. A primary key is a field that has a unique value for each record in a table. A foreign key is a field that is a primary key in another table. Foreign keys are used to establish the relationships between the various tables in the database. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Relational Database Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Database Operations The primary use of a database is to enable the user to obtain information from it by constructing queries to it. For a relational database, these queries are constructed using SQL (Structured Queried Language). Once found, records can be displayed, edited, deleted, or added. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Advantages of Databases vs. Arrays
Databases are superior to arrays for the following reasons: A database table can store multiple types of data in the same table while arrays are restricted to a single data type. Any changes to the database are immediately saved to disk as they occur. A sophisticated database engine can be used to handle processing. Multiple computers can be connected to the same database. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Using VB to Work with Databases
Visual Basic can be used to work with existing databases. In our case, we will assume a Microsoft Access database with an .mdb extension. Visual Basic can be used to create a user-friendly front-end to a database. The data control (with dat prefix) is essential to working with databases in VB. It uses an internal pointer to point to the current record. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Data Control DatabaseName property must be set to the pathname of the database. RecordSource property must be set to the table of the database. Textboxes and other controls can be bound to a data control by assigning their DataSource property to the data control. The bound control’s DataField property is set to a field of the DataSource table. The Recordset object represents the records in the database. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

RecordSet Methods There are numerous useful methods for the Recordset object: MoveFirst - move to first record MoveLast - move to last record MoveNext - move to next record MovePrevious - move to previous record AddNew - add a new record (save by moving to new record or using UpdateRecord method) Delete - delete current record UpdateControls - make bound controls the same as database Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Recordset Properties There are numerous useful properties for the Recordset object: AbsolutePosition - the current position of pointer RecordCount - the number of records in the Recordset BOF (EOF) - True if at Beginning (End) of File Bookmark - A unique identification of each record Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

Finding Records The form of the FindFirst method to find first occurrence of a matching record is: datName.Recordset.FindFirst Query string where the Query string is in quotation marks and is a combination of field name, comparison operator, and a value. For example: datMembers.Recordset.FindFirst “Late_Fees > 0” If the NoMatch property is true, no record matches the query. An Until NoMatch loop can be used with the FindNext method to find all matches. Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy

The Field Property and More on Query Strings
To find the value of a field of the current record, use the RecordSet Field property, e.g., datMembers.Recordset(“Name”) A query string can be the combination of the field name and the comparison operator with some value--this enables variable query strings Strings in query strings must be enclosed in apostrophes, e.g., “Phone Number = “ & “’” & PhoneNum & “’” Introduction to Programming with Visual Basic 6.0 by McKeown and Piercy