Index

• __automated
  • keywords%2C C++ (__automated)
• dispid
  • keywords%2C C++ (__dispid)
• __except
  • keywords%2C C++ (__except)
• _mbsncat
  • Strncat
• _mbsnbcat
  • Strncat
• _wcsmpi
  • Strcmpi
• _wsetlocale
  • Setlocale, _wsetlocale

#

• #if (if, elif, else, And endif)
• #ifdef (ifdef And ifndef)
• #define (define)
• #undef (undef)
• #error (error)
• #include (include)
• #import (import)
• #line (line)
• # character (Converting Actual Arguments to Strings with # Operator)
• #pragma (pragma)
• #pragma alignment (pragma alignment)
• #pragma argsused (pragma argsused)
• #pragma checkoption (pragma checkoption)
• #pragma codeseg (pragma codeseg)
• #pragma comments, pragma (pragma comment)
• #pragma defineonoption (pragma defineonoption and pragma undefineonoption)
• #pragma exit (pragma exit and pragma startup)
• #pragma hdrfile (pragma hdrfile)
• #pragma hdrstop (pragma hdrstop)
• #pragma inline (pragma inline)
• #pragma intrinsic (pragma intrinsic)
• #pragma link (pragma link)
• #pragma message (pragma message)
• #pragma nopushoptwarn (pragma nopushoptwarn)
• #pragma obsolete (pragma obsolete)
• #pragma option (pragma option)
• #pragma pack (pragma pack)
• #pragma package (pragma package)
• #pragma region (pragma region and pragma end_region)
• #pragma resource (pragma resource)
• #pragma warn (pragma warn)

$

• $A
  • Align fields (Align fields (Delphi))
• $ALIGN
  • Align fields (Align fields (Delphi))
• $APPTYPE
  • Application type (Application type (Delphi))
• $ASSERTIONS
  • Assert directives (Assert directives (Delphi))
• $C
  • Assert directives (Assert directives (Delphi))
• $B
  • Boolean short-circuit evaluation (Boolean short-circuit evaluation (Delphi compiler directive))
• $BOOLEVAL
  • Boolean short-circuit evaluation (Boolean short-circuit evaluation (Delphi compiler directive))
• $D
  • Debug information (Debug information (Delphi))
• $DEBUGINFO
  • Debug information (Debug information (Delphi))
• $DEFINE
  • DEFINE directive (DEFINE directive (Delphi))
• $DENYPACKAGEUNIT
  • DENYPACKAGEUNIT directive (DENYPACKAGEUNIT directive (Delphi))
• $HIGHCHARUNICODE
  • HIGHCHARUNICODE directive (HIGHCHARUNICODE directive (Delphi))
• $DESCRIPTION
  • Description (Description (Delphi))
• $DESIGNONLY
  • DESIGNONLY directive (DESIGNONLY directive (Delphi))
• $ELSE
  • ELSE (ELSE (Delphi))
• $ELSEIF
  • ELSEIF (ELSEIF (Delphi))
• $ENDIF
  • ENDIF directive (ENDIF directive)
• $E
  • Executable extension (Executable extension (Delphi))
• $EXTENSION
  • Executable extension (Executable extension (Delphi))
• $ObjExportAll
  • Export symbols (Export symbols (Delphi))
• $EXTENDEDSYNTAX
  • Extended syntax (Extended syntax (Delphi))
• $X
  • Extended syntax (Extended syntax (Delphi))
• $EXTERNALSYM
  • External Symbols (Delphi) (External Symbols (Delphi))
• $FINITEFLOAT
  • Floating Point Exception Checking (Floating Point Exception Checking (Delphi))
• $HINTS
  • Hints (Hints (Delphi))
• $HPPEMIT
  • HPP emit (HPP emit (Delphi))
• $IFDEF
  • IFDEF directive (IFDEF directive (Delphi))
• $IF
  • IF directive (IF directive (Delphi))
• $IFEND
  • IFEND directive (IFEND directive (Delphi))
• $IFNDEF
  • IFNDEF directive (IFNDEF directive (Delphi))
• $IFOPT
  • IFOPT directive (IFOPT directive (Delphi))
• $IMAGEBASE
  • Image base address (Image base address)
• $IMPLICITBUILD
  • Implicit Build (Implicit Build (Delphi))
• $IMPORTEDDATA
  • Imported data (Imported data)
• $G
  • Imported data (Imported data)
• $INCLUDE
  • Include file (Include file (Delphi))
• $I
  • Include file (Include file (Delphi))
• $IOCHECKS
  • Input output checking (Input output checking (Delphi))
• $I+ or $I-
  • Input output checking (Input output checking (Delphi))
• $LIB
  • Compiler directives for libraries or shared objects (Compiler directives for libraries or shared objects (Delphi))
• $LINK
  • Link object file (Link object file (Delphi))
• $L
  • Link object file (Link object file (Delphi))
• $LOCALSYMBOLS
  • Local symbol information (Local symbol information (Delphi))
• $L+ or $L-
  • Local symbol information (Local symbol information (Delphi))
• $LONGSTRINGS
  • Long strings (Long strings (Delphi))
• $H+ or $H-
  • Long strings (Long strings (Delphi))
• $MINSTACKSIZE; $MAXSTACKSIZE
  • Memory allocation sizes (Memory allocation sizes (Delphi))
• $M
  • Memory allocation sizes (Memory allocation sizes (Delphi))
• $MESSAGE
  • MESSAGE directive (MESSAGE directive (Delphi))
• $METHODINFO
  • METHODINFO directive (METHODINFO directive (Delphi))
• $MINENUMSIZE
  • Minimum enumeration size (Minimum enumeration size (Delphi))
• $Z
  • Minimum enumeration size (Minimum enumeration size (Delphi))
• $OPENSTRINGS
  • Open String Parameters (Open String Parameters (Delphi))
• $P
  • Open String Parameters (Open String Parameters (Delphi))
• $OPTIMIZATION
  • Optimization (Optimization (Delphi))
• $O
  • Optimization (Optimization (Delphi))
• $OVERFLOWCHECKS
  • Overflow checking (Overflow checking (Delphi))
• $Q
  • Overflow checking (Overflow checking (Delphi))
• $SAFEDIVIDE
• $U
  • Pentium-safe FDIV operations (Pentium-safe FDIV operations (Delphi))
• $POINTERMATH
  • Pointer Math (Pointer Math (Delphi))
• $NODEFINE
  • NODEFINE (NODEFINE)
• $NOINCLUDE
  • NOINCLUDE (NOINCLUDE (Delphi))
• $RANGECHECKS
  • Range checking (Range checking)
• $R+ or $R-
  • Range checking (Range checking)
• $REALCOMPATIBILITY
  • Real48 compatibility (Real48 compatibility (Delphi))
• $REGION; $ENDREGION
  • Regions (Regions)
• $RESOURCE
  • Resource file (Resource file (Delphi))
• $R
  • Resource file (Resource file (Delphi))
• $RUNONLY
  • RUNONLY directive (RUNONLY directive (Delphi))
• $TYPEINFO
  • Runtime type information (Runtime type information (Delphi))
• $M
  • Runtime type information (Runtime type information (Delphi))
• $SCOPEDENUMS
  • Scoped Enums (Scoped Enums (Delphi))
• $REFERENCEINFO; $DEFINITIONINFO
  • Symbol declaration and cross-reference information (Symbol declaration and cross-reference information (Delphi))
• $Y or &YD
  • Symbol declaration and cross-reference information (Symbol declaration and cross-reference information (Delphi))
• $TYPEDADDRESS
  • Type-checked pointers (Type-checked pointers (Delphi))
• $T
  • Type-checked pointers (Type-checked pointers (Delphi))
• $UNDEF
  • UNDEF directive (UNDEF directive (Delphi))
• $VARSTRINGCHECKS
  • Var-string checking (Var-string checking (Delphi))
• $V
  • Var-string checking (Var-string checking (Delphi))
• $WARN
  • Warning messages (Warning messages (Delphi))
• $WARNINGS
  • Warnings (Warnings (Delphi))
• $WEAKPACKAGEUNIT
  • Weak packaging (Weak packaging)
• $STACKFRAMES
  • Stack frames (Stack frames (Delphi))
• $W
  • Stack frames (Stack frames (Delphi))
• $J
  • Writeable typed constants (Writeable typed constants (Delphi))
• $WRITEABLECONST
  • Writeable typed constants (Writeable typed constants (Delphi))
• $SetPEFlags
  • PE (PE (portable executable) header flags (Delphi))
• $RESOURCERESERVE
  • Reserved address space for resources (Reserved address space for resources (Delphi))

*

• * operator
  • Reference/Dereference Operators%2C C++ (Reference/Deference Operators)

+

• ++ operator
  • operators%2C C++ (Increment/decrement Operators)
• + operator
  • operators%2C C++ (Plus And Minus Operators)

-

• -D compile option (Using The -D And -U Command-line Options)

.

• .targets files (Targets files)
• . operator
  • operators%2C C++ (. (direct Member Selector))

?

• ?: operator
  • operators%2C C++ (Conditional Operators)

A

• Project Options) (Application)
• Alignment (Edit menu) (Alignment)
• AnsiStringT and code page
  • C++ handling (How to Handle Delphi AnsiString Code Page Specification in C++)
• AnsiString
  • C++ handling (How to Handle Delphi AnsiString Code Page Specification in C++)
  • compared to UnicodeString (Unicode in RAD Studio)
• Add Reference
  • Add dialog box, Requires tab (Add dialog box, Requires tab)
• API Categories
  • Action Support (Action Support Routines)
  • Application-level Information (Application-level Information)
  • BCD Support (BCD Support Routines)
  • Business Routines (Business And Finance Routines)
  • COM/OLE Support (COM/OLE Support Members)
  • Character Manipulation (Character Manipulation Routines)
  • Clipboard Support (Clipboard Support Routines)
  • Color Constants (Color Constants)
  • Command Line Support (Command Line Support Routines)
  • Complex Numbers Support (Complex Numbers Support Routines)
  • Copy Mode Constants (Copy Mode Constants)
  • Date/Time Support (Date/Time Support)
  • Dialogs Support (Dialogs Support Routines)
  • Disk And Directory Support (Disk And Directory Support Routines)
  • Dynamic Allocation (Dynamic Memory Allocation Routines)
  • FPU Control (FPU Control Members)
  • File Attribute Constants (File Attribute List)
  • File IO Support (File Input/Output Support)
  • File Mode Constants (File Mode Constants)
  • GUID And Interface Support (GUID And Interface Support Routines)
  • Intrinsic Routines (Delphi Intrinsic Routines)
  • Math Routines (Comparison Routines)
  • Math Routines (Mathematic Routines)
  • Math Routines (Additional Controls)
  • Math Routines (BDE Controls)
  • Math Routines (Data Access Controls)
  • Math Routines (Data Controls)
  • Math Routines (Data Snap Client Controls)
  • Math Routines (Datasnap Server Controls)
  • Math Routines (DBExpress Controls)
  • Math Routines (DbGo Controls)
  • Math Routines (Dialog Controls)
  • Math Routines (Internet Controls)
  • Math Routines (Internet Express Controls)
  • Math Routines (Ribbon Controls)
  • Math Routines (Standard Controls)
  • Math Routines (System Controls)
  • Math Routines (Vista Dialog Controls)
  • Math Routines (Web Services)
  • Math Routines (WebSnap Controls)
  • Math Routines (Win 3.1 Controls)
  • Math Routines (Win32 Controls)
  • Menus Support (Menus Support Members)
  • Modal Result Constants (Modal Result Constants)
  • Mouse Cursor Constants (Mouse Cursor Constants)
  • Operator Constants (Operator Constants)
  • Path Manipulation (Path Manipulation Routines)
  • Random Support (Random Support Members)
  • Streams, Writers and Readers (Streams, Reader and Writers)
  • Thread Management (Thread Management Members)
  • Type conversion routines (Type conversion routines)
  • UCS4 Support (UTF-8 Conversion Routines)
  • UTF-8 Support (UTF-8 Conversion Routines)
  • Variant Support (Variant Support Routines)
  • Variant Types Constants (Variant Types Constants)
  • Variant Types Constants (Virtual Key Codes)
  • XML Support (XML Support Members)
• Assembler syntax
  • inline assembler (Understanding Assembler Syntax (Win32 Only))
• Assembly expression
  • inline assembler (Assembly Expressions (Win32 Only))
• Assembly procedures and functions
  • inline assembler (Assembly Procedures and Functions (Win32 Only))
• Automation objects
  • interfaces (Automation Objects (Win32 Only))
• Audit
  • bar chart (Audit and Metric Facilities)
• Activity diagram
  • sample (UML 2.0 Sample Project, Behavior Package)
• Assembly Metadata Explorer (Exploring Windows Type Libraries)
• Association class
  • delete (Creating an Association Class)
• Activity parameter
  • adding (Designing a UML 2.0 Activity Diagram)
• Artifact
  • deploying (Designing a UML 2.0 Deployment Diagram)
• Activate support (Activating UML Modeling Support for Projects)
• Audits
  • sorting (Viewing Audit Results)
• Access specifiers
  • C++ language specifics (Member Access Control)
• Accessing
  • namespaces%2C C++ (Accessing Elements Of A namespace)
  • namespaces%2C C++ (Explicit Access Qualification)
  • namespaces%2C C++ (using Directive)
  • namespaces%2C C++ (using (declaration))
• Anonymous namespaces
  • namespaces%2C C++ (Anonymous namespaces)
• Alias
  • namespaces%2C C++ (namespace Alias)
• Anonymous methods
  • C++ handling (How to Handle Delphi Anonymous Methods in C++)
• Arrays
  • C++ language specifics (The delete Operator With Arrays)
  • language structure, C++ (Arrays)
• Abstract classes
  • C++ language specifics (Abstract Classes)
• Alignas
  • keywords%2C C++ (alignas)
• Alignof
  • keywords%2C C++ (alignof)
• And
  • alternative representations of C++ tokens (and, &&)
• Asm
  • keywords%2C C++ (asm, _asm, __asm)
• Auto
  • keywords%2C C++ (auto)
• Axiom
  • keywords%2C C++ (axiom)
• Assignment
  • operators%2C C++ (Assignment Operators)
• Arithmetic operators
  • operators%2C C++ (Arithmetic Operators)
• Abstract methods (Abstract Methods)
  • methods (Abstract Class Members)
• Array
  • fields (Working with Array Fields)
  • properties (Creating Array Properties)
• Ancestor classes (Adding New Capabilities to a Class)
  • descendent classes (Ancestors, Descendants, and Class Hierarchies)
• Active documents (Active Documents)
• Active Server Pages
  • overview (Active Server Pages)
