Contents

Preface

Guide to Text, Native Language Support, and Time Media

CommonPoint information set

Getting started

Taxonomy

Developer guides

Usage and tools guidelines

Application documentation

Documented sample programs and sample code

Installation and late-breaking information

Typographical conventions

Reading notation diagrams

part 1 - Text and Native Language Support

Text and native language support overview

Storing and manipulating text data

Storing text strings

Styling text

Manipulating multilingual text

Displaying static text

Creating interactive text elements

Multilingual text input

Multilingual text display

Font support

Using the locale mechanism

What is a locale?

Localizing a presentation

Providing specific native language support services

Language-sensitive text analysis

Localizable number, date, and time formatting

Localizable message formatting

Character representation

Unicode character encoding

Representing Unicode characters

Unicode character naming

Querying Unicode character properties

Unicode private use area

Transcoding character data

Simple transcoding

Converting character data to Unicode

Converting character data from Unicode

Converting between ASCII and Unicode without transcoders

Handling separator characters

Handling exception characters

Using GetMaximumBytesPerCharacter

Using GetBufferSize

Using CanConvert

Transcoding complex data

Basic text classes

Referencing positions and ranges in a character string

Text ranges and regions

TTextRegion geometry functions

Representing a text selection

Representing insertion points

Encapsulating the selection

Creating and managing styled text

Applying styles to text

CommonPoint style classes

Style kinds

Style categories

Style sets

How a text object manages style sets

Querying a style set

Example: Creating and modifying styled text

Creating styled text

Modifying style data

String function mappings

Iterating through text data

Iterating through character data and style sets

Iterating through specific style runs

Style filters

Combining filters

Example: Using TStyleRunIterator

Encapsulating simple character strings

Using TUnicodeArray protocols

Using tokens

Deriving your own text and style classes

Creating your own text class

Creating your own styles

Style runs and style runs groups

Using TSharedStyle

Style propagation

Simple text display

Displaying static text

Using TTextDisplay

Text display options and defaults

Drawing the text

Creating a multiline text display

Getting information about individual lines

Using TTextGraphic

Font substitution

Performing font substitution

Requesting specific fonts

Missing glyphs

Text Editing framework

Text Editing framework roadmap

Editable text document components

Styled text support

Text layout and display

Text input

Getting started: Creating a text document component

Default text editing behavior

Default menus

Initializing the default model or presenter state

Text Editing framework architectural overview

Creating an editable text document component

Creating and opening a document

Creating selections

Handling typing input

Supporting component embedding

Creating a simple editable text element

Issuing and creating text editing commands

Issuing a text editing command

Creating a text editing command

TReplaceTextCommand declaration

TReplaceTextCommand implementation

Creating text controls

Text control classes

Control state classes

Control classes

Example: Creating a text control

Adding text menus

Using and creating text cursor tools

Classes for creating text cursor tools

Standard cursor tool classes

Highlight tool classes

Text selection I-beam

Creating your own text tool

Using TSimpleTextTool

Adding a tool to a menu

Deriving your own tool class

TSampleTextTool declaration

TSampleTextTool implementation

TSampleTextToolInteractor declaration

TSampleTextToolInteractor implementation

Text Editing framework interactors

Typing interactors

Selecting the typing configuration

Processing typing input

Supporting input methods

Selection interactors

Handling mouse events

Creating the selection

Calling your interactors

Text Editing framework core class reference

Text data representation classes

Text Editing framework notification mechanisms

Synchronizing data access

Text view classes

Text presentation classes

Text selection classes

Text selections

Presenter state selections

Text command classes

Editing character data

Modifying style data

Text Editing framework exception handling

Advanced text layout features

Controlling line layout

Exception handling

Creating TTextLineLayout instances

Controlling line height

Reusing TTextLineLayout instances

Drawing a text line

Measuring lines

Highlighting selected text ranges

Handling mouse clicks

Handling cursor key navigation

Supporting discontiguous selections

Creating a text formatter

Deriving from TAbstractPanelFormatter

Integrating your formatter

Text input

Typing configurations

Exception handling

Typing configuration elements

How the typing configuration handles typing input

Choosing the typing configuration

Representing text during editing

Processing keystrokes

Virtual keyboards

Exception handling

How virtual keyboards are used

Displaying command key sequences

Iterating through virtual keyboard contents

Editing keyboard layouts

Text modifiers

Transliterators

Transliterator classes

Available transliterators

