falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtpad/ttMsgSupport.c

938 lines
30 KiB
C
Raw Blame History

/*
* 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
*/
/* $TOG: ttMsgSupport.c /main/7 1999/09/15 14:23:02 mgreess $ */
/**********************************<+>*************************************
***************************************************************************
**
** File: ttMsgSupport.c
**
** Project: DT dtpad, a memo maker type editor based on the Dt Editor
** widget.
**
** Description:
** -----------
**
** Provides support for the Tool Talk "Desktop" and "Document and Media
** Exchange" message sets.
**
** XXX - Need to use message catalogs for error messages and not write to
** stdout or stderr.
**
*******************************************************************
** (c) Copyright Hewlett-Packard Company, 1990, 1991, 1992, 1993.
** All rights are
** reserved. Copying or other reproduction of this program
** except for archival purposes is prohibited without prior
** written consent of Hewlett-Packard Company.
********************************************************************
**
********************************************************************
** (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.
********************************************************************
**
**
**************************************************************************
**********************************<+>*************************************/
/* for asprintf */
#if defined(__linux__) || defined(CSRG_BASED)
# define _GNU_SOURCE
#endif
#include "dtpad.h"
#include <dirent.h>
#include <Dt/DtpadM.h>
#include <Dt/HourGlass.h>
#define TIMEOUT_FACTOR 1000
XtInputId ProcessToolTalkInputId = 0;
extern Editor *pPadList; /* list of Editor instances - declared in main.c */
extern char *initialServerGeometry; /* declared in main.c */
extern Tt_message TTSaveContractCB( /* declared in ttSaveSupport.c */
Tt_message m,
void * clientData,
Tt_message contract);
extern Tt_pattern TTCreateSavePattern( /* declared in ttSaveSupport.c */
Tt_message contract,
Ttdt_contract_cb clientCB,
void * clientData,
int register_it);
/************************************************************************
* TTdisplayError - posts a ToolTalk error dialog containing the specified
* error message followed by the related ToolTalk status message.
************************************************************************/
void
TTdisplayError(
Editor *pPad,
char *errorMsg,
Tt_status status)
{
char *statusMsg = tt_status_message(status);
char buf[1024];
if (errorMsg != (char *) NULL) {
sprintf(buf, "%s\n(%d: %s)", errorMsg, status, statusMsg);
} else {
sprintf(buf, "(%d: %s)", status, statusMsg);
}
tt_free(statusMsg);
Warning(pPad, buf, XmDIALOG_ERROR);
}
/******************************************************************************
* TTdt_session_joinCB - Callback passed to ttdt_session_join() to handle
* standard "Desktop" messages.
*
* In our case, this only deals with the standard Desktop Quit message with
* signature:
*
* Quit(in boolean silent, in boolean force, in messageID operation2Quit)
*
* XXX - This routine was setup by SUN but currently does nothing since:
* Requests to quit a specific Media Edit/Display request are handled in
* TTdt_message_acceptCB() (which is registered in TTmedia_ptype_declareCB()
* when the Media Edit/Display request is first accepted).
******************************************************************************/
Tt_message
TTdt_session_joinCB(
Tt_message m,
void * client_data,
Tt_message contract)
{
/* should never get here, if we do, notify sender with a fail */
tttk_message_fail(m,
TT_DESKTOP_ENOTSUP, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
return((Tt_message) 0); /* we handled this message */
}
/******************************************************************************
* TTdt_message_acceptCB - callback (setup in ttdt_message_accept()) to handle
* TT_HANDLER-addressed messages. Currently this routine handles:
*
* Quit(4) request which can contain the following arguments:
*
* silent - controls whether or not the user is notified
* when there are unsaved changes
* force - controls whether or not the Quit is aborted
* when there are unsaved changes
* operation2Quit - controls whether all edit window(s) are closed or
* whether a specific edit window is closed
*
* This routine is analogous to TTSaveContractCB() which handles
* Save requests. Patterns to handle Quit requests are automatically
* registered via ttdt_message_accept() whereas patterns to handle Save
* requests must be explicitly registered (see TTCreateSavePattern()).
*
* See dtpad(1) for more details.
*
******************************************************************************/
Tt_message
TTdt_message_acceptCB(
Tt_message m,
void * client_data,
Tt_message contract)
{
Editor *pPad;
int silent, force;
Tt_status status;
char *operation2Quit;
int mark = tt_mark();
char *opString = tt_message_op(m);
Tttk_op op = tttk_string_op(opString);
if (op == TTDT_QUIT) {
/* Search the list of Editor instances for one with a TT media
* msg id matching the originating media msg id supplied as the
* 'operation2Quit' (3rd) argument of the TTDT_QUIT msg */
if (operation2Quit = tt_message_arg_val(m, 2)) {
for (pPad = pPadList; pPad != (Editor *)NULL; pPad = pPad->pNextPad) {
if (pPad->inUse == True && pPad->ttEditReq.msg_id &&
strcmp(pPad->ttEditReq.msg_id, operation2Quit) == 0) {
pPad->ttQuitReq.contract = m; /* process Quit msg */
status = tt_message_arg_ival(m, 0, &silent);
status = tt_message_arg_ival(m, 1, &force);
pPad->ttQuitReq.silent = (Boolean) silent;
pPad->ttQuitReq.force = (Boolean) force;
pPad->ttQuitReq.operation2Quit = strdup(operation2Quit);
FileExitCB( (Widget) NULL, (caddr_t) pPad, (caddr_t) NULL);
tt_release(mark);
return((Tt_message) 0); /* handling Quit */
}
}
/* no Edit window matching the operation2Quit */
tttk_message_fail(m,
TT_DESKTOP_ENOMSG, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
} else { /* no operation2Quit - quit all Edit windows */
/* XXX - not currently processing this type of Quit */
tttk_message_fail(m,
TT_DESKTOP_ENOTSUP, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
}
/* We're handling all Quit requests. If the request has not been
* failed already, pPad->ttQuitReq.contract will be non-NULL and
* the Quit message will be responded to or failed later. */
tt_release(mark);
return((Tt_message) 0); /* handling Quit */
} else { /* unsupported message type */
tt_release(mark);
return(m); /* didn't handle message */
}
}
/******************************************************************************
* TTmedia_ptype_declareCB - callback (set up in ttmedia_ptype_declare()) to
* handle the standard ToolTalk Instantiate/Edit/Display media messages
* from a "requestor" dtpad or from other applications.
*
* It sets up TTdt_message_acceptCB() when it "accepts" the message which
* handles Quit messages relating to the accepted Instantiate/Edit/Display
* message.
*
* Returns: 0 if the message is handled; otherwise, returns Tt_message.
******************************************************************************/
Tt_message
TTmedia_ptype_declareCB(
Tt_message m,
void * client_data,
Tttk_op op,
Tt_status diag,
unsigned char * contents,
int len,
char * file,
char * docname)
{
Editor *pPad;
char *filename;
Tt_message TTdt_message_acceptCB(), incoming;
Tt_pattern *ttrc;
DtEditorContentRec contentRec;
DtEditorErrorCode errorCode;
Boolean foundPad = False;
char *context = (char *)NULL;
Boolean isCurrentlyVisible = False;
int mark = tt_mark();
char *localPath = tt_message_file(m);
if (diag != TT_OK
&& !(op == TTME_INSTANTIATE && diag == TT_DESKTOP_ENODATA)) { /* TTT - workaround for tttk bug */
fprintf(stderr,
"Ignored Media request with ToolTalk detected error: %s\n",
tt_status_message(diag));
return(m);
}
if (op != TTME_EDIT && op != TTME_DISPLAY && op != TTME_INSTANTIATE) {
return(m); /* Message not handled by this routine. */
}
/* if editing a file, make sure we can read it first,
* if not, fail the request immediately
*/
if (file) {
char *pathEnd;
if (MbStrrchr(localPath, '/') != (char *)NULL) {
char *dir; DIR *pDir;
dir = (char *) XtMalloc(strlen(localPath) + 1);
strcpy(dir, localPath);
pathEnd = MbStrrchr(dir, '/');
if (pathEnd == dir) {
/* file is in the root directory
*/
pathEnd++;
}
*pathEnd = (char)'\0';
if ((pDir = opendir(dir)) != (DIR *)NULL) {
closedir(pDir);
XtFree(dir);
} else {
tt_free(localPath);
localPath = (char *) NULL;
XtFree(dir);
tttk_message_fail(m,
TT_DESKTOP_ENOENT, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
tt_release(mark);
return((Tt_message) 0); /* Message handled by this routine. */
}
}
}
/*
* Create an Editor "instance" and manage/realize it.
* This involves creating its GUI components, setting it resources,
* mapping its windows and, if specified, loading the file to be edited.
*/
if (foundPad == False)
foundPad = FindOrCreatePad(&pPad); /* returns new Editor in pPad */
/*
* If this message is from a dtpad requestor then replace selective
* server resources with requestor resources shipped to the dtpad server
* in the message context fields
*/
if (tt_message_contexts_count(m)) {
/*----> a session file, want to restore a session */
if (*(context = tt_message_context_val(m, "SESSION"))) {
pPad->xrdb.session = strdup(context);
}
else {
/* -----> non text editor specific resource */
if (*(context = tt_message_context_val(m, "GEOMETRY"))) {
pPad->geometry = strdup(context);
}
/* -----> basic options */
if (context = tt_message_context_val(m, "STATUSLINE")) {
if (*context == 't')
pPad->xrdb.statusLine = True;
else
pPad->xrdb.statusLine = False;
}
if (context = tt_message_context_val(m, "WINDOWWORDWRAP")) {
if (*context == 't')
pPad->xrdb.wordWrap = True;
else
pPad->xrdb.wordWrap = False;
}
if (context = tt_message_context_val(m, "OVERSTRIKE")) {
if (*context == 't')
pPad->xrdb.overstrike = True;
else
pPad->xrdb.overstrike = False;
}
if (context = tt_message_context_val(m, "SAVEONCLOSE")) {
if (*context == 't')
pPad->xrdb.saveOnClose = True;
else
pPad->xrdb.saveOnClose = False;
}
if (context = tt_message_context_val(m, "MISSINGFILEWARNING")) {
if (*context == 't')
pPad->xrdb.missingFileWarning = True;
else
pPad->xrdb.missingFileWarning = False;
}
if (context = tt_message_context_val(m, "NOREADONLYWARNING")) {
if (*context == 't')
pPad->xrdb.readOnlyWarning = True;
else
pPad->xrdb.readOnlyWarning = False;
}
if (context = tt_message_context_val(m, "NONAMECHANGE")) {
if (*context == 't')
pPad->xrdb.nameChange = True;
else
pPad->xrdb.nameChange = False;
}
if (context = tt_message_context_val(m, "VIEWONLY")) {
if (*context == 't')
pPad->xrdb.viewOnly = True;
else
pPad->xrdb.viewOnly = False;
}
if (context = tt_message_context_val(m, "WORKSPACELIST")) {
pPad->xrdb.workspaceList = strdup(context);
}
/* -----> client/server control options */
if (*(context = tt_message_context_val(m, "BLOCKING"))) {
pPad->xrdb.blocking = True;
pPad->blockChannel = strdup(context);
}
}
}
pPad->ttEditReq.contract = m;
pPad->ttEditReq.msg_id = strdup(tt_message_id(m));
pPad->ttEditReq.op = op;
if (op == TTME_INSTANTIATE) {
pPad->ttEditReq.contents = False;
pPad->ttEditReq.returnBufContents = False;
} else { /* TTME_EDIT or TTME_DISPLAY */
if (file) {
/* the mediaType of the first arg (contents) applies to either
* contents or a file */
pPad->ttEditReq.vtype = strdup(tt_message_arg_type(m, 0));
pPad->ttEditReq.contents = False; /* editing a file */
pPad->ttEditReq.fileName = strdup(localPath);
pPad->fileStuff.fileName = XtNewString(pPad->ttEditReq.fileName);
} else {
pPad->ttEditReq.contents = True; /* editing a buffer */
pPad->xrdb.nameChange = False; /* disallow switching to another
file */
pPad->ttEditReq.returnBufContents = True;
}
if (docname) {
pPad->ttEditReq.docName = strdup(docname);
} else {
pPad->ttEditReq.docName = (char *) NULL;
}
if (op == TTME_DISPLAY)
pPad->xrdb.viewOnly = True;
}
/* -----> Create GUI components of Editor instance, set resouces,
* map window and load file (if specified). */
if (!foundPad) {
RealizeNewPad(pPad); /* pPad->mainWindow is created here */
} else {
ManageOldPad(pPad, isCurrentlyVisible);
}
/* -----> Accept the message.
*
* Registers patterns in the default session to handle TT_HANDLER-addressed
* requests (created by specifying the "handler" argument in
* tttk_message_create) in the following manner (based on the shell and
* Ttdt_contract_cb args):
*
* type requests handled notes
* ---- -------------------- ---------------------------- -----
* (1) Get|Set_Geometry, transparently (a)
* Get|Set_Iconified,
* Get|Set_Mapped,
* Get|Set_XInfo,
* Raise, Lower
* (2) Pause, Resume passed to Ttdt_contract_cb (b)
* (3) Quit, Get_Status passed to Ttdt_contract_cb (c)
*
* NOTES:
* (a) type (1) requests are handled transparently because the shell
* arg is specified (that is, a pattern is registered to handle
* these requests via an internal TT callback)
* (b) type (2) requests are handled like type (3) because
* Ttdt_contract_cb is specified; otherwise they would be
* handled transparently
* (c) type (3) request are handled in Ttdt_contract_cb because it
* was specified; otherwise they fail with TT_DESKTOP_ENOTSUP
* (that is, Ttdt_contract_cb is the pattern callback registered
* in the pattern to handle these requests).
*/
ttrc = ttdt_message_accept(
m, /* Tt_message */
TTdt_message_acceptCB, /* Ttdt_contract_cb */
pPad->app_shell, /* shell widget */
pPad->mainWindow, /* client data */
1, /* call tt_message_accept() */
1); /* send STATUS notice to requestor */
if (tt_ptr_error((void *) ttrc) != TT_OK) {
fprintf(stderr,
"Could not ttdt_message_accept the edit request: %s\n",
tt_status_message((tt_ptr_error((void *) ttrc))));
}
/* -----> Create pattern to handle "Save" requests in a manner analogous
* to "Quit" requests.
* NOTE: This pattern (unlike the Quit pattern automatically registered
* via ttdt_message_accept()) is *not* automatically destroyed
* when the original Edit request is destroyed. */
pPad->ttEditReq.savePattern = TTCreateSavePattern(
m, /* Tt_message */
TTSaveContractCB, /* Ttdt_contract_cb */
pPad->mainWindow, /* client data - not currently used */
1); /* register it */
/* -----> Set the DtEditor widget contents. */
if (pPad->ttEditReq.contents) {
contentRec.type = DtEDITOR_TEXT;
contentRec.value.string = (char *) contents;
errorCode = DtEditorSetContents(pPad->editor, &contentRec);
/* [SuG 5/18/95] Done
The NOT_SAMPLE warnings/errors need to be added to the message
catalog. Removed ifdefs.*/
switch (errorCode) {
case DtEDITOR_NO_ERRORS:
break;
case DtEDITOR_NULLS_REMOVED:
Warning(pPad, (char *) GETMESSAGE(6, 6,
"Embedded Nulls stripped from file."),
XmDIALOG_WARNING);
break;
case DtEDITOR_INSUFFICIENT_MEMORY:
Warning(pPad, (char*) GETMESSAGE(6, 7,
"Unable to load file (insufficient memory)."),
XmDIALOG_ERROR);
break;
default:
Warning(pPad, (char *) GETMESSAGE(6, 12,
"Unable to read from the file (unknown reason)."),
XmDIALOG_ERROR);
break;
}
}
tt_release(mark);
return((Tt_message) 0); /* Message handled by this routine. */
}
/********************** Exported Functions (via dtpad.h) **********************/
/******************************************************************************
* TTstartDesktopMediaExchange - Initializes Took Talk for handling the
* "Desktop" and "Document & Media Exchange" message sets.
*
* Returns: True if successful; 0 if failure.
******************************************************************************/
Tt_status
TTstartDesktopMediaExchange(
Widget topLevelWithWmCommand,
Editor * pPad)
{
char *my_procid = NULL;
int my_ttfd = 0;
Tt_pattern *tt_pat = NULL;
Tt_status status = TT_OK;
int mark = tt_mark();
char *sess = NULL;
/*
* Open a connection to the ToolTalk service
* and send a Started notice so other applications know we're up.
*/
sess = (char *)getenv("TT_SESSION");
if (!sess || (*sess == '\0')) {
sess = getenv("_SUN_TT_SESSION");
}
if (!sess || (*sess == '\0')) {
tt_default_session_set(
tt_X_session(XDisplayString(XtDisplay(topLevelWithWmCommand))) );
}
status = TTdesktopOpen( &my_ttfd, pPad, (int) pPad->xrdb.server);
if (TT_OK != status)
return(status);
if (pPad->xrdb.server == True) {
/*
* Declare we will handle messages defined under our ptype
* which in this case currently consist of the Instantialte, Display
* and Edit messages from the Media set, as defined in dtpad.ptypes.
* This will enable auto start of dtpad if any of the messages in the
* ptype are received.
*/
if ((status = ttmedia_ptype_declare(
DTPAD_TOOL_CLASS, /* ptype */
0, /* base opnum */
TTmedia_ptype_declareCB,/* Ttmedia_load_pat_cb */
(void *) pPadList, /* client data */
1)) /* call tt_ptype_declare() */
!= TT_OK) {
fprintf(stderr,
"Could not register as %s tool class handler: %s\n",
DTPAD_TOOL_CLASS,
tt_status_message(status)) ;
return(status);
}
/*
* Join the default session,
* and register to deal with standard Desktop requests in the following
* manner (controlled by the Ttdt_contract_cb and shell arguments):
*
* type requests handled notes
* ---- -------------------- ---------------------------- -----
* (1) Get|Set_Environment, transparently
* Get|Set_Locale,
* Get|Set_Situation,
* Signal, Get_Sysinfo
* (2) Get|Set_Geometry, fail with TT_DESKTOP_ENOTSUP (b)
* Get|Set_Iconified,
* Get|Set_Mapped,
* Raise, Lower,
* Set_Xinfo,
* Get_Xinfo transparently
* (3) Pause, Resume, Quit passed to Ttdt_contract_cb (c)
* (4) Get_Status, Do_Command passed to Ttdt_contract_cb
*
* NOTES:
* (b) type (2) requests (except Get_Xinfo) fail because the shell
* arg is not a "realized mappedWhenManaged applicationShellWidget"
* (c) type (3) requests are not handled transparently because
* Ttdt_contract_cb is specified
*/
tt_pat = ttdt_session_join(
(const char *) 0, /* join default session */
TTdt_session_joinCB, /* Ttdt_contract_cb */
topLevelWithWmCommand, /* shell widget */
(void *) 0, /* client data */
1); /* really join the session */
if ((status = tt_ptr_error(tt_pat)) != TT_OK) {
fprintf(stderr,
"Could not join default ToolTalk session: %s\n",
tt_status_message(tt_ptr_error(tt_pat)));
ttdt_close(0, 0, 1);
return(status);
}
}
/*
* Have Xt monitor the connection to the ToolTalk service.
* tttk_Xt_input_handler() will ultimately call tt_message_receive(),
* which will invoke the callbacks we've registered.
*/
XtAppAddInput(XtWidgetToApplicationContext(topLevelWithWmCommand),
my_ttfd, (XtPointer) XtInputReadMask, tttk_Xt_input_handler,
my_procid);
return(status);
}
/************************************************************************
* TTmediaDepositContents - sends a ToolTalk Deposit request (containing
* the current contents of the DtEditor widget) directly to the
* sender of the original media request.
*
* Returns: 0 if successful; !0 if failure.
************************************************************************/
Boolean
TTmediaDepositContents(
Editor *pPad)
{
DtEditorErrorCode errorCode;
DtEditorContentRec contentRec;
Boolean addNewlines = pPad->xrdb.wordWrap == True &&
pPad->fileStuff.saveWithNewlines == True;
Tt_status status;
_DtTurnOnHourGlass(pPad->app_shell);
contentRec.type = DtEDITOR_TEXT;
errorCode = DtEditorGetContents(
pPad->editor,
&contentRec,
addNewlines,
False); /* don't mark contents as saved yet */
if (errorCode != DtEDITOR_NO_ERRORS) {
Warning(pPad,
"Internal Error: Unable to get contents from Editor Widget.",
XmDIALOG_ERROR);
return(1);
}
status = ttmedia_Deposit(
pPad->ttEditReq.contract, /* original request */
(char *) NULL, /* send directly to requestor */
pPad->ttEditReq.vtype, /* media type */
(unsigned char *) contentRec.value.string, /*new contents */
strlen(contentRec.value.string),
(char *) NULL, /* don't use temp file for xfer */
pPad->app_context, /* we're the blocking application */
10 * TIMEOUT_FACTOR); /* milliseconds to block for reply */
if (status == TT_OK) {
/* XXX - an inefficient way of marking contents as saved -
* need to use a global to keep track of unsaved changes
* and replace DtEditorCheckForUnsavedChanges() */
errorCode = DtEditorGetContents(
pPad->editor,
&contentRec,
addNewlines,
True); /* mark contents as saved */
_DtTurnOffHourGlass(pPad->app_shell);
} else {
_DtTurnOffHourGlass(pPad->app_shell);
TTdisplayError(pPad,
(char *) GETMESSAGE(13, 1, "Checkpoint save failed."),
status);
return(1);
}
return(0);
}
/************************************************************************
* TTmediaReply - replies to (and closes) a ToolTalk media request.
*
* If a file is being edited, it is assumed at this point that it
* has already been updated with the current contents.
*
* If a buffer is being edited, the current text is included in the
* reply only if pPad->ttEditReq.returnBufContents is True.
*
* Returns: 0 if successful; !0 if failure.
************************************************************************/
Boolean
TTmediaReply(
Editor *pPad)
{
DtEditorErrorCode errorCode;
DtEditorContentRec contentRec;
Tt_status status;
Boolean addNewlines = pPad->xrdb.wordWrap == True &&
pPad->fileStuff.saveWithNewlines == True;
_DtTurnOnHourGlass(pPad->app_shell);
if (! pPad->ttEditReq.contract) {
return 0;
}
/* ----> Not editing a buffer */
if (! pPad->ttEditReq.contents) {
status = ttmedia_load_reply(
pPad->ttEditReq.contract, /* original request */
(unsigned char *) 0, /* new contents */
0, /* contents length */
True); /* destroy message after reply */
_DtTurnOffHourGlass(pPad->app_shell);
if (status == TT_OK) {
pPad->ttEditReq.contract = 0; /* request has been closed */
return(0);
} else {
TTdisplayError(pPad,
(char *) GETMESSAGE(13, 2, "Checkpoint reply failed."),
status);
return(1);
}
}
/* ----> Editing a buffer */
if (pPad->ttEditReq.returnBufContents) {
/* -----> Include the contents in the reply */
contentRec.type = DtEDITOR_TEXT;
errorCode = DtEditorGetContents(
pPad->editor,
&contentRec,
addNewlines,
False); /* don't mark contents as saved yet */
if (errorCode != DtEDITOR_NO_ERRORS) {
Warning(pPad,
"Internal Error: Unable to get contents from Editor Widget.",
XmDIALOG_ERROR);
tttk_message_fail(pPad->ttEditReq.contract,
TT_DESKTOP_ENODATA, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
return(1);
}
status = ttmedia_load_reply(
pPad->ttEditReq.contract, /* original request */
(unsigned char *) contentRec.value.string, /* new contents */
strlen(contentRec.value.string),
True); /* destroy message after reply */
if (status == TT_OK) {
/* XXX - an inefficient way of marking contents as saved -
* need to use a global to keep track of unsaved changes
* and replace DtEditorCheckForUnsavedChanges() */
errorCode = DtEditorGetContents(
pPad->editor,
&contentRec,
addNewlines,
True); /* mark contents as saved */
_DtTurnOffHourGlass(pPad->app_shell);
pPad->ttEditReq.contract = NULL; /* request has been closed */
} else {
_DtTurnOffHourGlass(pPad->app_shell);
TTdisplayError(pPad,
(char *) GETMESSAGE(13, 2, "Checkpoint reply failed."),
status);
return(1);
}
} else {
/* -----> Don't include anything in the buffer reply (e.g.
* when the user responds "no" to saving unsaved contents).
*
* NOTE: TT_DESKTOP_ECANCELED changes the "failure" into a "reply".
*/
status = tttk_message_fail(
pPad->ttEditReq.contract, /* original request */
TT_DESKTOP_ECANCELED, /* status */
(char *) NULL, /* status str */
1); /* destroy request */
_DtTurnOffHourGlass(pPad->app_shell);
if (status == TT_OK) {
pPad->ttEditReq.contract = NULL; /* request has been closed */
} else {
TTdisplayError(pPad,
(char *) GETMESSAGE(13, 2, "Checkpoint reply failed."),
status);
return(1);
}
}
return(0);
}
/************************************************************************
* TTresetQuitArgs - resets TTDT_QUIT arguments set in TTdt_message_acceptCB()
************************************************************************/
void
TTresetQuitArgs(
Editor *pPad)
{
if (!pPad->ttQuitReq.contract)
return;
pPad->ttQuitReq.contract = NULL;
if (pPad->ttQuitReq.operation2Quit != (char *) NULL) {
XtFree(pPad->ttQuitReq.operation2Quit);
pPad->ttQuitReq.operation2Quit = (char *) NULL;
}
pPad->ttQuitReq.silent = 0;
pPad->ttQuitReq.force = 0;
}
/************************************************************************
* TTfailPendingQuit - fails any pending Quit request - even if 'force' is
* specified
************************************************************************/
void
TTfailPendingQuit(
Editor *pPad)
{
if (pPad->ttQuitReq.contract) {
tttk_message_fail(pPad->ttQuitReq.contract, /* original Quit req */
TT_DESKTOP_ECANCELED, /* status */
(char *) NULL, /* status string */
1); /* destroy request */
TTresetQuitArgs(pPad);
}
}
/************************************************************************
* TTdesktopOpen - This procedure just opens a connection to
* ToolTalk so a simple message can be sent.
************************************************************************/
Tt_status
TTdesktopOpen( int *ttFd, Editor *pPad, Boolean sendStarted )
{
char * procId;
Tt_status status;
char *vendor;
#ifdef sun
vendor = "Sun Microsystems";
#elif defined(_AIX)
vendor = "IBM";
#else
vendor = "Unknown";
#endif /* _AIX */
procId = ttdt_open( ttFd, "dtpad", vendor, "2.1", sendStarted );
if ( (status = tt_ptr_error( procId )) != TT_OK )
{
ttdt_close( NULL, NULL, sendStarted );
return( status );
}
ProcessToolTalkInputId =
XtAppAddInput( pPad->app_context,
*ttFd, (XtPointer)XtInputReadMask,
tttk_Xt_input_handler, procId );
return( TT_OK );
}
/************************************************************************
* TTwarning - This procedure displays a message dialog and exits.
************************************************************************/
/* ARGSUSED */
static void
okCB(Widget w, XtPointer clientData, XtPointer callData)
{
*((int*) clientData) = 1;
}
void
TTwarning( Editor *pPad, Tt_status status, char *errsuff )
{
FileWidgets *pFileWidgets;
char *errfmt;
char *errmsg;
char *statmsg;
int done = 0;
if (TT_OK == status || NULL == pPad) return;
errfmt =
GETMESSAGE(7, 13, "Could not connect to ToolTalk service:\n%s\n%s\n");
statmsg = tt_status_message(status);
errmsg = XtMalloc(strlen(errfmt) + strlen(statmsg) + strlen(errsuff) + 2);
if (NULL == errsuff) errsuff = "";
fprintf(stderr, errfmt, statmsg, errsuff);
sprintf(errmsg, errfmt, statmsg, errsuff);
Warning(pPad, errmsg, XmDIALOG_ERROR);
pFileWidgets = &pPad->fileStuff.fileWidgets;
XtAddCallback(pFileWidgets->gen_warning, XmNokCallback,
(XtCallbackProc) okCB, (XtPointer) &done);
XFlush(pPad->display);
XSync(pPad->display, False);
while ( !done )
{
XtAppProcessEvent(
XtWidgetToApplicationContext(pFileWidgets->gen_warning),
XtIMAll);
}
}
Reference in New Issue View Git Blame Copy Permalink