C++Builder Developer's Guide

Go Up to Win32 Developer's Guide Index

The C++Builder Developer's Guide contains information for both Delphi and C++.

Tip: To select the language you want to see, click the Display Preferences control, located in the upper right corner of the page. To see C++ information only, enable the C++ checkbox and disable the Delphi checkbox, as shown here:

Part I: Programming with C++Builder

Developing Applications with C++Builder

• Integrated Development Environment
• Designing Applications
• Creating Projects
• Editing Code
• Compiling Applications
• Debugging Applications
• Deploying Applications

Understanding the Component Library

• Understanding the Component Library
  • Properties, Methods, and Events
    • Types of Events
• Objects, Components, and Controls
  • TObject Branch
  • TPersistent Branch
  • TComponent Branch
  • TControl Branch
  • TWinControl Branch

Using the RTL Index

• Using the RTL (Run-Time Library)
• Using Streams
  • Using Streams to Read or Write Data
  • Copying Data Between Streams
  • Specifying the Stream Position and Size
• Working with Files
  • Approaches to File I/O
  • Using File Streams
  • Manipulating Files
    • Deleting a File
    • Finding a File
    • Renaming a File
    • File Date-time Routines
    • Copying a File
  • Working with ini Files and the System Registry
    • Using TRegistry
    • Using TRegistryIniFile
    • Using TIniFile and TMemIniFile
• Working with Lists
  • Common List Operations
  • Persistent Lists
• Working with String Lists
  • Loading and Saving String Lists
  • Creating a New String List
  • Manipulating Strings in a List
    • Counting the Strings in a List
    • Accessing a Particular String
    • Locating Items in a String List
    • Adding a String to a List
    • Deleting a String from a List
    • Associating Objects with a String List
    • Copying a Complete String List
• Working with Strings
  • Wide Character Routines
  • Commonly Used Routines for AnsiStrings
  • Commonly Used Routines for Null-terminated Strings
  • Declaring and Initializing Strings
  • Mixing and Converting String Types
  • String to PChar Conversions
    • String Dependencies
    • Returning a PChar Local Variable
    • Passing a Local Variable as a PChar
  • Compiler Directives for Strings
• Creating Drawing Spaces
• Colors in VCL
• Printing
• Converting Measurements
  • Performing Conversions
  • Adding New Measurement Types
  • Creating a Simple Conversion Family and Adding Units
  • Using a Conversion Function
  • Using a Class to Manage Conversions
• Defining Custom Variants
  • Defining Custom Variant Types
  • Storing a Custom Variant Type's Data
  • Creating a Class to Enable the Custom Variant Type
    • Enabling Casting
    • Implementing Binary Operations
    • Implementing Comparison Operations
    • Implementing Unary Operations
  • Copying and Clearing Custom Variants
    • Loading and Saving Custom Variant Values
    • Using the TCustomVariantType Descendant
  • Writing Utilities to Work with a Custom Variant Type
  • Supporting Properties and Methods in Custom Variants
• Using the Floating-Point Rounding Routines
  • Floating-Point Rounding Issues

Working with Components Index

• Setting Component Properties
  • Setting Properties at Design Time
    • Using Property Editors
  • Setting Properties at Runtime
• Calling Methods
• Working with Events and Event Handlers
  • Generating a New Event Handler
  • Generating a Handler for a Component's Default Event
  • Locating Event Handlers
  • Associating an Event with an Existing Event Handler
    • Using the Sender Parameter
    • Displaying and Coding Shared Events
  • Associating Menu Events with Event Handlers
  • Deleting Event Handlers
• Adding Custom Components to the Tool Palette

Working with Controls Index

• Implementing Drag and Drop in Controls
  • Starting a Drag Operation
  • Accepting Dragged Items
  • Dropping Items
  • Ending a Drag Operation
  • Customizing Drag and Drop with a Drag Object
  • Changing the Drag Mouse Pointer
• Implementing Drag and Dock in Controls
  • Making a Windowed Control a Docking Site
  • Making a Control a Dockable Child
  • Controlling How Child Controls Are Docked
  • Controlling How Child Controls Are Undocked
  • Controlling How Child Controls Respond to Drag-and-dock Operations
• Working with Text in Controls
  • Setting Text Alignment
  • Adding Scroll Bars at Run-Time
  • Adding the Clipboard Object
  • Selecting Text
  • Selecting All Text
  • Cutting, Copying, and Pasting Text
  • Deleting Selected Text
  • Disabling Menu Items
  • Providing a Pop-up Menu
  • Handling the OnPopup Event
• Adding Graphics to Controls
  • Indicating That a Control Is Owner-drawn
  • Adding Graphical Objects to a String List
    • Adding Images to an Application
    • Adding Images to a String List
    • Drawing Owner-drawn Items
  • Sizing Owner-draw Items
  • Drawing Owner-draw Items
• Screen Scaling and ChangeScale

Building Applications, Components, and Libraries Index

• Creating Applications
  • GUI Applications
    • User Interface Models
    • SDI Applications
    • MDI Applications
    • Setting IDE, Project, and Compiler Options
  • Console Applications
  • Service Applications
    • Service Threads
    • Service Name Properties
    • Debugging Service Applications
  • Programming Templates