How a transliterator works

Transliteration rules

Iterating through transliterator rules

Creating your own transliterator

Providing transliteration rules

Adding rules individually

Deriving your own transliterator classes

Input Method framework

How input methods work

Input method operations

Input method dictionaries

Entering Japanese text

Supporting input methods in a text editor

Providing visual feedback

Accessing selections

Adopting behaviors

Processing input

Adding interface elements

Converting between text offsets and coordinates

Text analysis

Comparing and collating text

Using a text - ordering object

Comparison functions

Comparison options

Language-insensitive collation

Pattern matching

Using pattern iterators

Language-sensitive searching

Nonlanguage-sensitive searching

Comparing string spans

Language-sensitive text selection

Creating your own collation objects

Collation features

Creating a text-ordering specification

File syntax

Sample entries

Text scanning and formatting

How formatters operate

Converting data

Conversion results

Using TParameterFormatter

Creating a TParameterFormatter instance

Step 1: Setting up the template

Step 2: Setting the parameter types

Step 3: Attaching formatters to each parameter

Using the formatter

Specifying conditional formatters

Creating a TChoiceFormatter instance

Nesting formatters within a TChoiceFormatter

Providing alternate text matches for scanning

Example: Using TAlternateTextMatch

Localizing TParameterFormatter instances

Simple text formatting

Number formatting

Number conversion operations

Number conversion results

TNumberFormatResult

TNumberScanResult

Controlling basic TNumberFormatter behavior

Formatting positive and negative numbers

Setting text identifiers

Setting the formatting range

Mapping characters to numeric values

Using TUnicodeDecimalNumerals

Using THybridNumerals

Using TNumberFormatter subclasses

Formatting integers

Formatting floating-point numbers

Formatting rational numbers

Formatting in additive numbering systems

Formatting Han numbers

Formatting Hebrew numbers

Formatting Roman numbers

Creating hybrid number formatters

Creating outline-style sequences

Date and time formatting

How time is converted

TDateTimeFormatter protocol

Using a pattern-based formatter

Calendars

Calendar fields

Changing calendar fields

Time zones

Deriving TFormatter and TFormattable classes

TFormatter classes

TFormattable classes

Creating a number formatter

Creating a date and time formatter

Creating a new calendar

Locales

The locale mechanism

Locale class architecture

The locale hierarchy

Localizable names

Accessing locales

Retrieving locale contents

Predefined locale items

Getting a preferred object

Archiving localized presentations

Exception handling

Archiving an object

Retrieving an archived object

part 2 - Time Media

Getting started with time media

Using the Time Media User Interface framework

Launching a media document from within a program

Embedding a media presentation in a view

Embedding a media component in a compound document

Creating a document that contains synchronized players

Using the time-media convenience classes

Convenience player views

Convenience players

Getting started with audio

Playing an audio clip

Recording audio

Getting started with video

Playing a video clip

Recording a video clip

Getting started with MIDI

Playing a MIDI clip

Recording MIDI

Time-media overview

Building media networks

Controlling time media

Playing and recording time media

Notifying threads about TPlayer events

Allowing for preroll delay

Synchronizing time media

Routing time-media data

Connections

Type negotiation

Creating and registering new media sequence types

Creating a new sequence type

Creating a new media sequence creator

Registering media classes with the Media Registry

Audio

Audio concepts

Audio players

Audio sequences

Audio connections

Audio ports

Audio types

Audio synchronization and timing

Recording audio data

Playing audio data

Playing a sound with effects

Changing sequences in an audio player

Removing the current sequence

Inserting a new sequence

Synchronizing audio and other time media

Supporting a new audio data type

Adding an audio sequence

Providing an installation tool to register the sequence

Video

Video concepts

Graphic players

Graphic sequences

Video processors

Digitizers

Graphic views

Video connections

Graphic ports

Graphic types

Representing QuickTime movies

Playing video data

Time Media User Interface framework

Presenting media data

Controlling media presentations

Embedding media presentations

Lightweight embedding

Document embedding

Opening media documents

MIDI

MIDI sequences

MIDI track

MIDI packet

MIDI files

MIDI time code

MIDI ticks

Tempo maps

MIDI performance

Telephony

Telephony concepts

Handsets

Lines

Calls

Call handles

Call status

Features

Notification

Telephony interest classes

Telephony notification classes

Placing a call

Answering a call

Putting a call on hold

Supporting telephony hardware

Index