debian/cdesktop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7125b437f1f15445ee681494c866b3ae73312848
cdesktop/cde/programs/dtsession/SmCommun.c
T
Peter Howkins 94f78da5df dtsession: Change to ANSI function definitions
2018-06-28 04:18:25 +01:00

962 lines
23 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: SmCommun.c /main/14 1999/09/20 13:47:25 mgreess $ */
/*
* (c) Copyright 1997, The Open Group
*/
/*************************************<+>*************************************
*****************************************************************************
**
** File: SmCommun.c
**
** Project: HP DT Session Manager (dtsession)
**
** Description:
** -----------
** This file contains functionality needed to communicate with the
** other DT components. This includes initialization and callback code.
**
*****************************************************************************
*************************************<+>*************************************/
/*
* (c) Copyright 1996 Digital Equipment Corporation.
* (c) Copyright 1990, 1993, 1994, 1996 Hewlett-Packard Company
* (c) Copyright 1993, 1994, 1996 International Business Machines Corp.
* (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc.
* (c) Copyright 1993, 1994, 1996 Novell, Inc.
* (c) Copyright 1996 FUJITSU LIMITED.
* (c) Copyright 1996 Hitachi.
*/
#include <stdio.h>
#ifdef _SUN_OS /* for the strtok calls */
#include <string.h>
#endif
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#if defined (USE_X11SSEXT)
#include <X11/extensions/scrnsaver.h>
#endif /* USE_X11SSEXT */
#include <Xm/Xm.h>
#include <Dt/Dt.h>
#include <Dt/DtP.h>
#include <Dt/Action.h>
#include <Dt/SessionM.h>
#include <Dt/UserMsg.h>
#include <Dt/Indicator.h>
#include <Dt/MsgLog.h>
#include <Tt/tttk.h>
#include "Sm.h"
#include "SmError.h"
#include "SmLock.h"
#include "SmCommun.h"
#include "SmRestore.h"
#include "SmSave.h"
#include "SmUI.h"
#include "SmProtocol.h"
#include "SmGlobals.h"
#include "SmXSMP.h"
/*
* Pulic var declarations
*/
extern int clientRunning; /* from SmConMgmt.c */
extern char **smExecArray;
/*
* Defines for this file only
*/
#define SS_ON 0
#define SS_OFF 1
#define SS_DRAW 2
/*
* Constants for the Save_Session ToolTalk message
*/
static const char *SAVE_TYPE = "save_type";
static const char *SHUTDOWN = "shutdown";
static const char *INTERACT_STYLE = "interact_style";
static const char *FAST = "fast";
static const char *GLOBAL = "global";
static const char *NUM_BACKUPS = "num_sessions_backedup";
static const char *SAVE_LOCAL = "Local";
static const char *SAVE_GLOBAL = "Global";
static const char *SAVE_BOTH = "Both";
static const char *INTERACT_NONE = "None";
static const char *INTERACT_ERRORS = "Errors";
static const char *TRUE_STR = "True";
static const char *FALSE_STR = "False";
/*
* Local function definitions
*/
static void DtwmStarted(void);
static void
ProcessSaveSessionMessage (
Tt_message saveMsg )
{
int i;
int saveType = -1;
Boolean shutdown = DEFAULT_SHUTDOWN;
int interactStyle = DEFAULT_INTERACT_STYLE;
Boolean fast = DEFAULT_FAST;
Boolean global = DEFAULT_GLOBAL;
int numSessionsBackedup;
char * type;
char * value;
int num_args = tt_message_args_count (saveMsg);
Tt_message tmpMsg;
Tt_status status;
for (i = 0; i < num_args; i++) {
type = tt_message_arg_type (saveMsg, i);
status = tt_ptr_error (type);
if (status != TT_OK || type == NULL)
continue;
value = tt_message_arg_val (saveMsg, i);
status = tt_ptr_error (value);
if (status != TT_OK || value == NULL)
continue;
if (!strcmp (type, SAVE_TYPE)) {
if (!strcmp (value, SAVE_LOCAL))
saveType = SmSaveLocal;
else if (!strcmp (value, SAVE_GLOBAL))
saveType = SmSaveGlobal;
else if (!strcmp (value, SAVE_BOTH))
saveType = SmSaveBoth;
else {
tt_free (type);
tt_free (value);
break;
}
}
else if (!strcmp (type, SHUTDOWN)) {
if (!strcmp (value, TRUE_STR))
shutdown = True;
else if (!strcmp (value, FALSE_STR))
shutdown = False;
}
else if (!strcmp (type, INTERACT_STYLE)){
if (!strcmp (value, INTERACT_NONE))
interactStyle = SmInteractStyleNone;
else if (!strcmp (value, INTERACT_ERRORS))
interactStyle = SmInteractStyleErrors;
}
else if (!strcmp (type, FAST)) {
if (!strcmp (value, TRUE_STR))
fast = True;
else if (!strcmp (value, FALSE_STR))
fast = False;
}
else if (!strcmp (type, GLOBAL)) {
if (!strcmp (value, TRUE_STR))
global = True;
else if (!strcmp (value, FALSE_STR))
global = False;
}
else if (!strcmp (type, NUM_BACKUPS)) {
numSessionsBackedup = atoi (value);
if (numSessionsBackedup > 0)
smRes.numSessionsBackedup = numSessionsBackedup;
}
else {
char *pch1;
char *pch2;
pch1 = strdup ((char *) GETMESSAGE (40, 16,
"The Save_Session message contains the unrecognized argument '%s'."));
if (pch1) {
pch2 = XtMalloc (strlen (pch1)+strlen (type)+3);
if (pch2) {
(void) sprintf (pch2, pch1, type);
DtMsgLogMessage (smGD.programName,
DtMsgLogWarning, pch2);
free (pch1); free (pch2);
}
else {
free (pch1);
}
}
}
tt_free (type);
tt_free (value);
}
if (saveType == -1) {
PostSaveSessionErrorDialog ();
return;
}
smGD.smState = IN_PROCESS;
tmpMsg = tttk_message_create (0, TT_NOTICE, TT_SESSION, 0,
"DtActivity_Beginning", 0);
tt_message_send (tmpMsg);
tt_message_destroy (tmpMsg);
SaveState ((smGD.sessionType == HOME_SESSION),
smSettings.startState, saveType, shutdown,
interactStyle, fast, global);
tmpMsg = tttk_message_create (0, TT_NOTICE, TT_SESSION, 0,
"DtActivity_Began", 0);
tt_message_send (tmpMsg);
tt_message_destroy (tmpMsg);
SetSystemReady ();
}
/*************************************<->*************************************
*
* handleSessionMgrRequest ()
*
*
* Description:
* -----------
* Handle ToolTalk requests for which the session manager is responsible.
*
*
* Inputs:
* ------
* Incoming request, and the pattern it matched.
*
*
* Outputs:
* -------
* Whether the message has been consumed.
*
*
* Comments:
* --------
*
*************************************<->***********************************/
Tt_callback_action
handleSessionMgrRequest(
Tt_message msg,
Tt_pattern pat
)
{
char *op;
Tt_status status;
Tt_callback_action rc;
Boolean destroyMsg;
if (tt_message_state( msg ) != TT_SENT)
{
/* msg is a reply to ourself */
return TT_CALLBACK_CONTINUE;
}
op = tt_message_op( msg );
status = tt_ptr_error( op );
if ((status != TT_OK) || (op == 0))
{
/* Let tttk_Xt_input_handler() Do The Right Thing */
return TT_CALLBACK_CONTINUE;
}
destroyMsg = True;
if (strcmp( op, SM_DISPLAY_LOCK ) == 0)
{
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
LockDisplay(True);
}
rc = TT_CALLBACK_PROCESSED;
}
else if (strcmp( op, SM_XSESSION_EXIT ) == 0)
{
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
ExitSession( msg );
/*
* The session may have been canceled so set the smState
* back to ready.
*/
smGD.smState = READY;
destroyMsg = False; /* done in SmUI.c */
}
rc = TT_CALLBACK_PROCESSED;
}
else if (strcmp( op, SM_RESOURCES_RELOAD ) == 0)
{
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
ReloadResources();
}
rc = TT_CALLBACK_PROCESSED;
}
else if (strcmp( op, SM_SAVE_SESSION ) == 0)
{
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
ProcessSaveSessionMessage (msg);
}
rc = TT_CALLBACK_PROCESSED;
}
else
{
rc = TT_CALLBACK_CONTINUE;
destroyMsg = False;
}
if (destroyMsg == True)
{
tt_message_reply( msg );
tt_message_destroy( msg );
}
tt_free( op );
return (rc);
}
/*************************************<->*************************************
*
* StartMsgServer ()
*
*
* Description:
* -----------
* Initialize the BMS and register the session manager with it. Then
* register all requests and notifications that the session manager is
* interested in.
*
*
* Inputs:
* ------
* app = Application context for dtsession
*
*
* Outputs:
* -------
*
*
* Comments:
* --------
*
*************************************<->***********************************/
void
StartMsgServer(void)
{
Boolean makeConnect;
String tmpString;
char * sessId;
char * procId;
int fd;
Tt_status status;
/*
* Before we start anything - initialize the customize data structure
*/
smCust.screenSavChange = False;
smCust.audioChange = False;
smCust.keyboardChange = False;
smCust.fontChange = False;
smCust.pointerChange = False;
smCust.dClickChange = False;
smCust.preeditChange = False;
makeConnect = DtAppInitialize(smGD.appCon, smGD.display, smGD.topLevelWid,
SM_RESOURCE_NAME,
DtSM_TOOL_CLASS);
smDD.okString = XmStringCreateLocalized(((char *)GETMESSAGE(18, 39, "OK")));
smDD.okLogoutString = XmStringCreateLocalized(((char *)GETMESSAGE(18, 39, "OK")));
smDD.cancelLogoutString = XmStringCreateLocalized(((char *)GETMESSAGE(18,40, "Cancel")));
smDD.helpString = XmStringCreateLocalized(((char *)GETMESSAGE(18, 41, "Help")));
if(makeConnect == False)
{
smGD.bmsDead = True;
}
else
{
smGD.bmsDead = False;
}
procId = tt_open();
status = tt_ptr_error( procId );
if (status == TT_OK) {
fd = tt_fd();
status = tt_int_error( fd );
if (status == TT_OK) {
XtAppAddInput( smGD.appCon, fd, (XtPointer)XtInputReadMask,
tttk_Xt_input_handler, procId );
}
}
if (status != TT_OK) {
smGD.bmsDead = True;
}
smGD.requests2Handle = 0;
if (status == TT_OK) {
smGD.requests2Handle = tt_pattern_create();
tt_pattern_category_set( smGD.requests2Handle, TT_HANDLE );
tt_pattern_class_add( smGD.requests2Handle, TT_REQUEST );
tt_pattern_scope_add( smGD.requests2Handle, TT_SESSION );
sessId = tt_default_session();
tt_pattern_session_add( smGD.requests2Handle, sessId );
tt_free( sessId );
tt_pattern_op_add( smGD.requests2Handle, SM_DISPLAY_LOCK );
tt_pattern_op_add( smGD.requests2Handle, SM_XSESSION_EXIT );
tt_pattern_op_add( smGD.requests2Handle, SM_RESOURCES_RELOAD );
tt_pattern_op_add( smGD.requests2Handle, SM_SAVE_SESSION );
tt_pattern_callback_add( smGD.requests2Handle,
handleSessionMgrRequest );
status = tt_pattern_register( smGD.requests2Handle );
if (status != TT_OK) {
smGD.bmsDead = True;
}
}
if (smGD.bmsDead) {
char *errfmt, *errmsg, *statmsg;
errfmt = SmNewString((char *) GETMESSAGE (6, 1,
"Could not connect to ToolTalk message server:\n%sExiting ...\n"));
statmsg = tt_status_message(status);
errmsg = XtMalloc(strlen(errfmt) + strlen(statmsg) + 2);
sprintf(errmsg, errfmt, statmsg);
PrintError(DtError, errmsg);
SM_FREE(errfmt);
XtFree(errmsg);
WarnNoStartup();
}
} /* END OF FUNCTION StartMsgServer */
/*************************************<->*************************************
*
* DtwmStarted (fields, client_data, num_words)
*
*
* Description:
* -----------
*
* Inputs:
* ------
*
*
* Outputs:
* -------
*
*
* Comments:
* --------
*
*************************************<->***********************************/
static void
DtwmStarted(void)
{
smGD.dtwmRunning = True;
} /* END OF FUNCTION DtwmStarted */
/*************************************<->*************************************
*
* RestoreDefaults ()
*
*
* Description:
* -----------
* A request has come in (usually from the customizer) to restore one of
* the settings to their default states
*
* Inputs:
* ------
*
*
* Outputs:
* -------
* smToSet = (global) turns off flag of setting no longer set
*
*
* Comments:
* --------
*
*************************************<->***********************************/
void
RestoreDefaults(
Atom toRestore)
{
if(toRestore == XaDtSmScreenInfo)
{
smToSet.screenSavChange = False;
}
else if(toRestore == XaDtSmAudioInfo)
{
smToSet.audioChange = False;
}
else if(toRestore == XaDtSmKeyboardInfo)
{
smToSet.keyboardChange = False;
}
else if(toRestore == XaDtSmPointerInfo)
{
smToSet.pointerChange = False;
smToSet.pointerMapChange = False;
}
} /* END OF FUNCTION RestoreDefaults */
/*************************************<->*************************************
*
* ProcessPropertyNotify ()
*
*
* Description:
* -----------
* The customizer has changed one of the properties on the sm top level
* window. This fact is remembered, so that at shutdown the information
* can be saved
*
* Inputs:
* ------
*
*
* Outputs:
* -------
* smToSet = (global) turns on flag of setting being set
*
*
* Comments:
* --------
*
*************************************<->***********************************/
void
ProcessPropertyNotify(
XEvent *next)
{
XPropertyEvent *pEvent = (XPropertyEvent *) next;
if (pEvent->state != PropertyNewValue)
{
return;
}
if(pEvent->atom == XaDtSmScreenInfo)
{
smToSet.screenSavChange = True;
smCust.screenSavChange = True;
}
else if(pEvent->atom == XaDtSmAudioInfo)
{
smToSet.audioChange = True;
smCust.audioChange = True;
}
else if(pEvent->atom == XaDtSmKeyboardInfo)
{
smToSet.keyboardChange = True;
smCust.keyboardChange = True;
}
else if(pEvent->atom == XaDtSmFontInfo)
{
smCust.fontChange = True;
}
else if(pEvent->atom == XaDtSmPreeditInfo)
{
smCust.preeditChange = True;
}
else if(pEvent->atom == XaDtSmPointerInfo)
{
smToSet.pointerChange = True;
smCust.pointerChange = True;
smToSet.pointerMapChange = True;
smCust.dClickChange = True;
}
} /* END OF FUNCTION RecordChanges */
/*************************************<->*************************************
*
* ProcessClientMessage(next)
*
*
* Description:
* -----------
* A client message has come from somewhere. Process it if we know how.
*
* Inputs:
* ------
* next - the client message event
*
*
* Outputs:
* -------
*
*
* Comments:
* --------
*
*************************************<->***********************************/
void
ProcessClientMessage(
XEvent *next)
{
XClientMessageEvent *cEvent = (XClientMessageEvent *) next;
/*
* If this event came from the style manager - process it
*/
if(cEvent->message_type == XaDtSmStmProtocol)
{
if(cEvent->data.l[0] == XaDtSmSaveToHome)
{
/*
* The style manager is asking for a save home session
*/
if(smGD.smState == READY)
{
int startStateOrig;
int confirmModeOrig;
Tt_message msg;
smGD.smState = IN_PROCESS;
msg = tttk_message_create( 0, TT_NOTICE, TT_SESSION, 0,
"DtActivity_Beginning", 0 );
tt_message_send( msg );
tt_message_destroy( msg );
startStateOrig = smSettings.startState;
confirmModeOrig = smSettings.confirmMode;
smSettings.startState = cEvent->data.l[1];
smSettings.confirmMode = cEvent->data.l[2];;
smGD.homeSave = True;
SaveState(True, smSettings.startState, SmSaveLocal,
DEFAULT_SHUTDOWN, SmInteractStyleNone,
DEFAULT_FAST, DEFAULT_GLOBAL);
smGD.homeSave = False;
smSettings.startState = startStateOrig;
smSettings.confirmMode = confirmModeOrig;
msg = tttk_message_create( 0, TT_NOTICE, TT_SESSION, 0,
"DtActivity_Began", 0 );
tt_message_send( msg );
tt_message_destroy( msg );
SetSystemReady();
}
}
else if (cEvent->data.l[0] == XaDtSmRestoreDefault)
{
RestoreDefaults((Atom) cEvent->data.l[1]);
}
}
else if(cEvent->message_type == XaSmWmProtocol)
{
/*
* If this event came from the ws manager - process it
*/
if(cEvent->data.l[0] == XaWmExitSession)
{
/*
* The ws manager is sending an exit session message
*/
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
ExitSession(0);
}
}
else if(cEvent->data.l[0] == XaWmLockDisplay)
{
/*
* The ws manager is sending an lock display message
*/
if(smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
LockDisplay(True);
}
}
else if(cEvent->data.l[0] == XaWmWindowAck)
{
/*
* The ws manager is sending a "client has been managed"
*/
clientRunning = True;
}
else if(cEvent->data.l[0] == XaWmReady)
{
/*
* The ws manager is sending a "ready for clients"
*/
smGD.dtwmRunning = True;
}
}
else if (cEvent->message_type == XaDtSmStateInfo)
{
SmStateInfo state;
int flags = (int)cEvent->data.l[0];
/*
* Session state has been changed. Get new values.
*/
if(_DtGetSmState(smGD.display, smGD.topLevelWindow, &state) == Success)
{
char *newRes = malloc(BUFSIZ);
/*
* Copy selected changes to data areas.
*/
if (flags & SM_STATE_START)
{
smSettings.startState = state.smStartState;
}
if (flags & SM_STATE_CONFIRM)
{
smSettings.confirmMode = state.smConfirmMode;
}
newRes[0] = '\0';
if (flags & SM_STATE_CYCLETIMEOUT)
{
smSaverRes.cycleTimeout = state.smCycleTimeout;
sprintf(newRes+strlen(newRes), "dtsession*%scycleTimeout: %d\n",
smGD.extensionSpec,
smSaverRes.cycleTimeout/60);
}
if (flags & SM_STATE_LOCKTIMEOUT)
{
smSaverRes.lockTimeout = state.smLockTimeout;
sprintf(newRes+strlen(newRes), "dtsession*%slockTimeout: %d\n",
smGD.extensionSpec,
smSaverRes.lockTimeout/60);
}
if (flags & SM_STATE_SAVERTIMEOUT)
{
smSaverRes.saverTimeout = state.smSaverTimeout;
sprintf(newRes+strlen(newRes), "dtsession*%ssaverTimeout: %d\n",
smGD.extensionSpec,
smSaverRes.saverTimeout/60);
}
if (flags & SM_STATE_RANDOM)
{
smSaverRes.random = state.smRandom;
sprintf(newRes+strlen(newRes), "dtsession*%srandom: %s\n",
smGD.extensionSpec,
smSaverRes.random ? "True\n" : "False\n");
}
if (newRes[0] != '\0')
{
_DtAddToResource(smGD.display, newRes);
}
free(newRes);
}
}
else if (cEvent->message_type == XaDtSmSaverInfo)
{
SmSaverInfo saver;
/*
* Session screen saver list has been changed. Get new values.
*/
if(_DtGetSmSaver(smGD.display, smGD.topLevelWindow, &saver) == Success)
{
char *pRes;
SM_FREE(smGD.saverList);
smGD.saverList = SmNewString(saver.saverList);
SM_FREE(saver.saverList);
pRes = malloc(strlen("dtsession*saverList: ") +
strlen(smGD.saverList) +
strlen(smGD.extensionSpec) +
2); /* for the '/n' and '/0' */
if (pRes)
{
sprintf(pRes, "dtsession*%ssaverList: %s\n",
smGD.extensionSpec,
smGD.saverList);
_DtAddToResource(smGD.display, pRes);
free(pRes);
}
if (smGD.saverListParse)
{
SM_FREE(smGD.saverListParse);
smGD.saverListParse = NULL;
}
}
}
#if defined (USE_HPSSEXT)
else if(cEvent->message_type == XaSmScreenSaveRet)
{
if(cEvent->data.l[0] == SS_ON)
{
if (smSaverRes.saverTimeout + smSaverRes.lockTimeout > 0 &&
smGD.smState == READY)
{
smGD.smState = IN_PROCESS;
LockDisplay(False);
}
}
}
#endif /* USE_HPSSEXT */
return;
} /* END OF FUNCTION ProcessClientMessage */
/*************************************<->*************************************
*
* ProcessScreenSaverMessage(next)
*
*
* Description:
* -----------
* A screen saver message has come from the server. Process it if we know how.
*
* Inputs:
* ------
* next - the client message event
*
*
* Outputs:
* -------
*
*
* Comments:
* --------
*
*************************************<->***********************************/
#if defined (USE_X11SSEXT)
void
ProcessScreenSaverMessage(
XEvent *next)
{
XScreenSaverNotifyEvent *ssEvent = (XScreenSaverNotifyEvent *) next;
static int ssCount = 0;
if (ssEvent->state == ScreenSaverOn)
{
/*
* Screen saver activated.
*/
if (smSaverRes.saverTimeout + smSaverRes.lockTimeout > 0 &&
smGD.smState == READY)
{
/*
* Resource says to lock the display and SM is ready, so lock it.
*/
smGD.smState = IN_PROCESS;
LockDisplay(False);
}
}
}
#endif /* USE_X11SSEXT */
/*************************************<->*************************************
*
* ProcessReloadActionsDatabase(void)
*
*
* Description:
* -----------
* Register for notification of action database changes and load the action
* database into our address space. This function can be called directly
* by session mgr code, or called as a callback by the actions database.
*
* Inputs:
* ------
*
* Outputs:
* -------
*
* Comments:
* --------
* The first time in, this call registers itself as a callback routine with
* the actions database. The first and subsequent times in, this call will
* load the actions database into the session mgr address space.
*
*************************************<->***********************************/
void
ProcessReloadActionsDatabase(void)
{
static int needtoregister = 1;
if (needtoregister)
{
/*
* Have not yet registered with the actions database to call this
* callback when the database changes. Do so.
*/
DtDbReloadNotify((DtDbReloadCallbackProc) ProcessReloadActionsDatabase,
(XtPointer) NULL);
needtoregister = 0;
}
/*
* Our copy of the actions database must be out of date. Reload.
*/
DtDbLoad();
}
void
ProcessEvent(Widget w, XtPointer client_data, XEvent *event,
Boolean *continue_to_dispatch)
{
switch(event->type)
{
case ClientMessage:
ProcessClientMessage(event);
break;
case PropertyNotify:
ProcessPropertyNotify(event);
break;
default:
#if defined (USE_X11SSEXT)
if (event->type == smGD.ssEventType)
ProcessScreenSaverMessage(event);
#endif
break;
}
}
Reference in New Issue View Git Blame Copy Permalink