• Creating Packages and DLLs
  • When to Use Packages and DLLs
  • Using DLLs in RAD Studio (C++)
  • Creating DLLs in C++Builder
  • Creating DLLs Containing VCL Components (C++)
  • Linking DLLs (C++)
• Writing Database Applications
  • Distributing Database Applications
• Creating Web Server Applications
  • Creating Web Services Applications
  • Creating WebSnap Applications
  • Creating Web Broker Applications
• Writing Applications Using COM
• Using Data Modules
  • Creating and Editing Standard Data Modules
    • Naming a Data Module and Its Unit File
    • Placing and Naming Components
    • Using Component Properties and Events in a Data Module
    • ClassGroup pseudo-property of TDataModule
    • Creating Business Rules in a Data Module
  • Accessing a Data Module from a Form
  • Adding a Remote Data Module to an Application Server Project
• Using the Object Repository
  • Sharing Items Within a Project
  • Adding Items to the Object Repository
  • Sharing Objects in a Team Environment
  • Using an Object Repository Item in a Project
  • Using Project Templates
  • Modifying Shared Items
• Enabling Help in Applications
  • Calling HTML Help from Applications
    • Types of HTML Help
    • Default Handling of F1 Help in VCL Applications
    • Customizing F1 Help in VCL Applications
    • Showing Help with Help Buttons
    • Associating Help with Menu Commands
    • Showing Help About Selected Menu Commands
    • Using the Hint Property to Show Contextual Help About Screen Objects
  • Help System Interfaces
    • Implementing ICustomHelpViewer
    • Communicating with the Help Manager
    • Asking the Help Manager for Information
    • Displaying Keyword-based Help
    • Displaying Tables of Contents
    • Implementing IExtendedHelpViewer
    • Using IHelpSystem
    • Implementing IHelpSelector
    • Registering Help System Objects
  • Using Help in a VCL Application
    • How TApplication Processes VCL Help
    • How VCL Controls Process Help
    • Calling a Help System Directly

Developing the Application User Interface Index

• Developing the Application User Interface - Overview
• Controlling Application Behavior
  • Working at the Application Level
  • Handling the Screen
• Using the Main Form
  • Hiding the Main Form
  • Adding Forms
  • Managing Layout
• Using Forms
  • Controlling When Forms Reside in Memory
    • Displaying an Auto-created Form
    • Creating Forms Dynamically
    • Creating Modeless Forms Such as Windows
    • Creating a Form Instance Using a Local Variable
  • Passing Additional Arguments to Forms
  • Retrieving Data from Forms
    • Retrieving Data from Modal Forms
    • Retrieving Data from Modeless Forms
• Reusing Components and Groups of Components
• Creating and Using Component Templates
• Working with Frames
  • Creating Frames
  • Using and Modifying Frames
  • Sharing Frames
• Developing Dialog Boxes
  • Using Windows Common Dialog Boxes
• Organizing Actions for Toolbars and Menus
  • What Is an Action
  • Setting Up Action Bands
  • Creating Toolbars and Menus
    • Adding Color, Patterns, or Pictures to Menus, Buttons, and Toolbars
    • Adding Icons to Menus and Toolbars
    • Selecting Menu and Toolbar Styles
    • Creating Dynamic Menus
    • Creating Customizable Toolbars and Menus
    • Hiding Unused Items and Categories in Action Bands
    • Creating Most Recently Used Lists
• Using Action Lists
  • Setting Up Action Lists
  • What Happens When an Action Fires
    • How Actions Find Their Targets
  • Updating Actions
  • Predefined Action Classes
  • Writing Action Components
  • Registering Actions
• Creating and Managing Menus
  • Opening the Menu Designer
  • Building Menus
    • Naming Menus
    • Naming the Menu Items
    • Adding, Inserting, and Deleting Menu Items
    • Adding Separator Bars
    • Specifying Accelerator Keys and Keyboard Shortcuts
  • Creating Submenus
    • Moving Menu Items
    • Adding Images to Menu Items
    • Viewing the Menu
  • Editing Menu Items in the Object Inspector
  • Using the Menu Designer Context Menu
    • Switching Between Menus at Design Time
  • Using Menu Templates
  • Saving a Menu as a Template
    • Naming Conventions for Template Menu Items and Event Handlers
  • Manipulating Menu Items at Runtime
  • Merging Menus
    • Specifying the Active Menu: Menu Property
    • Determining the Order of Merged Menu Items: GroupIndex Property
  • Importing Resource Files
• Designing Toolbars and Cool Bars
  • Adding a Toolbar Using a Panel Component
    • Adding a Speed Button to a Panel
    • Assigning a Speed Button's Glyph
    • Setting the Initial Condition of a Speed Button
    • Creating a Group of Speed Buttons
    • Allowing Toggle Buttons
  • Adding a Toolbar Using the Toolbar Component
    • Adding a Tool Button
    • Assigning Images to Tool Buttons
    • Setting Tool Button Appearance and Initial Conditions
    • Creating Groups of Tool Buttons
    • Allowing Toggled Tool Buttons
  • Adding a Cool Bar Component
    • Setting the Appearance of the Cool Bar
  • Responding to Clicks
    • Assigning a Menu to a Tool Button
  • Adding Hidden Toolbars
  • Hiding and Showing Toolbars
  • Demo Programs, Actions, Action Lists, Menus, and Toolbars
