419 lines
10 KiB
C
419 lines
10 KiB
C
/*
|
|
* CDE - Common Desktop Environment
|
|
*
|
|
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
|
*
|
|
* These libraries and programs are free software; you can
|
|
* redistribute them and/or modify them under the terms of the GNU
|
|
* Lesser General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* These libraries and programs are distributed in the hope that
|
|
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU Lesser General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with these libraries and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
//%% (c) Copyright 1993, 1994 Hewlett-Packard Company
|
|
//%% (c) Copyright 1993, 1994 International Business Machines Corp.
|
|
//%% (c) Copyright 1993, 1994 Sun Microsystems, Inc.
|
|
//%% (c) Copyright 1993, 1994 Novell, Inc.
|
|
//%% $XConsortium: tt_c++.C /main/3 1995/11/06 17:14:22 rswiston $
|
|
|
|
#include <string.h>
|
|
#include <Tt/tttk.h>
|
|
#include "tt_c++.h"
|
|
|
|
char *
|
|
tt_status_string(
|
|
Tt_status status
|
|
)
|
|
{
|
|
char *string = tt_status_message( status );
|
|
if (string == 0) {
|
|
return 0;
|
|
}
|
|
char *tab = strchr( string, '\t' );
|
|
if (tab != 0) {
|
|
*tab = '\0';
|
|
}
|
|
return string;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_status status2Print
|
|
)
|
|
{
|
|
char *string = tt_status_string( status2Print );
|
|
sink << string;
|
|
tt_free( string );
|
|
return sink;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_scope scope
|
|
)
|
|
{
|
|
char *string = 0;
|
|
switch (scope) {
|
|
case TT_SCOPE_NONE: string = "TT_SCOPE_NONE"; break;
|
|
case TT_SESSION: string = "TT_SESSION"; break;
|
|
case TT_FILE: string = "TT_FILE"; break;
|
|
case TT_BOTH: string = "TT_BOTH"; break;
|
|
case TT_FILE_IN_SESSION: string = "TT_FILE_IN_SESSION"; break;
|
|
}
|
|
if (string != 0) {
|
|
sink << string;
|
|
} else {
|
|
sink << "(Tt_scope)" << (int)scope;
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_class _class
|
|
)
|
|
{
|
|
char *string = 0;
|
|
switch (_class) {
|
|
case TT_CLASS_UNDEFINED: string = "TT_CLASS_UNDEFINED"; break;
|
|
case TT_NOTICE: string = "TT_NOTICE"; break;
|
|
case TT_REQUEST: string = "TT_REQUEST"; break;
|
|
case TT_OFFER: string = "TT_OFFER"; break;
|
|
}
|
|
if (string != 0) {
|
|
sink << string;
|
|
} else {
|
|
sink << "(Tt_class)" << (int)_class;
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_mode mode
|
|
)
|
|
{
|
|
char *string = 0;
|
|
switch (mode) {
|
|
case TT_MODE_UNDEFINED: string = "TT_MODE_UNDEFINED"; break;
|
|
case TT_IN: string = "TT_IN"; break;
|
|
case TT_OUT: string = "TT_OUT"; break;
|
|
case TT_INOUT: string = "TT_INOUT"; break;
|
|
}
|
|
if (string != 0) {
|
|
sink << string;
|
|
} else {
|
|
sink << "(Tt_mode)" << (int)mode;
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_address address
|
|
)
|
|
{
|
|
char *string = 0;
|
|
switch (address) {
|
|
case TT_PROCEDURE: string = "TT_PROCEDURE"; break;
|
|
case TT_OBJECT: string = "TT_OBJECT"; break;
|
|
case TT_HANDLER: string = "TT_HANDLER"; break;
|
|
case TT_OTYPE: string = "TT_OTYPE"; break;
|
|
}
|
|
if (string != 0) {
|
|
sink << string;
|
|
} else {
|
|
sink << "(Tt_address)" << (int)address;
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
ostream &
|
|
operator<<(
|
|
ostream & sink,
|
|
Tt_callback_action action
|
|
)
|
|
{
|
|
char *string = 0;
|
|
switch (action) {
|
|
case TT_CALLBACK_CONTINUE: string = "TT_CALLBACK_CONTINUE";break;
|
|
case TT_CALLBACK_PROCESSED: string = "TT_CALLBACK_PROCESSED";break;
|
|
}
|
|
if (string != 0) {
|
|
sink << string;
|
|
} else {
|
|
sink << "(Tt_callback_action)" << (int)action;
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
Tt_message
|
|
tt_message_copy(
|
|
Tt_message msg1
|
|
)
|
|
{
|
|
if (tt_ptr_error( msg1 ) != TT_OK) {
|
|
return msg1;
|
|
}
|
|
Tt_message msg2 = tt_message_create();
|
|
Tt_status status = tt_ptr_error( msg2 );
|
|
if (tt_ptr_error( msg2 ) != TT_OK) {
|
|
return msg2;
|
|
}
|
|
int contexts = tt_message_contexts_count( msg1 );
|
|
status = tt_int_error( contexts );
|
|
if (status != TT_OK) {
|
|
tt_message_destroy( msg2 );
|
|
return (Tt_message)tt_error_pointer( status );
|
|
}
|
|
for (int context = 0; context < contexts; context++) {
|
|
char *slot = tt_message_context_slotname( msg1, context );
|
|
int ival;
|
|
status = tt_message_context_ival( msg1, slot, &ival );
|
|
switch (status) {
|
|
unsigned char *bval;
|
|
int len;
|
|
case TT_OK:
|
|
tt_message_icontext_set( msg2, slot, ival );
|
|
break;
|
|
case TT_ERR_NUM:
|
|
tt_message_context_bval( msg1, slot, &bval, &len );
|
|
tt_message_bcontext_set( msg2, slot, bval, len );
|
|
tt_free( (caddr_t)bval );
|
|
break;
|
|
}
|
|
tt_free( slot );
|
|
}
|
|
int args = tt_message_args_count( msg1 );
|
|
status = tt_int_error( args );
|
|
if (status != TT_OK) {
|
|
tt_message_destroy( msg2 );
|
|
return (Tt_message)tt_error_pointer( status );
|
|
}
|
|
for (int arg = 0; arg < args; arg++) {
|
|
Tt_mode mode = tt_message_arg_mode( msg1, arg );
|
|
char *vtype = tt_message_arg_type( msg1, arg );
|
|
int ival;
|
|
status = tt_message_arg_ival( msg1, arg, &ival );
|
|
switch (status) {
|
|
unsigned char *bval;
|
|
int len;
|
|
case TT_OK:
|
|
tt_message_iarg_add( msg2, mode, vtype, ival );
|
|
break;
|
|
case TT_ERR_NUM:
|
|
tt_message_arg_bval( msg1, arg, &bval, &len );
|
|
tt_message_barg_add( msg2, mode, vtype, bval, len );
|
|
tt_free( (caddr_t)bval );
|
|
break;
|
|
}
|
|
tt_free( vtype );
|
|
}
|
|
|
|
tt_message_class_set( msg2, tt_message_class( msg1 ));
|
|
|
|
char *file = tt_message_file( msg1 );
|
|
if ((tt_ptr_error( file ) == TT_OK) && (file != 0)) {
|
|
tt_message_file_set( msg2, file );
|
|
tt_free( file );
|
|
}
|
|
|
|
char *object = tt_message_object( msg1 );
|
|
if ((tt_ptr_error( object ) == TT_OK) && (object != 0)) {
|
|
tt_message_object_set( msg2, object );
|
|
tt_free( object );
|
|
}
|
|
|
|
char *op = tt_message_op( msg1 );
|
|
if ((tt_ptr_error( op ) == TT_OK) && (op != 0)) {
|
|
tt_message_op_set( msg2, op );
|
|
tt_free( op );
|
|
}
|
|
|
|
char *otype = tt_message_otype( msg1 );
|
|
if ((tt_ptr_error( otype ) == TT_OK) && (otype != 0)) {
|
|
tt_message_otype_set( msg2, otype );
|
|
tt_free( otype );
|
|
}
|
|
|
|
tt_message_address_set( msg2, tt_message_address( msg1 ));
|
|
|
|
// XXX skip handler, handler_ptype, sender
|
|
|
|
tt_message_scope_set( msg2, tt_message_scope( msg1 ));
|
|
|
|
char *sender_ptype = tt_message_sender_ptype( msg1 );
|
|
if ((tt_ptr_error( sender_ptype ) == TT_OK) && (sender_ptype != 0)) {
|
|
tt_message_sender_ptype_set( msg2, sender_ptype );
|
|
tt_free( sender_ptype );
|
|
}
|
|
|
|
char *session = tt_message_session( msg1 );
|
|
if ((tt_ptr_error( session ) == TT_OK) && (session != 0)) {
|
|
tt_message_session_set( msg2, session );
|
|
tt_free( session );
|
|
}
|
|
|
|
tt_message_status_set( msg2, tt_message_status( msg1 ));
|
|
|
|
char *status_string = tt_message_status_string( msg1 );
|
|
if ((tt_ptr_error( status_string ) == TT_OK) && (status_string != 0)) {
|
|
tt_message_status_string_set( msg2, status_string );
|
|
tt_free( status_string );
|
|
}
|
|
|
|
return msg2;
|
|
}
|
|
|
|
Tt_message
|
|
tttk_message_create(
|
|
const char *optext
|
|
)
|
|
{
|
|
Tttk_op op = tttk_string_op( optext );
|
|
Tt_class theClass;
|
|
switch (op) {
|
|
default:
|
|
theClass = TT_REQUEST;
|
|
break;
|
|
case TTDT_CREATED:
|
|
case TTDT_DELETED:
|
|
case TTDT_MODIFIED:
|
|
case TTDT_REVERTED:
|
|
case TTDT_MOVED:
|
|
case TTDT_SAVED:
|
|
case TTDT_STARTED:
|
|
case TTDT_STOPPED:
|
|
case TTDT_STATUS:
|
|
theClass = TT_NOTICE;
|
|
break;
|
|
}
|
|
Tt_scope scope;
|
|
switch (op) {
|
|
default:
|
|
scope = TT_SESSION;
|
|
break;
|
|
case TTDT_CREATED:
|
|
case TTDT_DELETED:
|
|
case TTDT_MODIFIED:
|
|
case TTDT_REVERTED:
|
|
case TTDT_MOVED:
|
|
case TTDT_SAVED:
|
|
case TTDT_GET_MODIFIED:
|
|
case TTDT_SAVE:
|
|
case TTDT_REVERT:
|
|
scope = TT_BOTH;
|
|
break;
|
|
}
|
|
Tt_message msg = tttk_message_create( 0, theClass, scope,
|
|
0, optext, 0 );
|
|
Tt_mode mode = TT_INOUT;
|
|
switch (op) {
|
|
default:
|
|
break;
|
|
case TTDT_MOVED:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_file, 0 );
|
|
// fall through
|
|
case TTDT_CREATED:
|
|
case TTDT_DELETED:
|
|
case TTDT_MODIFIED:
|
|
case TTDT_REVERTED:
|
|
case TTDT_SAVED:
|
|
case TTDT_GET_MODIFIED:
|
|
case TTDT_SAVE:
|
|
case TTDT_REVERT:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_file, 0 );
|
|
break;
|
|
case TTDT_GET_SYSINFO:
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
// fall through
|
|
case TTDT_GET_STATUS:
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
break;
|
|
case TTDT_STATUS:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
// fall through
|
|
case TTDT_STARTED:
|
|
case TTDT_STOPPED:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
break;
|
|
case TTDT_GET_ICONIFIED:
|
|
case TTDT_GET_MAPPED:
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_boolean, 0 );
|
|
break;
|
|
case TTDT_QUIT:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_boolean, 0 );
|
|
// fall through
|
|
case TTDT_SET_MAPPED:
|
|
case TTDT_SET_ICONIFIED:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_boolean, 0 );
|
|
break;
|
|
case TTDT_GET_GEOMETRY:
|
|
mode = TT_OUT;
|
|
case TTDT_SET_GEOMETRY:
|
|
tt_message_arg_add( msg, mode, Tttk_width, 0 );
|
|
tt_message_arg_add( msg, mode, Tttk_height, 0 );
|
|
tt_message_arg_add( msg, mode, Tttk_xoffset, 0 );
|
|
tt_message_arg_add( msg, mode, Tttk_yoffset, 0 );
|
|
break;
|
|
case TTDT_GET_XINFO:
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_integer, 0 );
|
|
break;
|
|
case TTDT_GET_SITUATION:
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
break;
|
|
case TTDT_SIGNAL:
|
|
case TTDT_SET_SITUATION:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
break;
|
|
case TTDT_DO_COMMAND:
|
|
case TTDT_GET_ENVIRONMENT:
|
|
case TTDT_GET_LOCALE:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_OUT, Tttk_string, 0 );
|
|
break;
|
|
case TTDT_SET_LOCALE:
|
|
case TTDT_SET_ENVIRONMENT:
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
tt_message_arg_add( msg, TT_IN, Tttk_string, 0 );
|
|
break;
|
|
}
|
|
return msg;
|
|
}
|
|
|
|
int
|
|
tt_procid_fd(
|
|
const char *procid
|
|
)
|
|
{
|
|
char *defaultProcid = tt_default_procid();
|
|
tt_default_procid_set( procid );
|
|
int val2return = tt_fd();
|
|
if (! tt_is_err( tt_ptr_error( defaultProcid ))) {
|
|
tt_default_procid_set( defaultProcid );
|
|
}
|
|
return val2return;
|
|
}
|