Help  |   Contact Us  |   About Us  |   News and Events
Books, conferences, and other information about... Moving to Linux Switching to OOo Building Linux Apps Using Visual FoxPro
Buy      Download      Your Account      Catalog      Support      Conferences      Resources      Fun

Fundamentals: Building Visual Studio Applications on a Visual FoxPro 6.0 Foundation
Table of Contents


Section I-The Interactive Use of Visual FoxPro
Chapter 1: Introduction to the Tool
Chapter 2: The Language
Chapter 3: The Interactive Data Engine
Chapter 4: Visual FoxPro's SQL Implementation

Section II-Tools Needed for Building an Application
Chapter 5: Creating Programs
Chapter 6: The VFP Project Manager
Chapter 7: Building Menus
Chapter 8: Building Forms
Chapter 9: Native Visual FoxPro Controls
Chapter 10: Using VFP's Object- Oriented Tools
Chapter 11: Output: The Report and Label Designers

Section III-Building Your First Application
Chapter 12: The Structure of a LAN Application
Chapter 13: Building a LAN Application
Chapter 14: Your First LAN Application:
Chapter 15: Your First LAN Application:

Section IV-The Development Environment
Chapter 16: Customizing Your Development Environment
Chapter 17: The Component Gallery
Chapter 18: Project Hooks
Chapter 19: Using the Debugger
Chapter 20: Builders
Chapter 21: The Coverage Profiler
Chapter 22: Using MSDN Help

Section V-Advanced Development Tools & Techniques
Chapter 23: Including ActiveX Controls in Your Application
Chapter 24: Extending VFP Through the Windows API
Chapter 25: Adding HTML Help to Your Applications
Chapter 26: Distributing Your Applications

Section VI-Visual Studio Topics
Chapter 27: Weird Question Time
Chapter 28: An Introduction to ADO
Chapter 29: Using Microsoft Transaction Server
Chapter 30: A Visual Basic Primer for Visual FoxPro Developers

SECTION I-The Interactive Use of Visual FoxPro

Chapter 1: Introduction to the Tool

Today's computing environment
Installing and starting Visual FoxPro
The Visual FoxPro interface
The Command window
Windows, menus, and toolbars
Controls
Conclusion

Chapter 2: The Language

Working with Visual FoxPro interactively
Using the Command window
The Command window context menu
Building commands, functions, and expressions
Commands
Variables
Operators
Functions
Expressions
A Visual FoxPro command and function overview
Arrays
Client/Server
Colors
Data - Database
Data - Editing
Data - Fields
Data - Indexes
Data - Locking
Data - Memo Fields
Data - Navigation
Data - SQL commands
Data - Structure
Data - Tables
DateTime
DDE
Debugging
Environment - General
Environment - Disk
Environment - Keyboard
Environment - Monitor
Environment - Network
Error handling
File name manipulations
File information
File selection
File and directory writing
Fonts
Help
Interrupts (Mouse, Keyboard, Other)
International
Low-level file functions
Macros
Math
Math - Financial
Math - Numeric
Math - Statistical
Math - Trig and Exponential
Memory
Miscellaneous
OOP
OOP - Control-specific
Printing
Programming - Comments
Program control structures
Program event handling
Program subroutines
Program variable scoping
Project manager
String functions
Text merge
User interface
Variables
VFP
Visual Studio
Windows/menus
Obsolete commands and functions

Chapter 3: The Interactive Data Engine