• Common Controls and XP Themes

Types of Controls Index

• Text Controls
  • Edit Controls
    • Memo and Rich Edit Controls
  • Text Viewing Controls
  • Labels
• Specialized Input Controls
  • Scroll Bars
  • Track Bars
  • Up-down Controls
  • Hot Key Controls
  • Splitter Controls
• Buttons and Similar Controls
  • Button Controls
  • Bitmap Buttons
  • Speed Buttons
  • Check Boxes
  • Radio Buttons
  • Toolbar Controls
  • Cool Bars
• List Controls
  • List Boxes and Check-list Boxes
  • Combo Boxes
  • Tree Views
  • List Views
• Grouping Controls
  • Group Boxes and Radio Groups
  • Panels
  • Scroll Boxes
  • Tab Controls
  • Page Controls
  • Header Controls
• Display Controls
  • Status Bars
  • Progress Bars
  • Help and Hint Properties
• Grids
  • Draw Grids
  • String Grids
• Value List Editors
• Graphic Controls
  • Images
  • Shapes
  • Bevels
  • Paint Boxes
  • Animation Control

Working with Graphics and Multimedia Index

• Working with Graphics and Multimedia - Overview
• Overview of Graphics Programming
  • Refreshing the Screen
  • Types of Graphic Objects
  • Common Properties and Methods of Canvas
  • Using the Properties of the Canvas Object
    • Using Pens
      • Changing the Pen Color
      • Changing the Pen Width
      • Changing the Pen Style
      • Changing the Pen Mode
      • Getting the Pen Position
    • Using Brushes
      • Changing the Brush Color
      • Changing the Brush Style
      • Setting the Brush Bitmap Property
    • Reading and Setting Pixels
  • Using Canvas Methods to Draw Graphic Objects
    • Drawing Lines and Polylines
      • Drawing Lines
      • Drawing Polylines
    • Drawing Shapes
      • Drawing Rectangles and Ellipses
      • Drawing Rounded Rectangles
      • Drawing Polygons
  • Handling Multiple Drawing Objects in Your Application
    • Keeping Track of Which Drawing Tool to Use
    • Changing the Tool with Speed Buttons
    • Using Drawing Tools
      • Drawing Shapes (Code)
      • Sharing Code Among Event Handlers
  • Drawing On a Graphic
    • Making Scrollable Graphics
    • Adding an Image Control
      • Placing the Control
      • Setting the Initial Bitmap Size
      • Drawing On the Bitmap
  • Loading and Saving Graphics Files
    • Loading a Picture from a File
    • Saving a Picture to a File
    • Replacing the Picture
  • Using the Clipboard with Graphics
    • Copying Graphics to the Clipboard
    • Cutting Graphics to the Clipboard
    • Pasting Graphics from the Clipboard
  • Rubber Banding Example
    • Responding to the Mouse
      • What's in a Mouse Event
      • Responding to a Mouse-down Action
      • Responding to a Mouse-up Action
      • Responding to a Mouse Move
    • Adding a Field to a Form Object to Track Mouse Actions
    • Refining Line Drawing
      • Tracking the Origin Point
      • Tracking Movement
• Working with Multimedia
  • Adding Silent Video Clips to an Application
    • Example of Adding Silent Video Clips
  • Adding Audio or Video Clips to an Application
    • Example of Adding Audio or Video Clips (VCL Only)

Writing Multithreaded Applications Index

• Writing Multi-threaded Applications
• Defining thread objects
  • Defining Thread Objects
  • Initializing the Thread
  • Writing the Thread Function
    • Using the Main VCL Thread
    • Using Thread-local Variables
    • Checking for Termination by Other Threads
    • Handling Exceptions in the Thread Function
  • Writing Clean-up Code
• Coordinating threads
  • Coordinating Threads
  • Avoiding Simultaneous Access
    • Locking Objects
    • Using Critical Sections
    • Using the Multi-read Exclusive-write Synchronizer
    • Other Techniques for Sharing Memory
  • Waiting for Other Threads
    • Waiting for a Thread to Finish Executing
    • Waiting for a Task to Be Completed
• Executing thread objects
  • Executing Thread Objects
  • Overriding the Default Priority
  • Starting and Stopping Threads
• Debugging Multi-threaded Applications
  • Naming a Thread
    • Converting an Unnamed Thread to a Named Thread
    • Assigning Separate Names to Similar Threads

Exception Handling in C++Builder

• Standard C++ Exception Handling
  • Standard C++ Exception Handling Syntax
  • Rethrowing Exceptions (C++)
  • Exception Specifications (C++)
  • Unwinding Exceptions (C++)
  • Constructors in Exception Handling (C++)
  • Handling Uncaught and Unexpected Exceptions (C++)
  • Leaking C++ Exceptions into Delphi RTL
• Structured Exceptions Under Win32 (C++)
  • Syntax of Structured Exceptions (C++)
  • Handling Structured Exceptions (C++)
  • Filtering Structured Exceptions (C++)
  • Mixing Standard Exceptions with Structured Exceptions (C++)
  • Defining Structured Exceptions (C++)
  • Raising Structured Exceptions (C++)
  • SEH Termination Blocks (C++)
