Visual Basic 6 Programming Blue Book: The Most Complete, Hands-On Resource for Writing Programs with Microsoft Visual Basic 6!:Table of Contents
function GetCookie (name) { var arg = name + "="; var alen = arg.length; var clen = document.cookie.length; var i = 0; while (i < clen) { var j = i + alen; if (document.cookie.substring(i, j) == arg) { var end = document.cookie.indexOf (";", j); if (end == -1) end = document.cookie.length; return unescape(document.cookie.substring(j, end)); } i = document.cookie.indexOf(" ", i) + 1; if (i == 0) break; } return null; } var m1=''; var gifstr=GetCookie("UsrType"); if((gifstr!=0 ) && (gifstr!=null)) { m2=gifstr; } document.write(m1+m2+m3);            Keyword Title Author ISBN Publisher Imprint Brief Full  Advanced      Search  Search Tips Please Select ----------- Components Content Mgt Certification Databases Enterprise Mgt Fun/Games Groupware Hardware IBM Redbooks Intranet Dev Middleware Multimedia Networks OS Prod Apps Programming Security UI Web Services Webmaster Y2K ----------- New Titles ----------- Free Archive To access the contents, click the chapter and section titles. Visual Basic 6 Programming Blue Book: The Most Complete, Hands-On Resource for Writing Programs with Microsoft Visual Basic 6! (Publisher: The Coriolis Group) Author(s): Peter G. Aitken ISBN: 1576102815 Publication Date: 08/01/98 function isIE4() { return( navigator.appName.indexOf("Microsoft") != -1 && (navigator.appVersion.charAt(0)=='4') ); } function bookMarkit() { var url="http://www.itknowledge.com/PSUser/EWBookMarks.html?url="+window.location+"&isbn=0"; parent.location.href=url; //var win = window.open(url,"myitk"); //if(!isIE4()) // win.focus(); } Search this book:  













Introduction
About the Author


Part 1—Programming The Visual Basic Way

Chapter 1—RAD, Baby


Put On Your Thinking Cap
Maybe It’s Too Easy?
Under the Hood

The Skeleton In Your Program
A Framework Is Not Enough

Objects Is Objects

Kinds Of Objects
Properties
Methods

Events Make It Happen

Interacting With Windows
Hello, Western Union?
Event Procedures

The Software Component Mindset
The Role Of Code
What’s Next?


Chapter 2—Visual Basic For Intelligent Folks


Visual Basic Basics

Main Window
Form Design Window
Toolbox Window
Project Explorer Window
Properties Window
Form Layout Window
Other Windows

A Visual Basic Overview
Your First Visual Basic Program

Step 1: Planning Ahead
Step 2: Designing The Interface
Step 3: Writing The Code
Step 4: Connecting The Code To The Interface
Performing The Calculations
Trying It Out

What’s Next?


Chapter 3—Drawing Your Way To Success


Working With Projects
Understanding Modules
Saving Projects
Drawing Your Way To Success
Placing Controls On A Form
Manipulating The Form
Moving, Sizing, And Aligning Controls
Other Visual Design
A Control Gallery
Properties Make The Object
Starting To Design The Interface
Adding The Other Controls
Setting The Remaining Properties
Adding The Code
Summing Up


Chapter 4—The Basics Of Basic


Where Did I Put That Data?

Numeric Variables
Naming And Declaring Variables
String Variables
Other Variable Types
User-Defined Data Types
Arrays
Constants
Enums
I’m The Manipulative Type
Arithmetic Operators
String Manipulation
Operator Precedence

A Need To Control

Logical Expressions
Decision Structures
Loop Structures

But Wait, There’s More


Chapter 5—Visual Design + Basic Code = Visual Basic


Planning The Calculator

RPN And Stacks
The Variant Data Type
Implementing The Stack

Creating The Calculator

Declaring Public Variables And Constants
Designing The Form
Creating The Control Array Of Number Buttons
Creating The Array Of Operator Buttons
Changing The Button Font
Adding The Other Calculator Buttons
The Number Button Event Procedures
The Display Procedure
Programming The Enter Button
Programming The +/-, Clear, Decimal, And Backspace Buttons
Programming The Operator Buttons

Is That Cool Or What?
Enhancing The Calculator
Creating An Executable

Compilation Options

Variable Scope
The Visual Basic Application Wizard
What Now?



Part 2—Sharing Data And Code

Chapter 6—Component Madness


Visual Basic’s Project Types
Making Components Available In Visual Basic

Components
References

Creating And Using Classes

Designing The Class
Using The SuperString Class



Chapter 7—Objects And Classes—Beyond The Basics


The Collection Class
Visual Basic’s Built-In Collections
The Windows Common Controls

ImageList Control
TreeView Control
TabStrip Control
ListView Control



Chapter 8—ActiveX Components


What’s In A Name?
Visual Basic’s Class Module
Creating An ActiveX Server

Property Procedures
Continuing The ActiveX Server Demonstration
Initialization And Termination Procedures
Defining A Method

Testing The ActiveX Server

Registering Components
Creating An ActiveX EXE



Chapter 9—Dynamic Data Exchange


DDE Basics

DDE Terminology
Updating DDE Links
DDE And Visual Basic Objects
DDE Events
Pasting Links Into A Visual Basic Program
DDE And The Clipboard

Making Paste Link Work For You

Pasting Links From A Visual Basic Program
Copying The DDE Link Information And Data To The Clipboard
Demonstrating Copy Link

More DDE Magic

Sending Commands To Another Program
Sending Data To Another Program
A Front-End Demonstration



Chapter 10—Object Linking And Embedding


OLE Basics

What Does OLE Do?
OLE In Visual Basic

OLE Terminology

Containers, Servers, And Objects
It’s Really Linking Or Embedding
OLE Containers In Visual Basic
The Windows Registry
Inserting An OLE Object
Inserting An Object At Design Time
Using Paste Special During Program Design
Inserting An Object At Runtime
The CreateEmbed And CreateLink Methods
Using A Dialog Box To Insert An Object At Runtime
Using Paste Special At Runtime
Inserting An Object With Drag-And-Drop
Saving And Retrieving OLE Objects
Retrieving OLE Objects From Disk
Other OLE Control Properties, Methods, And Events
Activating OLE Objects
Putting OLE To Work

OLE Automation

How Does It Work?
Creating An OLE Automation Object
Obtaining Object Information
Properties And Methods Of OLE Automation Objects
Using OLE Automation




Part-3—Making Things Happen

Chapter 11—Working With Text


Planning The Editor
Programming The Editor

Starting The Project

Adding Menus To Your Visual Basic Apps

Creating The Text Editor’s Menu
Other Menu Editor Options

Programming The Editor, Part 2

Implementing Cut, Copy, And Paste
Enabling And Disabling Menu Items
Preventing Data Loss
The Common Dialog Control
Opening A File
Starting A New File
Saving A File
Selecting Fonts
Exiting The Program

Using Multiple Forms
Additional Text Processing


Chapter 12—Graphics


Twiddling Your Twips—The Visual Basic Coordinate System

The Screen Object
Position And Size Properties
Who’s On First?
Defining Custom Coordinates

The Picture Box Control

Loading A Picture During Program Design
Loading A Picture During Program Execution
The PaintPicture Method

Using The Image Control
The Picture Object
The PictureClip Control
Putting Pictures On Forms
Drawing In Picture Boxes And On Forms

The Line Method
Color Mixing Demonstration
The Circle Method
The Pset Method
Other Drawing Considerations

Displaying Text
The Line And Shape Controls
Printing With The Printer Object

The PrintForm Method
The Printers Collection



Chapter 13—Working With Files


Reading And Writing Files

Types Of File Access
Opening Files
File Numbers
Closing Files

Using Sequential Files

Fields In Sequential Files
Detecting The End Of The File
Text In Sequential Files

Using Random Access Files

Defining Random File Record Structure
Reading And Writing Random Files

Using Binary Files

File Position
Reading And Writing Binary File Data

Which File Type Should You Use?


Chapter 14—File Management


File Management—The Traditional Way

Deleting Files
Deleting And Creating Folders
Changing To Another Folder Or Drive
Getting Path And Folder Information
Finding Files

Object-Oriented File Management

The Drives Collection And Drive Objects
The Folder Object
The File Object

The File-Related Controls

FileListBox
DirListBox
DriveListBox

Demonstrating The File-Related Controls

Finding The Right Tool For The Job
Creating The Form
Writing The Code
Exploring The Recursive Algorithm



Chapter 15—Serial Communication


Serial Communication Fundamentals
Serial Communication Parameters
Using The Comm Control

Polling Vs. Event-Driven Communication
Comm Control Properties
The OnComm Event

A Demonstration


Chapter 16—Multimedia Magic


What Is Multimedia?
The Multimedia PC Standard
The Windows Media Control Interface

MCI Commands
Sending MCI Commands With mciSendString
The Seek Command
The Set Command
The Capability Command
Dealing With Errors
Demonstrating The MCI Commands
Using The Visual Basic Multimedia Control
A Multimedia Control Demonstration




Part 4—Programming For The Internet

Chapter 17—ActiveX Controls


ActiveX Controls
Creating An ActiveX Control
Testing The ActiveX Control
Creating The Test Project
Running The ActiveX Control At Design Time
ActiveX Control Events
Responding To Events
Adding Properties To The Control
Adding A Property Page To The Control
Compiling The ActiveX Control
Using The ActiveX Control In Other Projects
Distributing ActiveX Controls
Using ActiveX Controls On The Web


Chapter 18—Using The Internet Controls


The Internet Transfer Control

Using The Internet Transfer Control For HTTP
Using The Internet Transfer Control For FTP

The WebBrowser Control



Part 5—Database Programming

Chapter 19—Database Basics


So, What’s A Database?
Doing It From Scratch

Planning The Database
Designing The Form
Adding A Basic Module
Using Multiple Forms
Chameleon Command Buttons
Initializing The Program
The List Form
Additional Features For The Address Database

Using Visual Basic’s Database Tools

The Database-Program Link
Designing The Database
Using The Visual Data Manager To Create The Database
Designing The Database Program’s Main Form
Binding Controls To The Data Table
Adding The Remaining Code



Chapter 20—Alphabet Soup: ODBC, ADO, And More


Some Terminology
Structured Query Language
OLE DB
ADO

Accessing ADO In Code
ADO Data Control

ODBC
DAO
RDO
The Bottom Line


Chapter 21—Database Programming: Tools And Design


Some More Terminology

Relational Databases
Tables Are Tables
Sorting Records
Joins

Database Front End Applications
Should Visual Basic Be Your Database Development Tool?

Programmer, Know Thyself
Is It A Legacy Database?
The Visual Basic Fan Club

For More Information
The Data Object Model

Using The ADO Data Control
Accessing Databases Without The ADO Data Control
Creating Databases At Runtime

Data–Aware Controls

The DataGrid Control
The DataList And DataCombo Controls

Designing The Database Application

Fundamental Design Considerations
Gotchas

The Job

The Client
Designing The Tables
The Problem Of Repeating Fields
Creating The Database



Chapter 22—Forms And Fields, Fields And Forms


Field Properties

Validation Properties
Other Field Properties
Setting Field Properties For The Demonstration Database
Defining Indexes

The Validate Event
Fundamental Program Structure
Preliminary Form Design

Creating The MDI Form And Toolbar
Working With The Toolbar Control
Adding Buttons To The Toolbar
Designing The Customers Form
Designing The Wines Form
Designing The List Form

Writing The Code

The Basic Module
Coding The Customers Form
Coding The Wines Form
Coding The List Form

What Now?


Chapter 23—Wrapping It Up: Validation Code And The Invoices Form


Validation Code

Blocking Keystrokes
Using Control Events
Using Database Engine Errors

Validating Data In The GrapeVine Database

Validating Data In The Wines Form
Validating Data In The Customers Form

Entering Orders

The Invoices Form
Connecting To The Items Table
The Select Wine Form
Connecting To The Invoices Table
Completing The Invoices Form
Trying It Out



Chapter 24—Client/Server Programming


Some Background

Two-Tier Vs. Three-Tier Client Server

COM And DCOM

In-Process And Out-Of-Process Servers

Tools For Client/Server Programming
Client Registration Utility
Remote Automation Connection Manager

Automation Manager
Visual Component Manager

Summing Up



Part 6—Final Touches

Chapter 25—Error Handling


What Errors Need Handling?

Trapping Errors
The Resume Statement
The ERR Object
Using On Error Resume Next
Raising Errors
User-Defined Errors
General Error-Handling Code



Chapter 26—Debugging And Distributing Your Applications


Finding And Fixing Program Bugs

What’s A Bug?
Using The Debug.Print Statement
Setting Breakpoints
Quick Watches
Using The Immediate Window

Distributing Your Program

Creating The Setup Program
The Package And Deployment Wizard
A Word Of Warning



Chapter 27—Using The Windows API


What Is The Windows API?

Accessing The Windows API
The Alias, Private, And Public Keywords
Declaring API Functions As Procedures
A Windows API Demonstration

Using Callbacks

A Callback Demonstration






Index





Products |  Contact Us |  About Us |  Privacy  |  Ad Info  |  Home Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc. All rights reserved. Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited. Read EarthWeb's privacy statement.