Developing ColdFusion MX Applications

• Introduction
• Introduction to ColdFusion MX
  • About Internet applications and web application servers
    • About web pages and Internet applications
    • About web application servers
      • How a web server and web application server work together
  • About ColdFusion MX
    • The ColdFusion scripting environment
    • ColdFusion Markup Language
      • CFML tags
      • CFML functions and CFScript
      • CFML extensions
      • CFML development tools
      • Server-side ActionScript
    • ColdFusion application services
    • ColdFusion MX Administrator
  • Using ColdFusion MX with Macromedia Flash MX
  • About J2EE and the ColdFusion architecture
    • About ColdFusion MX and the J2EE platform
  • ColdFusion features described in this book
• Elements of CFML
  • Introduction
  • Character case
  • Tags
    • Tag syntax
    • Built-in tags
    • Custom tags
  • Functions
    • Built-in functions
    • User-defined functions
  • Expressions
  • Constants
  • Variables
    • Variable scopes
  • Data types
  • ColdFusion components
  • CFScript
  • Flow control
    • cfif, cfelseif, and cfelse
    • cfswitch, cfcase, and cfdefaultcase
    • cfloop and cfbreak
      • cfloop
      • cfbreak
    • cfabort and cfexit
  • Comments
  • Special characters
  • Reserved words
• Using ColdFusion Variables
  • Creating variables
    • Variable naming rules
  • Variable characteristics
  • Data types
    • Numbers
      • Integers
      • Real numbers
  • Strings
    • Boolean values
    • Date-Time values
      • Date and time formats
      • Locale-specific dates and times
      • How ColdFusion stores dates and times
    • Binary data type and Base64 encoding
    • Complex data types
      • Arrays
      • Structures
      • Queries
      • Working with structures and queries
  • Using periods in variable references
    • Understanding variables and periods
      • Getting a variable
      • Setting a variable
    • Creating variables with periods
      • Using brackets to create variables with periods
      • Creating Client and Cookie variables with periods
  • Data type conversion
    • Operation-driven evaluation
    • Conversion between types
      • Type conversion considerations
    • Evaluation and type conversion issues
    • Examples of type conversion in expression evaluation
  • About scopes
    • Scope types
    • Creating and using variables in scopes
    • Using scopes
      • Evaluating unscoped variables
      • Scopes and CFX tags
      • Using scopes as structures
      • Using the This scope outside CFCs (advanced topic)
  • Ensuring variable existence
    • Testing for a variable's existence
    • Using the cfparam tag
      • Example: testing for variables
      • Example: setting default values
  • Validating data types
    • Using the cfparam tag to validate the data type
  • Passing variables to custom tags and UDFs
    • Passing variables to CFML tags and UDFs
    • Passing variables to CFX tags
• Using Expressions and Pound Signs
  • Expressions
    • Operator types
      • Arithmetic operators
      • Boolean operators
      • Decision operators
      • String operators
    • Operator precedence and evaluation ordering
    • Using functions as operators
      • Function syntax
      • Optional function arguments
      • Expression evaluation and functions
  • Using pound signs
    • Using pound signs in ColdFusion tag attribute values
    • Using pound signs in tag bodies
    • Using pound signs in strings
    • Nested pound signs
    • Using pound signs in expressions
  • Dynamic expressions and dynamic variables
    • About dynamic variables
    • About dynamic expressions and dynamic evaluation
      • Selecting how to create variable names
    • Dynamic variable naming without dynamic evaluation
      • Using pound signs to construct a variable name in assignments
      • Dynamically constructing structure references
    • Using dynamic evaluation
      • ColdFusion dynamic evaluation functions
      • Function argument evaluation considerations
      • About the Evaluate function
      • Avoiding the Evaluate function
      • SetVariable function considerations
    • Using the IIF function
    • Example: a dynamic shopping cart
• Using Arrays and Structures
  • About arrays
    • Basic array concepts
    • About ColdFusion arrays
  • Basic array techniques
    • Referencing array elements
    • Creating arrays
      • Creating complex multidimensional arrays
    • Adding elements to an array
      • Adding an array element by assignment
      • Adding an array element with a function
    • Deleting elements from an array
    • Copying arrays
  • Populating arrays with data
    • Populating an array with the ArraySet function
    • Populating an array with the cfloop tag
      • Using nested loops for 2D and 3D arrays
    • Populating an array from a query
  • Array functions
  • About structures
    • Structure notation
    • Referencing complex structures
  • Creating and using structures
    • Creating structures
      • Creating structures by assigning values
      • Creating structures using a function
    • Adding data elements to structures
    • Updating values in structures
    • Getting information about structures and keys
      • Getting information about structures
      • Finding a specific key and its value
      • Getting a list of keys in a structure
    • Copying structures
    • Deleting structure elements and structures
    • Looping through structures
  • Structure example
      • Example file newemployee.cfm
      • Example file addemployee.cfm
  • Structure functions