• VCL Exception Handling in C++
• C++Builder Exception Handling Compiler Options
• External Exception EEFFACE

Language Support for the VCL (C++)

• C++ and Object Pascal Object Models
  • Inheritance and Interfaces
  • Object Identity and Instantiation
  • Object Construction for C++Builder VCL
  • Calling Virtual Methods in Base Class Constructors
  • Object Destruction
  • AfterConstruction and BeforeConstruction
  • Class Virtual Functions
• Support for Object Pascal Data Types and Language Concepts
  • Typedefs
  • C++ Classes that Support the Object Pascal Language
  • C++ Language Counterparts to the Object Pascal Language
  • Open Arrays
  • Types Defined Differently
  • Delphi to C++ types mapping
  • Delphi Interfaces
  • Resource Strings
  • Default Parameters
  • Run-time Type Information
  • Unmapped Types
  • C++ Keyword Extensions
  • The __declspec Keyword Extension

Working with Packages and Components Index

• Working with Packages and Components - Overview
• Why Use Packages
  • Packages and Standard DLLs
• Runtime Packages
  • Loading Packages in an Application
    • Loading Packages with the LoadPackage Function
  • Deciding Which Runtime Packages to Use
  • Custom Packages
• Design-time Packages
  • Installing Component Packages
• Creating and Editing Packages
  • Creating a Package
  • Editing an Existing Package
  • Understanding the Structure of a Package
  • Editing Package Source Files Manually
  • Compiling Packages
    • Package-specific Compiler Directives
    • Using the Weak Packaging Directive
    • Compiling and Linking from the Command Line
    • Package Files Created by Compiling
    • Building Static Packages
• Deploying Packages

Creating International Applications Index

• Internationalization and Localization
  • Internationalizing Applications
    • Enabling Application Code to Work for Different Locales
      • Character Sets
      • Including Bi-directional Functionality in Applications
      • Locale-specific Features
  • Localizing Applications
    • Localization Considerations in UI Design
      • Text
      • Graphic Images
      • Formats and Sort Order
      • Keyboard Mappings
    • Isolating Resources
    • Using Resource DLLs
      • Creating Resource DLLs
      • Dynamic Switching of Resource DLLs
• Deploying Localized Applications
• Localizing Applications by Using Translation Manager

Deploying RAD Studio Applications

• Deploying Applications - Overview
• Deploying General Applications
  • Using Installation Programs
    • Identifying Application Files
    • Application Files, Listed by File Name Extension
    • Package Files
    • Merge Modules
    • Deploying ActiveX Controls
    • Helper Applications
    • DLL Locations
• Deploying Database Applications
  • Deploying dbExpress Database Applications
  • Deploying BDE Applications
    • BDE
• Deploying Web Applications
• Programming for Varying Host Environments
  • Screen Resolutions and Color Depths
  • Considerations When Dynamically Resizing Forms and Controls
  • Considerations When Not Dynamically Resizing
  • Accommodating Varying Color Depths
  • Fonts
  • Operating System Versions
• Software License Requirements

Part II: Developing Database Applications

Designing Database Applications - Overview

• Using Databases
  • Types of Databases
  • Database Security
  • Transactions
  • Referential Integrity, Stored Procedures, and Triggers
• Database Architecture
  • Connecting Directly to a Database Server
  • Using a Dedicated File on Disk
  • Connecting to Another Dataset
    • Connecting a Client Dataset to Another Dataset in the Same Application
    • Using a Multi-Tiered Architecture
  • Combining Approaches
• Designing the User Interface
  • Analyzing Data

Using Data Controls

• Using Common Data Control Features
  • Associating a Data Control with a Dataset
    • Changing the Associated Dataset at Runtime
    • Enabling and Disabling the Data Source
    • Responding to Changes Mediated by the Data Source
  • Editing and Updating Data
    • Enabling Editing in Controls On User Entry
    • Editing Data in a Control
  • Disabling and Enabling Data Display
  • Refreshing Data Display
  • Enabling Mouse, Keyboard, and Timer Events
• Choosing How to Organize the Data
  • Displaying a Single Record
  • Displaying Data as Labels
  • Displaying and Editing Fields in an Edit Box
  • Displaying and Editing Text in a Memo Control
  • Displaying and Editing Text in a Rich Edit Memo Control
  • Displaying and Editing Graphics Fields in an Image Control
  • Displaying and Editing Data in List and Combo Boxes
  • Displaying and Editing Data in Lookup List and Combo Boxes
    • Using TDBListBox and TDBComboBox
    • Handling Boolean Field Values with Check Boxes
    • Restricting Field Values with Radio Controls
    • Displaying Multiple Records
  • Viewing and Editing Data with TDBGrid
    • Using a Grid Control in Its Default State
    • Creating a Customized Grid
      • Creating Persistent Columns
      • Deleting Persistent Columns
      • Arranging the Order of Persistent Columns
      • Setting Column Properties at Design Time
      • Defining a Lookup List Column
      • Putting a Button in a Column
      • Restoring Default Values to a Column
    • Displaying ADT and Array Fields
    • Setting Grid Options
    • Editing in the Grid
    • Controlling Grid Drawing
    • Responding to User Actions at Runtime
  • Creating a Grid That Contains Other Data-aware Controls
  • Navigating and Manipulating Records
    • Choosing Navigator Buttons to Display
    • Displaying Fly-over Help
    • Using a Single Navigator for Multiple Datasets

