C++Builder Developer's Guide

Go Up to Windows Developer's Guide

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

Working with Components Index

• Setting Properties and Events
  • • Using Property Editors
• 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
• Double-buffering and Remote Connections

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
  • WinAPI Application
  • 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 WebBroker 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
  • Setting the Framework Affinity for a Data Module
• 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
• 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
  • 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
• 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
  • VCL Taskbars
• 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
    • Creating Drawing Spaces
    • Colors
    • Printing
    • 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 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++)
• Delphi Exception Handling in C++
• C++Builder Exception Handling Compiler Options
• External Exception EEFFACE

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
• Packaging Components Or Libraries Written In Classic and Clang C++ Win32 Compilers
• Packages for C++ New Toolchain

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

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
    • 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

• BDE-based Architecture
• Using BDE
• 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 a Database Server Using dbExpress
  • 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
  • Filtering the DataSnap Communication Stream
  • Setting Up the Data Module
    • Configuring DataSnap Data Module
    • Configuring TDSServerModule
    • Configuring TRemoteDataModule
    • Configuring TMTSDataModule
    • Configuring TSOAPDataModule
  • Using Multiple Server Data Modules (COM)
  • Extending the Interface of the Application Server (COM)
  • Managing Transactions in Multi-tiered Applications (COM)
  • Supporting Master/detail Relationships
  • Supporting State Information in Exposed Data Modules
• 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
  • Using an XML Broker

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
• 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 Web Broker Index

• Using Web Broker
• WebBroker Sessions Management
• 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
  • 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 {{f|vcl|

Working with XML documents

• 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

• Working with Sockets
  • Installing Socket Components
  • 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

• 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 - 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 Delphi 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
• 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 - Overview
• Designing a COM Object
• Using the COM Object Wizard
• Using the Automation Object Wizard
  • COM Object Instancing Types
  • 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 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

• 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
• Licensing ActiveX Controls
• Customizing the ActiveX Control's Interface
  • Adding Additional Properties, Methods, and Events
    • Adding Events
    • Adding Properties
  • 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
• Creating a 64-bit Windows C++ ActiveX Form or ActiveX Control (C++)

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
• Using 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)
• Deploying Components
• Packaging Components Or Libraries Written In Classic and Clang C++ Win32 Compilers

See Also

• Language Support for the RAD Studio Libraries (C++)