• Extending ColdFusion Pages with CFML Scripting
  • About CFScript
    • Comparing tags and CFScript
  • The CFScript language
    • Identifying CFScript
    • Variables
    • Expressions and operators
    • Statements
    • Statement blocks
    • Comments
    • Reserved words
    • Differences from JavaScript
    • CFScript limitation
    • CFScript functional equivalents to ColdFusion tags
  • Using CFScript statements
    • Using assignment statements and functions
    • Using conditional processing statements
      • Using if and else statements
      • Using switch and case statements
    • Using looping statements
      • Using for loops
      • Using while loops
      • Using do-while loops
      • using for-in loops
      • Using continue and break statements
  • Handling exceptions
      • Exception handling syntax and rules
      • Exception handling example
  • CFScript example
• Using Regular Expressions in Functions
  • About regular expressions
    • Using ColdFusion regular expression functions
    • Basic regular expression syntax
  • Regular expression syntax
    • Using character sets
      • Considerations when using special characters
    • Finding repeating characters
    • Case sensitivity in regular expressions
    • Using subexpressions
    • Using special characters
    • Using escape sequences
    • Using character classes
  • Using backreferences
    • Using backreferences in replacement strings
      • Using backreferences to perform case conversions in replacement strings
      • Escaping special characters in replacement strings
    • Omitting subexpressions from backreferences
  • Returning matched subexpressions
    • Specifying minimal matching
  • Regular expression examples
    • Regular expressions in CFML
  • Types of regular expression technologies
• Reusing Code in ColdFusion Pages
  • About reusable CFML elements
  • Including pages with the cfinclude tag
    • Using the cfinclude tag
    • Recommended uses
  • Calling user-defined functions
    • Calling UDFs
    • Recommended uses
    • For more information
  • Using custom CFML tags
    • Calling custom CFML tags
    • Recommended uses
    • For more information
  • Using CFX tags
    • Calling CFX tags
    • Recommended uses
    • For more information
  • Using ColdFusion components
    • Creating and using ColdFusion components
    • Recommended uses
    • For more information
  • Selecting among ColdFusion code reuse methods
• Creating and Using Custom CFML Tags
  • Creating custom tags
    • Creating and calling custom tags
      • Storing custom tag pages
      • Calling custom tags using the cfmodule tag
      • Calling custom tags using the cfimport tag
    • Securing custom tags
    • Accessing existing custom tags
  • Passing data to custom tags
    • Passing values to and from custom tags
    • Using tag attributes summary
    • Custom tag example with attributes
    • Passing custom tag attributes using CFML structures
  • Managing custom tags
    • Securing custom tags
    • Encoding custom tags
  • Executing custom tags
    • Accessing tag instance data
    • Handling end tags
      • Determining if an end tag is specified
      • Determining the tag execution mode
      • Considerations when using end tags
    • Processing body text
    • Terminating tag execution
  • Nesting custom tags
    • Passing data between nested custom tags
      • What data is accessible?
    • Variable scopes and special variables
      • Where is data accessible?
    • High-level data exchange
      • Ancestor data access
      • Example: ancestor data access
• Writing and Calling User-Defined Functions
  • About user-defined functions
  • Calling user-defined functions
  • Creating user-defined functions
    • Creating functions using CFScript
    • Creating functions using tags
    • Rules for function definitions
      • About the Arguments scope
      • Function-only variables
      • Good argument naming practice
    • Defining functions in CFScript
      • CFScript function definition syntax
      • A simple CFScript example
      • Using the Arguments scope in CFScript
    • Defining functions using the cffunction tag
      • The cffunction tag function definition format
      • Using a CFML tag in a user-defined function
      • Using the Arguments scope in cffunction definitions
  • Calling functions and using variables
    • Passing arguments
    • Referencing caller variables
    • Using function-only variables
    • Using arguments
  • A User-defined function example
    • Defining the function using CFScript
    • Defining the function using the cffunction tag
  • Using UDFs effectively
    • Using Application.cfm and function include files
    • Specifying the scope of a function
      • About functions and scopes
      • Selecting a function scope
      • Using the Request scope
    • Using the Request scope for static variables and constants
    • Using function names as function arguments
    • Handling query results using UDFs
    • Identifying and checking for UDFs
    • Using the Evaluate function
    • Passing complex data
      • Passing structures, queries, and objects
      • Passing arrays
    • Using recursion
    • Handling errors in UDFs
      • Displaying error messages
      • Providing status information
      • Using exceptions