Connecting to databases Index

• Connecting to Databases - Overview
  • Using Implicit Connections
  • Controlling Connections
    • Connecting to a Database Server
    • Disconnecting from a Database Server
  • Controlling Server Login
  • Managing Transactions
    • Specifying the Transaction Isolation Level
  • Sending Commands to the Server
  • Working with Associated Datasets
  • Obtaining Metadata

Understanding datasets Index

• Understanding Datasets - Overview
  • Using TDataSet Descendants
  • Determining Dataset States
  • Opening and Closing Datasets
  • Navigating Datasets
    • Using the First and Last Methods
    • Using the Next and Prior Methods
    • Using the MoveBy Method
    • Using the Eof and Bof Properties
    • Marking and Returning to Records
  • Searching Datasets
    • Using Locate
    • Using Lookup
  • Displaying and Editing a Subset of Data Using Filters
    • Enabling and Disabling Filtering
    • Creating Filters
      • Setting the Filter Property
      • Writing an OnFilterRecord Event Handler
    • Setting Filter Options
    • Navigating Records in a Filtered Dataset
  • Modifying Data
    • Editing Records
    • Adding New Records
    • Deleting Records
    • Posting Data
    • Canceling Changes
    • Modifying Entire Records
  • Calculating Fields
  • Types of Datasets
  • Using Table Type Datasets
    • Sorting Records with Indexes
      • Obtaining Information About Indexes
      • Specifying an Index with IndexName
      • Creating an Index with IndexFieldNames
    • Using Indexes to Search for Records
      • Executing a Search with Goto Methods
      • Executing a Search with Find Methods
      • Specifying the Current Record After a Successful Search
      • Searching On Partial Keys
      • Repeating or Extending a Search
    • Limiting Records with Ranges
      • Understanding the Differences Between Ranges and Filters
      • Specifying Ranges
      • Modifying a Range
      • Applying or Canceling a Range
    • Creating Master-Detail Relationships
      • Making the Table a Detail of Another Dataset
      • Using Nested Detail Tables
    • Controlling Read-Write Access to Tables
    • Creating and Deleting Tables
    • Emptying Tables
    • Synchronizing Tables
  • Using Query-type Datasets
    • Specifying the Query
    • Using Parameters in Queries
      • Supplying Parameters at Design Time
      • Supplying Parameters at Runtime
    • Establishing Master-detail Relationships Using Parameters
    • Preparing Queries
    • Executing Queries That Don't Return a Result Set
    • Using Unidirectional Result Sets
  • Using Stored Procedure-type Datasets
    • Working with Stored Procedure Parameters
    • Preparing Stored Procedures
  • Executing Stored Procedures That Don't Return a Result Set
    • Fetching Multiple Result Sets

Working with field components Index

• Working with Field Components - Overview
  • Dynamic Field Components
  • Persistent Field Components
    • Creating Persistent Fields
    • Arranging Persistent Fields
    • Defining New Persistent Fields
      • Defining a Data Field
      • Defining a Calculated Field
      • Programming a Calculated Field
      • Defining a Lookup Field
      • Defining an Aggregate Field
    • Deleting Persistent Field Components
    • Setting Persistent Field Properties and Events
      • Setting Display and Edit Properties at Design Time
      • Setting Field Component Properties at Runtime
      • Creating Attribute Sets for Field Components
      • Associating Attribute Sets with Field Components
      • Removing Attribute Associations
      • Controlling and Masking User Input
      • Using Default Formatting for Numeric, Date, and Time Fields
      • Handling Events
  • Working with Field Component Methods at Runtime
  • Displaying, Converting, and Accessing Field Values
    • Displaying Field Component Values in Standard Controls
    • Converting Field Values
    • Accessing Field Values with the Default Dataset Property
    • Accessing Field Values with a Dataset's FieldByName Method
    • Accessing Field Values with a Dataset's Fields Property
  • Setting a Default Value for a Field
  • Working with Constraints
    • Creating a Custom Constraint
    • Using Server Constraints
  • Using Object Fields
    • Working with ADT Fields
    • Working with Array Fields
    • Working with Dataset Fields
    • Working with Reference Fields

Using BDE Index

• Executing an Update Statement
• Using Multiple Update Objects
• Connecting to databases with TDatabase
• Managing database sessions
• Using BDE-enabled datasets
• Using TBatchMove
• Using the BDE to cache updates
• Using transactions with the BDE

Working with ADO components Index

