Peter Howkins
1067 lines
27 KiB
C
1067 lines
27 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 librararies and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
/* $XConsortium: SmComm.c /main/7 1996/06/21 17:26:07 ageorge $ */
|
|
/******************************************************************************
|
|
*
|
|
* File Name: SmComm.c
|
|
*
|
|
* Contains functionality for communication with the session manager via
|
|
* properties put on its top level window
|
|
*
|
|
*****************************************************************************/
|
|
/*
|
|
* (c) Copyright 1996 Digital Equipment Corporation.
|
|
* (c) Copyright 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 <X11/Xlib.h>
|
|
#include <X11/Intrinsic.h>
|
|
#include <X11/IntrinsicP.h>
|
|
#include <X11/Xatom.h>
|
|
#include <Dt/DtP.h>
|
|
#include <Dt/SessionP.h>
|
|
#include <Dt/SessionM.h>
|
|
#include "DtSvcLock.h"
|
|
|
|
/******** Static Function Declarations ********/
|
|
static int _GetSmWindow(Display *, Window, Window *, Atom);
|
|
static Status _GetSmState(Display *, Window, Atom, PropDtSmStateInfo **);
|
|
static Atom _GetSmAtom(Display *, int);
|
|
static void NotifySm( Display *, Window, Atom, CARD32);
|
|
/******** End Static Function Declarations ********/
|
|
|
|
/*
|
|
* _GetSmAtom() identifiers.
|
|
*/
|
|
#define SM_ATOMID_STATE 0
|
|
#define SM_ATOMID_SAVER 1
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmWindow (display, root, pSmWindow)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* root - root window of screen
|
|
* pSmWindow - pointer to a window (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmWindow - dt SM window id, if successful
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmWindow(
|
|
Display *display,
|
|
Window root,
|
|
Window *pSmWindow )
|
|
{
|
|
Atom xa_DT_SM_WINDOW_INFO;
|
|
|
|
xa_DT_SM_WINDOW_INFO = XInternAtom (display, _XA_DT_SM_WINDOW_INFO, False);
|
|
return (_GetSmWindow (display, root, pSmWindow, xa_DT_SM_WINDOW_INFO));
|
|
} /* END OF FUNCTION _DtGetSmWindow */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* Status _DtGetSmState (display, smWindow, pSmStateInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt state information from the session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* pSmStateInfo - pointer to a state info (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmStateInfo - SM state info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmState(
|
|
Display *display,
|
|
Window smWindow,
|
|
SmStateInfo *pSmStateInfo)
|
|
{
|
|
int propStatus;
|
|
PropDtSmStateInfo *pPropSmStateInfo;
|
|
|
|
propStatus = _GetSmState(display, smWindow,
|
|
_GetSmAtom(display, SM_ATOMID_STATE),
|
|
&pPropSmStateInfo);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
pSmStateInfo->flags = pPropSmStateInfo->flags;
|
|
pSmStateInfo->smStartState = pPropSmStateInfo->smStartState;
|
|
pSmStateInfo->smConfirmMode = pPropSmStateInfo->smConfirmMode;
|
|
pSmStateInfo->smCompatMode = pPropSmStateInfo->smCompatMode;
|
|
pSmStateInfo->smSendSettings = pPropSmStateInfo->smSendSettings;
|
|
pSmStateInfo->smCoverScreen = pPropSmStateInfo->smCoverScreen;
|
|
pSmStateInfo->smLockOnTimeout = pPropSmStateInfo->smLockOnTimeout;
|
|
pSmStateInfo->smLockOnTimeoutStatus = pPropSmStateInfo->smLockOnTimeoutStatus;
|
|
pSmStateInfo->smCycleTimeout = pPropSmStateInfo->smCycleTimeout;
|
|
pSmStateInfo->smLockTimeout = pPropSmStateInfo->smLockTimeout;
|
|
pSmStateInfo->smSaverTimeout = pPropSmStateInfo->smSaverTimeout;
|
|
pSmStateInfo->smRandom = pPropSmStateInfo->smRandom;
|
|
pSmStateInfo->smDisplaySpecific = pPropSmStateInfo->smDisplaySpecific;
|
|
XFree((char *)pPropSmStateInfo);
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmState */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* Status _DtSetSmState (display, smWindow, pSmStateInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Set the DT Session Manager state property on the provided window
|
|
* and notify that window of the changes via a ClientMessage.
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* pSmStateInfo - pointer to a state info (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmStateInfo - SM state info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtSetSmState(
|
|
Display *display,
|
|
Window smWindow,
|
|
SmStateInfo *pSmStateInfo)
|
|
{
|
|
int propStatus;
|
|
PropDtSmStateInfo propSmStateInfo;
|
|
PropDtSmStateInfo *pPropSmStateInfo;
|
|
Atom xaDtSmStateInfo;
|
|
|
|
xaDtSmStateInfo = _GetSmAtom(display, SM_ATOMID_STATE);
|
|
|
|
if (pSmStateInfo->flags != SM_STATE_ALL)
|
|
{
|
|
/*
|
|
* Caller not setting all fields in state, so get the other fields
|
|
* from property.
|
|
*/
|
|
propStatus = _GetSmState(display, smWindow,
|
|
xaDtSmStateInfo, &pPropSmStateInfo);
|
|
if (propStatus != Success)
|
|
{
|
|
/*
|
|
* Whoa. Property could not be obtained. Do a reasonable thing by
|
|
* setting unspecified fields to zero.
|
|
*/
|
|
pPropSmStateInfo = &propSmStateInfo;
|
|
memset(pPropSmStateInfo, 0x00, sizeof(*pPropSmStateInfo));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Caller setting all fields in state. No need to attempt to retrieve
|
|
* existing values from property.
|
|
*/
|
|
pPropSmStateInfo = &propSmStateInfo;
|
|
}
|
|
|
|
/*
|
|
* Set specified fields.
|
|
*/
|
|
pPropSmStateInfo->flags = pSmStateInfo->flags;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_START)
|
|
pPropSmStateInfo->smStartState = pSmStateInfo->smStartState;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_CONFIRM)
|
|
pPropSmStateInfo->smConfirmMode = pSmStateInfo->smConfirmMode;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_COMPAT)
|
|
pPropSmStateInfo->smCompatMode = pSmStateInfo->smCompatMode;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_SEND)
|
|
pPropSmStateInfo->smSendSettings = pSmStateInfo->smSendSettings;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_COVER)
|
|
pPropSmStateInfo->smCoverScreen = pSmStateInfo->smCoverScreen;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_LOTOUT)
|
|
pPropSmStateInfo->smLockOnTimeout = pSmStateInfo->smLockOnTimeout;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_LOTOUTSTAT)
|
|
pPropSmStateInfo->smLockOnTimeoutStatus = pSmStateInfo->smLockOnTimeoutStatus;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_CYCLETIMEOUT)
|
|
pPropSmStateInfo->smCycleTimeout = pSmStateInfo->smCycleTimeout;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_LOCKTIMEOUT)
|
|
pPropSmStateInfo->smLockTimeout = pSmStateInfo->smLockTimeout;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_SAVERTIMEOUT)
|
|
pPropSmStateInfo->smSaverTimeout = pSmStateInfo->smSaverTimeout;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_RANDOM)
|
|
pPropSmStateInfo->smRandom = pSmStateInfo->smRandom;
|
|
|
|
if (pSmStateInfo->flags & SM_STATE_DISP_SESSION)
|
|
pPropSmStateInfo->smDisplaySpecific = pSmStateInfo->smDisplaySpecific;
|
|
|
|
XChangeProperty (display, smWindow,
|
|
xaDtSmStateInfo, xaDtSmStateInfo,
|
|
32, PropModeReplace, (unsigned char *)pPropSmStateInfo,
|
|
PROP_DT_SM_STATE_INFO_ELEMENTS);
|
|
|
|
if (pPropSmStateInfo != &propSmStateInfo)
|
|
{
|
|
/*
|
|
* Memory must have come from _GetStateInfo(). Deallocate.
|
|
*/
|
|
XFree((char *)pPropSmStateInfo);
|
|
}
|
|
|
|
/*
|
|
* Notify receiver of which state fields have changed. Now one might
|
|
* ask why the receiver doesn't just check the 'flags' field on a
|
|
* PropertyNotify event. Well they can, and it will work fine, most of
|
|
* the time. However, it is possible for the sender to change the property
|
|
* multiple times before the receiver get its first PropertyNotify event.
|
|
* By the time the receiver reads the property, the flags field might
|
|
* have changed. The flags field will only tell the receiver which
|
|
* fields changed on the last call to _DtSetSmStateInfo().
|
|
*
|
|
* This way the receiver has a record of changes to the state.
|
|
*/
|
|
NotifySm(display, smWindow, xaDtSmStateInfo, (CARD32)pSmStateInfo->flags);
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtSetSmState */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmSaver (display, smWindow, pSmSaverInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt screen saver information from the session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* pSmSaverInfo - pointer to a screen saver information (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmSaverInfo - SM screen saver info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* Caller needs to deallocate pSmSaverInfo->saverList with XFree().
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmSaver(
|
|
Display *display,
|
|
Window smWindow,
|
|
SmSaverInfo *pSmSaverInfo)
|
|
{
|
|
int propStatus;
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow,
|
|
_GetSmAtom(display, SM_ATOMID_SAVER), 0L,
|
|
100000000L, False,
|
|
XA_STRING, &actualType,
|
|
&actualFormat, &nitems, &leftover,
|
|
(unsigned char **)&pSmSaverInfo->saverList);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != XA_STRING)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmSaver */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtSetSmSaver (display, smWindow, pSmSaverInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Set the Dt screen saver information on the session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* pSmSaverInfo - pointer to screen saver information struct (to be set)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmSaverInfo - SM screen saver info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
*
|
|
*************************************<->***********************************/
|
|
void
|
|
_DtSetSmSaver(
|
|
Display *display,
|
|
Window smWindow,
|
|
SmSaverInfo *pSmSaverInfo)
|
|
{
|
|
Atom xaDtSmSaverInfo;
|
|
|
|
xaDtSmSaverInfo = _GetSmAtom(display, SM_ATOMID_SAVER);
|
|
|
|
XChangeProperty (display, smWindow,
|
|
xaDtSmSaverInfo,
|
|
XA_STRING,
|
|
8, PropModeReplace,
|
|
(unsigned char *)pSmSaverInfo->saverList,
|
|
strlen(pSmSaverInfo->saverList));
|
|
|
|
NotifySm(display, smWindow, xaDtSmSaverInfo, (CARD32)0);
|
|
|
|
} /* END OF FUNCTION _DtSetSmSaver */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmScreen (display, smWindow, xaDtSmScreenInfo, pSmScreenInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt screen saver information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmScreenInfo - Atom for screen property
|
|
* pSmScreenInfo - pointer to a screen info (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmScreenInfo - SM screen info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmScreen(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmScreenInfo,
|
|
SmScreenInfo *pSmScreenInfo)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
PropDtSmScreenInfo *pSmScreenRet;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmScreenInfo, 0L,
|
|
PROP_DT_SM_SCREEN_INFO_ELEMENTS, False,
|
|
xaDtSmScreenInfo, &actualType,
|
|
&actualFormat, &nitems, &leftover,
|
|
(unsigned char **)&pSmScreenRet);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != xaDtSmScreenInfo)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
else
|
|
{
|
|
pSmScreenInfo->flags = pSmScreenRet->flags;
|
|
pSmScreenInfo->smTimeout = pSmScreenRet->smTimeout;
|
|
pSmScreenInfo->smInterval = pSmScreenRet->smInterval;
|
|
pSmScreenInfo->smPreferBlank = pSmScreenRet->smPreferBlank;
|
|
pSmScreenInfo->smAllowExp = pSmScreenRet->smAllowExp;
|
|
|
|
XFree((char *)pSmScreenRet);
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmScreen */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmAudio (display, smWindow, xaDtSmAudioInfo, pSmAudioInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt audio information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmAudioInfo - Atom for audio property
|
|
* pSmAudioInfo - pointer to bell info (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmAudioInfo - SM bell info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmAudio(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmAudioInfo,
|
|
SmAudioInfo *pSmAudioInfo)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
PropDtSmAudioInfo *pSmAudioRet;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmAudioInfo, 0L,
|
|
PROP_DT_SM_AUDIO_INFO_ELEMENTS, False,
|
|
xaDtSmAudioInfo, &actualType,
|
|
&actualFormat, &nitems, &leftover,
|
|
(unsigned char **)&pSmAudioRet);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != xaDtSmAudioInfo)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
else
|
|
{
|
|
pSmAudioInfo->flags = pSmAudioRet->flags;
|
|
pSmAudioInfo->smBellPercent = pSmAudioRet->smBellPercent;
|
|
pSmAudioInfo->smBellPitch = pSmAudioRet->smBellPitch;
|
|
pSmAudioInfo->smBellDuration = pSmAudioRet->smBellDuration;
|
|
|
|
XFree((char *)pSmAudioRet);
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmAudio */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmKeyboard (display, smWindow,
|
|
* xaDtSmKeyboardInfo, pSmKeyboardInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt keyboard information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmKeyboardInfo - Atom for keyboard property
|
|
* pSmKeyboardInfo - pointer to keyboard info (to be returned)
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmKeyboardInfo - SM keyboard info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmKeyboard(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmKeyboardInfo,
|
|
SmKeyboardInfo *pSmKeyboardInfo)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
PropDtSmKeyboardInfo *pSmKeyboardRet;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmKeyboardInfo, 0L,
|
|
PROP_DT_SM_KEYBOARD_INFO_ELEMENTS, False,
|
|
xaDtSmKeyboardInfo, &actualType,
|
|
&actualFormat, &nitems, &leftover,
|
|
(unsigned char **)&pSmKeyboardRet);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != xaDtSmKeyboardInfo)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
else
|
|
{
|
|
pSmKeyboardInfo->flags = pSmKeyboardRet->flags;
|
|
pSmKeyboardInfo->smKeyClickPercent =
|
|
pSmKeyboardRet->smKeyClickPercent;
|
|
pSmKeyboardInfo->smGlobalAutoRepeat =
|
|
pSmKeyboardRet->smGlobalAutoRepeat;
|
|
|
|
XFree((char *)pSmKeyboardRet);
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmKeyboard */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmFont (display, smWindow, xaDtSmFontInfo, retFont)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt font information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmFontInfo - Atom for font property
|
|
* retFont - pointer to font info
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* retFont - SM fontinfo
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmFont(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmFontInfo,
|
|
char **retFont)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmFontInfo, 0L,
|
|
100000000L,False,XA_STRING,&actualType,
|
|
&actualFormat,&nitems,&leftover,
|
|
(unsigned char**) retFont);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != XA_STRING)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmFont */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmPreedit (display, smWindow, xaDtSmPreeditInfo, retPreedit)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the preeditType information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmPreeditInfo - Atom for preeditType property
|
|
* retPreedit - pointer to preeditType info
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* retPreedit - SM preeditType info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmPreedit(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmPreeditInfo,
|
|
char **retPreedit)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmPreeditInfo, 0L,
|
|
100000000L,False,XA_STRING,&actualType,
|
|
&actualFormat,&nitems,&leftover,
|
|
(unsigned char**) retPreedit);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != XA_STRING)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmPreedit */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _DtGetSmPointer (display, smWindow, xaDtSmPointerInfo, retFont)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt pointer information from the dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* xaDtSmPointerInfo - Atom for pointer property
|
|
* retPointer - pointer to pointer info
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* retPointer - SM pointer info
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
Status
|
|
_DtGetSmPointer(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmPointerInfo,
|
|
char **retPointer)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmPointerInfo, 0L,
|
|
100000000L,False,XA_STRING,&actualType,
|
|
&actualFormat,&nitems,&leftover,
|
|
(unsigned char**) retPointer);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != XA_STRING)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _DtGetSmPointer */
|
|
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* static Status
|
|
* _GetSmWindow (display, root, pSmWindow, property)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* root - root window of screen
|
|
* pSmWindow - pointer to a window (to be returned)
|
|
* property - the property atom
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmWindow - dt SM window id, if successful
|
|
* Return - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
static int
|
|
_GetSmWindow(
|
|
Display *display,
|
|
Window root,
|
|
Window *pSmWindow,
|
|
Atom property )
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
PropDtSmWindowInfo *pSmInfo = NULL;
|
|
int rcode;
|
|
Window wroot, wparent, *pchildren;
|
|
unsigned int nchildren;
|
|
|
|
*pSmWindow = NULL;
|
|
if ((rcode=XGetWindowProperty(display,root,
|
|
property,0L, PROP_DT_SM_WINDOW_INFO_ELEMENTS,
|
|
False,property,
|
|
&actualType,&actualFormat,
|
|
&nitems,&leftover,
|
|
(unsigned char **)&pSmInfo))==Success)
|
|
{
|
|
|
|
if (actualType != property)
|
|
{
|
|
/* wrong type, force failure */
|
|
rcode = BadValue;
|
|
}
|
|
else
|
|
#ifdef BAD
|
|
{
|
|
rcode = BadWindow; /* assume the worst */
|
|
|
|
/*
|
|
* The SM window should be a direct child of root
|
|
*/
|
|
if (XQueryTree (display, root, &wroot, &wparent,
|
|
&pchildren, &nchildren))
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; (i < nchildren) && (rcode != Success); i++)
|
|
{
|
|
if (pchildren[i] == pSmInfo->smWindow)
|
|
{
|
|
rcode = Success;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rcode == Success);
|
|
{
|
|
*pSmWindow = pSmInfo->smWindow;
|
|
}
|
|
|
|
if (pchildren)
|
|
{
|
|
XFree ((char *)pchildren);
|
|
}
|
|
|
|
}
|
|
#else
|
|
*pSmWindow = pSmInfo->smWindow;
|
|
|
|
#endif /* BAD */
|
|
|
|
|
|
if (pSmInfo)
|
|
{
|
|
XFree ((char *)pSmInfo);
|
|
}
|
|
}
|
|
|
|
return(rcode);
|
|
|
|
} /* END OF FUNCTION _GetSmWindow */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* Atom _GetSmAtom (display, id)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get a session manager atom
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* id - SM_ATOMID_* value
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
*
|
|
* Return:
|
|
* -------
|
|
* atom - sm state atom
|
|
*
|
|
* Comments:
|
|
* --------
|
|
*
|
|
*************************************<->***********************************/
|
|
|
|
static struct {
|
|
char *string;
|
|
Atom atom;
|
|
} smAtomList[] = {
|
|
{_XA_DT_SM_STATE_INFO, NULL},
|
|
{_XA_DT_SM_SAVER_INFO, NULL},
|
|
};
|
|
|
|
static Atom
|
|
_GetSmAtom(Display *display, int id)
|
|
{
|
|
_DtSvcProcessLock();
|
|
if (!smAtomList[id].atom)
|
|
{
|
|
smAtomList[id].atom = XInternAtom (display, smAtomList[id].string, False);
|
|
}
|
|
_DtSvcProcessUnlock();
|
|
|
|
return(smAtomList[id].atom);
|
|
|
|
} /* END OF FUNCTION _GetSmAtom */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* status _GetSmState (display, smWindow, xaDtSmStateInfo, pPropSmStateInfo)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Get the Dt state information from the session manager window
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* pSmStateInfo - pointer to mem in which to place state info pointer
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
* *pSmStateInfo - pointer to state info (use XFree() to free)
|
|
*
|
|
* Return:
|
|
* -------
|
|
* status - status from XGetWindowProperty
|
|
*
|
|
* Comments:
|
|
* --------
|
|
* This can fail if dt SM is not running
|
|
*
|
|
*************************************<->***********************************/
|
|
static Status
|
|
_GetSmState(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom xaDtSmStateInfo,
|
|
PropDtSmStateInfo **pPropSmStateInfo)
|
|
{
|
|
Atom actualType;
|
|
int actualFormat;
|
|
unsigned long nitems;
|
|
unsigned long leftover;
|
|
int propStatus;
|
|
|
|
propStatus = XGetWindowProperty(display, smWindow, xaDtSmStateInfo, 0L,
|
|
PROP_DT_SM_STATE_INFO_ELEMENTS, False,
|
|
xaDtSmStateInfo, &actualType,
|
|
&actualFormat, &nitems, &leftover,
|
|
(unsigned char **)pPropSmStateInfo);
|
|
|
|
if(propStatus == Success)
|
|
{
|
|
if(actualType != xaDtSmStateInfo)
|
|
{
|
|
propStatus = BadValue;
|
|
}
|
|
}
|
|
|
|
return(propStatus);
|
|
|
|
} /* END OF FUNCTION _GetSmState */
|
|
|
|
|
|
/*************************************<->*************************************
|
|
*
|
|
* static void
|
|
* _NotifySm (display, smWindow, atom, card32)
|
|
*
|
|
*
|
|
* Description:
|
|
* -----------
|
|
* Notify session manager of change
|
|
*
|
|
*
|
|
* Inputs:
|
|
* ------
|
|
* display - display
|
|
* smWindow - session manager window
|
|
* atom - atom id of property changed
|
|
* card32 - additional property specific information
|
|
*
|
|
* Outputs:
|
|
* --------
|
|
*
|
|
* Return:
|
|
* -------
|
|
*
|
|
* Comments:
|
|
* --------
|
|
*
|
|
*************************************<->***********************************/
|
|
static void
|
|
NotifySm(
|
|
Display *display,
|
|
Window smWindow,
|
|
Atom atom,
|
|
CARD32 md0)
|
|
{
|
|
XClientMessageEvent message;
|
|
|
|
message.type = ClientMessage;
|
|
message.window = smWindow;
|
|
message.message_type = atom;
|
|
message.format = 32;
|
|
message.data.l[0] = md0;
|
|
message.data.l[1] = CurrentTime;
|
|
XSendEvent(display, smWindow, False, NoEventMask, (XEvent *)&message);
|
|
|
|
} /* END OF FUNCTION _NotifySm */
|