• Building and Using ColdFusion Components
  • About ColdFusion components
    • Basic component concepts
      • What CFCs are
      • CFCs and object-oriented programming
      • When to use CFCs
    • ColdFusion component features and use
      • Tags and functions for creating and using CFCs
      • Elements of a CFC
      • CFC invocation and instantiation
  • Using ColdFusion components
      • Specifying the CFC location
    • Instantiating CFCs
    • CFC invocation techniques
    • Invoking CFC methods with the cfinvoke tag
      • Invoking component methods transiently using the cfinvoke tag
      • Invoking methods of a CFC instance
      • Using cfinvoke within the CFC definition
      • Passing parameters to methods using cfinvoke
      • Invoking methods using dynamic method names
    • Using components directly in CFScript and CFML
      • Invoking component methods directly
      • Passing parameters in direct method invocations
    • Invoking CFC methods using forms and URLs
      • Invoking component methods using a URL
      • Invoking component methods using a form
    • Accessing CFCs from outside ColdFusion and basic HTML
      • Using Flash Remoting MX
    • Invoking components as web services
    • Introspection: getting information about components
      • Requesting a component page from the browser
      • Using the ColdFusion component browser
      • Using Dreamweaver
      • Using the GetMetaData function
  • Building ColdFusion components
    • Initializing instance data
    • Defining component methods
      • Putting method executable code in a separate file
      • Defining and using method parameters
    • Providing results
      • Displaying output
      • Returning a results variable
      • Documenting CFCs
      • Saving and naming ColdFusion components
    • CFC variables
      • The This scope
      • The Variables scope
      • The Arguments scope
      • Function local variables
      • Other variable scopes
    • Structuring and reusing code
      • Using inheritance and the Super keyword
      • Using component packages
      • Using CFCs in persistent scopes
    • Building secure ColdFusion components
      • Using access security
      • Using role-based security
• Building Custom CFXAPI Tags
  • What are CFX tags?
  • Before you begin developing CFX tags in Java
    • Sample Java CFX tags
    • Setting up your development environment to develop CFX tags in Java
      • Configuring the classpath
    • Customizing and configuring Java
  • Writing a Java CFX tag
    • Calling the CFX tag from a ColdFusion page
    • Processing requests
      • Request object
      • Response object
      • Query object
    • Loading Java CFX classes
    • Automatic class reloading
    • Life cycle of Java CFX tags
  • ZipBrowser example
  • Approaches to debugging Java CFX tags
    • Outputting debugging information
    • Debugging in a Java IDE
    • Using the debugging classes
      • Debugging classes example
  • Developing CFX tags in C++
    • Sample C++ CFX tags
    • Setting up your C++ development environment
    • Compiling C++ CFX tags
    • Locating your C++ library files on UNIX
    • Implementing C++ CFX tags
    • Debugging C++ CFX tags
      • Debugging on Windows
    • Registering CFX tags
• Designing and Optimizing a ColdFusion Application
  • About applications
  • Elements of a ColdFusion application
    • The application framework
    • Application-level settings and functions
    • Reusable application elements
    • Shared variables
    • Application security and user identification
  • Mapping an application
    • Processing the Application.cfm and OnRequestEnd.cfm pages
      • Processing the Application.cfm page
      • Processing the OnRequestEnd.cfm page
    • Defining the directory structure
  • Creating the Application.cfm page
    • Naming the application
    • Setting the client, application, and session variables options
    • Defining page processing settings
    • Setting application default variables and constants
    • Processing logins
    • Handling errors
    • Example: an Application.cfm page
  • Optimizing ColdFusion applications
    • Caching ColdFusion pages that change infrequently
      • Using the cfcache tag
      • Flushing cached pages
    • Caching parts of ColdFusion pages
    • Optimizing database use
      • Using stored procedures
      • Using the cfquery tag cachedWithin attribute
    • Providing visual feedback to the user
