CARD16
UnpackCARD16(MessageData *data_ptr)
{
CARD16 val = UnpackCARD8(data_ptr) << 8;
val |= UnpackCARD8(data_ptr);
return(val);
}
String
UnpackString(MessageData *data_ptr)
{
register int i;
int len = UnpackListNum(data_ptr);
char *str, *top = XtMalloc((len + 1) * sizeof(char));
for (str = top, i = 0; i < len; i++, str++) {
*str = (char) UnpackCARD8(data_ptr);
}
*str = '\0';
return((String) top);
}
*outputLen = (targetCount * sizeof(Atom)) >> 2;
*outputFmt = 32;
found = True;
}
#ifdef MWM_WSM
/* virtual screen support */
else if (target == wmGD._MOTIF_WM_PAN)
{
int dx, dy;
Boolean config;
dx = (int) UnpackCARD32(&input);
dy = (int) UnpackCARD32(&input);
config = (Boolean) UnpackCARD8(&input);
PanRoot(dx, dy, config);
/*
* Update the root property
*/
SetPanPosition (ACTIVE_PSD->panDx, ACTIVE_PSD->panDy);
found = True;
}
else if (target == wmGD._MOTIF_WM_GOTO)
{
int x, y;
/*ARGSUSED*/
void
_WSMUnpackReply(Display *dpy, int screen_num, MessageData data,
unsigned long len, WSMRequestType type, WSMReply *reply)
{
register int i;
reply->any.type = type; /* Save the type. */
reply->any.allocated = False;
switch (reply->any.type) {
case WSM_CONNECT:
if (data != NULL)
reply->connect.version = (short) UnpackCARD8(&data);
else
fprintf(stderr, "Error - Connection request reply data is empty!\n");
break;
case WSM_EXTENSIONS:
{
register int num;
register String *ptr;
num = reply->extensions.num_extensions = UnpackListNum(&data);
ptr = (String *) XtMalloc(sizeof(String) * num);
reply->extensions.allocated = True;
reply->extensions.extensions = ptr;
for (i = 0; i < num; i++, ptr++)
*ptr = UnpackString(&data);
}
break;
case WSM_CONFIG_FMT:
{
register int types;
WSMConfigFormatReply * config_format = &(reply->config_format);
WSMConfigFormatData *fmt;
WSMScreenInfo *scr_info = _WSMGetScreenInfo(dpy, screen_num);
config_format->accepts_diffs = UnpackBoolean(&data);
for (types = 0; types < 3; types++) {
switch(types) {
case WSM_GLOBAL_FMT:
fmt = &(scr_info->global);
break;
case WSM_WINDOW_FMT:
fmt = &(scr_info->window);
break;
case WSM_ICON_FMT:
fmt = &(scr_info->icon);
break;
}
fmt->num_attrs = UnpackListNum(&data);
fmt->attr_list = (WSMAttribute *)
XtMalloc(sizeof(WSMAttribute) * fmt->num_attrs);
for (i = 0; i < fmt->num_attrs; i++) {
String str = UnpackString(&data);
fmt->attr_list[i].nameq = XrmStringToQuark(str);
XtFree(str);
fmt->attr_list[i].size = UnpackCARD8(&data);
fmt->attr_list[i].is_list = UnpackCARD8(&data);
}
}
/*
* No need to allocate this, since they are just pointers
* back to global data.
*/
config_format->global_formats = scr_info->global.attr_list;
config_format->num_global_formats = scr_info->global.num_attrs;
config_format->window_formats = scr_info->window.attr_list;
config_format->num_window_formats = scr_info->window.num_attrs;
config_format->icon_formats = scr_info->icon.attr_list;
config_format->num_icon_formats = scr_info->icon.num_attrs;
}
break;
case WSM_GET_STATE:
{
int num =reply->get_state.num_win_info_list = UnpackListNum(&data);
reply->get_state.win_info_list =
(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);
reply->get_state.allocated = True;
for (i = 0; i < num; i++)
UnpackWinInfo(&data, dpy, screen_num,
reply->get_state.win_info_list + i);
}
break;
case WSM_SET_STATE:
break;
case WSM_REG_WINDOW:
if (data != NULL)
{
UnpackWinData(&data, dpy, screen_num, WSM_WINDOW_FMT,
&(reply->register_window.window_data),
&(reply->register_window.num_window_data));
reply->register_window.allocated = True;
}
else
fprintf(stderr, "Error - Register Window reply data is empty!\n");
break;
case WSM_WM_GET_BACKGROUND_WINDOW:
reply->get_background.window = UnpackWindow(&data);
break;
case WSM_WM_SET_BACKGROUND_WINDOW:
reply->set_background.window = UnpackWindow(&data);
break;
case WSM_WM_WINDOWS:
{
int num;
num = reply->wm_windows.num_win_entry_list = UnpackListNum(&data);
reply->wm_windows.win_entry_list =
(WSMWinEntry *) XtMalloc(sizeof(WSMWinEntry) * num);
reply->wm_windows.allocated = True;
for (i = 0; i < num; i++)
UnpackWinEntry(&data, dpy, screen_num,
reply->wm_windows.win_entry_list + i);
}
break;
case WSM_WM_FOCUS:
reply->wm_focus.window = UnpackWindow(&data);
break;
case WSM_WM_POINTER:
reply->wm_pointer.location_flag = UnpackCARD32(&data);
break;
default:
break;
}
} /* _WSMUnpackReply */
/*ARGSUSED*/
void
_WSMUnpackRequest(Display *dpy, int screen_num, MessageData data,
unsigned long len, WSMRequestType type, WSMRequest *request)
{
register int i;
request->any.type = type; /* Save the type. */
request->any.allocated = False;
switch (request->any.type) {
case WSM_CONNECT:
request->connect.num_versions = UnpackListNum(&data);
request->connect.known_versions =
(short *) XtMalloc(sizeof(short) * request->connect.num_versions);
request->connect.allocated = True;
for (i = 0; i < request->connect.num_versions; i++)
request->connect.known_versions[i] = (short) UnpackCARD8(&data);
break;
case WSM_EXTENSIONS:
{
register int num;
register String *ptr;
num = request->extensions.num_extensions = UnpackListNum(&data);
ptr = (String *) XtMalloc(sizeof(String) * num);
request->extensions.extension_suggestions = ptr;
request->extensions.allocated = True;
for (i = 0; i < num; i++, ptr++)
*ptr = UnpackString(&data);
}
break;
case WSM_CONFIG_FMT:
break;
case WSM_GET_STATE:
request->get_state.window = UnpackWindow(&data);
request->get_state.diffs_allowed = UnpackBoolean(&data);
break;
case WSM_SET_STATE:
{
int num = UnpackListNum(&data);
request->set_state.num_win_info_list = num;
request->set_state.win_info_list =
(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);
request->extensions.allocated = True;
for (i = 0; i < num; i++) {
UnpackWinInfo(&data, dpy, screen_num,
request->set_state.win_info_list + i);
}
}
break;
case WSM_REG_WINDOW:
request->register_window.window = UnpackWindow(&data);
break;
case WSM_WM_GET_BACKGROUND_WINDOW:
request->get_background.screen = (int)UnpackCARD16(&data);
break;
case WSM_WM_SET_BACKGROUND_WINDOW:
request->set_background.window = UnpackWindow(&data);
break;
case WSM_WM_WINDOWS:
{
int num, i, j;
request->extensions.allocated = True;
request->wm_windows.location_flag = UnpackCARD32(&data);
num = request->wm_windows.num_window_properties = UnpackListNum(&data);
request->wm_windows.window_properties =
(WindowProperty *) XtMalloc(sizeof(WindowProperty) * num);
for (i=0; i<num; i++)
request->wm_windows.window_properties[i] = UnpackProperty(&data);
num = request->wm_windows.num_match_attributes = UnpackListNum(&data);
request->wm_windows.match_attributes =
(AttributePair **) XtMalloc(sizeof(AttributePair*) * num);
for (i=0; i<request->wm_windows.num_match_attributes; i++)
{
num = UnpackListNum(&data);
request->wm_windows.match_attributes[i] = (AttributePair *)
XtMalloc(sizeof(AttributePair) * num * 2 + sizeof(int));
request->wm_windows.match_attributes[i]->num_attributes = num;
for (j=0; j<num; j++)
{
request->wm_windows.match_attributes[i]->allowed_attributes[j] =
UnpackProperty(&data);
}
for (j=0; j<num; j++)
{
request->wm_windows.match_attributes[i]->prohibited_attributes[j] =
UnpackProperty(&data);
}
}
}
break;
case WSM_WM_FOCUS:
break;
case WSM_WM_POINTER:
break;
default:
break;
}
} /* _WSMUnpackRequest */
static void
UnpackSingleWinDataRec(MessageData *data_ptr,
WSMAttribute *attr, WSMWinData *win_data)
{
register int i;
/*
* Set these no matter what the size.
*/
win_data->nameq = attr->nameq; /* Save the name. */
if (attr->is_list) {
win_data->data_len = UnpackListNum(data_ptr);
}
else {
win_data->type = WSM_VALUE_DATA;
win_data->data_len = 0; /* unused... */
}
/*
* Based on the size, and whether or not this is a list, unpack
* the data from the wire.
*/
switch(attr->size) {
case 8:
if (attr->is_list) {
char *local;
win_data->type = WSM_CHAR_LIST_DATA;
local = win_data->data.char_ptr =
(char *) XtMalloc(sizeof(char) * win_data->data_len);
for (i = 0; i < win_data->data_len; i++, local++)
*local = UnpackCARD8(data_ptr);
}
else
win_data->data.value = UnpackCARD8(data_ptr);
break;
case 16:
if (attr->is_list) {
short *local;
win_data->type = WSM_SHORT_LIST_DATA;
local = win_data->data.short_ptr =
(short *) XtMalloc(sizeof(short) * win_data->data_len);
for (i = 0; i < win_data->data_len; i++, local++)
*local = UnpackCARD16(data_ptr);
}
else
win_data->data.value = UnpackCARD16(data_ptr);
break;
case 32:
if (attr->is_list) {
long *local;
win_data->type = WSM_LONG_LIST_DATA;
local = win_data->data.long_ptr =
(long *) XtMalloc(sizeof(long) * win_data->data_len);
for (i = 0; i < win_data->data_len; i++, local++)
*local = UnpackCARD32(data_ptr);
}
else
win_data->data.value = UnpackCARD32(data_ptr);
break;
}
}
static void
UnpackWinData(MessageData *data_ptr, Display *dpy, int screen_num,
WSMConfigFormatType fmt,
WSMWinData **win_data, int *num)
{
register int i, size;
WSMConfigFormatData *conf_fmt = _WSMGetConfigFormat(dpy, screen_num, fmt);
unsigned char *bit_mask, *current_mask, check_mask;
WSMAttribute *attr;
WSMWinData *ptr;
/*
* Figure out how many values have been specified so we know how much
* memory to allocate.
*/
size = conf_fmt->num_attrs / 8 + 1;
current_mask = bit_mask = (unsigned char *) XtMalloc(size);
/*
* Unpack the bits from the wire.
*/
for (i = 0; i < size; i++, current_mask++)
*current_mask = UnpackCARD8(data_ptr);
current_mask = bit_mask;
check_mask = START_CHECK_MASK;
for (*num = 0, i = 0; i < conf_fmt->num_attrs; i++) {
if (*current_mask & check_mask)
(*num)++;
check_mask >>= 1;
if ((i % 8) == 7) {
current_mask++;
check_mask = START_CHECK_MASK;
}
}
ptr = *win_data = (WSMWinData *) XtMalloc(*num * sizeof(WSMWinData));
/*
* For each value that was specified pack the data into the window
* data record.
*/
current_mask = bit_mask;
check_mask = START_CHECK_MASK;
attr = conf_fmt->attr_list;
for (i = 0; i < conf_fmt->num_attrs; i++, attr++) {
if (*current_mask & check_mask)
UnpackSingleWinDataRec(data_ptr, attr, ptr++);
check_mask >>= 1;
if ((i % 8) == 7) {
current_mask++;
check_mask = START_CHECK_MASK;
}
}
XtFree((XtPointer) bit_mask);
}
