/*
 * 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;
  }
}