• ActiveX controls
  • and VCL wrappers (Code Generated When You Import Type Library Information)
  • and events (Handling Events in an Automation Controller)
  • adding additional properties (Adding Additional Properties, Methods, and Events)
  • connecting with property page (Connecting a Property Page to an ActiveX Control)
  • creating a property page (Creating a Property Page for an ActiveX Control)
  • customizing (Customizing the ActiveX Control's Interface)
  • deploying (Deploying ActiveX Controls)
  • description (ActiveX Controls)
  • designing (Designing an ActiveX Control)
  • elements of (Elements of an ActiveX Control)
  • for Web deployment (Generating an ActiveX Control Based On a VCL Form)
  • licensing (Licensing ActiveX Controls)
• Aggregation
  • COM objects (Aggregation (COM))
  • interfaces (Aggregation)
• Automation
  • Servers (Automation Servers)
  • managing events (Managing Events in Your Automation Object)
• Active server page
  • overview (Creating Active Server Pages: Overview)
• Active Server Page
  • creating (Creating an Active Server Object)
  • intrinsic objects (Using the ASP Intrinsics)
• Active Server Objects
  • out-of-process servers (Creating ASPs for In-process or Out-of-process Servers)
  • registering (Registering an Active Server Object)
  • testing and debugging (Testing and Debugging the Active Server Page Application)
• Automation controllers
  • importing a type library (Code Generated When You Import Type Library Information)
  • writing (Writing Client Code Based On Type Library Definitions)
• Automation servers
  • connecting to (Connecting to a Server)
  • debugging (Testing and Debugging the Application)
• Automation controller
  • dispatch interface (Controlling an Automation Server Using a Dispatch Interface)
• Automation server
  • creating (Using the Automation Object Wizard)
• ADO
  • asynchronous fetching (Fetching Records Asynchronously)
  • batch updates (Using Batch Updates)
  • connecting to data stores (Connecting an ADO Dataset to a Data Store)
  • connection modes (Indicating the Types of Operations the Connection Supports)
  • connection object (Accessing the Connection Object)
  • recordset objects (Working with Record Sets)
• ADO connection components
  • associated commands (Accessing the Connection's Datasets)
  • connections (Connecting to a Data Store Using TADOConnection)
  • connections (Fine-tuning a Connection)
• ADO connections
  • events (ADO Connection Events)
• ADO datasets (Using TADODataSet)
• ADO command components
  • SQL commands (Using Command Objects)
• ADO components
  • databases (Working with ADO Components)
• Application servers
  • Web clients (Building an InternetExpress Application)
  • access and launch permissions (Granting Permission to Access and Launch the Application Server)
  • creating (Creating the Server Application)
  • providing data (Responding to Client Data Requests)
  • registering (Registering the Application Server)
  • structure (The Structure of the Application Server)
• Active Forms
  • client applications (Creating an Active Form for the Client Application)
• Architecture
  • BDE-based (BDE-based Architecture)
  • database applications (Database Architecture)
  • single-tiered applications (Connecting Directly to a Database Server)
  • single-tiered applications (Using a Dedicated File on Disk)
• Aggregate fields
  • defining (Defining an Aggregate Field)
• ADT fields (Working with ADT Fields)
• Applications
  • compiling (Compiling Applications)
  • console (Console Applications)
  • creating (Creating Applications)
  • creating (GUI Applications)
  • creating (Creating Projects)
  • debugging (Debugging Applications)
  • deploying (Deploying Applications)
  • deploying (Deploying Applications: Overview)
  • designing (Designing Applications)
• Application files
  • file name extensions (Application Files, Listed by File Name Extension)
  • identifying (Identifying Application Files)
• Action bands
  • creating dynamic menus (Creating Dynamic Menus)
  • creating most recently used lists (Creating Most Recently Used Lists)
  • hiding unused items (Hiding Unused Items and Categories in Action Bands)
  • setting up action bands (Setting Up Action Bands)
• Actions (What Is an Action)
  • action bands (Creating Toolbars and Menus)
  • action bands (Setting Up Action Bands)
  • action lists (Demo Programs, Actions, Action Lists, Menus, and Toolbars)
  • action lists (Organizing Actions for Toolbars and Menus)
  • action lists (Registering Actions)
  • component writing using (How Actions Find Their Targets)
  • component writing using (Writing Action Components)
  • executing (What Happens When an Action Fires)
  • predefined (Predefined Action Classes)
  • using (Using Action Lists)
• Action lists
  • actions (Setting Up Action Lists)
• Animation
  • AVI (Animation Control)
• As operator
  • operators (Using the as Operator with Interfaces)
• Audio
  • video (Adding Audio and/or Video Clips to an Application)
  • video (Example of Adding Audio and/or Video Clips (VCL Only))
• Avi
  • animation (Adding Silent Video Clips to an Application)
  • animation (Example of Adding Silent Video Clips)
• Action editor
  • action items (Adding Actions to the Dispatcher)
• Action items (Action Items)
  • HTTP requests (Responding to Request Messages with Action Items)
  • default (Choosing a Default Action Item)
  • enabling (Enabling and Disabling Action Items)
  • properties (Determining When Action Items Fire)

B

• Breakpoints
  • setting and modifying (Setting and Modifying Breakpoints)
• Build configurations (C++) (Precompiled Headers Overview)
• Browse through sequence (Hyperlinking in UML Models)
• Build configurations
  • activating (Activating a Build Configuration for a Project)
• Bookmarks, using (Using Bookmarks)
• BCC32.EXE
  • command line (BCC32, the C++ Command-Line Compiler)
• BRC32.EXE (BRC32, the Resource Shell)
• BRCC32.EXE (BRCC32.EXE, the Resource Compiler)
• Base classes
  • C++ language specifics (Base And Derived Class Access)
• Bool __has_nothrow_assign ( typename T )
  • C++0x type trait functions (__has_nothrow_assign)
• Bool __ has_nothrow_copy_constructor( typename T )
  • C++0x type trait functions (__has_nothrow_copy_constructor)
• Bool __has_nothrow_default_constructor( typename T )
  • C++0x type trait functions (__has_nothrow_default_constructor)
• Bool __has_trivial_assign( typename T )
  • C++0x type trait functions (__has_trivial_assign)
• Bool_has __trivial_default_constructor( typename T )
  • C++0x type trait functions (__has_trivial_copy_constructor)
• Bool __has_trivial_default_constructor(typename T )
  • C++0x type trait functions (__has_trivial_default_constructor)
• Bool __has_virtual_destructor ( typename T )
  • C++0x type trait functions (__has_virtual_destructor)
• Bool __is_abstract (typename T )
  • C++0x type trait functions (__is_abstract)
• Bool __is_arithmetic(Typename T)
  • C++0x type trait functions (__is_arithmetic)
• Bool __is_array( Typename T )
  • C++0x type trait functions (__is_array)
• Bool __is_base_of ( typename Base, typename Derived )
  • C++0x type trait functions (__is_base_of)
• Bool __is_class(T)
  • C++0x type trait functions (__is_class)
• Bool __is_complete_type(T)
  • C++0x type trait functions (__is_complete_type (typename T ))
• Bool __is_compound( typename T )
  • C++0x type trait functions (__is_compound)
• Bool __is_const (typename T)
  • C++0x type trait functions (__is_const)
• Bool __is_convertible (typename From, typename To )(typename T)
  • C++0x type trait functions (__is_convertible)
• Bool __is_empty( typename T )
  • C++0x type trait functions (__is_empty)
• Bool __is_enum_type( typename T )
  • C++0x type trait functions (__is_enum)
• Bool __is_floating_point( typename T )
  • C++0x type trait functions (__is_floating_point)
• Bool __is_function( typename T )
  • C++0x type trait functions (__is_function)
• Bool __is_fundamental (typename T)
  • C++0x type trait functions (__is_fundamental)
• Bool __is_integral( typename T )
  • C++0x type trait functions (__is_integral)
• Bool __is_lvalue_expr( typename T )
  • C++0x type trait functions (__is_lvalue_expr)
• Bool __is_lvalue_reference(typename T)
  • C++0x type trait functions (__is_lvalue_reference)
• Bool __is_member_function_pointer( typename T )
  • C++0x type trait functions (__is_member_function_pointer)
• Bool __is_member_object_pointer( typename T )
  • C++0x type trait functions (__is_member_object_pointer)
• Bool __is_member_pointer( typename T )
  • C++0x type trait functions (__is_member_pointer)
• Bool __is_object( typename T )
  • C++0x type trait functions (__is_object)
• Bool __is_pod( typename T )
  • C++0x type trait functions (__is_pod)
• Bool __is_pointer( Typename T )
  • C++0x type trait functions (__is_pointer)
• Bool __is_polymorphic( typename T )
  • C++0x type trait functions (__is_polymorphic)
• Bool __is_reference( typename T )
  • C++0x type trait functions (__is_reference)
• Bool __is_rvalue_expr( typename T )
  • C++0x type trait functions (__is_rvalue_expr)
• Bool __is_rvalue_reference( typename T )
  • C++0x type trait functions (__is_rvalue_reference)
• Bool __is_same ( typename T, typename U )
  • C++0x type trait functions (__is_same)
• Bool __is_scalar( typename T )
  • C++0x type trait functions (__is_scalar)
• Bool __is_signed( typename T )
  • C++0x type trait functions (__is_signed)
• Bool __is_standard_layout(typename T)
  • C++0x type trait functions (__is_standard_layout)
• Bool __is_trivial( typename T )
  • C++0x type trait functions (__is_trivial)
• Bool __is_union( typename T )
  • C++0x type trait functions (__is_union)
• Bool __is_unsigned( typename T )
  • C++0x type trait functions (__is_unsigned ( typename T ))
• Bool __is_void(typename T)
  • C++0x type trait functions (__is_void)
• Bool __is_volatile( typename T )
  • C++0x type trait functions (__is_volatile)
• Bitand
  • C++ language specifics (bitand, &)
• Bitor
  • alternative representations of C++ tokens (bitor, )
• Bool
  • keywords%2C C++ (bool, false, true)
• Break
  • keywords%2C C++ (break)
• Bitwise operators,
  • operators%2C C++ (Bitwise Operators)
• Blocks
  • language structure, C++ (Blocks)
• Bit fields
  • language structure, C++ (Bit Fields)
• Broadcast method
  • sending messages (Broadcasting a Message to All Controls in a Form)
• Bitmaps
  • drawing on (Drawing On the Bitmap)
  • offscreen bitmaps (Off-screen Bitmaps)
  • setting size (Setting the Initial Bitmap Size)
• Batch updates
  • canceling (Canceling Batch Updates)
• Briefcase model
  • mobile computing (Combining Approaches)
• Borland Database Engine
  • aliases (Setting BDE Alias Parameters)
  • aliases (Identifying the Database)
  • aliases (Working with BDE Aliases)
  • deploying (Borland Database Engine)
  • direct calls (Working with BDE Handle Properties)
• BLOBs
  • caching (Caching BLOBs)
• BatchMove component
  • adding (Creating a Batch Move Component)
  • batch operations (Using TBatchMove)
  • error handling (Handling Batch Move Errors)
• Batch operations
  • mapping data types (Mapping Data Types)
  • modes (Specifying a Batch Move Mode)
  • running (Executing a Batch Move)
• BDE
  • utilities (Tools for Working with the BDE)
• BeforeUpdateRecord event
  • OnGetTableName event (Intervening as Updates Are Applied)
• Bevels (Bevels)
• Bitmap buttons (Bitmap Buttons)
• Button controls (Buttons and Similar Controls)
• Brush color (Changing the Brush Color)
• Brush bitmap property (Setting the Brush Bitmap Property)
• Brushes (Using Brushes)
• Blocking connections (Blocking Connections)
• Blackfish SQL
  • overview (Blackfish SQL Overview)
• Browsing a database
  • browsing objects (Browsing a Database in the Data Explorer)
  • browsing objects (Using Data Explorer to Obtain Connection Information)

C

• Change (Run menu) (Change)
• Component (Project Options) (Component)
• Cut (Edit menu) (Cut)
• Copy (Edit menu) (Copy)
• Calling conventions in C++
  • C++ Compiler (C++ Compiler)
  • Mixed-Language Calling Conventions (Mixed-Language Calling Conventions)
  • Function Modifiers (Function Modifiers)
• Calling conventions in Delphi
  • Calling Procedures and Functions (Calling Procedures and Functions)
  • Procedures and Functions (Procedures and Functions)
• Character sets
  • ANSI character sets (ANSI Character Sets)
  • OEM character sets (OEM Character Sets)
  • Wide characters (Wide characters)
  • Multibyte characters (Multibyte characters)
  • Unicode (Unicode)
  • Code pages (Code pages)
  • Windows code pages (Windows code pages)
• Conditional compilation (Conditional Compilation)
  • Conditional compilation (Conditional compilation (Delphi))
• Classes and objects
  • classes and objects (Classes and Objects)
• Class helpers
  • classes and objects (Class Helpers)
• Class references
  • classes and objects (Class References)
• Code page
  • setting in C++ (Code Page)
• Constants
  • data types (Declared Constants)
  • lexical elements, C++ (Constants)
• C++ Classes that Support the Object Pascal Language
• C++0x features
  • Unicode char types (Unicode Character Types and Literals (C++0x))
  • alignof operator (Anonymous Methods in Delphi)
  • alignof operator (alignof Operator (C++0x))
  • alignof operator (rvalue References (C++0x))
  • attributes noreturn and final (Attributes noreturn and final (C++0x))
  • decltype specifier (Type Specifier decltype (C++0x))
  • explicit conversion operatorsl (Explicit Conversion Operators (C++0x))
  • extern templates (extern Templates (C++0x))
  • forward declaration of enums (Forward Declaration of Enums (C++0x))
  • static assertions (Static Assertions (C++0x))
  • strongly typed enums (Strongly Typed Enums (C++0x))
  • type trait functions (Type Trait Functions Overview (C++0x))
• Calling procedures and functions
  • procedures and functions (Calling Procedures and Functions)
• Character set (Delphi)
  • reserved words (Fundamental Syntactic Elements)
• Comments (Delphi)
  • Fundamental Syntactic Elements#Comments and Compiler Directives (Fundamental Syntactic Elements)
• Component
  • Import Component (Import Component Wizard)
• Combined fragment (Operator and Operand for a Combined Fragment)
• Configurations
  • overview (Build Configurations Overview)
• Compiling (Compiling, Building, and Running Applications)
• Code Completion
  • overview (Code Completion)
• Change bars
  • in the Code Editor (Code Editor)
• Change parameters
  • refactoring (Change Parameters Overview (Delphi))
• Code Visualization (Using the Overview Window)
  • exporting diagrams (Exporting a Code Visualization Diagram to an Image)
• Class diagram
  • sample (UML 2.0 Sample Project, Structure Package)
• Configurations
  • creating and modifying (Creating and Modifying Build Configurations)
• Creating Option Sets (Option Sets: Creating, Applying, Editing, and Deleting)
• Code folding
  • collapsing code (Using Code Folding)
• Code Editor
  • customizing (Customizing Code Editor)
• Code insight
  • code insight (Using Code Insight)
• Component templates (Creating a Component Template)
• Comment (Annotating a Diagram)
• Compartment controls
  • viewing (Changing Appearance of Compartments)
• Conditional block
  • adding (Adding a Conditional Block)
• Class
  • filtering (Using View Filters)
  • keywords%2C C++ (class)
• Chart
  • creating (Creating a Metrics Chart)
• COFF2OMF.EXE (COFF2OMF.EXE, the Import Library Conversion Tool)
• Classes%2C member list
  • C++ language specifics (Class Member List)
• Class methods
  • C++ language specifics (Class Methods)
• Classes%2C names
  • C++ language specifics (Class Names)
  • C++ language specifics (Class Name Scope)
• Classes%2C objects
  • C++ language specifics (Class Objects)
• Classes%2C types
  • C++ language specifics (Class Types)
• Classes,
  • C++ language specifics (C++ Classes)
• Classes%2C forward
  • C++ language specifics (VCL Class Declarations)
• Constructors
  • C++ language specifics (Introduction To Constructors And Destructors)
  • C++ language specifics (Constructors)
  • overriding (Overriding the Constructor)
• Class initialization
  • C++ language specifics (Class Initialization)
• Constructors%2C defaults
  • C++ language specifics (Constructor Defaults)
• Constructors%2C order of calling
  • C++ language specifics (Order Of Calling Constructors)
• Constructors%2C overloading
  • C++ language specifics (Overloading Constructors)
• Constructors%2C copy
  • C++ language specifics (The Copy Constructor)
• Classes%2C scope
  • C++ language specifics (Class Scope)
• Casting%2C C++ style
  • C++ language specifics (New-style Typecasting)
• C++ compiler strictness
  • binding references and qualifiers (Stricter C++ Compiler: Binding of References and Qualifiers)
  • function overload resolution (Stricter C++ Compiler: Function Overload Resolution)
  • initialization and conversion (Stricter C++ Compiler: Initialization and Conversion)
  • string literals (Stricter C++ Compiler: String Literals Are Now Constants)
  • template changes (Stricter C++ Compiler: Template Changes)
• Case
  • keywords%2C C++ (case)
• Catch
  • keywords%2C C++ (catch)
• Cdecl
  • keywords%2C C++ (cdecl, _cdecl, __cdecl)
• Char
  • keywords%2C C++ (char)
• Char16_t
  • keywords%2C C++ (char16_t)
• Char32_t
  • keywords%2C C++ (char32_t)
• Compl
  • alternative representations of C++ token (compl, ~)
• Concept
  • keywords%2C C++ (concept)
• Concept_map
  • keywords%2C C++ (concept_map)
• Const
  • keywords%2C C++ (const)
• Const_cast
  • typecasting%2C C++ (const_cast (typecast Operator))
• Constexpr
  • keywords%2C C++ (constexpr)
• Continue
  • keywords%2C C++ (continue)
• C++ language
  • C++ language specifics (C++ Specifics)
• Constants%2C integer
  • lexical elements, C++ (Integer Constants)
• Constants, floating-point
  • lexical elements, C++ (Floating Point Constants)
• Constants%2C character
  • lexical elements, C++ (Character Constants)
• Character types
  • lexical elements, C++ (The Three char Types)
• Constants, wide-character
  • lexical elements, C++ (Wide-character And Multi-character Constants)
• Constant expressions
  • lexical elements, C++ (Constant Expressions)
• Constants%2C internal representation
  • lexical elements, C++ (Constants And Internal Representation)
  • lexical elements, C++ (Internal Representation Of Numerical Types)
• Constants%2C enumeration
  • lexical elements, C++ (Enumeration Constants)
• Constants%2C string
  • lexical elements, C++ (String Constants)
• Comments
  • lexical elements, C++ (Comments)
• Cpp32 preprocessor directives (Preprocessor Directives)
• Component writing (Modifying an Existing Component: Overview)
  • adding graphic capabilities (Adding Graphic Capabilities)
  • controlling access (Controlling Access)
  • default property values (Specifying the New Default Property Value)
  • drawing the component image (Drawing the Component Image)
  • hiding implementation details (Hiding Implementation Details)
  • making a control read-only (Making the Control Read-only)
  • properties (Publishing Inherited Properties)
  • providing an OnChange event (Providing an OnChange Event)
  • publishing inherited properties (Publishing Inherited Properties (Graphic))
• Creating
  • data browsing control (Creating a Data Browsing Control)
  • data editing controls (Creating a Data Editing Control)
  • graphic component (Creating a Graphic Component)
• Customizing a grid (Customizing a Grid: Overview)
• Components (Overview of Component Creation)
  • adding to the Tool palette (Making Components Available at Design Time: Overview)
  • classes (Components and Classes)
  • creating (Creating a New Component)
  • creating (Creating Components)
  • creating and registering (Creating and Registering the Modified Component)
  • designing (What Goes into a Component)
  • graphics (Using Graphics in Components: Overview)
  • grouping (Grouping Controls)
  • installing (Compiling Components into Packages)
  • installing (Adding Custom Components to the Tool Palette)
  • memory management (Components and Ownership)
  • properties (Setting Properties, Methods, and Events)
  • property categories (Property Categories)
  • property categories (Specifying Property Categories)
  • property categories (Registering Multiple Properties at Once)
  • property categories (Registering One Property at a Time)
  • property categories (Using the IsPropertyInCategory Function)
  • registering (Registering the Component)
  • registering (Registering Components (Introduction))
  • renaming (Changing the Name of a Component)
  • testing (Testing Installed Components)
  • testing (Testing Uninstalled Components)
  • troubleshooting (Troubleshooting Custom Components (C++))
• Controls
  • ancestor classes (Modifying Existing Controls)
  • data-aware (Making a Control Data Aware)
  • data-aware (Using Common Data Control Features)
  • graphic controls (Creating Graphic Controls)
  • subclassing Windows controls (Subclassing Windows Controls)
  • up-down controls (Up-down Controls)
  • windowed (Creating Original Controls)
• Constructor
  • declaring (Declaring A New Constructor (C++))
• Classes
  • defining (Defining New Classes (Delphi))
  • defining new (Defining New Classes)
  • deriving (Deriving the Component)
  • deriving new (Deriving New Classes)
  • removing dependencies (Removing Dependencies)
• Component wizard
  • components (Creating a Component with the Component Wizard)
• Change method (Modifying the Change Method)
• Component editors
  • clipboard formats (Adding Clipboard Formats)
  • context menus (Adding Items to the Context Menu)
  • creating (Adding Component Editors)
  • double-clicks (Changing the Double-click Behavior)
  • registering (Registering the Component Editor)
• Canvases
  • graphics (Using the Canvas)
• Class factories
  • COM objects (CoClasses and Class Factories)
• COM objects
  • choosing a threading model (Choosing a Threading Model)
  • creating (Using the COM Object Wizard)
  • designing (Designing a COM Object)
  • implementing (Code Generated by Wizards)
  • implementing (Implementing COM Objects with Wizards)
  • instancing types (COM Object Instancing Types)
  • marshaling data (Marshaling Data)
  • registering (Registering a COM Object)
• Clients
  • COM (COM Clients)
  • multi-tiered applications (Creating the Client Application)
• COM extensions (COM Extensions)
• COM interfaces
  • IUnknown (The Fundamental COM Interface, IUnknown)
  • pointers (COM Interface Pointers)
• COM Interfaces
  • Interfaces (COM Interfaces)
• COM+ (COM+ Event And Event Subscriber Objects)
• COM servers
  • COM object (COM Servers)
  • types of (In-process, Out-of-process, and Remote Servers)
• COM
  • clients (Creating COM Clients)
  • exposing properties (Defining a COM Object's Interface)
  • overview (Overview of COM Technologies)
  • overview of creating objects (Creating Simple COM Servers: Overview)
• COM application parts (Parts of a COM Application)
• COM clients
  • importing a type library (Importing Type Library Information)
  • writing (Controlling an Imported Object)
• Component wrappers
  • COM (Using Component Wrappers)
• Custom interfaces
  • interfaces (Custom Interfaces)
• Connections
  • ADO (Connecting to ADO Data Stores)
  • asynchronous (Forcing Asynchronous Connections)
  • timing out (Controlling Timeouts)
• Connection components
  • client applications (Connecting to the Application Server)
  • implicit (Using Implicit Connections)
• Client applications
  • calling server interfaces (Calling Server Interfaces)
  • connecting to servers (Connecting to the Server)
  • dropping connections (Dropping or Changing a Server Connection)
  • multi-tiered (The Structure of the Client Application)
• Client datasets (Using Client Datasets: Overview)
  • adding indexes (Adding a New Index)
  • architecture (Connecting a Client Dataset to Another Dataset in the Same Application)
  • cached updates (Overview of Using Cached Updates)
  • cached updates (Using a Client Dataset to Cache Updates)
  • calculated values (Representing Calculated Values)
  • constraints (Constraining Data Values)
  • copying data (Copying Data from Another Dataset)
  • copying data (Assigning Data Directly)
  • creating (Creating a New Dataset)
  • data manipulation (Working with Data Using a Client Dataset)
  • data packets (Requesting Data from the Source Dataset or Document)
  • deleting indexes (Deleting and Switching Indexes)
  • editing (Editing Data)
  • file-based applications (Using a Client Dataset with File-based Data)
  • grouping data (Using Indexes to Group Data)
  • internally calculated fields (Using Internally Calculated Fields in Client Datasets)
  • limiting records in data packets (Limiting Records with Parameters)
  • maintained aggregates (Obtaining Aggregate Values)
  • maintained aggregates (Specifying Aggregates)
  • maintained aggregates (Using Maintained Aggregates)
  • navigating (Navigating Data in Client Datasets)
  • optional parameters (Adding Application-specific Information to the Data)
  • parameters (Passing Parameters to the Source Dataset)
  • providers (Connecting to Another Dataset)
  • providers (Specifying a Provider)
  • query parameters (Sending Query or Stored Procedure Parameters)
  • saving changes (Saving Changes)
  • sharing data (Cloning a Client Dataset Cursor)
  • sorting and indexing (Sorting and Indexing)
  • types (Choosing the Type of Dataset for Caching Updates)
  • types (Indicating What Records Are Modified)
  • undoing changes (Undoing Changes)
  • using providers (Using a Client Dataset with a Provider)
  • with internal source dataset (Using a Simple Dataset)
• Calculated fields (Calculating Fields)
  • assigning values (Programming a Calculated Field)
  • defining (Defining a Calculated Field)
• Canceling data changes (Canceling Changes)
• Cached updates
  • BDE (Using the BDE to Cache Updates)
  • BDE-based (Enabling BDE-based Cached Updates)
  • applying (Applying BDE-based Cached Updates)
  • error handling (Handling Cached Update Errors)
• Constraints
  • client datasets (Handling Constraints from the Server)
  • custom (Creating a Custom Constraint)
  • data integrity (Handling Server Constraints)
  • fields (Working with Constraints)
  • server (Using Server Constraints)
• CommandText
  • client datasets (Overriding the Dataset On the Application Server)
• Check boxes (Check Boxes)
  • data-aware (Handling Boolean Field Values with Check Boxes)
• Columns
  • lookup lists (Defining a Lookup List Column)
  • properties (Displaying ADT and Array Fields)
  • properties (Restoring Default Values to a Column)
  • properties (Setting Column Properties at Design Time)
• Compiler options
  • project options (Setting IDE, Project, and Compiler Options)
• COM applications
  • DCOM applications (Writing Applications Using COM)
• Code
  • editing (Editing Code)
• Cool bars (Cool Bars)
  • adding (Adding a Cool Bar Component)
  • setting appearance (Setting the Appearance of the Cool Bar)
• Common dialog boxes
  • using (Using Windows Common Dialog Boxes)
• Clicks
  • responding to (Responding to Clicks)
• Combo boxes (Combo Boxes)
• Class library
  • TObject branch (TObject Branch)
• Class members
  • visibility (Private, Protected, Public, and Published Declarations)
• Compiler directives
  • strings (Compiler Directives for Strings)
• Conversion utilities
  • measurements (Converting Measurements)
  • measurements (Performing Conversions)
• Custom variants
  • binary operations (Implementing Binary Operations)
  • comparison operations (Implementing Comparison Operations)
  • copying (Copying and Clearing Custom Variants)
  • defining (Creating a Class to Enable the Custom Variant Type)
  • enabling (Using the TCustomVariantType Descendant)
  • loading and saving (Loading and Saving Custom Variant Values)
  • properties (Supporting Properties and Methods in Custom Variants)
  • typecasts (Enabling Casting)
  • unary operations (Implementing Unary Operations)
  • utilities (Writing Utilities to Work with a Custom Variant Type)
• Conversions
  • string to PChar (String to PChar Conversions)
  • string types (Mixing and Converting String Types)
• Clipboard (Adding the Clipboard Object)
• ChangeScale
  • typecasts (Screen Scaling and ChangeScale)
• Canvas
  • properties and methods (Common Properties and Methods of Canvas)
• Control placement (Placing the Control)
• Code sharing among event handlers (Sharing Code Among Event Handlers)
• Canvas methods
  • graphic objects (Using Canvas Methods to Draw Graphic Objects)
• Canvas object
  • properties (Using the Properties of the Canvas Object)
• Critical sections (Using Critical Sections)
• Client sockets
  • ClientSocket component (Using Client Sockets)
  • events (Client Events)
• Client connections (Client Connections)
• CodeGuard
  • errors (Access Errors)
  • errors (Exception Errors)
  • errors (Function Failure Errors)
  • errors (Resource Errors)
  • overview (CodeGuard Overview)
  • using (Using CodeGuard)
  • warnings (Memory Block Comparison Warnings)
  • warnings (Pathname Merging and Splitting Warnings)
  • warnings (String Comparison Warnings)
• COM wizards (Using COM Wizards)

D

• Display (Tools Options) (Display)
• Data types, variables, and constants (Data Types, Variables, and Constants)
• Declaring types
  • data types (Declaring Types)
• Data types
  • ordinal and real%2C Delphi (Simple Types)
  • fundamental%2C C++ (The Fundamental Types)
• Dynamically loaded libraries
  • libraries (Writing Dynamically Loaded Libraries)
• Delphi language overview (Language Overview)
• Declarations and statements
  • compiler directives,%2C delphi (Declarations and Statements)
• Diagram layout options
  • general group (Modeling - Diagram Layout Options)
• Debug build configuration
  • Build Configurations Overview
• Debug Desktop
  • SetDebug Desktop (Select Debug Desktop)
• Debugging
  • adding a watch (Adding a Watch)
  • attaching to a process (Attaching to a Running Process)
  • breakpoints (Setting and Modifying Breakpoints)
  • inspecting data elements (Inspecting and Changing the Value of Data Elements)
  • modifying expressions (Modifying Variable Expressions)
  • overview (Overview of Debugging)
  • overview (Wait Chain Traversal Overview)
  • preparation (Preparing a Project for Debugging)
  • remote applications (Installing, Starting, and Stopping the Remote Debug Server)
  • remote applications (Remote Debugging: Metaprocedure)
• Deployment
  • overview (Deploying Applications Overview)
• Development lifecycle
  • tool overview (Managing the Development Cycle Overview)
• Declare variable and field
  • initial type (Declare Variable and Declare Field Overview (Delphi))
• Documentation generation (Documentation Generation Facility)
• Delphi packages (C++)
  • Compiling C++ Design-Time Packages That Contain Delphi Source (Compiling C++ Design-Time Packages That Contain Delphi Source)
• Desktop layouts
  • saving desktop layouts (Saving Desktop Layouts)
• Database
  • adding a new connection (Using Design Guidelines with VCL Components)
  • connections (Controlling Connections)
  • dbExpress (dbExpress Framework)
  • dbExpress (dbExpress Framework Compatibility)
• Diagram
  • renaming (Renaming a Diagram)
• Diagram View
  • opening (Synchronizing the Model View, Diagram View, and Source Code)
• DCC32.EXE
  • compiling C++ (DCC32.EXE, the Delphi Command Line Compiler)
• Directives for MAKE (MAKE Directives)
• Destructors%2C directives and
  • C++ language specifics (abort And Destructors)
  • C++ language specifics (atexit, pragma exit, And Destructors)
  • C++ language specifics (Exit And Destructors)
• Destructors
  • C++ language specifics (Destructors)
• Destructors%2C invoking
  • C++ language specifics (Invoking Destructors)
• Declarations%2C namespaces
  • namespaces%2C C++ (Declaring A namespace)
• Defining
  • namespaces%2C C++ (Defining A namespace)
• Dynamic functions
  • C++ language specifics (Dynamic Functions)
• Decltype
  • keywords%2C C++ (decltype)
• Default
  • keywords%2C C++ (default)
• Delete
  • C++ language specifics (delete)
• Do
  • keywords%2C C++ (do)
• Double
  • keywords%2C C++ (double)
  • keywords%2C C++ (long)
• Dynamic_cast
  • typecasting%2C C++ (dynamic_cast (typecast Operator))
• Division
  • operators%2C C++ (Multiplicative Operators)
• Duration
  • language structure, C++ (Duration)
• Declarations%2C external
  • language structure, C++ (External Declarations and Definitions)
• Declarations
  • language structure, C++ (Possible Declarations)
• Definitions
  • language structure, C++ (Tentative Definitions)
• Declarations%2C incomplete
  • language structure, C++ (Incomplete Declarations)
• Defined (Defined)
• Declaring methods
  • methods (Declaring Methods)
• Default property values
  • properties (Default Property Values)
• Data links
  • adding to components (Adding the Data Link)
• Datasets
  • BDE-enabled (Using BDE-enabled Datasets)
  • Dataset component (Understanding Datasets: Overview)
  • HTML representation (Using Dataset Page Producers)
  • HTML representation (Using Table Producers)
  • associating with databases (Associating a Dataset with Database and Session Connections)
  • cached updates (Applying Cached Updates with Dataset Component Methods)
  • opening (Opening and Closing Datasets)
  • queries (Specifying the Query)
  • queries (Using Query-type Datasets)
  • resolving (Choosing How to Apply Updates Using a Dataset Provider)
  • states (Determining Dataset States)
  • stored procedures (Using Stored Procedure-type Datasets)
  • tables (Using Table Type Datasets)
  • types (Using TDataSet Descendants)
  • types (Types of Datasets)
  • unidirectional (Types of dbExpress Datasets)
  • updating (Updating the Dataset)
• Deriving classes
  • property editors (Deriving a Property-editor Class)
• Dialog box as component
  • component writing (Making a Dialog Box a Component: Overview)
• Declaring component types
  • deriving classes (Declaring a New Component Class)
• Dual interface
  • Automation controller (Controlling an Automation Server Using a Dual Interface)
  • interfaces (Dual Interfaces)
• Database servers
  • connecting (Connecting to a Database Server)
  • connecting (Opening a Connection Using TDataBase)
  • disconnecting (Disconnecting from a Database Server)
• Databases
  • associating with sessions (Associating a Database Component with a Session)
  • cached updates (Applying Cached Updates Using a Database)
  • changing data (Modifying Data)
  • connecting (Using TDatabase to Connect to Databases)
  • connecting (Connecting to the Database Server)
  • connection components (Connecting to Databases: Overview)
  • considerations (Using Databases)
  • database applications (Designing Database Applications: Overview)
  • datasets (Working with Associated Datasets)
  • locating (Searching for a Database Connection)
  • metadata (Obtaining Metadata)
  • security (Controlling Server Login)
  • security (Database Security)
  • sessions (Understanding Database and Session Component Interactions)
  • transactions (Transactions)
• DCOM
  • advantages (Using DCOM Connections)
• Data
  • analyzing (Analyzing Data)
  • displaying (Displaying Field Component Values in Standard Controls)
• Database applications (Writing Database Applications)
  • BDE-based (Using the Borland Database Engine)
  • deploying (Deploying Database Applications)
  • multi-tiered applications (Distributing Database Applications)
  • reports (Writing Reports)
• Database connections
  • disconnecting (Closing Database Connections)
  • dropping (Dropping Inactive Database Connections)
  • managing (Managing Database Connections)
  • opening (Opening Database Connections)
• DBASE index
  • specifying (Specifying a dBASE Index File)
• Data dictionary
  • field attributes (The Data Dictionary)
• DataRequest method
  • client datasets (Communicating with Providers Using Custom Events)
• Data-aware controls
  • associating with datasets (Associating a Data Control with a Dataset)
  • displaying data (Refreshing Data Display)
  • editing (Editing and Updating Data)
  • editing (Enabling Editing in Controls On User Entry)
  • fields (Displaying, Converting, and Accessing Field Values)
• Data sources
  • associating with datasets (Changing the Associated Dataset at Runtime)
  • disabling and enabling (Enabling and Disabling the Data Source)
  • events (Responding to Changes Mediated by the Data Source)
• Displaying data
  • disabling and enabling (Disabling and Enabling Data Display)
• Data-aware
  • controls (Using Data Controls)
• Data grids
  • customizing (Creating a Customized Grid)
  • default columns (Using a Grid Control in Its Default State)
  • drawing (Controlling Grid Drawing)
  • event handling (Responding to User Actions at Runtime)
  • runtime options DBGrid component (Setting Grid Options)
• DBCtrlGrid component (Creating a Grid That Contains Other Data-aware Controls)
• Database navigator
  • help hints (Displaying Fly-over Help)
  • multiple datasets (Using a Single Navigator for Multiple Datasets)
• DBGrid component
  • DBGridColumns component (Viewing and Editing Data with TDBGrid)
• Data packets
  • converting to XML documents (Using an XML Document as the Client of a Provider)
  • field attributes (Controlling What Information Is Included in Data Packets)
  • optional parameters (Adding Custom Information to Data Packets)
  • persistent fields (Specifying What Fields Appear in Data Packets)
  • provider options (Setting Options That Influence the Data Packets)
• Delta packets
  • editing (Editing Delta Packets Before Updating the Database)
• DbExpress
  • debugging (Debugging dbExpress Applications)
• Drivers
  • dbExpress (Setting Up TSQLConnection)
• Data formats
  • assigning (Associating Attribute Sets with Field Components)
• Dataset fields (Working with DataSet Fields)
• Data Dictionary
  • field attributes (Creating Attribute Sets for Field Components)
• DLLs
  • creating that contain VCL components (Creating DLLs Containing VCL Components (C++))
  • dynamic link libraries, using (Using DLLs in RAD Studio (C++))
  • linking (Linking DLLs)
  • locations (DLL Locations)
• Data modules (Using Component Properties and Events in a Data Module)
  • accessing from a form (Accessing a Data Module from a Form)
  • business rules (Creating Business Rules in a Data Module)
  • creating and editing (Creating and Editing Standard Data Modules)
  • naming (Naming a Data Module and Its Unit File)
  • overview (Using Data Modules)
  • placing components (Placing and Naming Components)
  • remote (Adding a Remote Data Module to an Application Server Project)
• Double-byte character sets
  • two-byte character codes (Multibyte Character Sets (MBCS))
• DbExpress database applications
  • deploying (Deploying BDE Applications)
  • deploying (Deploying dbExpress Database Applications)
• Dialog boxes
  • common dialogs (Developing Dialog Boxes)
• Distributed applications
  • interfaces (Using Interfaces in Distributed Applications)
• Drag-and-drop (Ending a Drag Operation)
• Docking
  • dockable child controls (Controlling How Child Controls Are Docked)
  • dockable child controls (Controlling How Child Controls Are Undocked)
  • dockable child controls (Making a Control a Dockable Child)
• Drag-and-dock
  • docking (Controlling How Child Controls Respond to Drag-and-dock Operations)
  • docking (Implementing Drag and Dock in Controls)
• Drag and drop (Starting a Drag Operation)
• Drawing objects (Handling Multiple Drawing Objects in Your Application)
• Drawing tools (Using Drawing Tools)
• DOM
  • Document Object Model (Using the Document Object Model)
• Database
  • adding a new connection (Adding a New Connection to the Data Explorer)
• Data Explorer
  • executing SQL (Executing SQL in the Data Explorer)
  • modifying connections (Modifying Connections in the Data Explorer)
• Displaying bitmap images (Displaying a Full View Bitmap Image in a VCL Forms Application)
• Drawing
  • polygons (Drawing a Polygon in a VCL Forms Application)
  • rectangles and ellipses (Drawing Rectangles and Ellipses in a VCL Forms Application)
  • round rectangles (Drawing a Rounded Rectangle in a VCL Forms Application)
  • straight lines (Drawing Straight Lines In a VCL Forms Application)

E

• Events (What Are Events?)
  • Automation controllers (Handling Events in an Automation Controller)
  • OnUpdateRecord (Creating an OnUpdateRecord Event Handler)
  • Code Generated When You Import Type Library Information (Code Generated When You Import Type Library Information)
  • classes and objects (Events)
  • creating (Creating Events: Overview)
  • default (Generating a Handler for a Component's Default Event)
  • handling (Displaying and Coding Shared Events)
  • handling (Associating an Event with an Existing Event Handler)
  • handling (Generating a New Event Handler)
  • handling (Locating Event Handlers)
  • handling (Using the Sender Parameter)
  • handling (Working with Events and Event Handlers)
  • menu (Associating Menu Events with Event Handlers)
  • triggering events (Triggering the Event)
  • types (Types of Events)
  • user-defined events (Defining Your Own Events)
• Exceptions
  • classes and objects (Exceptions)
  • finally blocks (Writing finally Blocks)
  • handlers (Writing Exception Handlers)
  • raising (Raising an Exception)
  • silent (Silent Exceptions)
  • throwing (Throwing An Exception (C++))
  • try blocks (Writing the Try Block)
• Expressions
  • expressions (Expressions (Delphi))
  • language structure, C++ (Expressions (C++))
  • language structure, C++ (Expressions And C++)
• Extract method
  • refactoring (Extract Method Overview (Delphi))
• Expandable tooltips (Using Tooltips During Debugging)
• Editing code
  • class completion (Using Class Completion)
• ECO framework (Importing and Exporting a Model Using XML Metadata Interchange (XMI))
• Entry and exit action
  • creating (Designing a UML 1.5 Statechart Diagram)
• ERC.EXE (RC.EXE, the Microsoft SDK Resource Compiler)
• Extending
  • namespaces%2C C++ (Extending A namespace)
• Enum
  • keywords%2C C++ (enum)
• Explicit
  • keywords%2C C++ (explicit)
• Export,
  • keywords%2C C++ (export)
• Extern
  • keywords%2C C++ (extern)
• Enum%2C assignment
  • language structure, C++ (Assignment To Enum Types)
• Enumerations
  • language structure, C++ (Enumerations)
• Expressions%2C errors
  • language structure, C++ (Errors And Overflows)
• Expressions%2C evaluation order
  • language structure, C++ (Evaluation Order)
• Escape sequences
  • lexical elements, C++ (Escape Sequences)
• Event handlers
  • declaring events (Calling the Event)
  • deleting (Deleting Event Handlers)
  • events (Changing the Standard Event Handling)
• Event handler
  • Defining the Handler Type (Defining the Handler Type)
• Editing properties
  • properties (Editing the Property as a Whole)
• Edit controls
  • displaying data (Displaying and Editing Fields in an Edit Box)
  • text controls (Edit Controls)
• Editing data
  • in grids (Editing in the Grid)
• Executable files
  • internationalizing (Dynamic Switching of Resource DLLs)
  • internationalizing (Using Resource DLLs)
• Exception objects
  • VCL (VCL Exception Classes)
  • classes (Handling Classes of Exceptions)
  • defining (Defining Your Own VCL Exceptions)
• Exception handling
  • VCL (Default Exception Handling in VCL)
  • VCL (Handling Exceptions in VCL Applications)
  • compiler options (Exception Handling Options (C++))
  • constructors (Constructors In Exception Handling (C++))
  • exceptions (Defining Protected Blocks)
  • exceptions (Exception Handling)
  • safe pointers (Smart Pointers (C++))
• Exception handlers
  • keyword (Exception-handling Statements)
  • reraising (Reraising Exceptions)
  • scope (Scope of Exception Handlers)
• Exceptions, unwinding (Unwinding Exceptions (C++))

F

• Find (Search menu) (Find)
• FastMM memory manager
• Fatal errors (Fatal errors)
• Fields
  • classes and objects (Fields)
  • default values (Setting a Default Value for a Field)
  • restricting input (Controlling and Masking User Input)
  • updating values (Editing Data in a Control)
• Filters
  • bookmark-based (Filtering Records Based On Bookmarks)
  • client datasets (Limiting What Records Appear)
  • member (Modeling - Diagram View Filters Options)
  • ranges (Understanding the Differences Between Ranges and Filters)
  • specifying (Setting the Filter Property)
  • specifying (Writing an OnFilterRecord Event Handler)
• Find references
  • find declaration symbol (Find References Overview (Delphi, C++))
  • find local references (Finding References)
• Friends%2C of classes
  • C++ language specifics (Friends Of Classes)
• Float
  • keywords%2C C++ (float)
• For
  • keywords%2C C++ (for)
• Friend
  • keywords%2C C++ (friend)
• Functions%2C declarations
  • language structure, C++ (Declarations And Definitions)
  • language structure, C++ (Declarations And Prototypes)
• Functions
  • conversion (Using a Class to Manage Conversions)
  • conversion (Using a Conversion Function)
  • language structure, C++ (Definitions)
• Functions%2C parameters
  • language structure, C++ (Formal Parameter Declarations)
• Function calls (Side Effects And Other Dangers)
  • language structure, C++ (Function Calls And Argument Conversions)
• Field datalink class (Updating the Field Data Link Class)
• Flat files
  • loading (Loading Data from a File or Stream)
  • saving (Saving Data to a File or Stream)
• Field attributes
  • removing (Removing Attribute Associations)
• Field objects
  • dynamic vs. persistent (Dynamic Field Components)
  • events (Handling Events)
  • fields (Working with Field Components: Overview)
  • methods (Working with Field Component Methods at Runtime)
  • properties (Setting Display and Edit Properties at Design Time)
  • properties (Setting Persistent Field Properties and Events)
  • properties (Setting Field Component Properties at Runtime)
• Formatting data
  • data formats (Using Default Formatting for Numeric, Date, and Time Fields)
• Formats
  • internationalizing (Formats and Sort Order)
• Fonts
  • deploying (Fonts)
• Forms
  • adding (Adding Forms)
  • creating (Using Forms)
  • creating dynamically (Creating Forms Dynamically)
  • creating modeless (Creating Modeless Forms Such as Windows)
  • displaying an auto-created (Displaying an Auto-created Form)
  • layout (Managing Layout)
  • memory management (Controlling When Forms Reside in Memory)
  • passing additional arguments (Passing Additional Arguments to Forms)
  • retrieving data from (Retrieving Data from Forms)
  • retrieving data from (Retrieving Data from Modeless Forms)
  • retrieving data from modal (Retrieving Data from Modal Forms)
  • using a local variable to create an instance (Creating a Form Instance Using a Local Variable)
• Frames (Working with Frames)
  • creating (Creating Frames)
  • sharing (Sharing Frames)
  • sharing (Using and Modifying Frames)
• Files (Working with Files)
  • TFileStream (Using File Streams)
  • copying (Copying a File)
  • date-time routines (File Date-time Routines)
  • deleting (Deleting a File)
  • finding (Finding a File)
  • manipulating (Manipulating Files)
  • reading and writing (Approaches to File I/O)
  • renaming (Renaming a File)
• Frame
  • published properties (Setting Properties at Design Time)

G

• Generics or generic types (Generics Index)
  • C++ handling (How to Handle Delphi Generics in C++)
  • constraints (Constraints in Generics)
  • function and grammar changes (Changes in Standard Functions and Grammar)
  • overview (Overview of Generics)
  • procedural types (Declaring Generics)
  • terminology (Terminology for Generics)
• Gestures (Gesturing Overview)
• GenTLB.exe
  • type library compiler (Type Library Editor Window)
• Getting started
  • adding files to a project (Adding and Removing Files)
  • adding templates to repository (Adding Templates to the Object Repository)
  • copying references (Copying References to a Local Path)
  • customizing forms (Customizing the Form)
  • customizing tool palette (Customizing the Tool Palette)
  • docking tool windows (Docking Tool Windows)
  • filtering searched components (Finding Items on the Tool Palette)
  • renaming files (Renaming Files Using the Project Manager)
  • setting component properties (Setting Component Properties (Procedure))
  • setting project options (Setting Project Options)
  • setting properties and events (Setting Properties and Events)
  • setting tool preferences (Setting Tool Preferences)
  • writing event handlers (Writing Event Handlers)
• GREP.EXE
  • GREP.EXE (GREP.EXE, the text search utility)
• Goto
  • keywords C C++ (goto)
• Graphics in the IDE (Overview of Graphics Programming)
  • VCL Forms applications (How To Build a VCL Forms Application With Graphics)
  • adding to controls (Adding Graphics to Controls)
  • canvases (Encapsulating Graphics)
  • copying to clipboard (Copying Graphics to the Clipboard)
  • cutting to clipboard (Cutting Graphics to the Clipboard)
  • displaying (Graphic Controls)
  • drawing on (Drawing On a Graphic)
  • internationalizing (Graphic Images)
  • object types (Types of Graphic Objects)
  • overview (Working with Graphics and Multimedia: Overview)
  • pasting from clipboard (Pasting Graphics from the Clipboard)
  • scrollable (Making Scrollable Graphics)
  • shapes (Shapes)
  • using the clipboard (Using the Clipboard with Graphics)
• Getting more information (Getting More Information)
• General applications
  • deploying (Deploying General Applications)
• Grids
  • draw grids (Draw Grids)
  • non-database (Grids)
  • string grids (String Grids)
  • value list editors (Value List Editors)
• Group boxes
  • radio groups (Group Boxes and Radio Groups)
• Global routines
  • helper objects (Using the VCL/RTL: Overview)
• Graphics files
  • loading and saving (Loading and Saving Graphics Files)
• GUID
  • Code Generated When You Import Type Library Information
  • Object Interfaces
  • Pages of Type Information

H

• Help
  • Microsoft Platform SDK (Help on Help)
• History Manager (Using the History Manager)
• Hiding names
  • C++ language specifics (Hiding)
• Help files for components (Creating the Help File)
• HTTP
  • advantages (Using Web Connections)
  • overview (HTTP Server Activity)
  • requests (Responding to Client Requests)
  • requests (Serving Client Requests)
• Help system (Using Help in a VCL Application)
  • Help Manager (Implementing IHelpSelector)
  • Help Manager (Registering Help System Objects)
  • Help viewers (Asking the Help Manager for Information)
  • Help viewers (Communicating with the Help Manager)
  • Help viewers (Displaying Keyword-based Help)
  • Help viewers (Displaying Tables of Contents)
  • Help viewers (Help System Interfaces)
  • IHelpSystem (Using IHelpSystem)
  • Man pages (Enabling Help in Applications)
  • Man pages (Implementing ICustomHelpViewer)
  • TApplication (Calling a Help System Directly)
  • TApplication (VCL) (How TApplication Processes VCL Help)
  • TControl (VCL) (How VCL Controls Process Help)
  • customizing (Customizing the IDE Help System)
• Helper applications (Helper Applications)
• Host environments
  • programming (Programming for Varying Host Environments)
• Header controls (Header Controls)
• Hints
  • help (Help and Hint Properties)
• Hot key controls (Hot Key Controls)
• Headers
  • HTTP (HTTP Request Header Information)
  • SOAP (Defining and Using SOAP Headers)
  • SOAP (Processing Headers in Client Applications)
• HTTP messages
  • content (The Content of HTTP Request Messages)
  • content (Setting the Response Content)
  • headers (Properties That Contain Request Header Information)
  • headers (Filling in the Response Header)
  • processing (Dispatching Request Messages)
  • responding to (Creating HTTP Response Messages)
  • response content (Generating the Content of Response Messages)
  • sending (Sending the Response)
  • types (The Request Method Type)
• HTML
  • producing (Using Page Producer Components)
• HTML-transparent tags (Using Predefined HTML-transparent Tag Names)
• HTML commands
  • database information (Representing a Dataset in HTML)
• HTML documents
  • databases and (Using Database Information in Responses)
• HTTP request messages
  • TWebRequest object (Accessing Client Request Information)
• Hello world
  • VCL Forms (Building a VCL Forms Hello World Application)
  • VCL Forms (Copying Data From One Stream To Another)
  • VCL Forms (Reading a String and Writing It To a File)
• HTML tag editor
  • editing HTML tags (Using the HTML Tag Editor)

I

• I/O errors (I/O Errors)
• Icon setting for application (Application)
• Inline assembler (Using Inline Assembly Code (Win32 Only))
• Implementing interfaces
  • interfaces (Implementing Interfaces)
• Interface references
  • interfaces (Interface References)
• Interface (UML 2.0 Class Diagram Definition)
  • changing notation (Changing Appearance of Interfaces)
  • hiding (Working with an Interface)
• Interaction use (Interaction)
  • creating (Designing a UML 2.0 Sequence or Communication Diagram)
• Ide
  • visual components (Form Designer)
  • welcome page (Tour of the IDE)
• Internal errors
  • resolving (Delphi) (Resolving Internal Errors)
  • resolving (C++) (Resolving Internal Errors)
• Instance specification
  • instantiating (Working with an Instance Specification)
• Inner classifier
  • creating (Creating an Inner Classifier)
• Interaction diagram
  • return link (Working with a UML 1.5 Message)
• ILINK32.EXE (ILINK32.EXE, the Incremental Linker)
• IMPDEF.EXE
  • IMPDEF.EXE (IMPDEF.EXE, the Module Definition Manager)
• IMPLIB.EXE (IMPLIB.EXE, the Import Library Tool)
• Include files (C++) (Using Include Files)
• Inline functions
  • keywords%2C C++ (inline)
  • C++ language specifics (Inline Functions)
  • keywords%2C C++ (__inline)
• If
  • keywords%2C C++ (if, else)
• Inline
  • keywords%2C C++ (inline)
• Int
  • keywords%2C C++ (int)
• Initialization
  • language structure, C++ (Initialization)
• Identifiers
  • lexical elements, C++ (Identifiers)
• Interfaces (Using Interfaces)
  • Automation (Automation Interfaces)
  • TInterfacedObject (TInterfacedObject)
  • dispatch (Dispatch Interfaces)
  • invokable (Understanding Invokable Interfaces)
  • polymorphism (Using Interfaces Across the Hierarchy)
  • properties (Creating Properties for Interfaces)
  • remote data modules (Extending the Interface of the Application Server)
  • reusing code (Reusing Code and Delegation)
• IDE
  • adding actions (Adding an Action to the Action List)
  • adding images (Adding an Image to the Image List)
  • deleting toolbar buttons (Deleting Toolbar Buttons)
  • extending (Extending the IDE)
  • responding to IDE events (Notifying a Wizard of IDE Events)
• IDL
  • type library syntax (Using Object Pascal or IDL Syntax)
• InternetExpress page producers
  • Web pages (Creating Web Pages with an InternetExpress Page Producer)
  • templates (Customizing the InternetExpress Page Producer Template)
• Indexes
  • listing (Obtaining Information About Indexes)
  • searching for records (Using Indexes to Search for Records)
  • sorting records (Sorting Records with Indexes)
  • specifying alternative (Specifying an Index with IndexName)
• Images
  • adding to a string list (Adding Images to a String List)
  • adding to an application (Adding Images to an Application)
  • data-aware (Displaying and Editing Graphics Fields in an Image Control)
  • displaying (Images)
• IAppServer interface
  • remote data modules (Communicating with the Client Dataset)
• International applications (Creating International Applications)
  • bi-directional (bi-directional Methods)
  • bi-directional (FlipChildren Method)
  • bi-directional (Including Bi-directional Functionality in Applications)
  • bi-directional (ParentBiDiMode Property)
  • localizing (Localizing Applications)
• Internationalization (Internationalizing Applications)
• Input method editor
  • IME (Locale-specific Features)
• Installation programs
  • InstallAware Express (Using Installation Programs)
• Input controls
  • controls (Specialized Input Controls)
• Inheritance
  • objects (Inheriting Data and Code from an Object)
• IInterface interface
  • interfaces:deriving (Implementing IInterface)
• Implements keyword
  • interfaces (Using Implements for Delegation)
• Image control adding (Adding an Image Control)
• Internet palette page
  • Web server applications (Creating Internet Applications: Overview)
• ISAPI applications
  • debugging (Debugging Web Applications That Are DLLs)
• IntraWeb
  • VCL for the Web (Using IntraWeb with Web Broker and WebSnap)
  • VCL for the Web (Creating Web Server Applications Using IntraWeb)
  • VCL for the Web (Changing VCL for the Web application type)
  • VCL for the Web (Editing the Main Form)
  • VCL for the Web (Getting Started with IntraWeb)
  • VCL for the Web (Running the Completed Application)
  • VCL for the Web (Writing an Event Handler for the Button)
• IntraWeb
  • VCL for the Web (Using IntraWeb Components)
• Invokable interfaces
  • calling (Calling Invokable Interfaces)
  • non-scalar types (Registering Nonscalar Types)
  • non-scalar types (Using Nonscalar Types in Invokable Interfaces)
• IP addresses
  • hosts vs. (Describing the Host)
• InterBase components
  • getting started (Getting Started with InterBase Express)

J

• Javascript libraries (Using the Javascript Libraries)

K

• Keywords (Keywords And Protected Words In Macros)
  • language structure, C++ (Type Specifiers)
  • lexical elements, C++ (Keywords)
  • lexical elements, C++ (Keyword Extensions)
  • lexical elements, C++ (C++-Specific Keywords)
• Key-down messages (Responding to Key-down Messages)

L

• Libraries and packages (Libraries and Packages)
• Link by Name Only
  • C++ linking (Linking C++ Library and Object Files)
• Live templates
  • creating (Creating Live Templates)
  • creating (Using Live Templates)
• Layout
  • setting up (Laying Out a Diagram Automatically)
• Late_check
  • keywords%2C C++ (late_check)
• Logical operators
  • operators%2C C++ (Logical Operators)
• Linkage
  • language structure, C++ (Linkage)
• Lexical elements
  • lexical elements, C++ (Lexical Elements)
• Line continuation (Using The Backslash For Line Continuation)
• Loading images
  • files (Loading and Storing Graphics)
• List boxes (List Boxes and Check-list Boxes)
  • data-aware (Using TDBListBox and TDBComboBox)
  • data-aware data (Displaying and Editing Data in List and Combo Boxes)
• Lookup list boxes
  • lookup combo boxes (Displaying and Editing Data in Lookup List and Combo Boxes)
• Labels
  • displaying data (Displaying Data as Labels)
  • static text controls (Labels)
• Lookup fields
  • defining (Defining a Lookup Field)
• Localization (Localizing Applications)
• License requirements
  • software license requirements (Software License Requirements)
• Lists (Working with Lists)
  • controls (List Controls)
  • operations (Common List Operations)
  • persistant (Persistent Lists)
  • string (Working with String Lists)
• List views (List Views)
• Long string routines
  • strings (Commonly Used Long String Routines)
• Line drawing (Drawing Lines)
  • refining (Refining Line Drawing)
• Lines and polylines drawing (Drawing Lines and Polylines)
• Locking objects (Locking Objects)
• Logins
  • requiring (Setting Pages to Require Logins)
• Listening connections (Listening Connections)

M

• Methods (Calling Methods)
  • classes and objects (Methods)
  • dispatching (Dispatching Methods)
  • dynamic (Dynamic Methods)
  • functions (Creating Methods: Overview)
  • nonvirtual (Regular Methods (C++))
  • static (Static Methods)
  • virtual methods (Virtual Methods)
• method pointers in Delphi (Procedural Types)
• Memory management
  • Delphi for Win32 (Memory Management on the Win32 Platform)
  • interfaced objects (Memory Management of Interface Objects)
  • interfaced objects (Not Using Reference Counting)
  • interfaced objects (Using Reference Counting)
• MIDAS redistributables (Understanding Multi-tiered Database Applications)
• Modeling options
  • Diagram Appearance General (Modeling - Diagram Appearance Options)
• MSBuild (MSBuild Overview)
• MDA (Synchronization Between Models and Source Code)
• MSBuild command (Building a Project Using an MSBuild Command)
• Macro
  • recording (Recording a Keystroke Macro)
• Message
  • self (Working with a UML 2.0 Message)
• Model element
  • hiding and showing (Hiding and Showing Model Elements)
• Model
  • reloading (Troubleshooting a Model)
• Metrics
  • sorting results (Viewing Metric Results)
• MAKE.EXE (MAKE)
• MAKE macros (MAKE Macros)
• Messages (C+) (Message Options)
• Module definition files (Module Definition Files)
• Member functions
  • C++ language specifics (Member Functions)
• Members%2C scope
  • C++ language specifics (Member Scope)
• Mutable
  • keywords%2C C++ (mutable)
• Modifiers
  • keywords%2C C++ (unsigned)
• Modifiers%2C function
  • language structure, C++ (Function Modifiers)
• Macros
  • predefined (C++) (Predefined Macros)
• Message handlers
  • Windows messages (Changing Message Handling)
  • creating (Creating New Message Handlers)
  • overriding message handlers (Overriding the Handler Method)
  • parameters (Using Message Parameters)
• Messages
  • dispatching messages (Dispatching Messages)
  • overview (Handling Messages and System Notifications: Overview)
  • trapping messages (Trapping Messages)
• Mouse-down messages (Responding to Mouse-down Messages)
  • key-down-messages (Handling Mouse-down and Key-down Messages)
• Marshaling
  • mechanism (The Marshaling Mechanism)
• Multi-tiered applications
  • ActiveX clients (Distributing a Client Application as an ActiveX Control)
  • InternetExpress (Building Web Applications Using InternetExpress)
  • advantages (Advantages of the Multi-tiered Database Model)
  • client applications (Creating Multi-tiered Applications: Overview)
  • connection protocols (Choosing a Connection Protocol)
  • creating (Building a Multi-tiered Application)
  • data providers (Using Provider Components)
  • multiple remote data modules (Connecting to an Application Server That Uses Multiple Data Modules)
  • multiple remote data modules (Using Multiple Server Data Modules)
  • overview (Overview of a Three-tiered Application)
  • providers (Understanding Multi-tiered Database Applications)
  • state information (Supporting State Information in Exposed Data Modules)
• Master/detail relationships
  • multi-tiered applications (Supporting Master/detail Relationships)
  • queries (Establishing Master/detail Relationships Using Parameters)
  • tables (Creating Master/detail Relationships)
• MTS
  • database applications (Using Transactional Data Modules)
• Multi-tiered database applications
  • client datasets (Using a Multi-Tiered Architecture)
• Multi-threaded applications
  • applications (Managing Multiple Sessions)
• Memo fields
  • displaying and editing (Displaying and Editing Text in a Memo Control)
  • displaying with format information (Displaying and Editing Text in a Rich Edit Memo Control)
• Mouse events
  • data controls (Enabling Mouse, Keyboard, and Timer Events)
  • parameters (What's in a Mouse Event)
• Metadata
  • dbExpress (Accessing dbExpress Schema Information)
  • dbExpress (Fetching Metadata into a dbExpress Dataset)
• Master/detail tables
  • unidirectional datasets (Setting Up Master/Detail Linked Relationships)
• MDI applications
  • SDI applications (User Interface Models)
  • multiple document interface (MDI Applications)
• Merge modules
  • packages (Merge Modules)
• Menus
  • VCL Forms (Creating Actions in a VCL Forms Application)
  • VCL Forms (Using ActionManager to Create Actions in a VCL Forms Application)
  • VCL Forms (Creating a VCL Form Instance Using a Local Variable)
  • VCL Forms (Displaying an Auto-Created VCL Form)
  • accelerator keys (Specifying Accelerator Keys and Keyboard Shortcuts)
  • adding images (Adding Images to Menu Items)
  • adding menu items (Adding, Inserting, and Deleting Menu Items)
  • building (Building Menus)
  • color and bitmaps (Adding Color, Patterns, or Pictures to Menus, Buttons, and Toolbars)
  • creating (Creating and Managing Menus)
  • creating submenus (Creating Submenus)
  • customizable (Creating Customizable Toolbars and Menus)
  • editing menu items (Editing Menu Items in the Object Inspector)
  • icons (Adding Icons to Menus and Toolbars)
  • icons (Selecting Menu and Toolbar Styles)
  • manipulating menu items at runtime (Manipulating Menu Items at Runtime)
  • merging (Determining the Order of Merged Menu Items: GroupIndex Property)
  • merging (Merging Menus)
  • moving menu items (Moving Menu Items)
  • naming (Naming Menus)
  • naming menu items (Naming the Menu Items)
  • specifying the active menu (Specifying the Active Menu: Menu Property)
  • switching between (Switching Between Menus at Design Time)
  • templates (Naming Conventions for Template Menu Items and Event Handlers)
  • templates (Saving a Menu as a Template)
  • templates (Using Menu Templates)
  • viewing (Viewing the Menu)
• Main form
  • hiding (Hiding the Main Form)
• Menu Designer
  • context menu (Using the Menu Designer Context Menu)
  • opening (Opening the Menu Designer)
• Measurements
  • adding units (Adding New Measurement Types)
  • adding units (Creating a Simple Conversion Family and Adding Units)
• Mouse pointer
  • drag-and-drop (Changing the Drag Mouse Pointer)
• Menu items
  • disabling (Disabling Menu Items)
• Mouse actions
  • adding a field to a form (Adding a Field to a Form Object to Track Mouse Actions)
• Mouse-down action (Responding to a Mouse-down Action)
• Mouse move
  • responding to (Responding to a Mouse Move)
• Mouse-up action (Responding to a Mouse-up Action)
• Mouse
  • responding to (Responding to the Mouse)
• Movement
  • tracking (Tracking Movement)
• Multimedia (Working with Multimedia)
• Multi-read exclusive write synchronizer
  • synchronizer (Using the Multi-read Exclusive-write Synchronizer)
• Modal
  • VCL Forms (Dynamically Creating a VCL Modal Form)
• Modeless
  • VCL Forms (Dynamically Creating a VCL Modeless Form)
• Multithreaded applications
  • cleaning up threads (Writing Cleanup Code)
  • exception handling (Handling Exceptions)
  • initializing threads (Initializing a Thread)
  • main thread (Using the Main VCL Thread)
  • simultaneous thread access (Avoiding Simultaneous Thread Access to the Same Memory)
  • thread object (Defining the Thread Object)
  • waiting for threads (Waiting for Threads)
  • writing the thread function (Writing the Thread Function (Procedure))

N

• Nested types
  • C++ language specifics (Nested Types)
  • classes and objects (Nested Type Declarations)
• Namespaces
  • programs and units (Using Namespaces with Delphi)
• Namespace
  • viewing (Working with a Namespace or a Package)
• Node
  • optimizing size (Resizing Model Elements)
• New
  • C++ language specifics (new)
  • alternative representations of C++ tokens (and_eq, &=)
• New users (Helpful Resources for New Users)
• Namespaces%2C overview
  • C++ language specifics (namespace)
• Not
  • alternative representations of C++ tokens (not, !)
• Not_eq
  • alternative representations of C++ token (not_eq, !=)
• Nullptr
  • keywords%2C C++ (nullptr)
• Nesting (Nesting Parentheses And Commas)
• Null directive ( (null Directive))
• Naming conventions
  • methods (Naming Methods)
• Nonvisual components
  • creating (Creating Nonvisual Components)
• New Field dialog box (Defining a Data Field)
• Null-terminated string routines
  • strings (Commonly Used Routines for Null-terminated Strings)
• Naming
  • threads (Assigning Separate Names to Similar Threads)
  • threads (Naming a Thread)
• Non-blocking connections (Non-blocking Connections)

O

• Options (Project menu) (Options)
• Open (File menu) (Open)
• of object (Procedural Types)
• object reserved word (Procedural Types)
• Operating system errors (Operating system errors)
• Operator overloading
  • classes and objects (Operator Overloading)
• Object interfaces
  • interfaces (Object Interfaces)
• Options
  • disabling changes (Configuring UML Modeling)
  • general (Modeling - General Options)
  • generate documentation general (Modeling - Generate Documentation Options)
• Option sets (C++) (Option Sets Overview)
• OCL
  • constraint (OCL Support)
• OCL object constraint
  • creating (Creating an OCL Constraint)
• Operator new
  • C++ language specifics (Operator new Placement Syntax)
  • C++ language specifics (Operator new)
  • C++ language specifics (The Operator new With Arrays)
• Overloading operators
  • C++ language specifics (Overloading The Operator delete)
  • C++ language specifics (Overloading The Operator new)
• Operators%2C overloading
  • operator overloading, C++ (Overloading Operators)
  • operator overloading, C++ (Example Of Overloading Operators)
  • operator overloading, C++ (Overloading The Assignment operator =)
  • operator overloading, C++ (Overloading Binary Operators)
  • operator overloading, C++ (Overloading The Class Member Access Operators -)
  • operator overloading, C++ (Overloading The Function Call Operator ( ))
  • operator overloading, C++ (Overloading Operator Functions)
  • operator overloading, C++ (Overloaded Operators And Inheritance)
  • operator overloading, C++ (Overloading The Subscript Operator )
  • operator overloading, C++ (Overloading Unary Operators)
• Operator
  • keywords%2C C++ (operator)
  • operators%2C C++ (Postfix Expression Operators Index)
  • operators%2C C++ (Unary Operators Index)
  • operators%2C C++ (Binary Operators Index)
  • operators%2C C++ (Operators Summary)
  • operators%2C C++ (Overloading Operator Functions Overview Index)
  • operators%2C C++ (Explicit Conversion Operators (C++0x))
• Or
  • alternative representations of C++ tokens (or, )
• Or_eq
  • alternative representations of C++ token (or_eq, )
• Operators%2C binary
  • operators%2C C++ (Binary Operators)
• Operators%2C C++ specific
  • operators%2C C++ (C++ Specific Operators)
• Operators%2C equality
  • language structure, C++ (Equality Operators)
• Objects
  • Delphi (Examining a Delphi Object)
  • classes (What Is an Object)
  • components (Objects, Components, and Controls)
  • creating (Creating, Instantiating, and Destroying Objects)
  • language structure, C++ (Objects)
  • variables (Using Object Variables)
• Operators%2C summary
  • operators%2C C++ (Operators Summary)
• Operators%2C function calls
  • operators%2C C++ (Function Call Operator)
• Operators%2C expressions
  • operators%2C C++ (Primary Expression Operators)
• Operators%2C unary
  • operators%2C C++ (Unary Operators)
• Open Tools API
  • Tools API (Overview of the Tools API)
• Object-oriented programming (Using the Object Model)
  • component writing (Object-oriented Programming for Component Writers: Overview)
• Overriding methods
  • methods (Overriding Methods)
• OLE containers
  • object linking and embedding (Creating Clients for Servers That Do Not Have a Type Library)
• Object pooling
  • remote data modules (Pooling Remote Data Modules)
• Object fields
  • fields (Using Object Fields)
• Object Repository
  • Repository (Adding Items to the Object Repository)
  • Repository (Copying an Item)
  • Repository (Inheriting an Item)
  • Repository (Modifying Shared Items)
  • Repository (Sharing Items Within a Project)
  • Repository (Sharing Objects in a Team Environment)
  • Repository (Using an Item)
  • Repository (Using an Object Repository Item in a Project)
  • Repository (Using the Object Repository)
• Owner-draw controls (Sizing Owner-draw Items)
• OnPopup event
  • handling (Handling the OnPopup Event)

P

• Paste (Edit menu) (Paste)
• Persisting breakpoints (Setting and Modifying Breakpoints)
• Properties
  • classes and objects (Properties)
  • component writing (Creating Properties: Overview)
  • component writing (Defining Properties)
  • events (Providing Help for Your Component)
  • methods (Properties, Methods, and Events)
  • setting (Setting Component Properties)
  • setting (Setting Properties at Runtime)
  • storing properties (Storing and Loading Properties)
  • types (Types of Properties)
• Pointer types
  • data types (Pointers and Pointer Types)
• Procedural types
  • data types (Procedural Types)
• Packages
  • and DLLs (Packages and Standard DLLs)
  • building (Building Packages)
  • compiler directives (Package-specific Compiler Directives)
  • compiling (Packages)
  • compiling (Compiling Packages)
  • creating (Creating a Package)
  • custom (Custom Packages)
  • deploying (Package Files)
  • deploying (Deploying Packages)
  • design-time (Design-time Packages)
  • editing an existing (Editing an Existing Package)
  • editing source files manually (Editing Package Source Files Manually)
  • files (Package Files Created by Compiling)
  • installing component (Installing Component Packages)
  • loading/unloading (Loading Packages with the LoadPackage Function)
  • overview of creating and editing (Creating and Editing Packages)
  • packages (Working with Packages and Components: Overview)
  • runtime defined (Runtime Packages)
  • structure (Understanding the Structure of a Package)
  • units (Building Packages)
  • using command-line compiler and linker (Compiling and Linking from the Command Line)
  • using in an application (Loading Packages in an Application)
  • weak packaging (Using the Weak Packaging Directive)
  • when to use (When to Use Packages and DLLs)
  • which runtime to use (Deciding Which Runtime Packages to Use)
  • why use (Why Use Packages)
• Parameters
  • ADO command (Handling Command Parameters)
  • getting from providers (Getting Parameters from the Application Server)
  • procedures and functions (Parameters (Delphi))
• Procedures and functions
  • procedures and functions (Procedures and Functions)
• Program control (Program Control)
• Program organization
  • programs and units (Programs and Units)
• Project
  • Clean (Project Manager)
• Projects
  • creating projects (Creating a Project)
  • types of (Starting a Project)
• Pattern Registry
  • Patterns (Patterns)
• Pin
  • creating (Creating a Pin)
• Patterns as First Class Citizens
  • adding participants (Adding Participants to the Patterns as First Class Citizens)
• Precompiled header files (Using Precompiled Header Files)
• Polymorphic classes
  • C++ language specifics (Polymorphic Classes)
• Property
  • keywords%2C C++ (__property)
• Published
  • keywords%2C C++ (__published)
• Pascal
  • keywords%2C C++ (pascal, _pascal, __pascal)
• Private
  • keywords%2C C++ (private)
• Protected
  • keywords%2C C++ (protected)
• Public
  • keywords%2C C++ (public)
• Precedence
  • operators%2C C++ (Precedence Of Operators)
• Pointers%2C objects
  • language structure, C++ (Pointer Arithmetic)
• Pointers%2C constants
  • language structure, C++ (Pointer Constants)
• Pointers%2C conversions
  • language structure, C++ (Pointer Conversions)
• Pointers
  • classes (Classes and Pointers)
  • language structure, C++ (Pointer Declarations)
  • language structure, C++ (Pointers)
  • language structure, C++ (Pointers To Functions)
  • language structure, C++ (Pointers To Objects)
• Pseudovariables
  • lexical elements, C++ (Table Of CodeGear C++ Register Pseudovariables)
• Punctuators
  • lexical elements, C++ (Punctuators)
• Protected methods
  • methods (Protecting Methods)
• Perform method
  • sending messages (Calling a Control's Message Handler Directly)
• PostMessage method
  • sending messages (Sending a Message That Does Not Execute Immediately)
• Property editors (Using Property Editors)
  • creating (Adding Property Editors)
• PaValueList
  • paSubProperties (Specifying Editor Attributes)
• Procedure
  • Register (Writing the Register Procedure)
• Palettes
  • graphics (Handling Palettes)
• Pictures
  • graphics (Working with Pictures)
  • replacing (Replacing the Picture)
• Property page
  • adding controls (Adding Controls to a Property Page)
  • associating with ActiveX controls (Associating Property Page Controls with ActiveX Control Properties)
  • updating (Updating the Property Page)
• Property page wizard
  • creating a new property page (Creating a New Property Page)
• Paradox tables
  • local transactions (Using Local Transactions)
  • network control files (Specifying Paradox Directory Locations)
  • passwords (Working with Password-protected Paradox and dBASE Tables)
• Persistent connections (Specifying Default Database Connection Behavior)
• Persistent columns
  • adding buttons (Putting a Button in a Column)
  • creating (Creating Persistent Columns)
  • deleting in Columns editor (Deleting Persistent Columns)
  • reordering (Arranging the Order of Persistent Columns)
• Providers
  • XML (Using an XML Document as the Source for a Provider)
  • custom events (Responding to Client-generated Events)
  • error handling (Resolving Update Errors On the Provider)
  • fetching data (Determining the Source of Data)
  • updating data (Responding to Client Update Requests)
• Persistent fields
  • creating (Creating Persistent Fields)
  • defining (Defining New Persistent Fields)
  • deleting (Deleting Persistent Field Components)
  • field objects (Persistent Field Components)
  • ordering (Arranging Persistent Fields)
• Packages and DLLs
  • creating (Creating Packages and DLLs)
• Page controls (Page Controls)
• Paint boxes
  • drawing (Paint Boxes)
• Panels (Panels)
• Progress bars (Progress Bars)
• Procedures
  • interfaces (Using Interfaces with Procedures)
• PChar local variables (Returning a PChar Local Variable)
• Popup menus (Providing a Pop-up Menu)
• Pen color (Changing the Pen Color)
• Pen mode (Changing the Pen Mode)
• Pen style (Changing the Pen Style)
• Pen width (Changing the Pen Width)
• Polygons (Drawing Polygons)
• Polylines (Drawing Polylines)
• Pen position (Getting the Pen Position)
• Picture
  • loading from a file (Loading a Picture from a File)
  • saving to file (Saving a Picture to a File)
• Pixels
  • reading and setting (Reading and Setting Pixels)
• Pens (Using Pens)
• Protocols
  • Internet (Terminology and Standards)
• Page producers
  • chaining (Chaining Page Producers Together)
• Ports (Using Ports)
  • services and (Services and Ports)
• Placing bitmap images (Placing A Bitmap Image in a Control in a VCL Forms Application)

Q

• Queries
  • datasets (Using TQuery)
  • executing (Executing Queries That Don't Return a Result Set)
  • heterogenous (Creating Heterogenous Queries)
  • heterogenous (Obtaining an Editable Result Set)
  • parameters (Using Parameters in Queries)
  • preparing (Preparing Queries)
  • setting parameters at design time (Supplying Parameters at Design Time)
  • setting parameters at runtime (Supplying Parameters at Runtime)
  • unidirectional cursors (Using Unidirectional Result Sets)
  • update objects (Using the Update SQL Editor)
  • update objects (Creating SQL Statements for Update Components)
  • updating a read-only result set (Updating a Read-only Result Set)

R

• redist.exe installer (Deploying Applications Overview)
• RTTI - working with (Working with RTTI)
• Range (Debug windows) (Range)
• Reopen (File menu) (Reopen)
• Run (Run menu command) (Run)
• Runtime errors (Delphi Runtime Errors)
• Reflection viewer (Assembly Metadata Explorer (Reflection viewer))
• Reflection viewer
  • Assembly Metadata Explorer (Reflection viewer) (Assembly Metadata Explorer (Reflection viewer))
• Release build configuration
  • Build Configurations Overview
• Refactoring (Refactoring Overview)
  • extract resource string (Extract Resource String (Delphi))
  • preview (Previewing and Applying Refactoring Operations)
  • procedures (Refactoring Code)
• Rename symbol
  • refactoring (Renaming a Symbol)
  • Pull Up/Push Down (Refactoring - Pull Members Up and Push Members Down)
  • change parameters (Refactoring - Changing Parameters)
  • extract interface (Refactoring - Extracting Interfaces)
  • extract method (Refactoring - Extracting Method)
  • extract superclass (Refactoring: Extracting Superclass)
  • inline variable (Refactoring - Creating Inline Variables)
  • introduce variable (Refactoring - Introducing Variables)
  • introduce field (Refactoring - Introducing Fields)
  • move members (Refactoring - Moving Members)
  • preview (Previewing and Applying Refactoring Operations)
  • renaming (Refactoring - Renaming Elements)
  • safe delete (Refactoring - Safe Delete)
• Required interface
  • creating (Working with a Provided or Required Interface)
• Reserved words in Delphi (Fundamental Syntactic Elements)
• Role
  • binding to different classifiers (Working with a Collaboration Use)
• RLINK32.DLL (RLINK32.DLL, the Resource Linker (C++))
• References%2C arguments
  • C++ language specifics (Reference Arguments)
• References
  • C++ language specifics (Referencing)
• References%2C simple
  • C++ language specifics (Simple References)
• RTTI
  • C++ language specifics (Runtime Type Identification (RTTI) Overview)
• Runtime type identification
  • C++ language specifics (Runtime Type Identification And Destructors)
• Register
  • keywords%2C C++ (register)
• Reinterpret_cast
  • typecasting%2C C++ (reinterpret_cast (typecast Operator))
• Requires
  • Delphi directive (requires)
  • keywords%2C C++ (requires)
• Restrict
  • keywords%2C C++ (restrict)
• Return
  • keywords%2C C++ (return)
• Relational operators
  • operators%2C C++ (, , =, = Relational Operators)
• Reference declarations
  • language structure, C++ (C++ Reference Declarations)
• Read
  • write (Access Methods (properties))
• ReadOnly property
  • FReadOnly (Changing the Default Value of FReadOnly)
• Responding to data changes (Responding to Data Changes)
• Registering components
  • Tool palette (Registering Components)
• RegisterPropertyEditor
  • registering property editors (Registering the Property Editor)
• Remote connections
  • brokering (Brokering Connections)
  • managing (Managing Server Connections)
  • using DCOM (Specifying a Connection Using DCOM)
  • using HTTP (Specifying a Connection Using HTTP)
  • using SOAP (Specifying a Connection Using SOAP)
  • using TCP/IP (Specifying a Connection Using Sockets)
• Remote data modules
  • creating (Configuring TMTSDataModule)
  • creating (Configuring TRemoteDataModule)
  • creating (Configuring TSOAPDataModule)
  • setting up (Setting Up the Data Module)
• Rave component overview (Rave Component Overview)
• Rave Reports
  • Tools (Adding Rave Reports to RAD Studio)
  • getting started (Getting Started with Rave Reports)
  • overview (Rave Reports: Overview)
• Rave Visual Designer (Rave Visual Designer)
• Referential integrity
  • stored procedures (Referential Integrity, Stored Procedures, and Triggers)
• Records
  • adding (Adding New Records)
  • advanced (Structured Types)
  • changing (Modifying Entire Records)
  • deleting (Deleting Records)
  • filters (Displaying and Editing a Subset of Data Using Filters)
  • finding (Searching Datasets)
  • iterating through (Using the Eof and Bof Properties)
  • marking (Marking and Returning to Records)
  • navigating (Navigating Records in a Filtered Dataset)
  • navigating (Navigating Datasets)
  • navigating and manipulating (Navigating and Manipulating Records)
  • posting (Posting Data)
  • refreshing (Refreshing Records)
  • specifying ranges (Specifying Ranges)
  • traditional (Structured Types)
  • updating (Updating Records)
• Ranges
  • applying (Applying or Canceling a Range)
  • modifying (Modifying a Range)
  • records (Limiting Records with Ranges)
• Resolving
  • influencing generated SQL (Influencing How Updates Are Applied)
• Reference fields (Working with Reference Fields)
• Resource DLLs
  • locales (Creating Resource DLLs)
• Resources
  • isolating (Isolating Resources)
• Resizing
  • dynamic (Considerations When Dynamically Resizing Forms and Controls)
• Resource files
  • menus (Importing Resource Files)
• Reusing code
  • techniques (Reusing Components and Groups of Components)
• Rich edit controls
  • memo controls (Memo and Rich Edit Controls)
• Radio buttons (Radio Buttons)
• Registry
  • system registry (Working with ini Files and the System Registry)
• repeat loops (Declarations and Statements)
• Rectangle drawing (Drawing Rectangles and Ellipses)
• Rounded rectangles (Drawing Rounded Rectangles)
• Rubber banding example (Rubber Banding Example)
• Resume method
  • Suspend method (Starting and Stopping Threads)
• Response templates
  • HTML templates (HTML Templates)
• Response messages
  • status (Indicating the Response Status)
• Remotable objects (Remotable Object Example)
• Reports
  • Rave Reports (Using Rave Reports in RAD Studio)
• Rename
  • renaming (Renaming Files)
• Ribbon Controls
  • adding commands to the ribbon (Adding Commands to the Ribbon)
  • creating an application (Creating an Application that Uses Ribbon Controls)

S

• Scale (Edit menu) (Scale)
• Size (Edit menu) (Size)
• search path
  • Compiler (Compiler)
  • Directories and Conditionals (Directories and Conditionals)
  • Paths and Directories (C++) (Paths and Directories (C++))
  • Add Symbol Table Search Path (Add Symbol Table Search Path)
• settime
  • gettime, settime (gettime, settime)
• String types
  • conversions (String Dependencies)
  • data types (String Types)
• Structured types
  • data types (Structured Types)
  • records (Structured Types)
• Standard routines
  • System unit (Standard Routines and I/O)
• Shortcuts
  • other (Modeling - Keyboard Shortcuts)
• Source control
  • basics (Using Source Control)
• Symbol rename
  • refactoring (Symbol Rename Overview (Delphi, C++))
• Sync Edit (Using Sync Edit)
  • editing code (Sync Edit Mode (Delphi, C++))
• State
  • nested (Working with a Complex State)
• Stereotype
  • assigning (Assigning an Element Stereotype)
• Shortcut
  • create (Creating a Shortcut)
• Shortcut to classifier
  • creating (Associating an Object with a Classifier)
• State invariant
  • connecting (Creating a State Invariant)
• Stub implementation
  • using (Using the Stub Implementation Pattern)
• Sets
  • using (Working with a Set of Audits)
  • using (Working with a Set of Metrics)
• Static properties
  • C++ language specifics (Static Properties)
• Static members
  • C++ language specifics (Static Members)
• Scope
  • C++ language specifics (C++ Scope)
  • language structure, C++ (Scope)
  • objects (Scope and Qualifiers)
• Scope%2C rules
  • C++ language specifics (C++ Scoping Rules Summary)
• Set_new_handler
  • C++ language specifics (Handling Errors For The New Operator)
• Scope%2C resolution operator
  • operator overloading, C++ (Scope Resolution Operator ::)
• Short
  • keywords%2C C++ (short)
• Signed
  • keywords%2C C++ (signed)
• Sizeof operator
  • keywords%2C C++ (sizeof)
• Static
  • keywords%2C C++ (static)
• Static_assert
  • keywords%2C C++ (static_assert)
• Static_cast
  • typecasting%2C C++ (static_cast (typecast Operator))
• Struct
  • keywords%2C C++ (struct)
• Switch
  • keywords%2C C++ (switch)
• Storage classes
  • language structure, C++ (Storage Classes And Types)
• Statements%2C expression
  • language structure, C++ (Expression Statements)
• Statements%2C iteration
  • language structure, C++ (Iteration Statements)
• Statements%2C jump
  • language structure, C++ (Jump Statements)
• Statements%2C labeled
  • language structure, C++ (Labeled Statements)
• Statements%2C selection
  • language structure, C++ (Selection Statements)
• Statements
  • language structure, C++ (Statements)
• Structures%2C member access
  • language structure, C++ (Structure Member Access)
• Structures%2C member declarations
  • language structure, C++ (Structure Member Declarations)
• Structures%2C name spaces
  • language structure, C++ (Structure Name Spaces)
• Structures
  • language structure, C++ (Structures)
  • language structure, C++ (Structures And Functions)
• Structures%2C untagged
  • language structure, C++ (Untagged Structures And Typedefs)
• Structures%2Canonymous (pragma anon_struct)
• Standard events
  • events (Implementing the Standard Events)
• Subcomponents
  • properties (Creating Properties for Subcomponents)
• SendMessage method
  • sending messages (Sending a Message Using the Windows Message Queue)
• Sending messages
  • overview (Sending Messages)
• Safecall
  • events (How Delphi Adds Events)
  • properties (How Delphi Adds Properties)
• SafeArrays (SafeArrays)
• SQL
  • executing commands (Sending Commands to the Server)
  • executing commands (Executing Commands That Do Not Return Records)
  • metadata commands (Creating and Modifying Server Metadata)
  • specifying commands (Specifying the Command to Execute)
• SOAP
  • advantages (Using SOAP Connections)
  • servers (Writing Servers that Support Web Services)
• Sockets
  • advantages (Using Socket Connections)
• Sort order
  • specifying (Creating an Index with IndexFieldNames)
• Search
  • Find methods (Executing a Search with Find Methods)
  • Goto methods (Executing a Search with Goto Methods)
  • partial keys (Searching On Partial Keys)
  • repeating or extending (Repeating or Extending a Search)
  • specifying current record (Specifying the Current Record After a Successful Search)
• Stored procedures
  • Oracle overloaded (Working with Oracle Overloaded Stored Procedures)
  • binding parameters (Binding Parameters)
  • datasets (Using TStoredProc)
  • executing (Executing Stored Procedures That Don't Return a Result Set)
  • multiple result sets (Fetching Multiple Result Sets)
  • parameters (Working with Stored Procedure Parameters)
  • preparing (Preparing Stored Procedures)
• Search criteria
  • index-based searches (Using Locate)
  • searching for data (Using Lookup)
• Sessions
  • Session component (Managing Database Sessions)
  • activating (Activating a Session)
  • getting information (Retrieving Information About a Session)
  • in Web applications (Adding a Session to the Web Module)
  • multiple (Creating Additional Sessions)
  • naming (Naming a Session)
• spin loop (System.YieldProcessor)
• SQL statements
  • passthrough (Using Passthrough SQL)
• SDI applications
  • single document interface (SDI Applications)
• Service applications
  • Application object (Service Applications)
  • debugging (Debugging Service Applications)
  • threads (Service Threads)
• Strings
  • accessing in a string list (Accessing a Particular String)
  • adding and sorting (Copying a Complete String List (VCL))
  • adding and sorting (Creating Strings)
  • adding and sorting (Deleting Strings)
  • adding and sorting (Iterating Through Strings in a List)
  • declaring and initializing (Declaring and Initializing Strings)
  • Enabling Application Code to Work for Different Locales (Enabling Application Code to Work for Different Locales)
  • sort list (Adding and Sorting Strings)
  • working with (Working with Strings)
• Speed button
  • adding to a panel (Adding a Speed Button to a Panel)
  • assigning a glyph (Assigning a Speed Button's Glyph)
  • creating a group (Creating a Group of Speed Buttons)
  • setting the initial condition (Setting the Initial Condition of a Speed Button)
• Scroll bars (Adding Scroll Bars at Runtime)
  • controls (Scroll Bars)
• Scroll boxes (Scroll Boxes)
• Speed buttons (Speed Buttons)
• Splitter control
  • resizing (Splitter Controls)
• Status bars (Status Bars)
• Streams (Using Streams)
  • copying data (Copying Data Between Streams)
  • position (Specifying the Stream Position and Size)
  • reading and writing data (Using Streams to Read or Write Data)
• String lists
  • adding to (Adding a String to a List)
  • associated objects (Associating Objects with a String List)
  • copying (Copying a Complete String List)
  • counting (Counting the Strings in a List)
  • creating (Creating a New String List)
  • deleting from (Deleting a String from a List)
  • finding strings (Locating Items in a String List)
  • graphical objects (Adding Graphical Objects to a String List)
  • iterating through (Iterating Through Strings in a List)
  • loading and saving (Loading and Saving String Lists)
  • manipulating (Manipulating Strings in a List)
• SelectAll (Selecting All Text)
• Style property
  • brushes (Changing the Brush Style)
• Shape drawing (Drawing Shapes (Code))
• Screen refreshing (Refreshing the Screen)
• SOAP application wizard
  • using (Using the SOAP Application Wizard)
• Sockets
  • TCP/IP protocol (Working with Sockets)
  • describing (Describing Sockets)
  • errors (Error Events)
  • event handling (Responding to Socket Events)
  • reading and writing (Reading and Writing Over Socket Connections)
  • types of connections (Types of Socket Connections)
• Services
  • sockets (Implementing Services)
• Server sockets
  • ServerSocket component (Using Server Sockets)
  • events (Server Events)
• Server connections (Server Connections)

T

• TClientDataSet redistributables (Understanding Multi-Tiered Database Applications)
• threads demo (Freezing and Thawing Threads in the Debugger)
• Type compatibility
  • data types (Type Compatibility and Identity)
• Transition
  • multiple (Transition (UML 1.5 Activity Diagrams))
  • multiple (Transition (UML 1.5))
  • multiple (Transition)
  • self (Creating a Self-Transition)
• Translation tools
  • External Translation Manager (Using the External Translation Manager)
  • adding languages to a project (Adding Languages to a Project)
  • editing with Translation Manager (Editing Resource Files in the Translation Manager)
  • overview (Language Culture Names, Codes, and ISO Values)
  • overview (Localizing Applications by Using Translation Manager )
  • setting the active language (Setting the Active Language for a Project)
  • setting up the External Translation Manager (Setting Up the External Translation Manager)
  • updating resource modules (Updating Resource Modules)
• Transform to source code (Transformation to Source Code)
• Targets files
  • using (Using Targets Files)
• Tool Palette
  • components (Adding Components to a Form)
• Toolbars (Toolbar Controls)
  • adding hidden (Adding Hidden Toolbars)
  • adding using a panel component (Adding a Toolbar Using a Panel Component)
  • adding using the toolbar component (Adding a Toolbar Using the Toolbar Component)
  • customizing (Customizing Toolbars)
  • designing (Designing Toolbars and Cool Bars)
  • hiding and showing (Hiding and Showing Toolbars)
• To-do lists
  • planning (Using To-Do Lists)
• TDUMP.EXE (TDUMP.EXE, the File Dumping Utility)
• TLIB.EXE (TLIB.EXE, the Library Manager)
• TOUCH.EXE (Using TOUCH.EXE)
• TRIGRAPH.EXE (TRIGRAPH)
• Templates
  • C++ language specifics (template)
  • component (Creating and Using Component Templates)
  • project (Using Project Templates)
  • templates%2C C++ (Using Angle Brackets In Templates)
  • templates%2C C++ (Eliminating Pointers In Templates)
  • templates%2C C++ (Using Type-safe Generic Lists In Templates)
  • templates%2C C++ (Implicit And Explicit Template Functions)
  • templates%2C C++ (Using Templates)
• Templates%2C arguments
  • templates%2C C++ (Template Arguments)
• Templates%2C class
  • templates%2C C++ (Class Templates)
• Templates%2C compiler options
  • templates%2C C++ (Template Compiler Switches)
• Templates,in version 3.0
  • templates%2C C++ (Template Generation Semantics)
• Templates%2C DLLs
  • C++ language specifics (Exporting And Importing Templates)
• Templates%2C function
  • templates%2C C++ (Function Templates)
• Templates%2C overriding
  • templates%2C C++ (Overriding A Template Function)
• Templates%2C syntax checking
  • templates%2C C++ (Template Body Parsing)
• This
  • keywords%2C C++ (this)
• Thread_local
  • keywords%2C C++ (thread_local)
• Throw
  • keywords%2C C++ (throw)
• Try
  • keywords%2C C++ (try)
• Typedef
  • keywords%2C C++ (typedef)
• Typeid
  • keywords%2C C++ (typeid)
• Typename
  • keywords%2C C++ (typename)
• Translation units
  • language structure, C++ (Translation Units)
• Types%2C fundamental
  • language structure, C++ (The Fundamental Types)
• Tokens (Token Pasting With )
  • lexical elements, C++ (Tokens)
• Tools API
  • creating modules (Creating Forms and Projects)
  • editor interfaces (Using Editor Interfaces)
  • module interfaces (Using Module Interfaces)
  • native IDE objects (Using Native IDE Objects)
  • services (Obtaining Tools API Services)
  • versioning (Interface Version Numbers)
• Type libraries (Working with Type Libraries: Overview)
  • tasks (Using the Type Library Editor)
• Type library
  • adding CoClass members (Adding an Interface to a CoClass)
  • adding a CoClass (Adding a CoClass to the Type Library)
  • adding a module (Adding a Module to the Type Library)
  • adding a record or union (Adding a Record or Union to the Type Library)
  • adding an alias (Adding an Alias to the Type Library)
  • adding an enumeration (Adding an Enumeration to the Type Library)
  • adding an interface (Adding an Interface to the Type Library)
  • adding properties and methods (Adding Properties and Methods to the Type Library)
  • apply updates dialog (Apply Updates Dialog)
  • code generated (Code Generated When You Import Type Library Information)
  • creating a new (Creating a New Type Library)
  • deploying (Deploying Type Libraries)
  • enabling simple data binding in an ActiveX control (Enabling Simple Data Binding with the Type Library)
  • modifying an interface (Modifying an Interface Using the Type Library)
  • opening an existing (Opening an Existing Type Library)
  • refresh (Refreshing the Type Library)
  • registering (Registering the Type Library)
  • saving (Saving a Type Library)
  • saving and registering information (Saving and Registering Type Library Information)
  • working with (Working with Type Libraries: Overview)
  • Type Library Editor tasks (Using the Type Library Editor)
• Type Library editor (Type Library Editor)
  • GenTLB.exe (GenTLB.exe)
  • Object list pane (Object List Pane)
  • RIDL file (RIDL File)
  • description (Parts of the Type Library Editor)
  • information pages (Pages of Type Information)
  • information pages (Type Library Elements)
  • status bar (Status Bar)
  • supported types (Valid Types)
• Toolbar
  • Type Library editor (Toolbar)
• Transactions
  • automatic (Specifying Whether the Connection Automatically Initiates Transactions)
  • databases (Managing Transactions)
  • databases (Using Transactions with the BDE)
  • isolation levels (Specifying the Transaction Isolation Level)
  • multi-tiered applications (Managing Transactions in Multi-tiered Applications)
• Types%2C Delphi (Data Types, Variables, and Constants Index)
• Types%2C C++ (The Fundamental Types)
• Tables
  • access rights (Controlling Read/Write Access to Tables)
  • batch operations (Importing Data from Another Table)
  • creating (Creating and Deleting Tables)
  • datasets (Using TTable)
  • emptying (Emptying Tables)
  • exclusive access (Controlling Read/Write Access to Local Tables)
  • local table types (Specifying the Table Type for Local Tables)
  • master/detail realtionships (Making the Table a Detail of Another Dataset)
  • master/detail realtionships (Using Nested Detail Tables)
  • renaming (Renaming a Table)
  • synchronizing (Synchronizing Tables)
• TSimpleDataSet
  • advantages and disadvantages (When to Use TSimpleDataSet)
  • using (Setting Up a Simple Dataset)
• Transformation files
  • xml mapper (Defining Transformations)
• TCP/IP
  • distributing applications (Creating Web Server Applications)
• TService
  • TDependency (Service Name Properties)
• Text
  • cutting (Cutting, Copying, and Pasting Text)
  • deleting (Deleting Selected Text)
  • in controls (Working with Text in Controls)
  • internationalizing (Text)
  • selecting (Selecting Text)
  • setting alignment (Setting Text Alignment)
• Tool buttons
  • adding (Adding a Tool Button)
  • assigning a menu to (Assigning a Menu to a Tool Button)
  • assigning images (Assigning Images to Tool Buttons)
  • creating groups (Allowing Toggled Tool Buttons)
  • creating groups (Creating Groups of Tool Buttons)
  • setting appearance and initial conditions (Setting Tool Button Appearance and Initial Conditions)
• Toggle buttons (Allowing Toggle Buttons)
• TScreen
  • using (Handling the Screen)
• TApplication
  • TScreen (Controlling Application Behavior)
  • using (Working at the Application Level)
• TForm
  • forms (Using the Main Form)
• Try..finally statements
  • finally keyword (Writing a Finally Block (Delphi))
• Tab controls (Tab Controls)
• Track bars
  • controls (Track Bars)
• Tree views (Tree Views)
• Text controls (Text Controls)
• Text viewing controls
  • controls (Text Viewing Controls)
• TComponent branch
  • overview (TComponent Branch)
• TControl branch
  • overview (TControl Branch)
• TPersistent branch
  • overview (TPersistent Branch)
• TWinControl branch
  • overview (TWinControl Branch)
• TRegistry
  • using (Using TRegistry)
• TCanvas
  • overview (Creating Drawing Spaces)
• TPrinter
  • overview (Printing)
• TRegistryIniFile
  • using (Using TRegistryIniFile)
• TVarData type
  • custom variants (Storing a Custom Variant Type's Data)
• TIniFile
  • using (Using TIniFile and TMemIniFile)
• Tool changing with speed buttons (Changing the Tool with Speed Buttons)
• Tracking
  • origin point (Tracking the Origin Point)
• Threads
  • Executing (Executing Thread Objects)
  • VCL objects (Using the Main VCL Thread)
  • avoiding simultaneous access (Avoiding Simultaneous Access)
  • clean-up code (Writing Clean-up Code)
  • constructors (Initializing the Thread)
  • debugging (Debugging Multi-threaded Applications)
  • exceptions (Handling Exceptions in the Thread Function)
  • freezing in the Debugger (Freezing and Thawing Threads in the Debugger)
  • multi-threaded applications (Writing Multi-threaded Applications)
  • priority (Overriding the Default Priority)
  • sharing memory (Other Techniques for Sharing Memory)
  • termination (Checking for Termination by Other Threads)
  • thawing in the Debugger (Freezing and Thawing Threads in the Debugger)
  • waiting (Waiting for a Task to Be Completed)
  • waiting (Waiting for a Thread to Finish Executing)
  • waiting (Waiting for Other Threads)
• Thread objects
  • New Thread Object dialog (Defining Thread Objects)
• Thread-local variables
  • threadvar (Using Thread-local Variables)
• Thread functions
  • Execute method (Writing the Thread Function)
• TXMLDocument (Using TXMLDocument)
• TEncoding
  • using for Unicode (Using TEncoding for Unicode Files)

U

• Unicode
  • Enabling C++ applications (Enabling C++ Applications for Unicode)
  • _TCHAR mapping for C++ (_TCHAR Mapping)
  • enabling applications (Enabling Applications for Unicode)
  • in RAD Studio (Unicode in RAD Studio)
  • in the command console (Using Unicode in the Command Console)
  • new features 2009 (What's New in Delphi and C++Builder 2009)
• Undo (refactoring) (Undoing a Refactoring (Delphi))
• Undo (Edit menu) (Undo)
• Unit testing (Unit Testing Overview)
• UML (Supported UML Specifications)
• Units
  • namespaces (Finding Units (Delphi))
• Unit tests
  • Adding source to a test project (Developing Tests)
• UML in color
  • using (Using the UML in Color Profile)
• Unsigned int __array_extent( typename T, unsigned intI )
  • C++0x type trait functions (__array_extent)
• Unsigned __int_array_rank( typename T )
  • C++0x type trait functions (__array_rank)
• Unicode _TCHAR mapping
  • C++ language specifics (Floating Functions)
• Union
  • keywords%2C C++ (union)
• Unions%2C anonymous
  • language structure, C++ (Anonymous Unions)
• Unions%2C declarations
  • language structure, C++ (Union Declarations)
• Unions
  • language structure, C++ (Unions)
• UpdateObject
  • property pages (Updating the Object)
• User interfaces
  • UI (Designing the User Interface)
  • internationalizing (Localization Considerations in UI Design)
  • multiple records (Displaying Multiple Records)
  • single record (Displaying a Single Record)
• Update objects
  • TUpdateSQL component (Using Update Objects to Update a Dataset)
  • accessing queries (Using an Update Component's Query Property)
  • applying (Calling the Apply Method)
  • applying (Executing the SQL Statements)
• Updates
  • client dataset (Applying Updates)
  • screening (Screening Individual Updates)
  • stored procedures (Applying Updates to Datasets That do Not Represent a Single Table)
• Update errors
  • reconciling (Reconciling Update Errors)
• Unidirectional datasets
  • accessing metadata (The Structure of Metadata Datasets)
  • datasets (Using dbExpress Datasets)
  • defining queries (Representing the Results of a Query)
  • defining record sets (Specifying What Data to Display)
  • executing SQL commands (Executing the Command)
  • opening (Fetching the Data)
  • representing tables (Representing the Records in a Table)
  • stored procedures (Representing the Results of a Stored Procedure)
• User interface
  • developing (Developing the Application User Interface: Overview)
• Updating
  • actions (Updating Actions)
• Unnamed threads
  • naming (Converting an Unnamed Thread to a Named Thread)
• URLs
  • hosts (Parts of a Uniform Resource Locator)
  • request targets (The Target URL)

V

• Variables
  • data types (Variables)
• Variant types
  • data types (Variant Types)
• Virtual folders (Using Virtual Folders)
• Visibility modifier
  • defining (Working with a Field)
• Virtual base classes
  • C++ language specifics (Virtual Base Classes)
• Virtual destructors
  • C++ language specifics (Virtual Destructors)
• Virtual functions
  • C++ language specifics (Virtual Functions)
• Variables%2C multithread
  • language structure, C++ (__thread, Multithread Variables)
• Virtual
  • keywords%2C C++ (virtual)
• Void
  • keywords%2C C++ (void)
• Volatile
  • keywords%2C C++ (volatile)
• Visibility
  • language structure, C++ (Visibility)
• Virtual methods
  • methods (Making Methods Virtual)
• VCL
  • component library (Understanding the Component Library)
  • class library (Class library)
  • components (VCL Overview)
• Visual feedback (Display Controls)
• Variants
  • custom (Defining Custom Variants)
• VCL for the Web
  • IntraWeb (Creating a New VCL for the Web Application)
• Vista
  • components available (Components Available Only on Specific OS)
• VCL Forms
  • ActiveX Active Forms (Creating a VCL Forms ActiveX Active Form)
  • ActiveX buttons (Creating a VCL Forms ActiveX Button)
  • MDI applications (Building a VCL Forms MDI Application Using a Wizard)
  • MDI applications (Building a VCL Forms MDI Application Without Using a Wizard)
  • SDI applications (Building a VCL Forms SDI Application)
  • XML components (Building an Application with XML Components)
  • database applications (Building a VCL Forms ADO Database Application)
  • multithreaded applications (Building a Multithreaded Application)
• VCL component
  • creating (Creating a New VCL Component)
• VCL applications
  • VCL Forms (Building a VCL Forms Application)
  • dbExpress (Building a VCL Forms dbExpress Database Application)

W

• Warnings (TASM) (Warnings)
• W1061 Narrowing given WideChar constant ($%04X) to AnsiChar lost information (Delphi)
  • H2451 and W1061 Narrowing given WideChar constant ('%s') to AnsiChar lost information (Delphi) (H2451 and W1061: Narrowing given WideChar constant ($%04X) to AnsiChar lost information (Delphi))
• wcsncat
  • Strncat
• Wchar_t
  • keywords%2C C++ (wchar_t)
• While
  • keywords%2C C++ (while)
• Whitespace
  • lexical elements, C++ (Whitespace)
• Wcstol, strtol (strtol, wcstol)
• Wcstoul (strtoul, wcstoul)
• Wizards
  • debugging (Debugging a Wizard)
  • implementing (Implementing the Wizard Interfaces)
  • installing (Installing the Wizard Package)
  • working with files and editors (Working with Files and Editors)
  • writing (Writing a Wizard Class)
• Web items
  • properties (Setting Web Item Properties)
• Web page editor (Using the Web Page Editor)
• Web applications
  • deploying (Deploying Web Applications)
  • deploying (Deploying On Apache Servers)
  • multi-tiered (Writing Web-based Client Applications)
• Web server applications
  • Web Broker applications (Creating Web Broker Applications)
  • WebSnap (About Web Broker and WebSnap)
  • WebSnap applications (Creating WebSnap Applications)
  • adapters (Adapters)
  • applications (Creating Web Services Applications)
  • architecture (The Structure of a Web Broker Application)
  • creating (Creating Web Server Applications Using WebSnap)
  • creating (Specifying Application Module Components)
  • creating (Creating Web Server Applications with WebSnap)
  • creating (Selecting a Server Type)
  • creating (Selecting Web Application Module Options)
  • creating (Page Producers)
  • creating (Web Application Module Types)
  • debugging (Debugging Server Applications)
  • types (Types of Web Server Applications)
• Wide characters
  • Unicode characters (Wide Characters)
• Windows versions (Operating System Versions)
• Windows XP
  • themes (Common Controls and XP Themes)
• Wide character routines (Wide Character Routines)
• Windowed controls
  • docking (Making a Windowed Control a Docking Site)
• Web Application Debugger (Using the Web Application Debugger)
• Web modules
  • Web dispatcher (The Web Dispatcher)
  • data modules (Using Web Broker)
  • data modules (Creating Web Server Applications with Web Broker Index)
  • data modules (The Web Module)
  • data modules (Web Modules)
• Web request properties (Properties That Identify the Purpose of the Request)
• Web client (Properties That Describe the Web Client)
• Web Application object
  • Web Broker (The Web Application Object)
• Web Services
  • adding (Adding New Web Services)
  • clients (Writing Clients for Web Services)
  • exceptions (Creating Custom Exception Classes for Web Services)
  • importing (Using the WSDL Importer)
  • using (Using Web Services)
• WSDL
  • generating (Generating WSDL Documents for a Web Service Application)
  • importing (Importing WSDL Documents)
• WebSnap
  • access rights (User Access Rights)
  • adapter dispatcher (Adapter Dispatcher Operation)
  • adapter requests and responses (Receiving Adapter Requests and Generating Responses)
  • adding login support (Adding Login Support)
  • dispatcher components (Dispatcher Components)
  • dispatching action items (Dispatching Action Items)
  • dispatching requests and responses (Dispatching Requests and Responses)
  • hello world (Building a WebSnap Hello World Application)
  • login pages (Login Pages)
  • login support (Login Support)
  • page dispatcher (Page dispatcher operation)
  • projects (Building a WebSnap Application)
  • script objects (Script Objects)
  • server-side scripting (Server-side Scripting in WebSnap)
  • sessions service (Using the Sessions Service)
  • tutorial (Advanced HTML Design)
• WebSnap components (Fundamental WebSnap Components)
• Web data modules
  • Web applications (Web Data Modules)
• Web page modules
  • Web applications (Web Page Modules)
• Web Application Support
  • Win32 (Win32 Web Applications Overview)
• Windows VCL Forms application
  • developing (Developing a Windows Application)
• Windows Forms
  • hello world (Building a Windows Hello World Console Application)
• Web browser
  • VCL Forms (Building a VCL Forms Web Browser Application)

X

• Xor
  • alternative representations of C++ token (xor, ^)
• Xor_eq
  • alternative representations of C++ token (xor_eq, ^=)
• XML brokers (Using an XML Broker)
• XML documents
  • components (Working with XML Components)
  • converting to data packets (Converting XML Documents into Data Packets)
  • data packets (Mapping Between XML Nodes and Data Packet Fields)
• XML (Working with XML Documents)
  • Data Binding wizard (Abstracting XML Documents with the Data Binding Wizard)
  • Data Binding wizard (Using the XML Data Binding Wizard)
  • database applications (Using XML in Database Applications)
• XML mapper
  • defining (Using XMLMapper)
• XML Nodes
  • working with (Working with XML Nodes)
• XML Document
  • using Data Binding wizard (Using Code That the XML Data Binding Wizard Generates)

[

• [ ] operator
  • operators%2C C++ (Array Subscript Operator)

_

• _unsigned __int_alignment_of( typename T )
  • C++0x type trait functions (__alignment_of)
• _bool __has_trivial_destructor (typename T )
  • C++0x type trait functions (__has_trivial_destructor)
• __classid
  • keywords%2C C++ (__classid)
• __classmethod
  • keywords%2C C++ (__classmethod)
• __closure
  • keywords%2C C++ (__closure)
• __declspec,
  • keywords%2C C++ (__declspec)
• __msfastcall
  • keywords%2C C++ (__msfastcall)
• __msreturn
  • keywords%2C C++ (__msreturn)
• __rtti
  • C++ language specifics (__rtti, -RT Option)
• __try
  • keywords%2C C++ (__try)
• _Bool
  • keywords%2C C++ (_Bool)
• _Complex
  • keywords%2C C++ (_Complex)
• _export
  • keywords%2C C++ (_export, __export)
• _fastcall
  • keywords%2C C++ (_fastcall, __fastcall)
  • keywords%2C C++ (final)
  • keywords%2C C++ (noreturn)
• _Imaginary
  • keywords%2C C++ (_Imaginary)
• _stdcall
  • keywords%2C C++ (_stdcall, __stdcall)
• __declspec, dllexport
  • keywords%2C C++ (__declspec(dllexport))
• __declspec, dllimport
  • keywords%2C C++ (__declspec(dllimport))
• __declspec, naked
  • keywords%2C C++ (__declspec(naked))
• __declspec, noreturndeclspec, noreturn
  • keywords%2C C++ (__declspec(noreturn))
• __declspec, nothrow
  • keywords%2C C++ (__declspec(nothrow))
• __declspec, novtable
  • keywords%2C C++ (__declspec(novtable))
• __declspec, property
  • keywords%2C C++ (__declspec(property))
• __declspec, selectany
  • keywords%2C C++ (__declspec(selectany))
• __declspec, thread
  • keywords%2C C++ (__declspec(thread))
• __declspec, uuid
  • keywords%2C C++ (__declspec(uuid(“ComObjectGUID”)))
• __int8, __int16, and so forth
  • lexical elements, C++ (__int8, __int16, __int32, __int64, Unsigned __int64, Extended Integer Types)
• __finally,
  • keywords%2C C++ (__finally)
• __import
  • keywords%2C C++ (import, _import, __import)
• _wargv, _argv
  • _argv (_argv, _wargv)
• _wtoi64, _atoi64 (_atoi64, _wtoi64)
• _crotr, _crotl (_crotl, _crotr)
• _lrotr, _lrotl (_lrotl, _lrotr)
• _rotr, _rotl (_rotl, _rotr)
• _wsearchenv,, _searchenv (_searchenv, _wsearchenv)
• _wsearchstr, _searchstr (_searchstr, _wsearchstr)
• _wsplitpath, _splitpath (_splitpath, _wsplitpath)
• _ui64tow, _ui64toa (_ui64toa, _ui64tow)
• _wtoi, atoi
  • conversion routine (atoi, _wtoi)
• _wtol, atol (atol, _wtol)
• _wenviron, _environ (_environ, _wenviron)
• _wgetenv, getenv (getenv, _wgetenv)
• _itow, itoa (itoa, _itow)
• _ltoa, _ltow, ltoa (ltoa, _ltoa, _ltow)
• _wputenv, putenv (putenv, _wputenv)
• _mbslen, strlen, wcslen, _mbstrlen (strlen, _mbslen, wcslen, _mbstrlen)
• _wcstod, wcstod (strtod, _strtold, wcstod, _wcstold)
• _wsystem, system (system, _wsystem)
• _ultow, ultoa (ultoa, _ultow)
• __finally keyword (Writing a finally Block (C++))