• Working with ADO Components
  • Overview of ADO Components
  • Connecting to ADO Data Stores
    • Connecting to a Data Store Using TADOConnection
      • Accessing the Connection Object
    • Fine-tuning a Connection
      • Forcing Asynchronous Connections
      • Controlling Timeouts
      • Indicating the Types of Operations the Connection Supports
      • Specifying Whether the Connection Automatically Initiates Transactions
    • Accessing the Connection's Datasets
    • ADO Connection Events
  • Using ADO datasets
    • Connecting an ADO Dataset to a Data Store
      • Working with Record Sets
      • Filtering Records Based On Bookmarks
      • Filtering Multiple Rows Based On Update Status
      • Fetching Records Asynchronously
      • Using Batch Updates
      • Loading Data from and Saving Data to Files
      • Inspecting the Update Status of Individual Rows
      • Opening the Dataset in Batch Update Mode
    • Using TADODataSet
  • Using Command Objects
    • Specifying the Command
    • Using the Execute Method
    • Canceling Commands
    • Retrieving Result Sets with Commands
    • Applying the Batch Updates to Base Tables
    • Canceling Batch Updates
    • Handling Command Parameters

Using dbExpress Components Index

• Using dbExpress Datasets
  • Types of dbExpress Datasets
  • Connecting to the Database Server
    • Setting Up TSQLConnection
  • Specifying What Data to Display
    • Representing the Results of a Query
    • Representing the Records in a Table
    • Representing the Results of a Stored Procedure
  • Fetching the Data
  • Executing Commands That Do Not Return Records
    • Specifying the Command to Execute
    • Executing the Command
    • Creating and Modifying Server Metadata
  • Setting Up Master-Detail Linked Relationships
  • Accessing dbExpress Schema Information
    • Fetching Metadata into a dbExpress Dataset
    • The Structure of Metadata Datasets
  • Debugging dbExpress Applications

Using client datasets Index

• Using Client Datasets - Overview
  • Working with Data Using a Client Dataset
    • Navigating Data in Client Datasets
    • Limiting What Records Appear
    • Editing Data
      • Undoing Changes
      • Saving Changes
    • Constraining Data Values
    • Sorting and Indexing
      • Adding a New Index
      • Deleting and Switching Indexes
      • Using Indexes to Group Data
    • Representing Calculated Values
      • Using Internally Calculated Fields in Client Datasets
    • Using Maintained Aggregates
      • Specifying Aggregates
      • Aggregating over groups of records
      • Obtaining Aggregate Values
    • Copying Data from Another Dataset
      • Assigning Data Directly
      • Cloning a Client Dataset Cursor
    • Adding Application-specific Information to the Data
  • Using a Client Dataset to Cache Updates
    • Overview of Using Cached Updates
    • Choosing the Type of Dataset for Caching Updates
    • Indicating What Records Are Modified
    • Updating Records
      • Applying Updates
      • Intervening as Updates Are Applied
      • Reconciling Update Errors
  • Using a Client Dataset with a Provider
    • Specifying a Provider
    • Requesting Data from the Source Dataset or Document
    • Getting Parameters from the Application Server
    • Passing Parameters to the Source Dataset
      • Sending Query or Stored Procedure Parameters
      • Limiting Records with Parameters
      • Handling Constraints from the Server
      • Refreshing Records
      • Communicating with Providers Using Custom Events
      • Overriding the Dataset On the Application Server
  • Using a Client Dataset with File-based Data
    • Creating a New Dataset
    • Loading Data from a File or Stream
    • Merging Changes into Data
    • Saving Data to a File or Stream
  • Using a Simple Dataset
    • When to Use TSimpleDataSet
    • Setting Up a Simple Dataset

Using provider components Index

• Using Provider Components
  • Determining the Source of Data
  • Communicating with the Client Dataset
  • Choosing How to Apply Updates Using a Dataset Provider
  • Controlling What Information Is Included in Data Packets
    • Specifying What Fields Appear in Data Packets
    • Setting Options That Influence the Data Packets
    • Adding Custom Information to Data Packets
  • Responding to Client Data Requests
  • Responding to Client Update Requests
    • Editing Delta Packets Before Updating the Database
    • Influencing How Updates Are Applied
    • Screening Individual Updates
    • Resolving Update Errors On the Provider
    • Applying Updates to Datasets That do Not Represent a Single Table
  • Responding to Client-generated Events
  • Handling Server Constraints

Creating multi-tiered applications Index

• Creating Multi-tiered Applications - Overview
• Advantages of the Multi-tiered Database Model
• Understanding Multi-tiered Database Applications
  • Overview of a Three-tiered Application
  • The Structure of the Client Application
  • The Structure of the Application Server
    • Using Transactional Data Modules (COM)
    • Data Module Lifetime Management
  • Choosing a Connection Protocol
    • Using dbExpress Connections
    • Using DCOM Connections
    • Using SOAP Connections
    • Using Socket Connections
    • Using Web Connections
• Building a Multi-tiered Application
• Creating the Server Application
  • Creating a DataSnap Server
  • Filtering the DataSnap Communication Stream
  • Setting Up the Data Module
    • Configuring DataSnap Data Module
    • Configuring TDSServerModule
    • Configuring TRemoteDataModule
    • Configuring TMTSDataModule
    • Configuring TSOAPDataModule
  • Exposing DataSnap Server Methods
  • Supporting Master/detail Relationships
  • Supporting State Information in Exposed Data Modules
  • Using Multiple Server Data Modules (COM)
  • Extending the Interface of the Application Server (COM)
  • Managing Transactions in Multi-tiered Applications (COM)