• Handling Errors
  • About error handling in ColdFusion
  • Understanding errors
    • About error causes and recovery
    • ColdFusion error types
    • About ColdFusion exceptions
      • When exceptions occur
      • ColdFusion exception types
    • How ColdFusion handles errors
      • Missing template errors
      • Form field validation errors
      • Compiler exception errors
      • Runtime exception errors
  • Error messages and the standard error format
  • Determining error-handling strategies
    • Handling missing template errors
    • Handling form field validation errors
    • Handling compiler exceptions
    • Handling runtime exceptions
  • Specifying custom error messages with cferror
    • Specifying a custom error page
    • Creating an error application page
      • Example of a request error page
      • Example of a validation error page
  • Logging errors with the cflog tag
  • Handling runtime exceptions with ColdFusion tags
    • Exception-handling tags
    • Using cftry and cfcatch tags
      • Try/catch code structure
      • Try/catch code rules and recommendations
      • Exception information in cfcatch blocks
    • Using cftry: an example
    • Using the cfthrow tag
      • Catching and displaying thrown errors
      • Custom error type name hierarchy
      • When to use cfthrow
    • Using the cfrethrow tag
      • The cfrethrow tag syntax
    • Example: using nested tags, cfthrow, and cfrethrow
• Using Persistent Data and Locking
  • About persistent scope variables
    • ColdFusion persistent variables and ColdFusion structures
    • ColdFusion persistent variable issues
      • Using variables in clustered systems
      • Locking memory variables
  • Managing the client state
    • About client and session variables
    • Maintaining client identity
      • About client identifiers
      • Using client and session variables without cookies
      • Client identifiers and security
      • Managing client identity information in a clustered environment
  • Configuring and using client variables
    • Enabling client variables
      • Choosing a client variable storage method
      • Specifying client variable storage in the Application.cfm file
    • Using client variables
      • Creating a client variable
      • Accessing and changing client variables
      • Standard client variables
      • Getting a list of client variables
      • Deleting client variables
      • Using client variables with cflocation
      • Caching client variable
      • Exporting the client variable database
  • Configuring and using session variables
    • What is a session?
      • ColdFusion and J2EE session management
    • Configuring and enabling session variables
      • Selecting and enabling session variables in ColdFusion MX Administrator
      • Enabling session variables in your application
    • Storing session data in session variables
    • Standard session variables
    • Getting a list of session variables
    • Creating and deleting session variables
    • Accessing and changing session variables
    • Ending a session
  • Configuring and using application variables
    • Configuring and enabling application variables
    • Storing application data in application variables
    • Using application variables
  • Using server variables
  • Locking code with cflock
    • Sample locking scenarios
    • Using the cflock tag with write-once variables
    • Using the cflock tag
      • Lock types
      • Lock scopes and names
      • Controlling and minimizing lock time-outs
    • Considering lock granularity
    • Nesting locks and avoiding deadlocks
      • Copying shared variables into the Request scope
      • Locking application variables efficiently
  • Examples of cflock
      • Example with application, server, and session variables
      • Example of synchronizing access to a file system
      • Example of protecting ColdFusion extensions
• Securing Applications
  • ColdFusion security features
  • About resource and sandbox security
    • Resource control
    • Sandbox security
  • About user security
    • Authenticating users
      • About web server authentication
      • About application authentication
      • ColdFusion authentication storage and persistence
      • Using ColdFusion security without cookies
  • Using ColdFusion security tags and functions
    • Using the cflogin tag
      • Login identification scope and the applicationToken attribute
      • Specifying the internet domain
    • Getting the user ID and password
    • Logging a user in using Flash Remoting
    • Logging users out
  • Security scenarios
    • A web server authentication security scenario
    • An application authentication security scenario
  • Implementing user security
    • Web-server-based authentication user security example
      • Example: Application.cfm
      • Example: securitytest.cfm
    • Application-based user security example
      • Example: Application.cfm
      • Example: loginform.cfm
      • Example: securitytest.cfm
    • Using an LDAP Directory for security information
• Developing Globalized Applications
  • Introduction to globalization
    • Defining globalization
    • Importance of globalization in ColdFusion applications
    • How ColdFusion MX supports globalization
    • Character sets, character encodings, and locales
  • About character encodings
    • The Java Unicode character encoding
    • Character encoding conversion issues
  • Locales
    • Setting the locale
    • Using the locale
  • Processing a request in ColdFusion
    • Determining the character encoding of a ColdFusion page
    • Determining the page encoding of server output
  • Tags and functions for globalizing
    • Tags and functions for controlling character encoding
    • Functions for controlling and using locales
    • Additional globalization tags and functions
  • Handling data in ColdFusion MX
    • General character encoding issues
    • Locale-specific content
      • Generating multi-locale content
      • Supporting the euro
    • Input data from URLs and HTML forms
      • Handling URL strings
      • Handling form data
    • File data
    • Databases
    • E-mail
    • HTTP
    • LDAP
    • WDDX
    • COM
    • CORBA
    • Searching and indexing