The relational model
Visual FoxPro's data structures
Tables
Fields
Nulls
Indexes
Original table
Index file (for order by Birth Date)
Table displayed according to Birth Date index
Index file
Table displayed according to Sex/Name tag
Indexes and Rushmore
Databases
.MEM files
Other FoxPro files
Working with data structures
Manipulating tables
Accessing an existing table
Exclusive vs. Shared use
Accessing multiple tables
Closing a table
Viewing the contents of a table
Specifying the order of records in a table
Creating indexes
Creating a table and modifying the structure of an existing table
Setting a filter
Manipulating databases
Accessing an existing database
Accessing multiple databases
Viewing the contents of a database
Using the Database Designer
Working with persistent relationships
Working with table structures programmatically
Modifying tables and databases programmatically
Working with data
Navigating through tables and finding specific data
SKIP
BOF(), EOF() and the Phantom Record
GO
SEEK
RUSHMORE-revisited
LOCATE
Modifying data
Adding records interactively
Adding records programmatically
Adding a batch of records from another source
Deleting records interactively
Deleting records programmatically
Handling deleted records: recalling and packing
Editing records interactively
Editing records programmatically
How do I save the data?

Chapter 4: Visual FoxPro's SQL Implementation

SELECT
Sample databases
Basic SELECT syntax
Field lists
Record subsets
Aggregate functions
Subtotaling-GROUP BY
Multi-Table SELECTs
Outer joins
Controlling the result set: destination
Controlling the result set: ORDER BY
Controlling the result set: DISTINCT
Controlling the result set: HAVING
INSERT
DELETE
UPDATE

SECTION II-Tools Needed for Building an Application

Chapter 5: Creating Programs

Creating a program with the editor
Running a program
Compiling a program
Up close with the VFP editor
Configuring Visual FoxPro program execution preferences

Chapter 6: The VFP Project Manager

Using the VFP Project Manager to build an .APP or .EXE
Up close with the Project Manager
The Project Manager dialog
The Project Manager context menu
The Project menu
Tips and tricks

Chapter 7: Building Menus

Driving an application with a menu
Using the Menu Designer to create a menu
Up close with the Menu Designer
The Menu Designer dialog
The Menu menu
The View menu
The Menu-generation process
Tips and tricks
Adding flexibility to the Visual FoxPro Menu Designer
Creating context menus
So why isn't the Menu Designer OOP-ified?

Chapter 8: Building Forms

The big picture
Terminology and tools
Creating and running a form
Changing form properties through user input
Calling methods from objects on the form
Integrating forms and data
Up close with the Form Designer
Form Designer
Properties window
Code window
Form Designer toolbar
Form Controls toolbar
Layout toolbar
Menus
Tab order
Include files
Referencing objects
Referencing objects by their full names
Referencing objects by their container
Indirect object references
Tips and tricks
Referencing generic objects
Names and captions
Code windows
Layout

Chapter 9: Native Visual FoxPro Controls

The proper care and feeding of controls
Focus and containers
Common properties
Common events
Event firing
Visual delineators
Label control
Image control
Line control
Shape control
Page Frame control
Separator control
Controls to initiate action
Command Button control
Command Button Group control
Timer control
Hyperlink control
Controls to manipulate data
Text Box control
Edit Box control
Check Box control
Option Group control
List Box and Combo Box controls
Uses of lists and combos
Populating a list or combo box
List Box functionality
Combo box functionality
Defining and returning values from a list box
Spinner control
Grid control
Other controls
Container
ActiveX control and ActiveX bound control
Custom class
Session class

Chapter 10: Using VFP's Object- Oriented Tools

A quick introduction to object-oriented programming
The original form and control objects
Inheriting from the original
Creating your own originals
OOP terminology
Inheritance and overriding methods
Non-visual classes
Where OOP fits in with Visual FoxPro
Quick start to creating classes
Form classes
Creating your own form base class
Using your own form base class
Creating a form from a Form Class template
Using a different form base class "on the fly"
Creating form subclasses
Registering a form class with Visual FoxPro
Attaching a custom icon to a registered class
Modifying a form class
Control classes
Creating your own control base class
Creating control subclasses from your base class
Registering your controls base class
Placing controls on a form from your base class or a subclass
Use the Project Manager
Select the class from the Form Control toolbar
Control and container classes
Working with Visual FoxPro's object orientation
Naming classes
Adding your own properties and methods
The property and method hierarchy
Overriding property inheritance
Overriding method inheritance
Preventing a parent's method from firing
Preventing an event from firing
Calling a parent's method in addition to the local method
Suggested base class modifications
Up close with the Class Designer
Up close with the Class Browser
Starting the Class Browser
Using the Class Browser

