/**************************************************************************
*
* Moves focus to specified window
*
*************************************************************************/
void FocusOn(FvwmWindow *t, Bool FocusByMouse, char *action)
{
int dx,dy;
int cx,cy;
Bool do_not_warp;
if (t == NULL || HAS_NEVER_FOCUS(t))
{
UngrabEm(GRAB_NORMAL);
if (t)
{
/* give the window a chance to take the focus itself */
MoveFocus(t->w, t, FocusByMouse, 1, 0);
}
return;
}
if (!(do_not_warp = StrEquals(PeekToken(action, NULL), "NoWarp")))
{
if (t->Desk != Scr.CurrentDesk)
{
goto_desk(t->Desk);
}
if (IS_ICONIFIED(t))
{
cx = t->icon_xl_loc + t->icon_g.width/2;
cy = t->icon_g.y + t->icon_p_height + ICON_HEIGHT(t) / 2;
}
else
{
cx = t->frame_g.x + t->frame_g.width/2;
cy = t->frame_g.y + t->frame_g.height/2;
}
dx = (cx + Scr.Vx)/Scr.MyDisplayWidth*Scr.MyDisplayWidth;
dy = (cy +Scr.Vy)/Scr.MyDisplayHeight*Scr.MyDisplayHeight;
MoveViewport(dx,dy,True);
/* If the window is still not visible, make it visible! */
if (((t->frame_g.x + t->frame_g.height)< 0)||
(t->frame_g.y + t->frame_g.width < 0)||
(t->frame_g.x >Scr.MyDisplayWidth)||(t->frame_g.y>Scr.MyDisplayHeight))
{
SetupFrame(t, 0, 0, t->frame_g.width, t->frame_g.height, False);
if (HAS_MOUSE_FOCUS(t) || HAS_SLOPPY_FOCUS(t))
{
XWarpPointer(dpy, None, Scr.Root, 0, 0, 0, 0, 2,2);
}
}
}
UngrabEm(GRAB_NORMAL);
if (t->Desk == Scr.CurrentDesk)
{
MoveFocus(t->w, t, FocusByMouse, do_not_warp, 0);
}
return;
}
/*****************************************************************************
*
* Builtin which determines if the button press was a click or double click...
*
****************************************************************************/
void ComplexFunction(XEvent * eventp, Window w, FvwmWindow * tmp_win,
unsigned long context, char *action, int *Module)
{
char type = MOTION;
char c;
MenuItem *mi;
Bool Persist = False;
Bool HaveDoubleClick = False;
Bool NeedsTarget = False;
char *arguments[10], *junk, *taction;
int x, y, i;
XEvent d, *ev;
MenuRoot *mr;
extern Bool desperate;
mr = FindPopup(action);
if (mr == NULL) {
if (!desperate)
fvwm_msg(ERR, "ComplexFunction", "No such function %s", action);
return;
}
desperate = 0;
/* Get the argument list */
/* First entry in action is the function-name, ignore it */
action = GetNextToken(action, &junk);
if (junk != NULL)
free(junk);
for (i = 0; i < 10; i++)
action = GetNextToken(action, &arguments[i]);
/* These built-ins require a selected window
* The function code is >= 100 and < 1000
* F_RESIZE
* F_MOVE
* F_ICONIFY
* F_RAISE
* F_LOWER
* F_DESTROY
* F_DELETE
* F_STICK
* F_RAISELOWER
* F_MAXIMIZE
* F_FOCUS
*
* These do not:
* The function code is < 100
* F_NOP
* F_TITLE
* F_BEEP
* F_SCROLL
* F_MOVECURSOR
* F_RESTART
* F_EXEC
* F_REFRESH
* F_GOTO_PAGE
* F_TOGGLE_PAGE
* F_CIRCULATE_UP
* F_CIRCULATE_DOWN
* F_WARP
* F_DESK
* F_MODULE
* F_POPUP
* F_QUIT
* F_WINDOWLIST
* F_FUNCTION
* F_SEND_WINDOW_LIST
*/
ev = eventp;
/* In case we want to perform an action on a button press, we
* need to fool other routines */
if (eventp->type == ButtonPress)
eventp->type = ButtonRelease;
mi = mr->first;
while (mi != NULL) {
/* make lower case */
c = *(mi->item);
if ((mi->func_type >= 100) && (mi->func_type < 1000))
NeedsTarget = True;
if (isupper(c))
c = tolower(c);
if (c == DOUBLE_CLICK) {
HaveDoubleClick = True;
Persist = True;
} else if (c == IMMEDIATE) {
if (tmp_win)
w = tmp_win->frame;
else
w = None;
taction = expand(mi->action, arguments, tmp_win);
ExecuteFunction(taction, tmp_win, eventp, context, -2);
free(taction);
} else
Persist = True;
mi = mi->next;
}
if (!Persist) {
for (i = 0; i < 10; i++)
if (arguments[i] != NULL)
free(arguments[i]);
return;
}
/* Only defer execution if there is a possibility of needing
* a window to operate on */
if (NeedsTarget) {
if (DeferExecution
(eventp, &w, &tmp_win, &context, SELECT, ButtonPress)) {
WaitForButtonsUp();
for (i = 0; i < 10; i++)
if (arguments[i] != NULL)
free(arguments[i]);
return;
}
}
if (!GrabEm(SELECT)) {
XBell(dpy, Scr.screen);
for (i = 0; i < 10; i++)
if (arguments[i] != NULL)
free(arguments[i]);
return;
}
XQueryPointer(dpy, Scr.Root, &JunkRoot, &JunkChild,
&x, &y, &JunkX, &JunkY, &JunkMask);
/* Wait and see if we have a click, or a move */
/* wait 100 msec, see if the user releases the button */
if (IsClick(x, y, ButtonReleaseMask, &d)) {
ev = &d;
type = CLICK;
}
/* If it was a click, wait to see if its a double click */
if ((HaveDoubleClick) && (type == CLICK) &&
(IsClick(x, y, ButtonPressMask, &d))) {
type = ONE_AND_A_HALF_CLICKS;
ev = &d;
}
if ((HaveDoubleClick) && (type == ONE_AND_A_HALF_CLICKS) &&
(IsClick(x, y, ButtonReleaseMask, &d))) {
type = DOUBLE_CLICK;
ev = &d;
}
/* some functions operate on button release instead of
* presses. These gets really weird for complex functions ... */
if (ev->type == ButtonPress)
ev->type = ButtonRelease;
mi = mr->first;
while (mi != NULL) {
/* make lower case */
c = *(mi->item);
if (isupper(c))
c = tolower(c);
if (c == type) {
if (tmp_win)
w = tmp_win->frame;
else
w = None;
taction = expand(mi->action, arguments, tmp_win);
ExecuteFunction(taction, tmp_win, ev, context, -2);
free(taction);
}
mi = mi->next;
}
WaitForButtonsUp();
UngrabEm();
for (i = 0; i < 10; i++)
if (arguments[i] != NULL)
free(arguments[i]);
}
/****************************************************************************
*
* Initiates a menu pop-up
*
* Style = 1 = sticky menu, stays up on initial button release.
* Style = 0 = transient menu, drops on initial release.
***************************************************************************/
int do_menu(MenuRoot * menu, int style)
{
int prevStashedX = 0, prevStashedY = 0;
MenuRoot *PrevActiveMenu = 0;
MenuItem *PrevActiveItem = 0;
int retval = MENU_NOP;
int x, y;
Time t0;
extern Time lastTimestamp;
int PrevMenuX = PrevActiveMenuX;
/* this condition could get ugly */
if (menu->in_use)
return MENU_ERROR;
/* In case we wind up with a move from a menu which is
* from a window border, we'll return to here to start
* the move */
XQueryPointer(dpy, Scr.Root, &JunkRoot, &JunkChild,
&x, &y, &JunkX, &JunkY, &JunkMask);
if (menu_on) {
prevStashedX = Stashed_X;
prevStashedY = Stashed_Y;
PrevActiveMenu = ActiveMenu;
PrevActiveItem = ActiveItem;
if (ActiveMenu)
x = Stashed_X + ActiveMenu->width - 3;
if (ActiveItem)
y = ActiveItem->y_offset + MenuY;
} else {
mouse_moved = 0;
t0 = lastTimestamp;
if (!GrabEm(MENU)) {
XBell(dpy, Scr.screen);
return MENU_DONE;
}
x += 2;
}
if (PopUpMenu(menu, x, y)) {
retval = UpdateMenu(style);
} else
XBell(dpy, Scr.screen);
ActiveMenu = PrevActiveMenu;
ActiveItem = PrevActiveItem;
if ((ActiveItem) && (menu_on))
ActiveItem->state = 1;
Stashed_X = prevStashedX;
Stashed_Y = prevStashedY;
if (!menu_on) {
UngrabEm();
WaitForButtonsUp();
}
if (((lastTimestamp - t0) < 3 * Scr.ClickTime) && (mouse_moved == 0))
menu_aborted = 1;
else
menu_aborted = 0;
PrevActiveMenuX = PrevMenuX;
return retval;
}
static void execute_complex_function(
cond_rc_t *cond_rc, const exec_context_t *exc, char *action,
Bool *desperate, Bool has_ref_window_moved)
{
cond_rc_t tmp_rc;
cfunc_action_t type = CF_MOTION;
char c;
FunctionItem *fi;
Bool Persist = False;
Bool HaveDoubleClick = False;
Bool HaveHold = False;
Bool NeedsTarget = False;
Bool ImmediateNeedsTarget = False;
int do_allow_unmanaged = FUNC_ALLOW_UNMANAGED;
int do_allow_unmanaged_immediate = FUNC_ALLOW_UNMANAGED;
char *arguments[11], *taction;
char *func_name;
int x, y ,i;
XEvent d;
FvwmFunction *func;
static int depth = 0;
const exec_context_t *exc2;
exec_context_changes_t ecc;
exec_context_change_mask_t mask;
int trigger_evtype;
int button;
XEvent *te;
if (cond_rc == NULL)
{
condrc_init(&tmp_rc);
cond_rc = &tmp_rc;
}
cond_rc->rc = COND_RC_OK;
mask = 0;
d.type = 0;
ecc.w.fw = exc->w.fw;
ecc.w.w = exc->w.w;
ecc.w.wcontext = exc->w.wcontext;
/* find_complex_function expects a token, not just a quoted string */
func_name = PeekToken(action, &taction);
if (!func_name)
{
return;
}
func = find_complex_function(func_name);
if (func == NULL)
{
if (*desperate == 0)
{
fvwm_msg(
ERR, "ComplexFunction", "No such function %s",
action);
}
return;
}
if (!depth)
{
Scr.flags.is_executing_complex_function = 1;
}
depth++;
*desperate = 0;
/* duplicate the whole argument list for use as '$*' */
if (taction)
{
arguments[0] = safestrdup(taction);
/* strip trailing newline */
if (arguments[0][0])
{
int l= strlen(arguments[0]);
if (arguments[0][l - 1] == '\n')
{
arguments[0][l - 1] = 0;
}
}
/* Get the argument list */
for (i = 1; i < 11; i++)
{
taction = GetNextToken(taction, &arguments[i]);
}
}
else
{
for (i = 0; i < 11; i++)
{
arguments[i] = NULL;
}
}
/* In case we want to perform an action on a button press, we
* need to fool other routines */
te = exc->x.elast;
if (te->type == ButtonPress)
{
trigger_evtype = ButtonRelease;
}
else
{
trigger_evtype = te->type;
}
func->use_depth++;
for (fi = func->first_item; fi != NULL; fi = fi->next_item)
{
if (fi->flags & FUNC_NEEDS_WINDOW)
{
NeedsTarget = True;
do_allow_unmanaged &= fi->flags;
if (fi->condition == CF_IMMEDIATE)
{
do_allow_unmanaged_immediate &= fi->flags;
ImmediateNeedsTarget = True;
break;
}
}
}
if (ImmediateNeedsTarget)
{
if (DeferExecution(
&ecc, &mask, CRS_SELECT, trigger_evtype,
do_allow_unmanaged_immediate))
{
func->use_depth--;
__cf_cleanup(&depth, arguments, cond_rc);
return;
}
NeedsTarget = False;
}
else
{
ecc.w.w = (ecc.w.fw) ? FW_W_FRAME(ecc.w.fw) : None;
mask |= ECC_W;
}
/* we have to grab buttons before executing immediate actions because
* these actions can move the window away from the pointer so that a
* button release would go to the application below. */
if (!GrabEm(CRS_NONE, GRAB_NORMAL))
{
func->use_depth--;
fvwm_msg(
ERR,
"ComplexFunction", "Grab failed in function %s,"
" unable to execute immediate action", action);
__cf_cleanup(&depth, arguments, cond_rc);
return;
}
exc2 = exc_clone_context(exc, &ecc, mask);
__run_complex_function_items(
cond_rc, CF_IMMEDIATE, func, exc2, arguments,
has_ref_window_moved);
exc_destroy_context(exc2);
for (fi = func->first_item;
fi != NULL && cond_rc->break_levels == 0;
fi = fi->next_item)
{
/* c is already lowercase here */
c = fi->condition;
switch (c)
{
case CF_IMMEDIATE:
break;
case CF_DOUBLE_CLICK:
HaveDoubleClick = True;
Persist = True;
break;
case CF_HOLD:
HaveHold = True;
Persist = True;
break;
default:
Persist = True;
break;
}
}
if (!Persist || cond_rc->break_levels != 0)
{
func->use_depth--;
__cf_cleanup(&depth, arguments, cond_rc);
UngrabEm(GRAB_NORMAL);
return;
}
/* Only defer execution if there is a possibility of needing
* a window to operate on */
if (NeedsTarget)
{
if (DeferExecution(
&ecc, &mask, CRS_SELECT, trigger_evtype,
do_allow_unmanaged))
{
func->use_depth--;
__cf_cleanup(&depth, arguments, cond_rc);
UngrabEm(GRAB_NORMAL);
return;
}
}
te = (mask & ECC_ETRIGGER) ? ecc.x.etrigger : exc->x.elast;
switch (te->xany.type)
{
case ButtonPress:
case ButtonRelease:
x = te->xbutton.x_root;
y = te->xbutton.y_root;
button = te->xbutton.button;
/* Take the click which started this fuction off the
* Event queue. -DDN- Dan D Niles [email protected] */
FCheckMaskEvent(dpy, ButtonPressMask, &d);
break;
default:
if (FQueryPointer(
dpy, Scr.Root, &JunkRoot, &JunkChild, &x, &y,
&JunkX, &JunkY, &JunkMask) == False)
{
/* pointer is on a different screen */
x = 0;
y = 0;
}
button = 0;
break;
}
/* Wait and see if we have a click, or a move */
/* wait forever, see if the user releases the button */
type = CheckActionType(x, y, &d, HaveHold, True, &button);
if (type == CF_CLICK)
{
int button2;
/* If it was a click, wait to see if its a double click */
if (HaveDoubleClick)
{
type = CheckActionType(
x, y, &d, True, False, &button2);
switch (type)
{
case CF_HOLD:
case CF_MOTION:
case CF_CLICK:
if (button == button2)
{
type = CF_DOUBLE_CLICK;
}
else
{
type = CF_CLICK;
}
break;
case CF_TIMEOUT:
type = CF_CLICK;
break;
default:
/* can't happen */
break;
}
}
}
else if (type == CF_TIMEOUT)
{
type = CF_HOLD;
}
/* some functions operate on button release instead of presses. These
* gets really weird for complex functions ... */
if (d.type == ButtonPress)
{
d.type = ButtonRelease;
if (d.xbutton.button > 0 &&
d.xbutton.button <= NUMBER_OF_MOUSE_BUTTONS)
{
d.xbutton.state &=
(~(Button1Mask >> (d.xbutton.button - 1)));
}
/*
* Defer the execution of a function to the next button press if the context is
* C_ROOT
*
* Inputs:
* cursor - the cursor to display while waiting
*/
static Bool DeferExecution(
exec_context_changes_t *ret_ecc, exec_context_change_mask_t *ret_mask,
cursor_t cursor, int trigger_evtype, int do_allow_unmanaged)
{
int done;
int finished = 0;
int just_waiting_for_finish = 0;
Window dummy;
Window original_w;
static XEvent e;
Window w;
int wcontext;
FvwmWindow *fw;
int FinishEvent;
fw = ret_ecc->w.fw;
w = ret_ecc->w.w;
original_w = w;
wcontext = ret_ecc->w.wcontext;
FinishEvent = ((fw != NULL) ? ButtonRelease : ButtonPress);
if (wcontext == C_UNMANAGED && do_allow_unmanaged)
{
return False;
}
if (wcontext != C_ROOT && wcontext != C_NO_CONTEXT && fw != NULL &&
wcontext != C_EWMH_DESKTOP)
{
if (FinishEvent == ButtonPress ||
(FinishEvent == ButtonRelease &&
trigger_evtype != ButtonPress))
{
return False;
}
else if (FinishEvent == ButtonRelease)
{
/* We are only waiting until the user releases the
* button. Do not change the cursor. */
cursor = CRS_NONE;
just_waiting_for_finish = 1;
}
}
if (Scr.flags.are_functions_silent)
{
return True;
}
if (!GrabEm(cursor, GRAB_NORMAL))
{
XBell(dpy, 0);
return True;
}
MyXGrabKeyboard(dpy);
while (!finished)
{
done = 0;
/* block until there is an event */
FMaskEvent(
dpy, ButtonPressMask | ButtonReleaseMask |
ExposureMask | KeyPressMask | VisibilityChangeMask |
ButtonMotionMask | PointerMotionMask
/* | EnterWindowMask | LeaveWindowMask*/, &e);
if (e.type == KeyPress)
{
KeySym keysym = XLookupKeysym(&e.xkey, 0);
if (keysym == XK_Escape)
{
ret_ecc->x.etrigger = &e;
*ret_mask |= ECC_ETRIGGER;
UngrabEm(GRAB_NORMAL);
MyXUngrabKeyboard(dpy);
return True;
}
Keyboard_shortcuts(&e, NULL, NULL, NULL, FinishEvent);
}
if (e.type == FinishEvent)
{
finished = 1;
}
switch (e.type)
{
case KeyPress:
case ButtonPress:
if (e.type != FinishEvent)
{
original_w = e.xany.window;
}
done = 1;
break;
case ButtonRelease:
done = 1;
break;
default:
break;
}
if (!done)
{
dispatch_event(&e);
}
}
MyXUngrabKeyboard(dpy);
UngrabEm(GRAB_NORMAL);
if (just_waiting_for_finish)
{
return False;
}
w = e.xany.window;
ret_ecc->x.etrigger = &e;
*ret_mask |= ECC_ETRIGGER | ECC_W | ECC_WCONTEXT;
if ((w == Scr.Root || w == Scr.NoFocusWin) &&
e.xbutton.subwindow != None)
{
w = e.xbutton.subwindow;
e.xany.window = w;
}
if (w == Scr.Root || IS_EWMH_DESKTOP(w))
{
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
*ret_mask |= ECC_FW;
if (XFindContext(dpy, w, FvwmContext, (caddr_t *)&fw) == XCNOENT)
{
ret_ecc->w.fw = NULL;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return (True);
}
if (w == FW_W_PARENT(fw))
{
w = FW_W(fw);
}
if (original_w == FW_W_PARENT(fw))
{
original_w = FW_W(fw);
}
/* this ugly mess attempts to ensure that the release and press
* are in the same window. */
if (w != original_w && original_w != Scr.Root &&
original_w != None && original_w != Scr.NoFocusWin &&
!IS_EWMH_DESKTOP(original_w))
{
if (w != FW_W_FRAME(fw) || original_w != FW_W(fw))
{
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
}
if (IS_EWMH_DESKTOP(FW_W(fw)))
{
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
wcontext = GetContext(NULL, fw, &e, &dummy);
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
return False;
}
void executeModule(XEvent * eventp, Window w, FvwmWindow * tmp_win,
unsigned long context, char *action, int *Module)
{
int fvwm_to_app[2], app_to_fvwm[2];
int i, val, nargs = 0;
char *cptr;
char *args[20];
char *arg1 = NULL;
char arg2[20];
char arg3[20];
char arg5[20];
char arg6[20];
extern char *ModulePath;
extern char *fvwm_file;
Window win;
if (eventp->type != KeyPress)
UngrabEm();
if (action == NULL)
return;
if (tmp_win)
win = tmp_win->w;
else
win = None;
/* If we execute a module, don't wait for buttons to come up,
* that way, a pop-up menu could be implemented */
*Module = 0;
action = GetNextToken(action, &cptr);
arg1 = findIconFile(cptr, ModulePath, X_OK);
if (arg1 == NULL) {
if (cptr != NULL) {
fvwm_msg(ERR, "executeModule",
"No such module %s%s", ModulePath, cptr);
free(cptr);
}
return;
}
/* Look for an available pipe slot */
for (i = 0; (i < npipes) && (writePipes[i] >= 0); ++i);
if (i >= npipes) {
fvwm_msg(ERR, "executeModule", "Too many Accessories!");
if (cptr != NULL)
free(cptr);
return;
}
/* I want one-ended pipes, so I open two two-ended pipes,
* and close one end of each. I need one ended pipes so that
* I can detect when the module crashes/malfunctions */
if (pipe(fvwm_to_app) != 0) {
fvwm_msg(ERR, "executeModule", "Failed to open pipe");
return;
}
if (pipe(app_to_fvwm) != 0) {
fvwm_msg(ERR, "executeModule", "Failed to open pipe2");
if (cptr != NULL)
free(cptr);
close(fvwm_to_app[0]);
close(fvwm_to_app[1]);
return;
}
pipeName[i] = stripcpy(cptr);
sprintf(arg2, "%d", app_to_fvwm[1]);
sprintf(arg3, "%d", fvwm_to_app[0]);
sprintf(arg5, "%lx", (unsigned long) win);
sprintf(arg6, "%lx", (unsigned long) context);
args[0] = arg1;
args[1] = arg2;
args[2] = arg3;
if (fvwm_file != NULL)
args[3] = fvwm_file;
else
args[3] = "none";
args[4] = arg5;
args[5] = arg6;
nargs = 6;
while ((action != NULL) && (nargs < 20) && (strlen(args[nargs - 1]) > 0)) {
args[nargs] = 0;
action = GetNextToken(action, &args[nargs]);
nargs++;
}
if (strlen(args[nargs - 1]) <= 0) {
nargs--;
if (args[nargs] != NULL)
free(args[nargs]);
}
args[nargs] = 0;
/* Try vfork instead of fork. The man page says that vfork is better! */
/* Also, had to change exit to _exit() */
/* Not everyone has vfork! */
val = fork();
if (val > 0) {
/* This fork remains running fvwm */
/* close appropriate descriptors from each pipe so
* that fvwm will be able to tell when the app dies */
close(app_to_fvwm[1]);
close(fvwm_to_app[0]);
/* add these pipes to fvwm's active pipe list */
writePipes[i] = fvwm_to_app[1];
readPipes[i] = app_to_fvwm[0];
pipeOn[i] = -1;
PipeMask[i] = MAX_MASK;
free(arg1);
pipeQueue[i] = NULL;
/* make the PositiveWrite pipe non-blocking. Don't want to jam up
fvwm because of an uncooperative module */
fcntl(writePipes[i], F_SETFL, O_NDELAY);
/* Mark the pipes close-on exec so other programs
* won`t inherit them */
if (fcntl(readPipes[i], F_SETFD, 1) == -1)
fvwm_msg(ERR, "executeModule", "module close-on-exec failed");
if (fcntl(writePipes[i], F_SETFD, 1) == -1)
fvwm_msg(ERR, "executeModule", "module close-on-exec failed");
for (i = 6; i < nargs; i++) {
if (args[i] != 0)
free(args[i]);
}
if (cptr != NULL)
free(cptr);
} else if (val == 0) {
/* this is the child */
/* this fork execs the module */
close(fvwm_to_app[1]);
close(app_to_fvwm[0]);
execvp(arg1, args);
fvwm_msg(ERR, "executeModule", "Execution of module failed: %s", arg1);
perror("");
close(app_to_fvwm[1]);
close(fvwm_to_app[0]);
exit(1);
} else {
fvwm_msg(ERR, "executeModule", "Fork failed");
free(arg1);
}
return;
}
void InteractiveMove(Window *win, FvwmWindow *tmp_win, int *FinalX, int *FinalY, XEvent *eventp)
{
extern int Stashed_X, Stashed_Y;
int origDragX,origDragY,DragX, DragY, DragWidth, DragHeight;
int XOffset, YOffset;
Window w;
Bool opaque_move = False;
#ifndef NO_PAGER
extern Bool pagerOn;
#endif
InstallRootColormap();
if (menuFromFrameOrWindowOrTitlebar)
{
/* warp the pointer to the cursor position from before menu appeared*/
XWarpPointer(dpy, None, Scr.Root, 0, 0, 0, 0, Stashed_X,Stashed_Y);
XFlush(dpy);
}
DragX = eventp->xbutton.x_root;
DragY = eventp->xbutton.y_root;
/* If this is left commented out, then the move starts from the button press
* location instead of the current location, which seems to be an
* improvement */
/* XQueryPointer(dpy, Scr.Root, &JunkRoot, &JunkChild,
&DragX, &DragY, &JunkX, &JunkY, &JunkMask);*/
if(!GrabEm(MOVE))
{
XBell(dpy,Scr.screen);
return;
}
#ifndef NO_PAGER
pagerOn = False;
#endif
w = tmp_win->frame;
if(tmp_win->flags & ICONIFIED)
if(tmp_win->icon_pixmap_w != None)
{
XUnmapWindow(dpy,tmp_win->icon_w);
w = tmp_win->icon_pixmap_w;
}
else
w = tmp_win->icon_w;
*win = w;
XGetGeometry(dpy, w, &JunkRoot, &origDragX, &origDragY,
(unsigned int *)&DragWidth, (unsigned int *)&DragHeight,
&JunkBW, &JunkDepth);
if(DragWidth*DragHeight <
(Scr.OpaqueSize*Scr.MyDisplayWidth*Scr.MyDisplayHeight)/100)
opaque_move = True;
else
XGrabServer(dpy);
if((!opaque_move)&&(tmp_win->flags & ICONIFIED))
XUnmapWindow(dpy,w);
DragWidth += JunkBW;
DragHeight+= JunkBW;
XOffset = origDragX - DragX;
YOffset = origDragY - DragY;
XMapRaised(dpy,Scr.SizeWindow);
moveLoop(tmp_win, XOffset,YOffset,DragWidth,DragHeight, FinalX,FinalY,
opaque_move,False);
XUnmapWindow(dpy,Scr.SizeWindow);
UninstallRootColormap();
if(!opaque_move)
XUngrabServer(dpy);
UngrabEm();
#ifndef NO_PAGER
pagerOn = True;
#endif
}
/*
*
* Moves focus to specified window; only to be called bay Focus and FlipFocus
*
*/
static void __activate_window_by_command(
F_CMD_ARGS, int is_focus_by_flip_focus_cmd)
{
int cx;
int cy;
Bool do_not_warp;
sftfwin_args_t sf_args;
FvwmWindow * const fw = exc->w.fw;
memset(&sf_args, 0, sizeof(sf_args));
sf_args.do_allow_force_broadcast = 1;
sf_args.is_focus_by_flip_focus_cmd = is_focus_by_flip_focus_cmd;
sf_args.set_by = FOCUS_SET_BY_FUNCTION;
sf_args.client_entered = 0;
if (fw == NULL || !FP_DO_FOCUS_BY_FUNCTION(FW_FOCUS_POLICY(fw)))
{
UngrabEm(GRAB_NORMAL);
if (fw)
{
/* give the window a chance to take the focus itself */
sf_args.do_forbid_warp = 1;
sf_args.do_force = 0;
set_focus_to_fwin(FW_W(fw), fw, &sf_args);
}
return;
}
do_not_warp = StrEquals(PeekToken(action, NULL), "NoWarp");
if (!do_not_warp)
{
if (fw->Desk != Scr.CurrentDesk)
{
goto_desk(fw->Desk);
}
if (IS_ICONIFIED(fw))
{
rectangle g;
Bool rc;
rc = get_visible_icon_title_geometry(fw, &g);
if (rc == False)
{
get_visible_icon_picture_geometry(fw, &g);
}
cx = g.x + g.width / 2;
cy = g.y + g.height / 2;
}
else
{
cx = fw->g.frame.x + fw->g.frame.width/2;
cy = fw->g.frame.y + fw->g.frame.height/2;
}
if (
cx < 0 || cx >= Scr.MyDisplayWidth ||
cy < 0 || cy >= Scr.MyDisplayHeight)
{
int dx;
int dy;
dx = ((cx + Scr.Vx) / Scr.MyDisplayWidth) *
Scr.MyDisplayWidth;
dy = ((cy + Scr.Vy) / Scr.MyDisplayHeight) *
Scr.MyDisplayHeight;
MoveViewport(dx, dy, True);
}
#if 0 /* can not happen */
/* If the window is still not visible, make it visible! */
if (fw->g.frame.x + fw->g.frame.width < 0 ||
fw->g.frame.y + fw->g.frame.height < 0 ||
fw->g.frame.x >= Scr.MyDisplayWidth ||
fw->g.frame.y >= Scr.MyDisplayHeight)
{
frame_setup_window(
fw, 0, 0, fw->g.frame.width,
fw->g.frame.height, False);
if (
FP_DO_WARP_POINTER_ON_FOCUS_FUNC(
FW_FOCUS_POLICY(fw)))
{
FWarpPointerUpdateEvpos(
exc->x.elast, dpy, None, Scr.Root, 0,
0, 0, 0, 2, 2);
}
}
#endif
}
UngrabEm(GRAB_NORMAL);
if (fw->Desk == Scr.CurrentDesk)
{
FvwmWindow *sf;
sf = get_focus_window();
sf_args.do_forbid_warp = !!do_not_warp;
sf_args.do_force = 0;
sf_args.client_entered = 0;
set_focus_to_fwin(FW_W(fw), fw, &sf_args);
if (sf != get_focus_window())
{
/* Ignore EnterNotify event while we are waiting for
* this window to be focused. */
Scr.focus_in_pending_window = sf;
}
}
return;
}