• Debugging and Troubleshooting Applications
  • Configuring debugging in the ColdFusion MX Administrator
    • Debugging Settings page
    • Debugging IP addresses page
  • Using debugging information from browser pages
    • General debugging information
    • Execution Time
      • Summary execution time format
      • Tree execution time format
    • Database Activity
      • SQL Queries
      • Stored Procedures
    • Exceptions
    • Trace points
    • Scope variables
    • Using the dockable.cfm output format
      • Application page selections
      • Debug pane features
  • Controlling debugging information in CFML
    • Generating debugging information for an individual query
    • Controlling debugging output with the cfsetting tag
    • Using the IsDebugMode function to run code selectively
  • Using the cftrace tag to trace execution
    • About the cftrace tag
    • Using tracing
    • Calling the cftrace tag
  • Using the Code Compatibility Analyzer
  • Troubleshooting common problems
    • CFML syntax errors
    • Data source access and queries
    • HTTP/URL
• Introduction to Databases and SQL
  • What is a database?
    • Using multiple database tables
    • Database permissions
    • Commits, rollbacks, and transactions
    • Database design guidelines
  • Using SQL
    • SQL example
    • Basic SQL syntax elements
      • Statements
      • Statement clauses
      • Operators
      • Case sensitivity with databases
      • SQL notes and considerations
    • Reading data from a database
      • Results of a SELECT statement
      • Filtering results
      • Sorting results
      • Returning a subset of columns
      • Using column aliases
      • Accessing multiple tables
    • Modifying a database
      • Inserting data into a database
      • Updating data in a database
      • Deleting data from a database
      • Updating multiple tables
  • Writing queries using an editor
    • Writing queries using Dreamweaver MX
    • Writing queries using Macromedia HomeSite+
      • The SQL Builder interface
      • Writing SQL statements
• Accessing and Retrieving Data
  • Working with dynamic data
  • Retrieving data
    • The cfquery tag
    • The cfquery tag syntax
    • Building queries
  • Outputting query data
    • Query output notes and considerations
  • Getting information about query results
    • Query variable notes and considerations
  • Enhancing security with cfqueryparam
    • About query string parameters
    • Using cfqueryparam
      • Using cfqueryparam with strings
      • Using cfSqlType
• Updating Your Database
  • About updating your dataSbase
  • Inserting data
    • Creating an HTML insert form
    • Data entry form notes and considerations
    • Creating an action page to insert data
      • Creating an insert action page with cfinsert
      • Creating an insert action page with cfquery
      • Inserting into specific fields
  • Updating data
    • Creating an update form
    • Creating an action page to update data
      • Creating an update action page with cfupdate
      • Creating an update action page with cfquery
  • Deleting data
    • Deleting a single record
    • Deleting multiple records
• Using Query of Queries
  • About record sets
    • Referencing queries as objects
    • Creating a record set
    • Creating a record set with a function
  • About Query of Queries
    • Benefits of Query of Queries
    • Performing a Query of Queries
      • Displaying record set data incrementally
      • Using the cfdump tag with query results
      • Using Query of Queries with non-SQL record sets
  • Query of Queries user guide
    • Using dot notation
    • Using joins
    • Using unions
      • Using aliases for column names
      • Duplicate rows and multiple tables
      • Parentheses and evaluation order
      • Using other keywords with UNION
    • Using conditional operators
      • Test conditional
      • Null conditional
      • Comparison conditional
      • Between conditional
      • IN conditional
      • LIKE conditional
      • Case sensitivity
      • Escaping wildcards
    • Using aggregate functions
      • Arbitrary expressions in aggregate functions
      • Aggregate functions in arbitrary expressions
    • Using group by and having expressions
    • Using ORDER BY clauses
    • Using aliases
    • Handling null values
    • Escaping reserved keywords
    • Using Queries of Queries with numeric dates
    • Understanding Query of Queries performance
  • BNF for Query of Queries
• Managing LDAP Directories
  • About LDAP
  • The LDAP information structure
    • Entry
    • Attribute
    • Distinguished name (DN)
    • Schema
      • Object class
      • Attribute type
  • Using LDAP with ColdFusion
  • Querying an LDAP directory
    • Scope
    • Search filter
    • Getting all the attributes of an entry
    • Example: querying an LDAP directory
  • Updating an LDAP directory
    • Adding a directory entry
    • Deleting a directory entry
    • Updating a directory entry
    • Adding and deleting attributes of a directory entry
    • Changing a directory entry's DN
  • Advanced topics
    • Specifying an attribute that includes a comma or semicolon
    • Using cfldap output
    • Viewing a directory schema
    • Referrals
    • Managing LDAP security
      • Server security
      • Application security
