misc.c

安装DDD之前

	i++;

	/* If you go too fast, other windows may not get a change to release
	 * any grab that they have. */
	_XmMicroSleep(1000);
    }

    /* If we fall out of the loop without grabbing the pointer, its
       time to give up */
    XSync(dpy, 0);

    if (val != GrabSuccess)
	return False;

    return True;
}


/*****************************************************************************
 *
 * UnGrab the pointer and keyboard
 *
 ****************************************************************************/
extern void
MISC_Ungrab(ScreenInfo *scr)
{
    Window w;

    XSync(dpy, 0);
    XUngrabPointer(dpy, CurrentTime);

    if (scr->mwm_last_focus != NULL)
    {
	w = scr->mwm_last_focus->w;

	/* if the window still exists, focus on it */
	if (w)
	{
	    WIN_SetFocusInTree(scr->mwm_last_focus);
	    WIN_SetFocus(scr, w, scr->mwm_last_focus);
	}
	scr->mwm_last_focus = NULL;
    }
    XSync(dpy, 0);
}

/*
 * Wait for all mouse buttons to be released 
 * This can ease some confusion on the part of the user sometimes 
 * 
 * Discard superflous button events during this wait period.
 */
extern void
MISC_WaitForButtonsUp(ScreenInfo *scr)
{
    Bool AllUp = False;
    XEvent JunkEvent;
    unsigned int mask;

    while (!AllUp)
    {
	XAllowEvents(dpy, ReplayPointer, CurrentTime);
	XQueryPointer(dpy, scr->root_win, &JunkRoot, &JunkChild,
		      &JunkX, &JunkY, &JunkX, &JunkY, &mask);

	if ((mask & (Button1Mask | Button2Mask | Button3Mask |
		     Button4Mask | Button5Mask)) == 0)
	    AllUp = True;
    }
    XSync(dpy, 0);
    while (XCheckMaskEvent(dpy,
			ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
			   &JunkEvent))
    {
	MISC_StashEventTime(&JunkEvent);
	XAllowEvents(dpy, ReplayPointer, CurrentTime);
    }

}

/*
 * For menus, move, and resize operations, we can effect keyboard 
 * shortcuts by warping the pointer.
 */
extern void
MISC_KeyboardShortcut(ScreenInfo *scr, XEvent *event, int ReturnEvent)
{
    int x, y, x_root, y_root;
    int move_size, x_move, y_move;
    KeySym keysym;

    /* Pick the size of the cursor movement */
    move_size = scr->components[MWM_MENU].f_height + HEIGHT_EXTRA;
    if (event->xkey.state & ControlMask)
	move_size = 1;
    if (event->xkey.state & ShiftMask)
	move_size = 100;

    keysym = XLookupKeysym(&event->xkey, 0);

    x_move = 0;
    y_move = 0;
    switch (keysym)
    {
    case XK_Up:
    case XK_k:
    case XK_p:
	y_move = -move_size;
	break;
    case XK_Down:
    case XK_n:
    case XK_j:
	y_move = move_size;
	break;
    case XK_Left:
    case XK_b:
    case XK_h:
	x_move = -move_size;
	break;
    case XK_Right:
    case XK_f:
    case XK_l:
	x_move = move_size;
	break;
    case XK_Return:
    case XK_space:
	/* beat up the event */
	event->type = ReturnEvent;
	break;
    default:
	break;
    }
    XQueryPointer(dpy, scr->root_win, &JunkRoot, &event->xany.window,
		  &x_root, &y_root, &x, &y, &JunkMask);

    if ((x_move != 0) || (y_move != 0))
    {
	/* beat up the event */
	XWarpPointer(dpy, None, scr->root_win, 0, 0, 0, 0, x_root + x_move,
		     y_root + y_move);

	/* beat up the event */
	event->type = MotionNotify;
	event->xkey.x += x_move;
	event->xkey.y += y_move;
	event->xkey.x_root += x_move;
	event->xkey.y_root += y_move;
    }
}

/*
 * find the root of a window tree
 */
extern MwmWindow *
MISC_RootOfTree(MwmWindow *win)
{
    MwmWindow *anc;

    if (win == NULL)
	return NULL;

    anc = win;
    while (anc->ancestor != NULL)
	anc = anc->ancestor;

    return anc;
}

/*
 * print the window tree
 */
extern void
MISC_PrintTree(ScreenInfo *scr)
{
    print_window_tree(scr->mwm_root.next, 0);
}

/*
 * add a window to the window tree
 */
extern void
MISC_AddToTree(ScreenInfo *scr, MwmWindow *win)
{
    MwmWindow *tmp;

    if ((win->flags & TRANSIENT) && win->transientfor != None)
    {
	tmp = find_by_window(&scr->mwm_root, win->transientfor);
	if (tmp)
	{
	    add_child(tmp, win);
	    return;
	}
    }

    if (win->wmhints && (win->wmhints->flags & WindowGroupHint))
    {
	tmp = find_by_group(&scr->mwm_root, win->wmhints->window_group);
	if (tmp && tmp->ancestor != NULL)
	{
	    add_child(tmp->ancestor, win);
	    return;
	}
    }

    win->next = scr->mwm_root.next;
    if (scr->mwm_root.next != NULL)
	scr->mwm_root.next->prev = win;
    win->prev = &scr->mwm_root;
    scr->mwm_root.next = win;
}

/*
 * remove a window from the window tree
 */
