/* This function is part of a hack to make focus handling work better with
* applications that use the passive focus model but manage focus in their own
* sub windows and should thus use the locally active focus model instead.
* There are many examples like netscape or ddd. */
void focus_force_refresh_focus(const FvwmWindow *fw)
{
XWindowAttributes winattrs;
MyXGrabServer(dpy);
if (XGetWindowAttributes(dpy, FW_W(fw), &winattrs))
{
XSelectInput(
dpy, FW_W(fw),
winattrs.your_event_mask & ~FocusChangeMask);
FOCUS_SET(FW_W(fw), NULL /* we don't expect an event */);
XSelectInput(dpy, FW_W(fw), winattrs.your_event_mask);
}
MyXUngrabServer(dpy);
return;
}
/* This function is part of a hack to make focus handling work better with
* applications that use the passive focus model but manage focus in their own
* sub windows and should thus use the locally active focus model instead.
* There are many examples like netscape or ddd. */
void refresh_focus(FvwmWindow *fw)
{
Bool do_refresh = False;
if (fw == NULL || fw != get_focus_window() || HAS_NEVER_FOCUS(fw))
{
/* only refresh the focus on the currently focused window */
return;
}
/* only refresh the focus for windows with the passive focus model so that
* we don't disturb focus handling more than necessary */
switch (fw->focus_model)
{
case FM_PASSIVE:
do_refresh = True;
break;
case FM_NO_INPUT:
case FM_GLOBALLY_ACTIVE:
case FM_LOCALLY_ACTIVE:
default:
do_refresh = False;
break;
}
if (do_refresh)
{
XWindowAttributes winattrs;
MyXGrabServer(dpy);
if (XGetWindowAttributes(dpy, fw->w, &winattrs))
{
XSelectInput(dpy, fw->w, winattrs.your_event_mask & ~FocusChangeMask);
FOCUS_SET(fw->w);
XSelectInput(dpy, fw->w, winattrs.your_event_mask);
}
MyXUngrabServer(dpy);
}
return;
}
/********************************************************************
*
* Sets the input focus to the indicated window.
*
**********************************************************************/
static void DoSetFocus(Window w, FvwmWindow *Fw, Bool FocusByMouse, Bool NoWarp)
{
extern Time lastTimestamp;
FvwmWindow *sf;
if (Fw && WM_TAKES_FOCUS(Fw))
{
send_clientmessage(dpy, w, _XA_WM_TAKE_FOCUS, lastTimestamp);
}
if (Fw && HAS_NEVER_FOCUS(Fw))
{
if (WM_TAKES_FOCUS(Fw))
{
/* give it a chance to take the focus itself */
XSync(dpy, 0);
}
else
{
/* make sure the window is not hilighted */
DrawDecorations(Fw, DRAW_ALL, False, False, None);
}
return;
}
if (Fw && !IS_LENIENT(Fw) &&
Fw->wmhints && (Fw->wmhints->flags & InputHint) && !Fw->wmhints->input &&
(sf = get_focus_window()) && sf->Desk == Scr.CurrentDesk)
{
return;
}
/* ClickToFocus focus queue manipulation - only performed for
* Focus-by-mouse type focus events */
/* Watch out: Fw may not be on the windowlist and the windowlist may be
* empty */
if (Fw && Fw != get_focus_window() && Fw != &Scr.FvwmRoot &&
!IS_SCHEDULED_FOR_DESTROY(Fw))
{
if (FocusByMouse) /* pluck window from list and deposit at top */
{
/* remove Fw from list */
if (Fw->prev)
Fw->prev->next = Fw->next;
if (Fw->next)
Fw->next->prev = Fw->prev;
/* insert Fw at start */
Fw->next = Scr.FvwmRoot.next;
if (Scr.FvwmRoot.next)
Scr.FvwmRoot.next->prev = Fw;
Scr.FvwmRoot.next = Fw;
Fw->prev = &Scr.FvwmRoot;
}
else
{
/* move the windowlist around so that Fw is at the top */
FvwmWindow *tmp_win;
/* find the window on the windowlist */
tmp_win = &Scr.FvwmRoot;
while (tmp_win && tmp_win != Fw)
tmp_win = tmp_win->next;
if (tmp_win) /* the window is on the (non-zero length) windowlist */
{
/* make tmp_win point to the last window on the list */
while (tmp_win->next)
tmp_win = tmp_win->next;
/* close the ends of the windowlist */
tmp_win->next = Scr.FvwmRoot.next;
Scr.FvwmRoot.next->prev = tmp_win;
/* make Fw the new start of the list */
Scr.FvwmRoot.next = Fw;
/* open the closed loop windowlist */
Fw->prev->next = NULL;
Fw->prev = &Scr.FvwmRoot;
}
}
}
lastFocusType = FocusByMouse;
if (!Fw && !Scr.flags.is_pointer_on_this_screen)
{
focus_grab_buttons(Scr.Ungrabbed, False);
set_focus_window(NULL);
/* DV (25-Nov-2000): Don't give the Scr.NoFocusWin the focus here. This
* would steal the focus from the other screen's root window again. */
/* FOCUS_SET(Scr.NoFocusWin); */
return;
}
if (Fw && !NoWarp)
{
if (IS_ICONIFIED(Fw))
{
rectangle r;
r.x = Fw->icon_g.x;
r.y = Fw->icon_g.y;
r.width = Fw->icon_g.width;
r.height = Fw->icon_p_height + Fw->icon_g.height;
if (!IsRectangleOnThisPage(&r, Fw->Desk))
{
Fw = NULL;
w = Scr.NoFocusWin;
}
}
else if (!IsRectangleOnThisPage(&(Fw->frame_g),Fw->Desk))
{
Fw = NULL;
w = Scr.NoFocusWin;
}
}
/*
RBW - 1999/12/08 - we have to re-grab the unfocused window here for the
MouseFocusClickRaises case also, but we can't ungrab the newly focused
window here, or we'll never catch the raise click. For this special case,
the newly-focused window is ungrabbed in events.c (HandleButtonPress).
*/
if (Scr.Ungrabbed != Fw)
{
/* need to grab all buttons for window that we are about to unfocus */
focus_grab_buttons(Scr.Ungrabbed, False);
}
/* if we do click to focus, remove the grab on mouse events that
* was made to detect the focus change */
if (Fw && HAS_CLICK_FOCUS(Fw))
{
focus_grab_buttons(Fw, True);
}
/* RBW - allow focus to go to a NoIconTitle icon window so
* auto-raise will work on it... */
if (Fw && IS_ICONIFIED(Fw))
{
Bool is_window_selected = False;
if (Fw->icon_w)
{
w = Fw->icon_w;
is_window_selected = True;
}
if ((!is_window_selected || WAS_ICON_HINT_PROVIDED(Fw)) &&
Fw->icon_pixmap_w)
{
w = Fw->icon_pixmap_w;
}
}
if (Fw && IS_LENIENT(Fw))
{
FOCUS_SET(w);
set_focus_window(Fw);
SET_FOCUS_CHANGE_BROADCAST_PENDING(Fw, 1);
Scr.UnknownWinFocused = None;
}
else if (!Fw || !(Fw->wmhints) || !(Fw->wmhints->flags & InputHint) ||
Fw->wmhints->input != False)
{
/* Window will accept input focus */
FOCUS_SET(w);
set_focus_window(Fw);
if (Fw)
{
SET_FOCUS_CHANGE_BROADCAST_PENDING(Fw, 1);
}
Scr.UnknownWinFocused = None;
}
else if ((sf = get_focus_window()) && sf->Desk == Scr.CurrentDesk)
{
/* Window doesn't want focus. Leave focus alone */
/* FOCUS_SET(Scr.Hilite->w);*/
}
else
{
FOCUS_SET(Scr.NoFocusWin);
set_focus_window(NULL);
}
XSync(dpy,0);
return;
}
/*
* Sets the input focus to the indicated window.
*/
static void __set_focus_to_fwin(
Window w, FvwmWindow *fw, sftfwin_args_t *args)
{
FvwmWindow *sf;
if (__try_forbid_user_focus(w, fw) == True)
{
return;
}
__try_program_focus(w, fw);
if (__check_allow_focus(w, fw, args->set_by) == False)
{
return;
}
__update_windowlist(fw, args->set_by, args->is_focus_by_flip_focus_cmd);
if (__try_other_screen_focus(fw) == True)
{
return;
}
if (fw && !args->do_forbid_warp)
{
if (IS_ICONIFIED(fw))
{
rectangle r;
Bool rc;
rc = get_visible_icon_geometry(fw, &r);
if (!rc || !IsRectangleOnThisPage(&r, fw->Desk))
{
fw = NULL;
w = Scr.NoFocusWin;
}
}
else if (!IsRectangleOnThisPage(&(fw->g.frame), fw->Desk))
{
fw = NULL;
w = Scr.NoFocusWin;
}
}
sf = get_focus_window();
if (fw == NULL)
{
FOCUS_SET(Scr.NoFocusWin, NULL);
set_focus_window(NULL);
Scr.UnknownWinFocused = None;
XFlush(dpy);
return;
}
/* RBW - allow focus to go to a NoIconTitle icon window so
* auto-raise will work on it. */
if (IS_ICONIFIED(fw))
{
Bool is_window_selected = False;
if (FW_W_ICON_TITLE(fw))
{
w = FW_W_ICON_TITLE(fw);
is_window_selected = True;
}
if ((!is_window_selected || WAS_ICON_HINT_PROVIDED(fw)) &&
FW_W_ICON_PIXMAP(fw))
{
w = FW_W_ICON_PIXMAP(fw);
}
}
if (FP_IS_LENIENT(FW_FOCUS_POLICY(fw)))
{
FOCUS_SET(w, fw);
set_focus_window(fw);
if (args->do_allow_force_broadcast)
{
SET_FOCUS_CHANGE_BROADCAST_PENDING(fw, 1);
}
Scr.UnknownWinFocused = None;
}
else if (focus_does_accept_input_focus(fw))
{
/* Window will accept input focus */
if (Scr.StolenFocusWin == w && Scr.UnknownWinFocused != None)
{
/* Without this FocusIn is not generated on the
* window if it was focuesed when the unmanaged
* window took focus. */
FOCUS_SET(Scr.NoFocusWin, NULL);
}
FOCUS_SET(w, fw);
set_focus_window(fw);
if (fw)
{
if (args->do_allow_force_broadcast)
{
SET_FOCUS_CHANGE_BROADCAST_PENDING(fw, 1);
}
}
Scr.UnknownWinFocused = None;
}
else if (sf && sf->Desk == Scr.CurrentDesk)
{
/* Window doesn't want focus. Leave focus alone */
}
else
{
FOCUS_SET(Scr.NoFocusWin, NULL);
set_focus_window(NULL);
}
XFlush(dpy);
return;
}
