//
// Add commission id and register in session, if appropriate
//
Tt_pattern
_ttDesktopPatternFinish(
Tt_pattern pat,
Tt_message commission,
int register_it
)
{
_TttkItem2Free fuse = pat;
Tt_status status;
if (commission != 0) {
char *id = _tttk_message_id( commission );
status = tt_pattern_arg_add( pat, TT_IN, Tttk_message_id, id );
tt_free( id );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
tt_pattern_user_set( pat, _TttkContractKey, commission );
}
if (register_it) {
status = tt_pattern_register( pat );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return pat;
}
//
// Create and optionally send a {GS}et_Iconified request or edict
//
static Tt_message
_ttdt_GSet_Iconified(
Tttk_op op,
const char *handler,
Tt_message commission,
Tt_class theClass,
Ttdt_Iconified_in_cb callback,
void *clientdata,
int iconified,
int send
)
{
Tt_message msg = _ttDesktopMessageCreate( commission, theClass,
handler, op, _ttdt_Iconified_in_cb,
(void *)callback, clientdata );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
_TttkItem2Free fuse = msg;
if (op == TTDT_GET_ICONIFIED) {
status = tt_message_arg_add( msg, TT_OUT, Tttk_boolean, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
} else {
status = tt_message_iarg_add( msg, TT_IN, Tttk_boolean,
iconified );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return _ttDesktopMessageFinish( msg, commission, send );
}
//
// Add commission id and send, if appropriate
//
Tt_message
_ttDesktopMessageFinish(
Tt_message msg,
Tt_message commission,
int send
)
{
_TttkItem2Free fuse = msg;
Tt_status status;
if (commission != 0) {
char *id = _tttk_message_id( commission );
status = tt_message_arg_add( msg, TT_IN, Tttk_message_id, id );
tt_free( id );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
if (send) {
status = tt_message_send( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return msg;
}
//
// If clientCB is 0, uses _ttDtApplyLocale, q.v. re clientData.
//
Tt_message
ttdt_Get_Locale(
const char *handler,
Tt_message commission,
Ttdt_Get_Locale_msg_cb clientCB,
void *clientData,
const char **categories,
int send
)
{
const char *_handler = handler;
if ((handler == 0) && (commission != 0)) {
_handler = tt_message_sender( commission );
}
if (clientCB == 0) {
clientCB = _ttDtApplyLocale;
}
Tt_message msg = _ttDtPMessageCreate( commission, TT_REQUEST,
TT_SESSION, handler,
TTDT_GET_LOCALE, _ttDtGetLocaleCB, (void *)clientCB,
clientData );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
//
// Guarantees that msg will be destroyed when this function returns
//
_TttkItem2Free fuse = msg;
const char **_cats = categories;
if (_cats == 0) {
_cats = _Tt_categories;
}
while (*_cats != 0) {
status = tt_message_arg_add( msg, TT_IN, Tttk_string, *_cats );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
_cats++;
}
if (send) {
status = tt_message_send( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return msg;
}
static Tt_message
_ttDtStarted(
Tttk_op op,
Tt_message context,
const char *toolName,
const char *vendor,
const char *version,
int sendAndDestroy
)
{
Tt_message msg = tttk_message_create( context, TT_NOTICE, TT_SESSION, 0,
_ttDtOp( op ), 0 );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
tt_message_arg_add( msg, TT_IN, Tttk_string, toolName );
tt_message_arg_add( msg, TT_IN, Tttk_string, vendor );
tt_message_arg_add( msg, TT_IN, Tttk_string, version );
if (! sendAndDestroy) {
return msg;
}
status = tt_message_send( msg );
if (status != TT_OK) {
tttk_message_destroy( msg );
return (Tt_message)tt_error_pointer( status );
}
tttk_message_destroy( msg );
return 0;
}
//
// Parse {GS}et_XInfo request, pass it to user callback,
// and optionally fill in and send the reply.
//
static Tt_message
_ttdt_XInfo_out_cb(
Tt_message msg,
Tt_pattern pat,
void *clientCB,
void *clientData
)
{
_TttkItem2Free fuse = msg;
char *display = _tttk_message_arg_val( msg, 0, 0 );
char *_visual = _tttk_message_arg_val( msg, 1, 0 );
int visual = _ttDtVisual( _visual );
tt_free( _visual );
int depth = _tttk_message_arg_ival( msg, 2, 1 );
Ttdt_XInfo_out_cb _cb = (Ttdt_XInfo_out_cb)clientCB;
msg = (*_cb)( msg, clientData, _tttk_pattern_contract( pat ),
&display, &visual, &depth );
Tt_status status = tt_ptr_error( msg );
if ((status != TT_OK) || (msg == 0)) {
// user already replied or failed, and destroyed
fuse = (caddr_t)0;
return msg;
}
tt_message_arg_val_set( msg, 0, display );
tt_message_arg_val_set( msg, 1, _ttDtVisualString( visual ));
tt_message_arg_ival_set( msg, 2, depth );
status = _tttk_message_reply( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
return 0;
}
//
// Parse {GS}et_Iconified request, pass it to user callback,
// and optionally fill in and send the reply.
//
static Tt_message
_ttdt_Iconified_out_cb(
Tt_message msg,
Tt_pattern pat,
void *clientCB,
void *clientData
)
{
_TttkItem2Free fuse = msg;
int iconified = _tttk_message_arg_ival( msg, 0, 0 );
Ttdt_Iconified_out_cb _cb = (Ttdt_Iconified_out_cb)clientCB;
msg = (*_cb)( msg, clientData, _tttk_pattern_contract( pat ),
&iconified );
Tt_status status = tt_ptr_error( msg );
if ((status != TT_OK) || (msg == 0)) {
// user already replied or failed, and destroyed
fuse = (caddr_t)0;
return msg;
}
tt_message_arg_ival_set( msg, 0, iconified );
status = _tttk_message_reply( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
return 0;
}
//
// Parse Get_Locale reply and pass it to user callback.
// Also used to parse Set_Locale request and pass it to _ttDtApplyLocale().
//
Tt_message
_ttDtGetLocaleCB(
Tt_message msg,
Tt_pattern ,
void *clientCB,
void *clientData
)
{
_TttkItem2Free fuse = msg;
int numArgs = tt_message_args_count( msg );
Tt_status status = tt_int_error( numArgs );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
_TttkList2Free fuses( numArgs + 2 );
int n = numArgs / 2;
char **categories = (char **)tt_malloc( (n + 1) * sizeof(char *) );
char **locales = (char **)tt_malloc( (n + 1) * sizeof(char *) );
categories[ n ] = 0;
locales[ n ] = 0;
//
// We only need these guys until after we call clientCB
//
fuses += (caddr_t)categories;
fuses += (caddr_t)locales;
for (int i = 0; i < n; i++) {
categories[i] = tt_message_arg_val( msg, 2 * i );
status = tt_ptr_error( categories[i] );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
fuses += categories[i];
locales[i] = tt_message_arg_val( msg, 2 * i + 1 );
status = tt_ptr_error( locales[i] );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
fuses += locales[i];
}
fuse = (caddr_t)0; // aborts message destruction
Ttdt_Get_Locale_msg_cb _cb = (Ttdt_Get_Locale_msg_cb)clientCB;
return (*_cb)( msg, clientData,
(const char **)categories,
(const char **)locales );
}
//
// If clientCB is 0, uses _ttDtApplySituation, q.v. re clientData.
//
Tt_message
ttdt_Get_Situation(
const char *handler,
Tt_message commission,
Ttdt_Get_Situation_msg_cb clientCB,
void *clientData,
int send
)
{
const char *_handler = handler;
if ((handler == 0) && (commission != 0)) {
_handler = tt_message_sender( commission );
}
if (clientCB == 0) {
clientCB = _ttDtApplySituation;
}
Tt_message msg = _ttDtPMessageCreate( commission, TT_REQUEST,
TT_SESSION, _handler,
TTDT_GET_SITUATION, _ttDtGetSituationCB,
(void *)clientCB, clientData );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
//
// Guarantees that msg will be destroyed when this function returns
//
_TttkItem2Free fuse = msg;
status = tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
if (send) {
status = tt_message_send( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return msg;
}
//
// Create and optionally send a {GS}et_XInfo request or edict
//
static Tt_message
_ttdt_GSet_XInfo(
Tttk_op op,
const char *handler,
Tt_message commission,
Tt_class theClass,
Ttdt_XInfo_in_cb callback,
void *clientdata,
const char *display,
int visual,
int depth,
int send
)
{
Tt_message msg = _ttDesktopMessageCreate( commission, theClass,
handler, op, _ttdt_XInfo_in_cb,
(void *)callback, clientdata );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
_TttkItem2Free fuse = msg;
if (op == TTDT_GET_XINFO) {
status = tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_integer, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
} else {
status = tt_message_arg_add( msg, TT_IN, Tttk_string, display);
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_IN, Tttk_string,
_ttDtVisualString( visual ));
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_iarg_add( msg, TT_INOUT, Tttk_integer,
depth );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return _ttDesktopMessageFinish( msg, commission, send );
}
//
// Parse {GS}et_Geometry request, pass it to user callback,
// and optionally fill in and send the reply.
//
static Tt_message
_ttdt_Geometry_out_cb(
Tt_message msg,
Tt_pattern pat,
void *clientCB,
void *clientData
)
{
_TttkItem2Free fuse = msg;
int width = _tttk_message_arg_ival( msg, 0, -1 );
int height = _tttk_message_arg_ival( msg, 1, -1 );
int xOffset = _tttk_message_arg_ival( msg, 2, INT_MAX );
int yOffset = _tttk_message_arg_ival( msg, 3, INT_MAX );
Ttdt_Geometry_out_cb _cb = (Ttdt_Geometry_out_cb)clientCB;
Tt_message contract = _tttk_pattern_contract( pat );
msg = (*_cb)( msg, clientData, contract, &width, &height, &xOffset,
&yOffset );
Tt_status status = tt_ptr_error( msg );
if ((status != TT_OK) || (msg == 0)) {
// user already replied or failed, and destroyed
fuse = (caddr_t)0;
return msg;
}
if (width != -1) {
tt_message_arg_ival_set( msg, 0, width );
}
if (height != -1) {
tt_message_arg_ival_set( msg, 1, height );
}
if (xOffset != INT_MAX) {
tt_message_arg_ival_set( msg, 2, xOffset );
}
if (yOffset != INT_MAX) {
tt_message_arg_ival_set( msg, 3, yOffset );
}
status = _tttk_message_reply( msg );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
return 0;
}
//
// Parse Get_Situation reply and pass it to user callback
//
static Tt_message
_ttDtGetSituationCB(
Tt_message msg,
Tt_pattern ,
void *clientCB,
void *clientData
)
{
if (! _tttk_message_in_final_state( msg )) {
// Not in final state; our address space is probably handler
return msg;
}
_TttkItem2Free fuse = msg;
char *cwd = tt_message_arg_val( msg, 0 );
Tt_status status = tt_ptr_error( cwd );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
Ttdt_Get_Situation_msg_cb _cb = (Ttdt_Get_Situation_msg_cb)clientCB;
msg = (*_cb)( msg, clientData, cwd );
fuse = (caddr_t)0; // prevent message destruction
return msg;
}
//
// Create patterns for either session_join or message_accept
//
Tt_pattern *_TtDtProcid::
pats_create(
Tt_message contract,
Ttdt_contract_cb cb,
Widget shell,
void *clientData
) const
{
int numPats = 11;
if (contract == 0) {
numPats = 13;
}
Tt_pattern *pats = (Tt_pattern *)malloc(numPats * sizeof(Tt_pattern));
if (pats == 0) {
return (Tt_pattern *)tt_error_pointer( TT_ERR_NOMEM );
}
int i = -1;
char *sess = tt_default_session();
if (shell != 0) {
pats[++i] = ttdt_Get_Geometry_pat( TT_HANDLE, contract,
_ttdt_do_GSet_Geometry, shell, 1 );
pats[++i] = ttdt_Set_Geometry_pat( TT_HANDLE, contract,
_ttdt_do_GSet_Geometry, shell, 1 );
pats[++i] = ttdt_Get_Iconified_pat( TT_HANDLE, contract,
_ttdt_do_wm_state, shell, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_MAPPED ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
pats[++i] = ttdt_Set_Iconified_pat( TT_HANDLE, contract,
_ttdt_do_wm_state, shell, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_SET_MAPPED ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
pats[++i] = ttdt_Get_XInfo_pat( TT_HANDLE, contract,
_ttdt_do_Get_XInfo, shell, 1 );
pats[++i] = ttdt_Set_XInfo_pat( TT_HANDLE, contract,
_ttdt_do_Set_XInfo, shell, 1 );
pats[++i] = _ttdt_pat(TTDT_RAISE, _ttdt_contract_cb, TT_HANDLE,
contract, (void *)_ttdt_do_RaiseLower, shell, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_LOWER ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
} else {
pats[++i] = ttdt_Get_Geometry_pat( TT_HANDLE, contract,
(Ttdt_Geometry_out_cb)cb, clientData, 1 );
pats[++i] = ttdt_Set_Geometry_pat( TT_HANDLE, contract,
(Ttdt_Geometry_out_cb)cb, clientData, 1 );
pats[++i] = ttdt_Get_Iconified_pat( TT_HANDLE, contract,
(Ttdt_Iconified_out_cb)cb, clientData, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_MAPPED ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
pats[++i] = ttdt_Set_Iconified_pat( TT_HANDLE, contract,
(Ttdt_Iconified_out_cb)cb, clientData, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_SET_MAPPED ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
pats[++i] = ttdt_Get_XInfo_pat( TT_HANDLE, contract,
(Ttdt_XInfo_out_cb)cb, clientData, 1 );
pats[++i] = ttdt_Set_XInfo_pat( TT_HANDLE, contract,
(Ttdt_XInfo_in_cb)cb, clientData, 1 );
pats[++i] = _ttdt_pat(TTDT_RAISE, _ttdt_contract_cb, TT_HANDLE,
contract, (void *)cb, clientData, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_LOWER ) );
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
}
void *_clientData = clientData;
if (cb == 0) {
// No callback, so set up our own client data
if (contract == 0) {
// tttk will send WM_DELETE_WINDOW to shell...
_clientData = shell;
} else {
// ...but that quits entire app, so do not do it
// for ttdt_message_accept(). Seeing no shell,
// _ttdt_contract_cb() will fail the Quit.
_clientData = 0;
}
}
pats[++i] = _ttdt_pat( TTDT_QUIT, _ttdt_contract_cb, TT_HANDLE,
contract, (void *)cb, _clientData, 1 );
pats[++i] = _ttdt_pat( TTDT_PAUSE, _ttdt_contract_cb, TT_HANDLE,
contract, (void *)cb, (cb ? clientData : shell), 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_RESUME ));
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
pats[++i] = _ttdt_pat( TTDT_GET_STATUS, _ttdt_contract_cb, TT_HANDLE,
contract, (void *)cb, clientData, 1 );
if (contract == 0) {
pats[++i]= _ttdt_pat( TTDT_DO_COMMAND, _ttdt_contract_cb,
TT_HANDLE, contract, (void *)cb, clientData, 1 );
pats[++i]= _ttdt_pat( TTDT_SET_LOCALE, _ttdt_posix_cb,
TT_HANDLE, contract, 0, 0, 0 );
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_LOCALE ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_SET_ENVIRONMENT ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_ENVIRONMENT ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_SET_SITUATION ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_SITUATION ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_SIGNAL ));
tt_pattern_op_add( pats[i], _ttDtOp( TTDT_GET_SYSINFO ));
tt_pattern_session_add( pats[i], sess );
tt_pattern_register( pats[i] );
}
pats[++i] = 0;
Tt_pattern *pat = pats;
while (*pat != 0) {
Tt_status status = tt_ptr_error( *pat );
if (status != TT_OK) {
_tttk_patterns_destroy( pats );
return (Tt_pattern *)tt_error_pointer( status );
}
pat++;
}
tt_free( sess );
return pats;
}
Tt_message
dtexec_tttk_message_create(
Tt_message context,
Tt_class theClass,
Tt_scope theScope,
const char *handler,
const char *op,
Tt_message_callback callback
)
{
Tt_message msg;
Tt_address address;
Tt_status status;
msg = tt_message_create();
status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
status = tt_message_class_set( msg, theClass );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_scope_set( msg, theScope );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
address = TT_PROCEDURE;
if (handler != 0) {
status = tt_message_handler_set( msg, handler );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
address = TT_HANDLER;
}
status = tt_message_address_set( msg, address );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
if (op != 0) {
status = tt_message_op_set( msg, op );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
if (callback != 0) {
status = tt_message_callback_add( msg, callback );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
return msg;
}
//
// Create and optionally send a {GS}et_Geometry request or edict
//
static Tt_message
_ttdt_GSet_Geometry(
Tttk_op op,
const char *handler,
Tt_message commission,
Tt_class theClass,
Ttdt_Geometry_in_cb callback,
void *clientdata,
int w,
int h,
int x,
int y,
int send
)
{
Tt_message msg = _ttDesktopMessageCreate( commission, theClass,
handler, op, _ttdt_Geometry_in_cb,
(void *)callback, clientdata );
Tt_status status = tt_ptr_error( msg );
if (status != TT_OK) {
return msg;
}
_TttkItem2Free fuse = msg;
if (op == TTDT_GET_GEOMETRY) {
status = tt_message_arg_add( msg, TT_OUT, Tttk_width, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_height, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_xoffset, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_arg_add( msg, TT_OUT, Tttk_yoffset, 0 );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
} else {
status = tt_message_iarg_add( msg, TT_INOUT, Tttk_width, w );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_iarg_add( msg, TT_INOUT, Tttk_height, h );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_iarg_add( msg, TT_INOUT, Tttk_xoffset, x );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
status = tt_message_iarg_add( msg, TT_INOUT, Tttk_yoffset, y );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
}
fuse = (caddr_t)0;
return _ttDesktopMessageFinish( msg, commission, send );
}
//
// Create a pattern for a desktop message
//
Tt_pattern
_ttdt_pat(
Tttk_op op,
_TtDtMessageCB internalCB,
Tt_category category,
Tt_message commission,
void *clientCB,
void *clientdata,
int register_it
)
{
Tt_pattern pat = _ttDtPatternCreate( category, TT_SESSION,
register_it, 0, op,
internalCB, clientCB,
clientdata, 0 );
Tt_status status = tt_ptr_error( pat );
if (status != TT_OK) {
return pat;
}
_TttkItem2Free fuse = pat;
Tt_mode mode = TT_OUT;
switch (op) {
case TTDT_SET_XINFO:
mode = TT_IN;
case TTDT_GET_XINFO:
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_integer, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_SET_GEOMETRY:
mode = TT_INOUT;
case TTDT_GET_GEOMETRY:
status = tt_pattern_arg_add( pat, mode, Tttk_width, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_height, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_xoffset, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_yoffset, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_SET_ICONIFIED:
mode = TT_IN;
case TTDT_GET_ICONIFIED:
status = tt_pattern_arg_add( pat, mode, Tttk_boolean, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_QUIT:
status = tt_pattern_arg_add( pat, TT_IN, Tttk_boolean, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, TT_IN, Tttk_boolean, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_STATUS:
mode = TT_IN;
case TTDT_GET_STATUS:
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, mode, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_DO_COMMAND:
status = tt_pattern_arg_add( pat, TT_IN, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
status = tt_pattern_arg_add( pat, TT_OUT, Tttk_string, 0 );
if (status != TT_OK) {
return (Tt_pattern)tt_error_pointer( status );
}
break;
case TTDT_PAUSE:
case TTDT_RESUME:
// No args
break;
}
fuse = (caddr_t)0;
return _ttDesktopPatternFinish( pat, commission, register_it );
}
//
// Handle a POSIX-related Desktop request
//
Tt_message
_ttdt_posix_cb(
Tt_message msg,
Tt_pattern pat,
void *,
void *
)
{ char *opString = tt_message_op( msg );
Tttk_op op = tttk_string_op( opString );
tt_free( opString );
int numArgs = tt_message_args_count( msg );
Tt_status status = tt_int_error( numArgs );
if (status != TT_OK) {
return (Tt_message)tt_error_pointer( status );
}
switch (op) {
char *categoryName, *variable, *value;
int category, i;
struct utsname names;
#if defined(OPT_SYSINFO)
char buf[ SYS_NMLN ];
#endif
case TTDT_SET_LOCALE:
return _ttDtGetLocaleCB( msg, pat, (void *)_ttDtApplyLocale, 0 );
case TTDT_GET_LOCALE:
for (i = 0; i < numArgs/2; i++) {
categoryName = _tttk_message_arg_val( msg, 2 * i, 0 );
if (categoryName == 0) {
continue;
}
category = _ttDtCategory( categoryName );
if (category > 0) {
tt_message_arg_val_set( msg, 2 * i + 1,
setlocale( category, 0 ));
}
tt_free( categoryName );
}
tt_message_reply( msg );
tttk_message_destroy( msg );
return 0;
case TTDT_SET_ENVIRONMENT:
case TTDT_GET_ENVIRONMENT:
for (i = 0; i < numArgs/2; i++) {
variable = _tttk_message_arg_val( msg, 2 * i, 0 );
if (variable == 0) {
continue;
}
if (op == TTDT_GET_ENVIRONMENT) {
tt_message_arg_val_set( msg, 2 * i + 1,
getenv( variable ));
} else if (_tttk_message_arg_is_set( msg, 2*i+1 )) {
value = _tttk_message_arg_val( msg, 2*i+1, 0 );
_tt_putenv( variable, value );
tt_free( value );
} else {
_tt_putenv( variable, 0 );
}
tt_free( variable );
}
tt_message_reply( msg );
tttk_message_destroy( msg );
return 0;
case TTDT_SET_SITUATION:
value = _tttk_message_arg_val( msg, 0, 0 );
if (value == 0) {
value = tt_message_file( msg );
if (tt_ptr_error( value ) != TT_OK) {
value = 0;
}
}
if (value == 0) {
tttk_message_fail( msg, TT_DESKTOP_EPROTO, 0, 1 );
return 0;
}
if (chdir( value ) != 0) {
tt_free( value );
tttk_message_fail( msg, _tt_errno_status( errno ),
0, 1 );
return 0;
}
tt_free( value );
tt_message_reply( msg );
tttk_message_destroy( msg );
return 0;
case TTDT_GET_SITUATION:
value = getcwd( 0, MAXPATHLEN );
if (value == 0) {
tttk_message_fail( msg, _tt_errno_status( errno ),
0, 1 );
return 0;
}
status = tt_message_arg_val_set( msg, 0, value );
free( value );
if (status != TT_OK) {
tttk_message_fail( msg, status, 0, 1 );
return 0;
}
tt_message_reply( msg );
tttk_message_destroy( msg );
return 0;
case TTDT_SIGNAL:
i = _tttk_message_arg_ival( msg, 0, 0 );
if (i <= 0) {
tttk_message_fail( msg, TT_DESKTOP_EINVAL, 0, 1 );
return 0;
}
// Reply before actually signalling, in case we die
tt_message_reply( msg );
tttk_message_destroy( msg );
kill( getpid(), i );
return 0;
case TTDT_GET_SYSINFO:
if (uname( &names ) < 0) {
tttk_message_fail( msg, _tt_errno_status( errno ),
0, 1 );
return 0;
}
// The first 5 values are from uname and seem pretty standard
tt_message_arg_val_set( msg, 0, names.sysname );
tt_message_arg_val_set( msg, 1, names.nodename );
tt_message_arg_val_set( msg, 2, names.release );
tt_message_arg_val_set( msg, 3, names.version );
tt_message_arg_val_set( msg, 4, names.machine );
// The last 3 are from sysinfo which seems to be SVR4 only.
// For platforms without the sysinfo call, we just leave
// the values unset for now, except for the serial
// number which is available from utsname onHPUX.
#if defined(OPT_SYSINFO)
if (sysinfo( SI_ARCHITECTURE, buf, SYS_NMLN ) >= 0) {
tt_message_arg_val_set( msg, 5, buf );
}
if (sysinfo( SI_HW_PROVIDER, buf, SYS_NMLN ) >= 0) {
tt_message_arg_val_set( msg, 6, buf );
}
if (sysinfo( SI_HW_SERIAL, buf, SYS_NMLN ) >= 0) {
tt_message_arg_val_set( msg, 7, buf );
}
#elif defined(__hpux) || defined(hpux)
tt_message_arg_val_set( msg, 7, names.idnumber);
#endif
tt_message_reply( msg );
tttk_message_destroy( msg );
return 0;
}
return msg;
}