Chapter 11: Output: The Report and Label Designers

Quick start to building reports
Report terminology
   To-may-to or tuh-mah-to?
   Dumbing down the Report Writer
   How about an example?
Up close with the Report Designer
   The Report Designer window
    Select a control
    Select a group of controls
    Move a control within a report
    Move a control from one report to another
    Duplicate a control
    Resize a control
    Delete a control
    Change the font or other attributes of a control
    Resize a band
  The Report Controls toolbar
    Change the text of a label
    Change the internal properties of a control
    Create a control
    The Layout Controls toolbar
  The Color Palette toolbar
  The Report menu
  The View menu
Up close with the Label Designer
  The Label Designer window
Tips and tricks
Is that all there is?

SECTION III-Building Your First Application

Chapter 12: The Structure of a LAN Application

Defining the application
Deciding on a menu style
Function-centric menu styles
CUA menu styles
Document-centric menu styles
A pseudo-object-oriented menu style
The Books and Software Inventory Control Application menu structure
Forms menu
Edit menu
Processes menu
Reports menu
Tools menu
Window menu
Help menu
Running a menu
Building a main program and an event handler to hold up the menu
Enhancing the main program
Starting the move to OOP
A quick review of non-visual classes
Creating a non-visual class
Implementing a non-visual class
Making setting up and cleaning up more automatic
Enhancing the non-visual class
Creating an application-level non-visual class

Chapter 13: Building a LAN Application

More on the sample application
Types of forms
Setting the stage: creating your class libraries
Creating HWCTRL.VCX, your control class library
Create your controls class library
Register the library
Creating your form classes
Create your form base class
Create your maintenance form class
Set the form template class
Creating a real form from your base class
Create the ORDERS maintenance form
What's happening behind the scenes
Inheritance at work!
Thinking about more application modifications

Chapter 14: Your First LAN Application:

Building Upon Your Forms
Enhancing your form class with toolbars and menus
Putting it all into a project
Creating a form with its own methods
Creating a new form based on the new form class
Adding a toolbar
Creating new control classes in HWCTRL
Creating your base toolbar class
Getting your toolbar to work with the app
Consolidating code in a generic method
Getting rid of the command buttons
Creating an instance handler
Getting the toolbar to dock automatically
Adding the form name to the Window menu
Enhancing your form class with generic methods
An introduction to MessageBox() and #INCLUDE
Toolbar positions
MessageBox parameters
MsgBox return values
Cursor buffering modes
Data handling-buffering and multi-user issues
A simple error handler
Causing a conflict-pessimistic row buffering
Optimistic row buffering
A generic Save() method
A generic Add() method
A generic Delete() method
Adding hooks to generic methods

Chapter 15: Your First LAN Application:

Odds and Ends
Adding more functionality to your customer form
The Sort Order combo box
Populating the combo box in the toolbar
Changing the order of the records
Concepts for child forms
Passing parameters to a form
Returning values from a form
Passing object references
Adding a list box to display child records
Populating a childbearing list box
Adding children
Editing an existing child record
Deleting an existing child record
Odds and ends
Checking for _screen.activeform
Dimming the Record menu pad
Setting tab order on a form
Creating OLIB (ridding MYPROC.APP)
Field mapping
Restoring the toolbar
Choosing between data sets
Developer-only controls

SECTION IV-The Development Environment

Chapter 16: Customizing Your Development Environment