• Registering the Application Server
• Creating the Client Application
  • Connecting to the Application Server
    • Specifying a Connection Using dbExpress
    • Specifying a Connection Using DCOM
    • Specifying a Connection Using Sockets
    • Specifying a Connection Using HTTP
    • Specifying a Connection Using SOAP
    • Brokering Connections
  • Managing Server Connections
    • Connecting to the Server
    • Dropping or Changing a Server Connection
  • Calling Server Interfaces
  • Connecting to an Application Server That Uses Multiple Data Modules
• Writing Web-based Client Applications
  • Distributing a Client Application as an ActiveX Control
    • Creating an Active Form for the Client Application
  • Building Web Applications Using InternetExpress
  • Building an InternetExpress Application
    • Using the Javascript Libraries
    • Granting Permission to Access and Launch the Application Server
  • Using an XML Broker
  • Creating Web Pages with an InternetExpress Page Producer
    • InetX Web Page Items Editor
    • Using the Web Page Editor
    • Setting Web Item Properties
    • Customizing the InternetExpress Page Producer Template

Using XML in database applications Index

• Using XML in Database Applications
  • Defining Transformations
    • Mapping Between XML Nodes and Data Packet Fields
    • Using XMLMapper
  • Converting XML Documents into Data Packets
  • Using an XML Document as the Source for a Provider
  • Using an XML Document as the Client of a Provider

Part III: Writing Internet Applications

Creating Internet server applications Index

• Creating Internet Applications - Overview
• About Web Broker and WebSnap
• Terminology and standards
  • Terminology and Standards
  • Parts of a Uniform Resource Locator
  • HTTP Request Header Information
• HTTP server activity
  • Composing Client Requests
  • HTTP Server Activity
  • Responding to Client Requests
  • Serving Client Requests
• Types of Web Server Applications
• Debugging server applications
  • Debugging Web Applications That Are DLLs
  • Debugging Server Applications
  • Using the Web Application Debugger

Using Web Broker Index

• Using Web Broker
  • Creating Web Server Applications with Web Broker
    • The Web Application Object
    • The Web Module
  • The Structure of a Web Broker Application
  • The Web Dispatcher
    • Adding Actions to the Dispatcher
    • Dispatching Request Messages
  • Action Items
    • Determining When Action Items Fire
      • The Target URL
      • The Request Method Type
      • Enabling and Disabling Action Items
      • Choosing a Default Action Item
  • Responding to Request Messages with Action Items
  • Accessing Client Request Information
    • Properties That Contain Request Header Information
      • Properties That Identify the Target
      • Properties That Describe the Web Client
      • Properties That Identify the Purpose of the Request
      • Properties That Describe the Expected Response
      • Properties That Describe the Content
      • Accessing Client Request Information
    • The Content of HTTP Request Messages
  • Creating HTTP Response Messages
    • Filling in the Response Header
      • Indicating the Response Status
      • Indicating the Need for Client Action
      • Describing the Server Application
      • Describing the Content
    • Setting the Response Content
    • Sending the Response
  • Generating the Content of Response Messages
    • Using Page Producer Components
      • HTML Templates
      • Specifying the HTML Template
      • Converting HTML-transparent Tags
      • Using Page Producers from an Action Item
      • Chaining Page Producers Together
      • Using Predefined HTML-transparent Tag Names
  • Using Database Information in Responses
    • Adding a Session to the Web Module
    • Representing a Dataset in HTML
      • Using Dataset Page Producers
      • Using Table Producers
      • Specifying the Table Attributes
      • Specifying the Row Attributes
      • Specifying the Columns
      • Embedding Tables in HTML Documents
      • Using TDataSetTableProducer
      • Using TQueryTableProducer

Using IntraWeb (VCL for the Web) Index

• Getting Started with IntraWeb
  • Creating a New IntraWeb Application
  • Changing IntraWeb application type
  • Editing the Main Form
  • Writing an Event Handler for the Button
  • Running the Completed Application
• Creating Web Server Applications Using IntraWeb
• Using IntraWeb Components
• Using IntraWeb with Web Broker and WebSnap

Working with XML documents Index

• Working with XML Documents
• Using the Document Object Model
• Working with XML Components
  • Using TXMLDocument
  • Working with XML Nodes
• Abstracting XML Documents with the Data Binding Wizard
  • Using the XML Data Binding Wizard
  • Using Code That the XML Data Binding Wizard Generates

Using Web Services Index

• Using Web Services
• Understanding Invokable Interfaces
  • Using Nonscalar Types in Invokable Interfaces
    • Registering Nonscalar Types
    • Using Remotable Objects
    • Remotable Object Example
• Writing Servers that Support Web Services
  • Using the SOAP Application Wizard
  • Adding New Web Services
  • Using the WSDL Importer
  • Defining and Using SOAP Headers
  • Creating Custom Exception Classes for Web Services
  • Generating WSDL Documents for a Web Service Application
• Writing Clients for Web Services
  • Importing WSDL Documents
  • Calling Invokable Interfaces
  • Processing Headers in Client Applications

Working with Sockets

• Implementing Services Overview
  • Understanding Service Protocols
  • Services and Ports
• Types of Socket Connections
  • Client Connections
  • Listening Connections
  • Server Connections
• Describing Sockets
  • Describing the Host
  • Using Ports
