> ToolTalk User's Guide
ToolTalk User's Guide
Numbers and Symbols
Chapter 1 Introducing the ToolTalk Service
Using the ToolTalk Desktop Services Message Set
The Smart Desktop
Using the ToolTalk Document and Media Exchange Message Set
Integrating Multimedia Functionality
Adding Multimedia Extensions to Existing Applications
Extending the X Cut and Paste Facility
Using the CASE Interoperability Message Sets
User Scenario: Fixing Bugs
Using the ToolTalk Filename Mapping Functions
Using ToolTalk in a Multi-Threaded Environment
How Applications Use ToolTalk Messages
Sending ToolTalk Messages
Receiving ToolTalk Messages
ToolTalk Message Distribution
Determining Message Delivery
Modifying Applications to Use the ToolTalk Service
Chapter 2 An Overview of the ToolTalk Service
Starting a ToolTalk Session
Background and Batch Sessions
X Window System
Maintaining ToolTalk Files and Databases
Chapter 3 Message Patterns
Message Pattern Attributes
Scoping to a Session Only
Scoping to a File Only
Scoping to a File in a Session
Scoping to a File and/or a Session
Adding Files to Scoped Patterns
Pattern Argument Attributes
Chapter 4 Setting Up and Maintaining the ToolTalk Processes
Location of the ToolTalk Service Files
ToolTalk Environment Variables
Other Environment Variables
Environment Variables Required to Start Programs on Remote Hosts
Using Context Slots to Create Environment Variables
Installing the ToolTalk Database Server
Confirming that the rpc.ttdbserverd is installed on a system.
Confirming that the rpc.ttdbserverd is running on a system.
From the Solaris Distribution CD-Rom
Running the New ToolTalk Database Server
Redirecting the ToolTalk Database Server
Redirecting the Host Machine
Redirecting the File System Partition
Chapter 5 Maintaining Application Information
Installing Application Types
Examining ToolTalk Type Information
Removing ToolTalk Type Information
Updating the ToolTalk Service
To send the ttsession process a SIGUSR2:
Process Type Errors
Using ttsnoop to Debug Messages and Patterns
Composing and Sending Messages
Composing and Registering Patterns
Displaying Message Components
Sending Pre-Created Messages
Stop Receiving Messages
Chapter 6 Maintaining Files and Objects Referenced in ToolTalk Messages
ToolTalk-Enhanced Shell Commands
Maintaining and Updating ToolTalk Databases
Displaying, Checking, and Repairing Databases
Chapter 7 Participating in ToolTalk Sessions
Including the ToolTalk API Header File
Registering with the ToolTalk Service
Registering in the Initial Session
Registering in a Specified Session
Registering in Multiple Sessions
Setting Up to Receive Messages
Sending and Receiving Messages in the Same Process
Sending and Receiving Messages in a Networked Environment
Unregistering from the ToolTalk Service
Using ToolTalk in a Multi-Threaded Environment
ToolTalk procids and sessions
Chapter 8 Sending Messages
How the ToolTalk Service Routes Messages
Changes in State of Sent Message
File-based Scoping in Patterns
File-based Scoping in Messages
Serialization of Structured Data
ToolTalk Message Delivery Algorithm
Process-Oriented Message Delivery
Object-Oriented Message Delivery
Modifying Applications to Send ToolTalk Messages
Using the General-Purpose Function to Create ToolTalk Messages
Creating Process-Oriented Messages
Creating and Completing Object-Oriented Messages
Adding Message Callbacks
Sending a Message
Chapter 9 Dynamic Message Patterns
Defining Dynamic Messages
Creating a Message Pattern
Adding a Message Pattern Callback
Registering a Message Pattern
Deleting and Unregistering a Message Pattern
Updating Message Patterns with the Current Session or File
Joining the Default Session
Joining Multiple Sessions
Joining Files of Interest
Chapter 10 Static Message Patterns
Defining Static Messages
Defining Process Types
Creating a Ptype File
Psignature Matching Information
Psignature Actions Information
Automatically Starting a Tool
Defining Object Types
Creating Otype Files
Osignature Actions Information
Installing Type Information
Checking for Existing Process Types
Declaring Process Type
Undeclaring Process Types
Chapter 11 Receiving Messages
Identifying and Processing Messages Easily
Recognizing and Handling Replies Easily
Checking Message Status
Callbacks for Messages Addressed to Handlers
Attaching Callbacks to Static Patterns
Replying to Requests
Rejecting or Failing a Request
Rejecting a Request
Failing a Request
Chapter 12 Objects
Creating Object Specs
Determining Object Specification Properties
Storing Spec Properties
Adding Values to Properties
Writing Object Specs
Updating Object Specs
Maintaining Object Specs
Examining Spec Information
Comparing Object Specs
Querying for Specific Specs in a File
Moving Object Specs
Destroying Object Specs
Managing Object and File Information
Managing Files that Contain Object Data
Managing Files that Contain ToolTalk Information
An Example of Object-Oriented Messaging
Chapter 13 Managing Information Storage
Information Provided to the ToolTalk Service
Information Provided by the ToolTalk Service
Calls Provided to Manage the Storage of Information
Marking and Releasing Information
Marking Information for Storage
Releasing Information No Longer Needed
Example of Marking and Releasing Information
Allocating and Freeing Storage Space
Allocating Storage Space
Freeing Allocated Storage Space
Special Case: Callback and Filter Routines
Chapter 14 Handling Errors
Retrieving ToolTalk Error Status
Checking ToolTalk Error Status
Returned Value Status
Functions with Natural Return Values
Functions with No Natural Return Values
Returned Pointer Status
Returned Integer Status
Appendix A Migrating from the Classing Engine to the ToolTalk Types Database
The ttce2xdr Script
Converting the User Database
Converting the System Database
Converting the Network Database
Appendix B A Simple Demonstration of How the ToolTalk Service Works
Inter-Application Communication Made Easy
Adding Inter-Operability Functionality
Modifying the Xedit Application
Modifying the Xfontsel Application
We Have Tool Communication!
Adding ToolTalk Code to the Demonstration Applications
Adding ToolTalk Code to the Xedit Files
Adding ToolTalk Code to the Xfontsel Files
Appendix C The ToolTalk Standard Message Sets
The ToolTalk Desktop Services Message Set
Why the ToolTalk Desktop Services Message Set was Developed
Key Benefits of the ToolTalk Desktop Services Message Set
The ToolTalk Document and Media Exchange Message Set
ToolTalk Document and Media Exchange Message Set Development History
Key Benefits of the ToolTalk Document and Media Exchange Message Set
General ToolTalk Message Definitions and Conventions
General ToolTalk Development Guidelines and Conventions
Always Make Anonymous Requests
Let Tools Be Started as Needed
Reply When Operation has been Completed
Avoid Statefulness Whenever Possible
Declare One Process Type per Role
Developing ToolTalk Applications
Appendix D Frequently Asked Questions
What is the ToolTalk service?
Is the ToolTalk Service the Sun implementation of the Common Object Request Broker Architecture (CORBA)?
What files are part of the ToolTalk service?
Where is the initial X-based ttsession started?
Where is rpc.ttdbserverd started?
Where are the ToolTalk type databases stored?
Do I need X Windows to use the ToolTalk service?
Can I use the ToolTalk service with MIT X?
Where is the session id of the X-session?
How does tt_open connect to a ttsession?
After calling tt_open, when does a session actually begin?
If another session is attached, does the first session get killed?
How can processes on different machines communicate using the ToolTalk service?
Connecting to the Same Session
Scoping to a NFS-mounted File
What is the purpose of tt_default_session_set?
How can a process connect to more than one session?
Can you start a ttsession with a known session id?
What information does a session id contain?
Is there a standard way to announce that a new program has joined a session?
Where is my message going?
What is the basic flow of a message?
Session-Scoped Message Flow
File-Scoped Message Flow
What happens when a message arrives to my application?
How can I differentiate between messages?
Can a process send a request to itself?
Can I pass my own data to a function registered by tt_message_callback_add?
How can I send arbitrary data in a message?
Can I transfer files with the ToolTalk service?
How are memory (byte) ordering issues handled by the ToolTalk service?
Can I re-use messages?
What happens when I destroy a message?
Can I have more than one handler per message?
Can I run more than one handler of a given ptype?
What value is disposition in a message?
What are the message status elements?
When should I use tt_free?
What does the ptype represent?
Why are my new types not recognized?
Is ptype information used if a process of that ptype already exists?
Can the ptype definition be modified to always start an instance (whether or not one is already running)?
What does tt_ptype_declare do?
What is TT_TOKEN?
When are my patterns active?
Must I register patterns to get replies?
How can I observe requests?
How do I match to attribute values in static patterns?
Why am I unable to wildcard a pattern for TT_HANDLER?
Can I set a pattern to watch for any file scoped message?
Is file scope in static patterns the same as file_in_session scope?
What is the difference between arg_add, barg_add, and iarg_add?
What is the type or vtype in a message argument?
How do I use contexts?
How does ttsession check for matches?
How many kinds of scope does the ToolTalk service have?
What are the TT_DB directories, and what is the difference between the types database and the TT_DB directories?
What should the tt_db databases contain?
What does rpc.ttdbserverd do?
Do ttsession and rpc.ttdbserverd ever communicate?
What message bandwidth can be supported?
Is there a limit to the message size or the number of arguments?
What is the most time efficient method to send a message?
What network overhead is involved?
Does the ToolTalk service use load balancing to handle requests?
What resources are required by a ToolTalk application?
What happens if the ttsession exits unexpectedly?
What happens if rpc.ttdbserverd exits unexpectedly?
What happens if a host or a link is down?
What does tt_close do?
Is message delivery guaranteed on a network?
Is there a temporal sequence of message delivery?
What is unix, xauth, and des?
Can my applications hide messages from each other?
Is there protection against interception or imitation?
Where are queued messages stored and how secure is the storage?
Is the ToolTalk service C2 qualified?
How can I trace my message's progress?
How can I isolate my debugging tool from all the other tools using the ToolTalk service?
Can I use the ToolTalk service with C++?
Should I qualify my filenames?
Can you tell me about ToolTalk objects?
Is there a ToolTalk news group?
© 2010, Oracle Corporation and/or its affiliates