# 
# send.info - User interface object help text.
#
# Copyright (c) 1992 Sun Microsystems, Inc.  All rights reserved.
# 
:send_edit_send_contexts_button
Edit Send Contexts: popup window to edit the list of contexts you wish to send.
# 
:send_msg_panel
Message
-------
To send a message, first allocate a new message,
fill in the proper information, then send it. Any
reply will show up in the same message. When
finished with the message free the storage for
the message. (for value returning requests, this
is after any needed return values are copied out;
for notifications, this is right after its been
sent),


To allocate the new message, use
tt_message_create(). It returns a "handle" or
"opaque pointer" to the message; use this handle
on succeeding calls to reference this message.


To fill in message information, use the
tt_message_*_set() calls; there is one of these
for each attribute of the message.

You should set Class, Address, Op and Args.

Send the message with tt_message_send().


# 
:address_setting
Address:
Because there are many types of tools and
different users will use different sets of tools
at different times, it's often impossible for the
sender of a message to identify the precise
recipient of a message.  Instead, the sender
gives an operation name which specifies the
meaning of the message and may give an object to
which the message is directed, or the object type
(otype).

Use object or otype for object oriented
messages.  If the address is handler, specify the
handler.

	TT_PROCEDURE: Op and Args supplied.

	TT_OBJECT: Object, Op, and Args
	supplied.

	TT_HANDLER: Handler, Op, and Args
	supplied.

	TT_OTYPE: Otype, Op, and Args supplied.

# 
:handler_textfield
Handler:
If you know the exact procid of the handler, you
can address messages to it directly. The usual
way this would happen would be for one process to
make a general request and then pick the Handler
attribute out of the reply, directing further
messages to the same handler; this allows two
processes to rendezvous through broadcast message
passing and then go into a dialogue.

# 
:handler_ptype_textfield
Handler_Ptype:
If you know the ptype of the process that will
handle the message, fill it in. You would know
the ptype if you consulted the type definitions
to find the details of the protocol.

# 
:object_textfield
Object:
Fill in the objid of the object to which the
message is to be sent.

# 
:otype_textfield
OType:
Type of the object.


# 
:op_textfield
Op:
Fill in the operation that describes the
notification or request being made. Consult
the type definitions for operation names.

# 
:scope_setting
Scope:
Use scope session if messages from other
processes in the same session as your process are
desired; use scope file if messages about a file
is desired.

	TT_SESSION: Receive messages from other
	processes in your session.

	TT_FILE: Receive messages about the file
	joined.

	TT_BOTH: Receive messages about a file
	and the session.

	TT_FILE_IN_SESSION:  Receive messages for
	the file joined while in this session.

# 
:session_textfield
Session:
For scope session, specify the session
(tt_default_session() by default).


# 
:file_name_textfield
File:
For file scope, must specify the name of the file.

# 
:class_setting
Class:
Use class request for messages that return
values, or for which you want feedback telling
you when the message is handled or queued, or
when a process is started to handle the request.
Use class notification for messages that just
notify other processes of events.

	TT_NOTICE: Notice are messages that
	inform other tools that some event has
	happened. Tools sending notices don't
	expect replies back; the sender is just
	letting the other tools know what's
	happening.

	TT_REQUEST: Requests are messages that
	ask another tool to perform an action.
	Often, but not always, the requesting
	tool expects some value returned. This
	value is returned as a reply to the
	request. Even if no value is returned,
	the tool processing the request sends a
	reply indicating success or failure.

# 
:disposition_setting
Disposition:
Specifies the action to take if the message
cannot be handled by any running process. Queue
if the message should be queued until a process
of the Handler_Ptype registers. Start if a
process of the Handler_Ptype should be started.
	TT_QUEUE: Queue the message until a
	process of the proper ptype receives the
	message.

	TT_START: Attempt to start a process of
	the proper ptype if none is running.

Note that Tt_disposition values can be added
together, so that TT_QUEUE+TT_START means both to
queue the message and to try to start a process.
This can be useful if the start can fail (or be
vetoed by the user), to ensure the message is
processed as soon as an eligible process does
start.

# 
:sender_ptype_textfield
Sender_Ptype:
The ptype of the process that sent the message.

# 
:arg_list
Args:
Fill in any arguments specific to the operation.
Use tt_message_arg_add to add each argument in
turn. For each argument, you must specify: mode
(in, out, or inout), type, and if the mode is in
or inout, the value.

# 
:mode_setting
Mode:
Specifies the mode of a message argument.
Possible values and meanings are:
	TT_IN: The argument is written by the
	sender and read by the handler and any
	observers.


	TT_OUT: The argument is written by the
	handler and read by the sender and any
	reply observers.


	TT_INOUT: The argument is written and
	read by the sender and the handler and
	any observers.

# 
:vtype_textfield
VType:
String indicating the 'application' type.
Remember: This is application type space 
and has nothing to do with 'C' types.

# 
:value_textfield
Value:
Entering NULL enters a NULL for the value. Else
value interpretation is dependent on kind of add.
If a Add or Badd is used, value becomes whatever
string was entered. If Iadd is used, value is the
result of atoi(whatever_was_entered).
[Sorry, no way yet to enter
full 8 bit bytes for Badds.]

#
:kind_of_add_setting
Kind of Add:
Determines which one of 
tt_message_arg_add
tt_message_barg_add
tt_message_iarg_add
is done when adding the argument

# 
:add_button
Add Button:
Add an argument with the Mode, VType and Value.

# 
:delete_button
Delete Button:
Delete the selected argument.
# 
:change_button
Change Button:
Change the selected argument to the current
values of Mode, VType and Value.

# 
:send_button
Send this message. Also print out to standard output the 
Tooltalk calls that will be made to
create and send this message.