• Building a Search Interface
  • About Verity
    • Using Verity with ColdFusion
    • Advantages of using Verity
    • Supported file types
    • Support for international languages
  • Creating a search tool for ColdFusion applications
    • Creating a collection with the ColdFusion MX Administrator
    • About indexing a collection
      • Updating an index
    • Indexing and building a search interface with the Verity Wizard
    • Creating a ColdFusion search tool programmatically
      • Creating a collection with the cfcollection tag
      • Indexing a collection using the cfindex tag
      • Indexing a collection with the ColdFusion MX Administrator
  • Using the cfsearch tag
  • Working with record sets
    • Indexing database record sets
    • Indexing cfldap query results
    • Indexing cfpop query results
    • Using database-directed indexing
• Using Verity Search Expressions
  • About Verity query types
  • Using simple queries
    • Stemming in simple queries
    • Preventing stemming
  • Using explicit queries
    • Using AND, OR, and NOT
    • Using wildcards and special characters
      • Searching with wildcards
      • Searching for special characters
  • Composing search expressions
    • Case sensitivity
    • Prefix and infix notation
    • Commas in expressions
    • Precedence rules
    • Delimiters in expressions
    • Operators and modifiers
      • Operators
      • Modifiers
  • Refining your searches with zones and fields
      • Zone searches
      • Field searches
• Retrieving and Formatting Data
  • Using forms to specify the data to retrieve
    • HTML form tag syntax
    • Form controls
    • Form notes and considerations
  • Working with action pages
    • Processing form variables on action pages
    • Dynamically generating SQL statements
    • Creating action pages
    • Testing for a variable's existence
    • Requiring users to enter values in form fields
    • Form variable notes and considerations
  • Working with queries and data
    • Using HTML tables to display query results
    • Formatting individual data items
    • Building flexible search interfaces
  • Returning results to the user
    • Handling no query results
    • Returning results incrementally
  • Dynamically populating list boxes
  • Creating dynamic check boxes and multiple-selection list boxes
    • Check boxes
      • Handling numeric values
      • Handling string values
    • Multiple selection lists
      • Handling numeric values
      • Handling string values
  • Validating form field data types
• Building Dynamic Forms
  • Creating forms with the cfform tag
    • Using HTML and cfform
    • The cfform controls
    • Preserving input data with preservedata
      • Usage notes for the preservedata attribute
    • Browser considerations
  • Building tree controls with cftree
    • Grouping output from a query
    • The cftree form variables
    • Input validation
    • Structuring tree controls
      • Creating a one-level tree control
      • Creating a multilevel tree control
    • Image names in a cftree
    • Embedding URLs in a cftree
      • Reviewing the code
    • Specifying the tree item in the URL
  • Building drop-down list boxes
  • Building text input boxes
  • Building slider bar controls
  • Creating data grids with cfgrid
    • Working with a data grid and entering data
    • Creating an editable grid
      • Controlling cell contents
      • How user edits are returned
      • Editing data in cfgrid
      • Updating the database with cfgridupdate
      • Updating the database with cfquery
  • Embedding Java applets
    • Registering a Java applet
      • Applet registration fields
    • Using cfapplet to embed an applet
      • Overriding alignment and positioning values
      • Overriding parameter values
    • Handling form variables from an applet
  • Input validation with cfform controls
    • Validating with regular expressions
      • Special characters
      • Single-character regular expressions
      • Multicharacter regular expressions
      • Backreferences
      • Exact and partial matches
      • Expression examples
  • Input validation with JavaScript
    • Handling failed validation
    • Example: validating an e-mail address
• Charting and Graphing Data
  • Creating a chart
    • Chart types
    • Creating a basic chart
  • Administering charts
  • Charting data
    • Charting a query
    • Charting individual data points
    • Combining a query and data points
    • Charting multiple data collections
    • Writing a chart to a variable
  • Controlling chart appearance
    • Common chart characteristics
    • Setting x-axis and y-axis characteristics
    • Creating a bar chart
    • Setting pie chart characteristics
    • Creating an area chart
    • Setting curve chart characteristics
  • Linking charts to URLs
    • Dynamically linking from a pie chart
    • Linking to JavaScript from a pie chart
• Using the Flash Remoting Service
  • About using the Flash Remoting service with ColdFusion
    • Planning your Flash application
  • Using the Flash Remoting service with ColdFusion pages
      • Accessing parameters passed from Flash
      • Returning results to Flash
      • Returning records in increments to Flash
  • Using Flash with ColdFusion components
      • Using component metadata with the Flash Remoting service
  • Using the Flash Remoting service with server-side ActionScript
  • Using the Flash Remoting service with ColdFusion Java objects
  • Handling errors with ColdFusion and Flash