• Using Socket Components - Overview
  • Getting Information About the Client or Server Socket Connection
  • Using Client Sockets
    • Specifying the Desired Server
    • Forming the Connection
    • Getting Information About the Client Socket Connection
    • Closing the Connection
  • Using Server Sockets
    • Specifying the Port
    • Listening for Client Requests
    • Connecting to Clients
    • Closing Server Connections Overview
• Responding to Socket Events
  • Error Events
  • Client Events
  • Server Events
• Reading and Writing Over Socket Connections - Overview
  • Non-blocking Connections
    • Reading and Writing Events
  • Blocking Connections

Part IV: Developing COM-based Applications Index

Overview of COM Technologies

• COM basics Index
  • Overview of COM Technologies
    • C++Builder Uses DAX for ActiveX and COM
  • Parts of a COM Application
    • COM Interfaces
      • The Fundamental COM Interface, IUnknown
      • COM Interface Pointers
  • COM Servers
    • CoClasses and Class Factories
    • In-process, Out-of-process, and Remote Servers
    • The Marshaling Mechanism
    • Aggregation (COM)
    • COM Clients
  • COM Extensions
    • Automation Servers
    • Active Server Pages
    • ActiveX Controls
    • Active Documents
    • Type Libraries
  • Implementing COM Objects with Wizards
    • Code Generated by Wizards
  • COM+ Event And Event Subscriber Objects

Working with Type Libraries

• Working with type libraries
  • Working with Type Libraries - Overview
  • Type Library Editor
    • Parts of the Type Library Editor
      • Toolbar
      • Object List Pane
      • Status Bar
      • Pages of Type Information
    • Type Library Elements
  • Using the Type Library Editor
    • Valid Types
    • Using Object Pascal or RIDL Syntax
      • RIDL File
      • GenTLB.exe
      • SafeArrays
    • Creating a New Type Library
    • Opening an Existing Type Library
    • Adding an Interface to the Type Library
    • Modifying an Interface Using the Type Library
    • Adding Properties and Methods to the Type Library
    • Adding a CoClass to the Type Library
    • Adding an Interface to a CoClass
    • Adding an Enumeration to the Type Library
    • Adding an Alias to the Type Library
    • Adding a Record or Union to the Type Library
    • Adding a Module to the Type Library
    • Saving and Registering Type Library Information
    • Apply Updates Dialog
    • Saving a Type Library
    • Refreshing the Type Library
    • Registering the Type Library
  • Deploying Type Libraries

Creating COM Clients

• Creating COM clients
  • Creating COM Clients
  • Importing Type Library Information
    • Code Generated When You Import Type Library Information
  • Controlling an Imported Object
    • Using Component Wrappers
    • Writing Client Code Based On Type Library Definitions
      • Connecting to a Server
      • Controlling an Automation Server Using a Dispatch Interface
      • Controlling an Automation Server Using a Dual Interface
      • Handling Events in an Automation Controller
  • Creating Clients for Servers That Do Not Have a Type Library

Creating Simple COM Servers

• Creating simple COM servers
  • Creating Simple COM Servers - Overview
  • Designing a COM Object
  • Using the COM Object Wizard
  • Using the Automation Object Wizard
    • COM Object Instancing Types -- not seen in C++ TOC ??
    • Choosing a Threading Model
  • Defining a COM Object's Interface
    • Managing Events in Your Automation Object
  • Automation Interfaces
    • Dual Interfaces
    • Dispatch Interfaces
    • Custom Interfaces
  • Marshaling Data
  • Registering a COM Object
    • Current-User Registration for ActiveX Servers
  • Testing and Debugging the Application

Creating an Active Server Page

• Creating an Active Server Page
  • Creating an Active Server Object
  • Creating Active Server Pages - Overview
    • Using the ASP Intrinsics
    • Creating ASPs for In-process or Out-of-process Servers
  • Registering an Active Server Object
  • Testing and Debugging the Active Server Page Application

Using ActiveX Controls

• Using ActiveX controls
  • Creating an ActiveX Control
  • Elements of an ActiveX Control
  • Designing an ActiveX Control
  • Generating an ActiveX Control from a VCL Control
  • Generating an Active Form Based on a VCL Form
  • Creating a 64-bit Windows C++ ActiveX Form or ActiveX Control
  • Licensing ActiveX Controls
  • Customizing the ActiveX Control's Interface
    • Adding Additional Properties, Methods, and Events
    • Enabling Simple Data Binding with the Type Library
  • Creating a Property Page for an ActiveX Control
    • Creating a New Property Page
    • Adding Controls to a Property Page
    • Associating Property Page Controls with ActiveX Control Properties
      • Updating the Property Page
      • Updating the Object
    • Connecting a Property Page to an ActiveX Control
  • Registering an ActiveX Control
  • Testing an ActiveX Control

Part V: Component Writer's Guide

• Introduction to Component Creation
• Object-oriented Programming for Component Writers
• Creating Properties
• Creating Events
• Creating Methods
• Using Graphics in Components
• Handling Messages
• Making Components Available at Design Time
• Modifying an Existing Component
• Creating a Graphic Component
• Customizing a Grid
• Making a Control Data Aware
• Making a Dialog Box a Component
• Extending the IDE (Tools API)