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

Advanced Object Oriented Programming with Visual FoxPro 6.0
Table of Contents


Section 1-Basic Concepts
Chapter 1: Basic Concepts
Chapter 2: How Things Are Done in Visual FoxPro
Chapter 3: What's Not So Obvious
Chapter 4: Using Shrink-Wrapped Classes
Chapter 5: OOP Standard Tools
Chapter 6: Good Habits
Chapter 7: Evaluating Risks and Benefits

Section 2-Advanced Object-Oriented Programming
Chapter 8: The Bigger Picture
Chapter 9: Three-Tiered Development
Chapter 10: Patterns
Chapter 11: Object Metrics

Section 3-Object Modeling
Chapter 12: The Unified Modeling Language
Chapter 13: Collecting Requirements
Chapter 14: Analyzing the Problem
Chapter 15: Object Modeling
Chapter 16: Implementation
Chapter 17: Documenting Existing Projects

SECTION 1-Basic Concepts

Chapter 1: Basic Concepts

Encapsulation
Classes
Properties
Methods
How to draw classes
Inheritance
Overwriting code
Programming by exception
What about multiple inheritance?
Base classes--a first look
How to draw subclassing
Polymorphism
Messages
Events
Events vs. event methods
Access and assign methods
Composition
Containers
Composition by reference
Abstraction
Building class hierarchies
Hiding information
Interfaces

Chapter 2: How Things Are Done in Visual FoxPro

Instantiating classes
Constructors and destructors
CreateObject()
NewObject()
.AddObject() and .NewObject()
Passing parameters to objects
SCATTER... NAME...
Object references
Object lifetime
THIS, THISFORM, THISFORMSET and Parent
Variable references
Property references
Cleaning up after yourself
Differences between classes and forms
Instantiating forms
DataEnvironment
Inheritance
Combining form classes and forms
Templates
Visual FoxPro base classes
NODEFAULT
Custom classes
Control classes
Adding properties on the fly
Should you, or shouldn't you?
Collections
FoxPro's collections
The collections you create yourself
Collections provided by others
Features you might miss in Visual FoxPro
Multiple inheritance revisited
Friendship relations
Static properties
Operator overloading
Copying objects

Chapter 3: What's Not So Obvious

Instance programming and pseudo-subclassing
Instance programming
Pseudo-subclassing
Visual vs. non-visual classes
Advantages ofnon-visual classes
Why not go the visual route?
Visual classes: Nintendo for adults?
Some classes are non-visual only
Creating your own set of base classes
Some suggestions

Chapter 4: Using Shrink-Wrapped Classes

Reuse what others create
What is available?
Black box objects
White box objects
COM components
Class libraries
Frameworks
Complimentary tools
The Fox Foundation Classes
Class overview
Application
Automation
Data editing
Data navigation
Data query
Data utilities
Date time
File utilities
Internet
Menus
Miscellaneous Buttons
Miscellaneous Formsv
Movers
Multimedia
Reporting
System utilities
Text formatting
User interface
Conclusion

Chapter 5: OOP Standard Tools

The Class Browser
Basic functionality
Opening libraries
Renaming items
Redefining classes
The class icon
Creating source code
Different ways to start the Class Browser
Customizing and extending the Class Browser
What's the deal with VCX file?
The VCX structure
How Visual FoxPro stores visual classes
Compiling a class library
Cleaning up class libraries
How to protect your source code in a VCX
The component Gallery
Basic functionality
Working with existing catalogs
Creating catalogs"
Conclusion

Chapter 6: Good Habits

Coding Standards
Object naming conventions
Class naming conventions
Variable naming conventions
Field naming conventions
Method naming conventions
Other conventions
Design standards
Class hierarchies
Documenting
Comment lines in source code
Description fields
Formal documentation

Chapter 7: Evaluating Risks and Benefits

Benefits
Faster development
Higher quality
Easier maintenance
Reduced cost
Increased scalability
Better information structures and complexity management
Increased adaptability
Better mapping to the problem domain
Concerns
Need for standards
Speed of execution
Availability of qualified personnel
Costs of conversion
Support for large-scale modularity
Learning curve

SECTION 2-Advanced Object-Oriented Programming

CHAPTER 8: The Bigger Picture

This isn't all about subclassing buttons, is it?
Creating behavioral objects
How everything comes together
Creating reusable objects
Reuse--a fairytale?
Application-internal reuse
Cross-application reuse
Reusing components that don't match your architecture
Conclusion

CHAPTER 9: Three-Tiered Development

A brief introduction
The model-view-controller approach
Better than sliced bread: sliced applications
Three tiered internally
Handling the data
Creating the interface
Invoking the business logic
Compiling one EXE
Displaying and manipulating data
Class and inheritance hierarchies
Exposed tiers
Conclusion

CHAPTER 10: Patterns

An overview
What exactly is an "object-oriented design pattern"?
Our first pattern
One common terminology
Some examples
Adaptor pattern
Observer pattern
Strategy pattern
Template method pattern
Conclusion

CHAPTER 11: Object Metrics

The importance of metrics
Automated measuring
Metrics based on code complexity
Number of lines of code
Metrics based on class hierarchies
Number of classes
Number of custom properties
Number of methods
Number of "Is-A" relations
Metrics based on objects
Number of instances
Number of times a class is reused
Number of dependencies
Conclusion

SECTION 3-Object Modeling

Chapter 12: The Unified Modeling Language

Introducing the Unified Modeling Language
Some modeling history
The ideas behind UML
UMLtools
UML notation
Packages and package diagrams
Use Case diagrams
Class diagrams
Interaction diagrams
Component diagrams
Deployment diagrams
Stereotypes
Conclusion

Chapter 13: Collecting Requirements

What we try to achieve
Collecting the requirements
Research for shrink-wrapped applications
Interviewing customers
Lay a good foundation
Hitting a moving target
Managing requirements
Requirement lists
RationalRequisitePro
Conclusion

Chapter 14: Analyzing the Problem

A Use Case-driven approach
What exactly is a use case?
Transition of a requirement to a use case
Use case tools
Microsoft Word
Rational Rose

Chapter 15: Object Modeling

Object Modeling - an overview
A picture is worth more than a thousand words
Object modeling tools
From use cases to objects
Identifying interface objects
Identifying the data services
Identifying the middle tier
Identifying methods and properties
Identifying common scenarios
Putting things together
You don't want three-tiered models?
Implementation details
Keeping things language independent
How Rose handles items
Reusing design

Chapter 16: Implementation

Creating Visual FoxPro code
The Code Generation Wizard
Importing your first model
Selecting model files more efficiently
Step 2's secret options
Resolving conflicts
Setting Visual FoxPro options in the model
Updating existing libraries
Filling in the blanks

Chapter 17: Documenting Existing Projects

Going back to the modeling tool
The Reverse Engineering Wizard
Creating diagrams
Updating existing models
Creating new models
Beyond basic modeling
A glimpse of the modeling future...