Machine setup and installation
Startup configuration
Default directory
Startup files
The Windows Registry
CONFIG.FPW
FoxUser.DBF
DEFAULT.FKY
FoxPro.INI
How to use the startup files
Default Directory
Menu Builder
Resource File
Search Path
Startup Program
A word about the help file
Startup switches
Developer vs. user requirements
Configuring development application directory structures
A little bit of history, or "how we got here"
Developer environment requirements
Drive divisions
Root directory contents
Application directory contents
Build directory contents
Developer utilities
My own stuff
WW
Array Browser
DevHelp
OpenAll
Z
HackCX
NIHBSM (Not Invented Here But Still Marvelous)
.CHM files
SoftServ's Command Window Emulator
Eraser
Third-party applications
CodeMine
DBI Technologies ActiveX controls
FoxAudit
Foxfire!
HTML Help Builder
INTL
Mail Manager
Mere Mortals Framework
QBF Builder
Stonefield Database Toolkit
Stonefield Query
Stonefield Reports
Visual FoxExpress
Visual MaxFrame Professional
Visual Web Builder
West Wind Web Connection
xCase

Chapter 17: The Component Gallery

A quick tour around the Component Gallery
Loading the Component Gallery
What are catalogs?
What's in a catalog?
Catalogs vs. folders
The contents of the default catalogs
Catalogs node
Favorites node
ActiveX Catalog node
My Base Classes node
Visual FoxPro Catalog node
Others
Where is the Component Gallery data stored?
Catalog data
Global settings
How to configure the Component Gallery so data isn't on C
Arranging components
Navigating around
Displaying existing catalogs that don't appear by default
Creating a new catalog
Adding a new folder to a catalog
Adding your own components
Making a copy of a component in your own catalog
Views: Finding things in catalogs
Using a component in your project
Summary

Chapter 18: Project Hooks

Accessing the project object
Application object
Projects collection
Project object
Files collection
File object
Servers collection
Server object
What next?
Project tools
Project hooks
Available functions that can be intercepted
At the beginning of the build process
After the build process is finished
When a file is added to the Project Manager
When a file is modified in the Project Manager
When a file is removed from the Project Manager
When a file is executed from the Project Manager
When a file is dragged over or dropped on the TreeView
control in the Project Manager
Enabling a project hook
Enabling a project hook for a specific project
Enabling a global project hook
Getting in and around a ProjectHook setting
Project hook examples

Chapter 19: Using the Debugger

Configuring the Debugger
Choosing a debugging frame
Configuring windows
Common settings
Settings for Call Stack window
Settings for Output window
Settings for Watch window
Settings for Locals window
Settings for Trace window
Other options
The five Debugger windows
Trace window
Watch window
Locals window
Call Stack window
Debug Output window
Debugger toolbar
Debug Frame menu
Event tracking
Using the Event Tracker
Going about the debugging process
Types of misbehavior
Defects in the product
Compile-time errors
Run-time errors
Logic errors
User-generated errors
Debugging covers developer-generated errors
The debugging mindset
A final word

Chapter 20: Builders

The Visual FoxPro Builder technology
Setting up your own builder in BUILDER.DBF
Setting up your own builder in a BUILDER property
Creating a user interface for a builder
Data-driving your builder-building process: BUILDERD

Chapter 21: The Coverage Profiler

Quick start with the Coverage Profiler
Basic configuration
Basic reports
Getting the Coverage Profiler to process a log file
Source List and Source Code panes
The Coverage Profiler toolbar
The Coverage Profiler context (shortcut) menu
Coverage Profiler options
Coverage mode vs. Profile mode
Zoom mode vs. Preview mode
Statistics
Find
Open
Save
Customizing the Coverage Profiler with Add-Ins

Chapter 22: Using MSDN Help

The MSDN Library
Installation
Opening MSDN Help
Features of MSDN Help
The Contents tab
The Index tab
The Search tab
The Favorites tab
The MSDN Library menu bar
Help on the Web
MSDN
The Microsoft Knowledge Base

SECTION V-Advanced Development Tools & Techniques

Chapter 23: Including ActiveX Controls in Your Application