extern void
MISC_RemoveFromTree(ScreenInfo *scr, MwmWindow *win)
{
    if (win->ancestor != NULL)
    {
	remove_child(win->ancestor, win);
    }
    else
    {
	if (win->prev != NULL)
	    win->prev->next = win->next;
	if (win->next != NULL)
	    win->next->prev = win->prev;
    }
}

/*
 * after starting, fix up the transients whose parent windows weren't
 * captured yet
 */
extern void
MISC_FixupTransients(ScreenInfo *scr)
{
    MwmWindow *tmp, *ptr;

    for (tmp = scr->mwm_root.next; tmp != NULL;)
    {
	ptr = tmp->next;
	if (tmp->flags & TRANSIENT)
	{
	    tmp->ancestor = NULL;
	    MISC_RemoveFromTree(scr, tmp);
	    tmp->prev = tmp->next = NULL;
	    MISC_AddToTree(scr, tmp);
	}
	tmp = ptr;
    }

    /* under the assumption that their parent may not be found, clear the
     * transient flag */
    for (tmp = scr->mwm_root.next; tmp != NULL; tmp = tmp->next)
    {
	if (tmp->flags & TRANSIENT)
	{
	    tmp->flags &= ~TRANSIENT;
	    tmp->ancestor = NULL;
	}
    }
}

extern void
MISC_DestroyChildren(ScreenInfo *scr, MwmWindow *win)
{
    MwmWindow *child, *tmp;

    for (child = win->child; child != NULL; child = tmp)
    {
	tmp = child->next;
	WIN_DestroyWindow(scr, child);
    }
}

/* Debugging purposes only */
extern const char *
_MwmPrintF(int x)
{
	switch(x) {
	case F_NOP:	return "F_NOP";
	case F_BEEP:	return "F_BEEP";
	case F_CHANGE_WINDOWS_DESK:	return "F_CHANGE_WINDOWS_DESK";
	case F_CIRCULATE_DOWN:	return "F_CIRCULATE_DOWN";
	case F_CIRCULATE_UP:	return "F_CIRCULATE_UP";
	case F_CLOSE:	return "F_CLOSE";
	case F_DESK:	return "F_DESK";
	case F_EXEC:	return "F_EXEC";
	case F_FOCUS:	return "F_FOCUS";
	case F_FOCUS_COLOR:	return "F_FOCUS_COLOR";
	case F_FOCUS_KEY:	return "F_FOCUS_KEY";
	case F_GOTO_PAGE:	return "F_GOTO_PAGE";
	case F_ICONIFY:	return "F_ICONIFY";
	case F_LOWER:	return "F_LOWER";
	case F_MAXIMIZE:	return "F_MAXIMIZE";
	case F_MOVE:	return "F_MOVE";
	case F_MOVECURSOR:	return "F_MOVECURSOR";
	case F_NEXT_CMAP:	return "F_NEXT_CMAP";
	case F_NEXT_KEY:	return "F_NEXT_KEY";
	case F_NORMALIZE:	return "F_NORMALIZE";
	case F_NORM_AND_RAISE:	return "F_NORM_AND_RAISE";
	case F_PACK_ICONS:	return "F_PACK_ICONS";
	case F_PASS_KEYS:	return "F_PASS_KEYS";
	case F_POPUP:	return "F_POPUP";
	case F_PREV_CMAP:	return "F_PREV_CMAP";
	case F_PREV_KEY:	return "F_PREV_KEY";
	case F_QUIT:	return "F_QUIT";
	case F_RAISE:	return "F_RAISE";
	case F_RAISE_IT:	return "F_RAISE_IT";
	case F_RAISELOWER:	return "F_RAISELOWER";
	case F_RESIZE:	return "F_RESIZE";
	case F_RESTART:	return "F_RESTART";
	case F_REFRESH:	return "F_REFRESH";
	case F_REFRESH_WIN:	return "F_REFRESH_WIN";
	case F_RESTORE_AND_RAISE:	return "F_RESTORE_AND_RAISE";
	case F_SCREEN:	return "F_SCREEN";
	case F_SCROLL:	return "F_SCROLL";
	case F_SEND_MSG:	return "F_SEND_MSG";
	case F_SET_BEHAVIOR:	return "F_SET_BEHAVIOR";
	case F_STICK:	return "F_STICK";
	case F_TITLE:	return "F_TITLE";
	case F_TOGGLE_PAGE:	return "F_TOGGLE_PAGE";
	case F_WARP:	return "F_WARP";
	case F_WINDOWLIST:	return "F_WINDOWLIST";
	case F_W_POPUP:	return "F_W_POPUP";
	default:	return "??";
	}
}

extern const char *
_MwmPrintC(int x)
{
	static char res[256];

	res[0] = 0;
	if (x == C_NO_CONTEXT)
		return "C_NO_CONTEXT";
	if (x & C_WINDOW)
		strcat(res, " | C_WINDOW");
	if (x & C_TITLE)
		strcat(res, " | C_TITLE");
	if (x & C_ICON)
		strcat(res, " | C_ICON");
	if (x & C_ROOT)
		strcat(res, " | C_ROOT");
	if (x & C_FRAME)
		strcat(res, " | C_FRAME");
	if (x & C_MENUB)
		strcat(res, " | C_MENUB");
	if (x & C_MINIMIZEB)
		strcat(res, " | C_MINIMIZEB");
	if (x & C_MAXIMIZEB)
		strcat(res, " | C_MAXIMIZEB");
	return &res[2];
}