• Using Server-Side ActionScript
  • About server-side ActionScript
    • Client-side ActionScript requirements
    • Server-side requirements
    • Software requirements
    • Location of server-side ActionScript files
    • Benefits
    • What to do next
  • Connecting to the Flash Remoting service
  • Using server-side ActionScript functions
    • Using the function results in ActionScript
      • Using results returned by the CF.query function
      • Using results returned by the CF.http function
  • Global and request scope objects
  • About the Cf.query function and data sources
    • Publishing dynamic data
    • About ColdFusion MX data sources
  • Using the CF.query function
    • About CF.query function syntax
      • Using CF.query named argument syntax
      • Using CF.query positional argument syntax
    • About the CF.query record set
  • Building a simple application
    • Writing the server-side ActionScript function
    • Creating the Flash movie interface
    • Submitting user data to the Flash Remoting service
    • Capturing Flash Remoting service results
    • Checking for a Flash Remoting service connection
  • About the CF.http function
  • Using the CF.http function
    • Referencing HTTP Post parameters in the CF.http function
    • Using the CF.http Post method
    • Using the CF.http Get method
• Using XML and WDDX
  • About XML and ColdFusion
  • The XML document object
    • A simple XML document
    • Basic view
    • DOM node view
    • XML document structures
      • The document object structure
      • The element structure
      • XML DOM node structure
  • ColdFusion XML tag and functions
  • Using an XML object
    • Referencing the contents of an XML object
    • Assigning data to an XML object
      • Referencing the last element on the left side of an expression
      • Assigning and retrieving CDATA values
  • Creating and saving an XML document object
    • Creating a new XML document object using the cfxml tag
    • Creating a new XML document object using the XmlNew function
    • Creating an XML document object from existing XML
    • Saving and exporting an XML document object
  • Modifying a ColdFusion XML object
    • Functions for XML object management
    • Treating elements with the same name as an array
    • XML document object management reference
    • Adding, deleting, and modifying XML elements
      • Counting and finding the position of child elements
      • Adding an element
      • Deleting elements
      • Adding, changing, and deleting element attributes
      • Changing element properties
      • Replacing or moving an element
    • Using XML and ColdFusion queries
      • Converting XML to a ColdFusion query
      • Converting a query object to XML
  • Transforming documents with XSLT
  • Extracting data with XPath
  • Example: using XML in a ColdFusion application
  • Moving complex data across the web with WDDX
    • Uses of WDDX
      • Exchanging data across application servers
      • Transferring data between the server and browser
      • WDDX and web services
    • How WDDX works
      • WDDX data type support
      • Time zone processing
  • Using WDDX
    • Using the cfwddx tag
    • Validating WDDX data
    • Using JavaScript objects
    • Converting CFML data to a JavaScript object
    • Transferring data from the browser to the server
    • Storing complex data in a string
• Using Web Services
  • Web services
    • Accessing a web service
    • Basic web service concepts
      • Supporting web services with SOAP
      • Describing web services with WSDL
      • Finding web services with UDDI
  • Working with WSDL files
    • Creating a WSDL file
    • Viewing a WSDL file using Dreamweaver MX
    • Reading a WSDL file
  • Consuming web services
    • About the examples in this section
    • Passing parameters to a web service
    • Handling return values from a web service
    • Using cfinvoke to consume a web service
    • Using CFScript to consume a web service
    • Consuming web services that are not generated by ColdFusion MX
    • Calling web services from a Flash client
    • Catching errors when consuming web services
    • Handling inout and out parameters
    • Configuring web services in the ColdFusion MX Administrator
    • Data conversions between ColdFusion and WSDL data types
    • Consuming ColdFusion web services
  • Publishing web services
    • Creating components for web services
    • Specifying data types of function arguments and return values
    • Producing WSDL files
    • Using ColdFusion components to define data types for web services
    • Securing your web services
      • Controlling access to component CFC files
      • Using your web server to control access
      • Using ColdFusion to control access
      • Assigning security roles to functions
      • Using programmatic security
    • Best practices for publishing web services
  • Handling complex data types
    • Consuming web services that use complex data types
      • Passing input parameters to web services as complex types
      • Handling return values as complex types
    • Publishing web services that use complex data types
      • Publishing structures
      • Publishing queries
