*outputType = XA_ATOM;
*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)
{
/*----------------------------------------------------------------------*
| InvokeCommand |
*----------------------------------------------------------------------*/
void
InvokeCommand (
Widget w,
Atom target,
MessageData data,
unsigned long len,
int fmt)
{
CARD32 commandID;
Window windowID;
WorkWindow *w_window;
CommandSpace *cs;
commandID = UnpackCARD32(&data);
windowID = UnpackCARD32(&data);
PRINT("commandID = %d\n",commandID);
PRINT("windowID = %d\n", windowID);
if (commandID == show_id)
{
if (wsm_shown)
{
PRINT("hide workspace manager\n");
HideWsm();
}
else
{
PRINT("show workspace manager\n");
ShowWsm();
}
}
else if (commandID == occupy_id)
{
PRINT("copy window\n");
w_window = GetWorkWindow(windowID);
if (w_window != NULL)
CreateOccupy(w_window);
}
else if (commandID == copy_all_id)
{
PRINT("copy window\n");
w_window = GetWorkWindow(windowID);
if (w_window != NULL)
CopyWindow(w_window,current_space,all_space);
}
else if (commandID == link_all_id)
{
PRINT("copy window\n");
w_window = GetWorkWindow(windowID);
if (w_window != NULL)
LinkWindow(w_window,current_space,all_space);
}
else if (commandID == remove_id)
{
PRINT("remove id\n");
w_window = GetWorkWindow(windowID);
if (w_window != 0)
{
if (w_window->s_list->next != NULL && w_window->window != None &&
_WSMGetConfigFormatType(w_window->window) != WSM_ICON_FMT)
DeleteWindow(w_window,current_space);
}
}
else if ((cs = GetCSFromSwitchID(commandID)) != NULL)
{
PRINT("SendLeaveRoom(%s)\n",cs->space->name);
XmToggleButtonSetState(wsm_ui->space_button[GetSpaceID(cs->space)],True,True);
}
else if ((cs = GetCSFromCopyID(commandID)) != NULL)
{
PRINT("copy space");
w_window = GetWorkWindow(windowID);
if (w_window != NULL)
{
PRINT(" %s\n",cs->space->name);
CopyWindow(w_window,current_space, cs->space);
}
}
else if ((cs = GetCSFromLinkID(commandID)) != NULL)
{
PRINT("link space");
w_window = GetWorkWindow(windowID);
if (w_window != NULL)
{
PRINT(" %s\n",cs->space->name);
LinkWindow(w_window,current_space, cs->space);
}
}
}
/*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 */
/*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 */
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;
}
}