What is an ActiveX control?
Where-and how-do I get them?
In the box
More? You want more?
Installing ActiveX controls in Windows
Manually installing ActiveX controls in Windows
How do I put them into my development environment?
How do I use them in an application?
How do I ship them with an application?
What if it doesn't work?
DLL hell

Chapter 24: Extending VFP Through the Windows API

What is the Windows API?
What do functions look like in the Windows API?
Using the API Viewer
How do I access a WinAPI function?
Once I've called it, how do I use it?
Structures
Pointers as return values
Conclusion

Chapter 25: Adding HTML Help to Your Applications

What is HTML Help?
Index and Search tabs
Creating an HTML Help file using HTML Help Workshop
Where is HTML Help Workshop?
Before you create your Help project
Creating your HTML Help project
Create levels for your help file
Add topics underneath a section heading
Setting .CHM file options and building the .CHM file
Add index and search capability
Including a .CHM file with your VFP application
Calling a .CHM file from your VFP application
Creating and calling context-sensitive help topics
Distributing HTML Help and your .CHM file with your VFP application

Chapter 26: Distributing Your Applications

With the VFP Setup Wizard
What does the Setup Wizard do?
Are you running SP?
Preparing your application
Running the wizard
Step 1: Locate files
Step 2: Specify components
Step 3: Create disk image directory
Step 4: Specify setup options
Step 5: Specify default destination
Step 6: Change file settings v Step 7: Finish
Stats of the build
Where are the results?

SECTION VI-Visual Studio Topics

Chapter 27: Weird Question Time

Should I or shouldn't I?
Where does VFP fit?
What is a type library?
What is a GUID?
What's the difference between early and late binding?
What is Visual InterDev?
What's a ProgID?
What does reentrant mean?
What's the difference between "in-process servers" and "out-of-process servers"?
Where do I go next?

Chapter 28: An Introduction to ADO

A (very brief and very rough) history of the Microsoft data access strategy
OLE DB (and ADO)
What is ADO?
Where do I find ADO on my computer?
What are the previous versions of ADO?
Getting started with ADO
Bare-bones steps for accessing data through ADO
The ADO object model
The Connection object
The Recordset object
The Fields collection
The Command object
The Parameters collection
The Errors collection
ADO errors
Dealing with constants
So should you use ADO?

Chapter 29: Using Microsoft Transaction Server

With Visual FoxPro
What is MTS and where does it come from?
Installing and accessing MTS
Creating a package
More information

Chapter 30: A Visual Basic Primer for Visual FoxPro Developers

The Visual Basic IDE
MDI versus SDI
What are all these windows?
Your first VB form
Adding code to a form
The VB Code window
Saving and printing projects
Project components and files
The basics of writing code
The Properties window, property pages, and toolbars
VB's version of containership
Slinging code
Procedures vs. functions
Option Explicit
Adding your own methods to forms and applications
A command and function summary
The Immediate window
Variables
Operators
Booleans (logicals)
Dates
Times
Variants
Constants
Static variables
Arrays
Functions
Data conversion
Number handling
Data manipulation
Machine and environment
Date and time
String manipulation
Math functions
Special functions
Commands
Logic structures
File handling
Program control
File system
Variables
Registry
Classes
N.E.C. (Not Elsewhere Classified)
Creating the user interface: VB forms and controls
Creating a form and dropping a control on it
VB's intrinsic controls
More controls
Incorporating data access into your VB app
A brief history of data access in Visual Basic
DAO, ADO, , Hike!
What is ADO?
Connections
Setting up a form with an ADO Data Control
Connecting controls to an ADO recordset
Revisiting the recordset idea
Real-world usage of ADO in VB
Populating a combo box and a list box
Using form-level methods
Filling the combo box
Filling the list box
Populating a grid
Setting up the data control
Adding controls to your toolbox
Setting up the DataGrid control
A quick ADO command reference
Properties
Methods
What's this business about Visual Basic classes