• Integrating J2EE and Java Elements in CFML Applications
  • About ColdFusion, Java, and J2EE
    • About ColdFusion and client-side JavaScript and applets
    • About ColdFusion and JSP
    • About ColdFusion and Servlets
    • About ColdFusion and Java objects
      • About class loading
      • About GetPageContext and the PageContext object.
    • About CFML variables and Java variables
  • Using JSP tags and tag libraries
    • Using a JSP tag in a ColdFusion page
      • Standard JSP tags and ColdFusion
      • Using custom JSP tags in a ColdFusion page
    • Example: using the random tag library
  • Interoperating with JSP pages and servlets
    • Integrating JSP and servlets in a ColdFusion application
      • Accessing a JSP page or servlet from a ColdFusion page
      • Sharing data between ColdFusion pages and JSP pages or servlets
    • Examples: using JSP with CFML
      • Calling a JSP page from a ColdFusion page
      • Calling a ColdFusion page from a JSP page
  • Using Java objects
    • Using basic object techniques
      • Invoking objects
      • Using properties
      • Calling methods
      • Calling JavaBean get and set methods
      • Calling nested objects
    • Creating and using a simple Java class
      • The Employee class
      • A CFML page that uses the Employee class
      • Java considerations
      • Using an alternate constructor
    • Java and ColdFusion data type conversions
      • Default data type conversion
      • Resolving ambiguous data types with the JavaCast function
    • Handling Java exceptions
      • Example: exception-throwing class
      • Example: CFML Java exception handling code
    • Examples: using Java with CFML
      • Using a Java API in a UDF
      • Using an EJB
      • Using a custom Java class
• Integrating COM and CORBA Objects in CFML Applications
  • About COM and CORBA
    • About objects
    • About COM and DCOM
    • About CORBA
  • Creating and using objects
    • Creating objects
    • Using properties
    • Calling methods
    • Calling nested objects
  • Getting started with COM and DCOM
    • COM Requirements
    • Registering the object
    • Finding the component ProgID and methods
      • Using the cfdump tag to view COM object interfaces
      • Using the OLE/COM Object Viewer
  • Creating and using COM objects
    • Connecting to COM objects
    • Setting properties and invoking methods
      • Releasing COM objects
    • General COM object considerations
      • Ensuring correct threading
      • Using input and output arguments
      • Understanding common COM-related error messages
    • Accessing Complex COM Objects using Java proxies
    • Using the Application Scope to improve COM performance
      • Example 1: Using the FileSystem object
      • Example 2: Using the Microsoft Word application object
  • Getting started with CORBA
  • Creating and using CORBA objects
    • Creating CORBA objects
      • Using a naming service
    • Using CORBA objects in ColdFusion
      • Using CORBA interface methods in ColdFusion
      • Using IDL types with ColdFusion variables
    • Handling exceptions
  • CORBA example
• Sending and Receiving E-Mail
  • Using ColdFusion with mail servers
  • Sending e-mail messages
    • Sending SMTP e-mail with cfmail
  • Sample uses of cfmail
    • Sending form-based e-mail
    • Sending query-based e-mail
    • Sending e-mail to multiple recipients
  • Customizing e-mail for multiple recipients
  • Using cfmailparam
    • Attaching files to a message
    • Adding a custom header to a message
  • Advanced sending options
    • Sending mail as HTML
    • Error logging and undelivered messages
  • Receiving e-mail messages
    • Using cfpop
    • The cfpop query variables
  • Handling POP mail
      • Retrieving only message headers
      • Retrieving a message
      • Retrieving a message and its attachments
      • Deleting messages
• Interacting with Remote Servers
  • About interacting with remote servers
  • Using cfhttp to interact with the web
    • Using the cfhttp Get method
  • Creating a query object from a text file
  • Using the cfhttp Post method
  • Performing file operations with cfftp
    • Caching connections across multiple pages
      • Example: caching a connection
    • Connection actions and attributes
• Managing Files on the Server
  • About file management
  • Using cffile
    • Uploading files
      • Resolving conflicting filenames
      • Controlling the type of file uploaded
      • Setting file and directory attributes
      • Evaluating the results of a file upload
    • Moving, renaming, copying, and deleting server files
    • Reading, writing, and appending to a text file
      • Reading a text file
      • Writing a text file on the server
      • Appending a text file
  • Using cfdirectory
    • Returning file information
  • Using cfcontent
    • About MIME types
    • Changing the MIME content type with cfcontent

ColdFusion 9 | ColdFusion 8 | ColdFusion MX 7 | ColdFusion MX 6.1 | ColdFusion MX | Forums | Developer Center | Bug Reporting

Version 6.1

Comments are no longer accepted for ColdFusion MX 6.1. ColdFusion 8 is the current version.