e16
/
e16
3
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
e16/src/ewins.c

2692 lines
59 KiB
C
Raw Blame History

/*
* Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
* Copyright (C) 2004-2014 Kim Woelders
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of the Software, its documentation and marketing & publicity
* materials, and acknowledgment shall be given in the documentation, materials
* and software packages that this Software was used.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "E.h"
#include "aclass.h"
#include "borders.h"
#include "cursors.h"
#include "desktops.h"
#include "ecompmgr.h"
#include "emodule.h"
#include "eobj.h"
#include "events.h"
#include "ewins.h"
#include "focus.h"
#include "grabs.h"
#include "groups.h"
#include "hints.h"
#include "screen.h"
#include "slide.h"
#include "snaps.h"
#include "windowmatch.h"
#include "xwin.h"
#include <X11/Xutil.h>
#include <X11/extensions/shape.h>
#define EWIN_TOP_EVENT_MASK \
(EnterWindowMask | LeaveWindowMask)
#define EWIN_CONTAINER_EVENT_MASK \
(SubstructureNotifyMask | SubstructureRedirectMask)
#define EWIN_CLIENT_EVENT_MASK \
(FocusChangeMask | ResizeRedirectMask | \
PropertyChangeMask | ColormapChangeMask | VisibilityChangeMask)
static void EwinChangesStart(EWin * ewin);
static void EwinChangesProcess(EWin * ewin);
static void EwinHandleEventsToplevel(Win win, XEvent * ev, void *prm);
#if USE_CONTAINER_WIN
static void EwinHandleEventsContainer(Win win, XEvent * ev, void *prm);
#endif
static void EwinHandleEventsClient(Win win, XEvent * ev, void *prm);
static void EwinUnmap1(EWin * ewin);
static void EwinUnmap2(EWin * ewin);
EX_Window
EwinGetClientXwin(const EWin * ewin)
{
Win win = EwinGetClientWin(ewin);
return (win) ? WinGetXwin(win) : NoXID;
}
static EWin *
EwinCreate(int type)
{
EWin *ewin;
ewin = ECALLOC(EWin, 1);
ewin->type = type;
ewin->state.state = (Mode.wm.startup) ? EWIN_STATE_STARTUP : EWIN_STATE_NEW;
ewin->o.stacked = -1; /* Not placed on desk yet */
EoSetDesk(ewin, DesksGetCurrent());
EoSetLayer(ewin, 4);
EoSetFade(ewin, 1);
EoSetShadow(ewin, 1);
ewin->update.shape = 1;
ewin->update.border = 1;
ewin->save_max.x = ewin->save_max.y = ewin->save_max.w = ewin->save_max.h =
-1;
ewin->save_fs.x = ewin->save_fs.y = ewin->save_fs.w = ewin->save_fs.h = -1;
ewin->save_fs.layer = -1;
ewin->icccm.need_input = 1;
ewin->icccm.width_min = 0;
ewin->icccm.height_min = 0;
ewin->icccm.width_max = 65535;
ewin->icccm.height_max = 65535;
ewin->icccm.base_w = 0;
ewin->icccm.base_h = 0;
ewin->icccm.w_inc = 1;
ewin->icccm.h_inc = 1;
ewin->icccm.aspect_min = 0.f;
ewin->icccm.aspect_max = 65535.f;
ewin->icccm.grav = NorthWestGravity;
ewin->area_x = -1;
ewin->area_y = -1;
ewin->place.gravity = -1;
return ewin;
}
static int
EwinGetAttributes(EWin * ewin, Win win, EX_Window xwin,
XWindowAttributes * pxwa)
{
XWindowAttributes xwa;
if (!win)
{
win = ERegisterWindow(xwin, pxwa);
if (!win)
return -1;
}
EGetWindowAttributes(win, &xwa);
ewin->client.win = win;
ewin->client.x = ewin->save_max.x = ewin->save_fs.x = xwa.x;
ewin->client.y = ewin->save_max.y = ewin->save_fs.y = xwa.y;
ewin->client.w = ewin->save_max.w = ewin->save_fs.w = xwa.width;
ewin->client.h = ewin->save_max.h = ewin->save_fs.h = xwa.height;
ewin->client.bw = xwa.border_width;
if (EDebug(EDBUG_TYPE_SNAPS))
Eprintf("Snap get attr %#x: %4d+%4d %4dx%4d: %s\n",
EwinGetClientXwin(ewin), ewin->client.x, ewin->client.y,
ewin->client.w, ewin->client.h, EwinGetTitle(ewin));
return 0;
}
static void
EwinGetHints(EWin * ewin)
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x\n", __func__, EwinGetClientXwin(ewin));
ICCCM_GetTitle(ewin);
ICCCM_GetHints(ewin);
ICCCM_GetGeoms(ewin);
MWM_GetHints(ewin, 0);
ICCCM_GetInfo(ewin); /* NB! Need group info first */
HintsGetWindowHints(ewin);
SessionGetInfo(ewin);
}
static void
EwinHintsInferProps(EWin * ewin)
{
if (ewin->ewmh.type.b.desktop)
{
EoSetLayer(ewin, 0);
if (!ewin->state.identified)
EoSetSticky(ewin, 1);
ewin->props.focusclick = 1;
ewin->props.skip_focuslist = 1;
EwinInhSetUser(ewin, move, 1);
EwinInhSetUser(ewin, size, 1);
ewin->props.donthide = 1;
ewin->props.no_border = 1;
}
if (ewin->ewmh.type.b.dock)
{
ewin->props.skip_ext_task = 1;
ewin->props.skip_winlist = 1;
ewin->props.skip_focuslist = 1;
if (!ewin->state.identified)
EoSetSticky(ewin, 1);
ewin->props.donthide = 1;
}
if (ewin->ewmh.type.b.utility)
{
/* Epplets hit this */
ewin->props.skip_ext_task = 1;
ewin->props.skip_winlist = 1;
ewin->props.skip_focuslist = 1;
ewin->props.never_use_area = 1;
ewin->props.donthide = 1;
}
}
static void
EwinManage(EWin * ewin)
{
XSetWindowAttributes att;
Win frame;
int type;
/* There seems to be a shape related problem when window dimensions
* are >= 32768. Also, it looks like it is not possible(?) to create
* pixmaps with dimensions >= 32768.
* So, limit to 32000 leaving room for borders. */
if (ewin->client.w <= 0)
ewin->client.w = 100;
else if (ewin->client.w > 32000)
ewin->client.w = 32000;
if (ewin->client.h <= 0)
ewin->client.h = 100;
else if (ewin->client.h > 32000)
ewin->client.h = 32000;
if (ewin->state.docked)
ewin->inh_wm.b.border = 1;
ewin->serial = NextRequest(disp);
frame = EoGetWin(ewin);
if (!frame)
{
type = (ewin->props.no_argb) ? WIN_TYPE_NO_ARGB : WIN_TYPE_CLIENT;
frame =
ECreateObjectWindow(VROOT, ewin->client.x, ewin->client.y,
ewin->client.w, ewin->client.h, 0, type,
EwinGetClientWin(ewin));
EoInit(ewin, EOBJ_TYPE_EWIN, frame, ewin->client.x, ewin->client.y,
ewin->client.w, ewin->client.h, 1, NULL);
EventCallbackRegister(EoGetWin(ewin), EwinHandleEventsToplevel, ewin);
#if USE_CONTAINER_WIN
ewin->win_container =
ECreateWindow(frame, 0, 0, ewin->client.w, ewin->client.h, 0);
EventCallbackRegister(ewin->win_container, EwinHandleEventsContainer,
ewin);
#endif
EventCallbackRegister(EwinGetClientWin(ewin), EwinHandleEventsClient,
ewin);
EobjListFocusAdd(&ewin->o, 1);
EobjListOrderAdd(&ewin->o);
}
#if USE_CONTAINER_WIN
att.event_mask = EWIN_CONTAINER_EVENT_MASK;
att.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask;
EChangeWindowAttributes(ewin->win_container,
CWEventMask | CWDontPropagate, &att);
EMapWindow(ewin->win_container);
#endif
#if USE_CONTAINER_WIN
att.event_mask = EWIN_TOP_EVENT_MASK;
#else
att.event_mask = EWIN_TOP_EVENT_MASK | EWIN_CONTAINER_EVENT_MASK;
#endif
att.do_not_propagate_mask =
KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask;
#if USE_XI2
EChangeWindowAttributes(EoGetWin(ewin), CWDontPropagate, &att);
ESelectInput(EoGetWin(ewin), att.event_mask);
#else
EChangeWindowAttributes(EoGetWin(ewin), CWEventMask | CWDontPropagate, &att);
#endif
ewin->client.event_mask = EWIN_CLIENT_EVENT_MASK;
ESelectInput(EwinGetClientWin(ewin), ewin->client.event_mask);
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x frame=%#x cont=%#x st=%d\n", __func__,
EwinGetClientXwin(ewin), EoGetXwin(ewin),
EwinGetContainerXwin(ewin), ewin->state.state);
if (!EwinIsInternal(ewin))
{
XShapeSelectInput(disp, EwinGetClientXwin(ewin), ShapeNotifyMask);
ESetWindowBorderWidth(EwinGetClientWin(ewin), 0);
ewin->client.bw = 0;
}
ICCCM_AdoptStart(ewin);
#if USE_CONTAINER_WIN
/* We must reparent after getting original window position */
EReparentWindow(EwinGetClientWin(ewin), ewin->win_container, 0, 0);
#else
EReparentWindow(EwinGetClientWin(ewin), frame, 0, 0);
#endif
/* Something (e.g. a match) may have changed the window size */
EResizeWindow(EwinGetClientWin(ewin), ewin->client.w, ewin->client.h);
EwinUpdateShapeInfo(ewin);
ModulesSignal(ESIGNAL_EWIN_CREATE, ewin);
}
/*
* Derive frame window geometry from client window properties
*/
static void
EwinSetGeometry(EWin * ewin)
{
int x, y, l, r, t, b;
int grav;
grav = (ewin->state.identified) ? StaticGravity : ewin->icccm.grav;
EwinGetPosition(ewin, ewin->client.x, ewin->client.y, grav, &x, &y);
l = ewin->border->border.left;
r = ewin->border->border.right;
t = ewin->border->border.top;
b = ewin->border->border.bottom;
ewin->client.x = x + l;
ewin->client.y = y + t;
EoMoveResize(ewin, x, y, ewin->client.w + l + r, ewin->client.h + t + b);
}
static void
EwinConfigure(EWin * ewin)
{
EwinStateUpdate(ewin);
if (!EwinIsInternal(ewin) && Mode.wm.startup)
EHintsGetInfo(ewin); /* E restart hints */
EwinHintsInferProps(ewin);
SnapshotEwinApply(ewin); /* Apply saved settings */
if (ewin->save_fs.layer < 0)
ewin->save_fs.layer = EoGetLayer(ewin);
EwinStateUpdate(ewin); /* Update after snaps etc. */
ICCCM_Adopt(ewin);
EwinBorderSelect(ewin); /* Select border before calculating geometry */
EwinSetGeometry(ewin); /* Calculate window geometry before border parts */
EwinBorderSetTo(ewin, NULL);
if (!ewin->props.no_button_grabs)
GrabButtonGrabs(EoGetWin(ewin));
if (ewin->state.shaded)
EwinInstantShade(ewin, 1);
EwinUpdateOpacity(ewin);
if ((ewin->border) && (!strcmp(ewin->border->name, "BORDERLESS")) &&
EoGetWin(ewin)->argb)
EoSetShadow(ewin, 0);
HintsSetWindowState(ewin);
HintsSetWindowOpacity(ewin);
HintsSetClientList();
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
}
static void
EwinCleanup(EWin * ewin)
{
EwinBorderDetach(ewin);
}
static void
EwinDestroy(EWin * ewin)
{
EWin **lst;
int i, num;
if (!ewin)
return;
EwinUnmap1(ewin);
if (EoIsMapped(ewin))
{
EoUnmap(ewin);
EwinUnmap2(ewin);
}
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
EventCallbackUnregister(EoGetWin(ewin), EwinHandleEventsToplevel, ewin);
#if USE_CONTAINER_WIN
EventCallbackUnregister(ewin->win_container, EwinHandleEventsContainer,
ewin);
#endif
EventCallbackUnregister(EwinGetClientWin(ewin), EwinHandleEventsClient,
ewin);
if (!EwinIsInternal(ewin))
EUnregisterWindow(EwinGetClientWin(ewin));
SnapshotEwinUnmatch(ewin);
ModulesSignal(ESIGNAL_EWIN_DESTROY, ewin);
lst = EwinListTransientFor(ewin, &num);
for (i = 0; i < num; i++)
{
lst[i]->icccm.transient_count--;
if (lst[i]->icccm.transient_count < 0) /* Paranoia? */
lst[i]->icccm.transient_count = 0;
}
Efree(lst);
EwinCleanup(ewin);
EobjListOrderDel(&ewin->o);
EobjListFocusDel(&ewin->o);
EoFini(ewin);
HintsSetClientList();
Efree(ewin->icccm.wm_icon_name);
Efree(ewin->icccm.wm_role);
Efree(ewin->icccm.wm_command);
Efree(ewin->icccm.wm_machine);
Efree(ewin->ewmh.wm_name);
Efree(ewin->ewmh.wm_icon_name);
Efree(ewin->ewmh.wm_icon);
Efree(ewin->bits);
Efree(ewin->session_id);
PmapMaskFree(&ewin->mini_pmm);
GroupsEwinRemove(ewin);
Efree(ewin);
}
void
DetermineEwinFloat(EWin * ewin, int dx, int dy)
{
char dofloat = 0;
int x, y, w, h, xd, yd;
Desk *dsk;
dsk = EoGetDesk(ewin);
x = EoGetX(ewin);
y = EoGetY(ewin);
w = EoGetW(ewin);
h = EoGetH(ewin);
xd = EoGetX(dsk);
yd = EoGetY(dsk);
if ((dsk->num != 0) && (EoIsFloating(ewin) < 2) &&
((xd != 0) || (yd != 0) || (DesksGetCurrent() != dsk)))
{
switch (Conf.desks.dragdir)
{
case 0:
if (((x + dx < 0) ||
((x + dx + w <= WinGetW(VROOT)) &&
(DesktopAt(xd + x + dx + w - 1, yd) != dsk))))
dofloat = 1;
break;
case 1:
if (((x + dx + w > WinGetW(VROOT)) ||
((x + dx >= 0) && (DesktopAt(xd + x + dx, yd) != dsk))))
dofloat = 1;
break;
case 2:
if (((y + dy < 0) ||
((y + dy + h <= WinGetH(VROOT)) &&
(DesktopAt(xd, yd + y + dy + h - 1) != dsk))))
dofloat = 1;
break;
case 3:
if (((y + dy + h > WinGetH(VROOT)) ||
((y + dy >= 0) && (DesktopAt(xd, yd + y + dy) != dsk))))
dofloat = 1;
break;
}
if (dofloat)
EwinOpFloatAt(ewin, OPSRC_USER, x + xd, y + yd);
}
}
EWin *
GetEwinPointerInClient(void)
{
int px, py;
EWin *const *lst, *ewin;
int i, num;
Desk *dsk;
dsk = DesktopAt(Mode.events.cx, Mode.events.cy);
EQueryPointer(EoGetWin(dsk), &px, &py, NULL, NULL);
lst = EwinListGetForDesk(&num, dsk);
for (i = 0; i < num; i++)
{
int x, y, w, h;
ewin = lst[i];
x = EoGetX(ewin);
y = EoGetY(ewin);
w = EoGetW(ewin);
h = EoGetH(ewin);
if ((px >= x) && (py >= y) && (px < (x + w)) && (py < (y + h)) &&
EoIsMapped(ewin))
return ewin;
}
return NULL;
}
EWin *
GetFocusEwin(void)
{
return Mode.focuswin;
}
EWin *
GetContextEwin(void)
{
EWin *ewin;
ewin = Mode.context_ewin;
if (ewin)
goto done;
ewin = NULL;
done:
#if 0
Eprintf("%s %#x %s\n", __func__, EwinGetClientXwin(ewin),
EwinGetTitle(ewin));
#endif
return ewin;
}
void
SetContextEwin(EWin * ewin)
{
if (ewin && ewin->type == EWIN_TYPE_MENU)
return;
#if 0
Eprintf("%s %#x %s\n", __func__, EwinGetClientXwin(ewin),
EwinGetTitle(ewin));
#endif
Mode.context_ewin = ewin;
}
/*
* Derive frame window position from client window and border properties
*/
void
EwinGetPosition(const EWin * ewin, int x, int y, int grav, int *px, int *py)
{
int bw, bd_lr, bd_tb;
bw = ewin->client.bw;
bd_lr = ewin->border->border.left + ewin->border->border.right;
bd_tb = ewin->border->border.top + ewin->border->border.bottom;
if (grav == 0)
grav = ewin->icccm.grav;
switch (grav)
{
case NorthWestGravity:
case WestGravity:
case SouthWestGravity:
x -= bw;
break;
case NorthGravity:
case CenterGravity:
case SouthGravity:
x -= bd_lr / 2;
break;
case NorthEastGravity:
case EastGravity:
case SouthEastGravity:
x -= bd_lr - bw;
break;
case StaticGravity:
x -= ewin->border->border.left;
break;
default:
break;
}
switch (grav)
{
case NorthWestGravity:
case NorthGravity:
case NorthEastGravity:
y -= bw;
break;
case WestGravity:
case CenterGravity:
case EastGravity:
y -= bd_tb / 2;
break;
case SouthWestGravity:
case SouthGravity:
case SouthEastGravity:
y -= bd_tb - bw;
break;
case StaticGravity:
y -= ewin->border->border.top;
break;
default:
break;
}
*px = x;
*py = y;
}
/*
* Keep resizing on-screen window on-screen
*/
static void
EwinKeepOnScreen(const EWin * ewin, int wn, int hn, int *px, int *py)
{
int x = *px, y = *py, w, h;
int sx, sy, sw, sh, xy;
w = EoGetW(ewin);
h = EoGetH(ewin);
ScreenGetAvailableArea(x, y, &sx, &sy, &sw, &sh, Conf.place.ignore_struts);
/* Quit if not on-screen to begin with */
if (x < sx || x + w > sx + sw || y < sy || y + h > sy + sh)
return;
/* Attempt to keep on-screen */
xy = sx + sw - (w - ewin->client.w + wn);
if (x > xy)
x = xy;
if (x < sx)
x = sx;
xy = sy + sh - (h - ewin->client.h + hn);
if (y > xy)
y = xy;
if (y < sy)
y = sy;
*px = x;
*py = y;
}
void
EwinUpdateShapeInfo(EWin * ewin)
{
ewin->state.shaped =
#if USE_CONTAINER_WIN
EShapeSetShape(ewin->win_container, 0, 0, EwinGetClientWin(ewin));
#else
EShapeUpdate(EwinGetClientWin(ewin));
#endif
if (EDebug(EX_EVENT_SHAPE_NOTIFY))
Eprintf("%s %#x cont=%#x shaped=%d\n", __func__,
EwinGetClientXwin(ewin), EwinGetContainerXwin(ewin),
ewin->state.shaped);
}
void
EwinPropagateShapes(EWin * ewin)
{
if (!EoIsShown(ewin))
return;
if (ewin->state.docked)
return;
if (!ewin->update.shape)
return;
if (EDebug(EX_EVENT_SHAPE_NOTIFY))
Eprintf("%s %#x frame=%#x shaped=%d\n", __func__,
EwinGetClientXwin(ewin), EoGetXwin(ewin), ewin->state.shaped);
EoShapeUpdate(ewin, 1);
ewin->update.shape = 0;
}
void
EwinStateUpdate(EWin * ewin)
{
int fs_zo;
fs_zo = ewin->state.fullscreen || ewin->state.zoomed;
ewin->state.inhibit_actions = ewin->props.no_actions;
ewin->state.inhibit_focus =
!(ewin->icccm.need_input || ewin->icccm.take_focus) ||
EwinInhGetWM(ewin, focus) || ewin->state.iconified;
ewin->state.inhibit_move = EwinInhGetUser(ewin, move) || fs_zo;
ewin->state.inhibit_resize = ewin->state.iconified || ewin->state.shaded ||
(ewin->props.no_resize_h && ewin->props.no_resize_v) ||
EwinInhGetUser(ewin, size) || fs_zo;
ewin->state.inhibit_iconify = EwinInhGetWM(ewin, iconify);
ewin->state.inhibit_shade = ewin->state.no_border ||
ewin->state.iconified || fs_zo;
ewin->state.inhibit_stick = 0;
ewin->state.inhibit_max_hor = ewin->state.inhibit_resize ||
ewin->props.no_resize_h || fs_zo;
ewin->state.inhibit_max_ver = ewin->state.inhibit_resize ||
ewin->props.no_resize_v || fs_zo;
ewin->state.inhibit_fullscreeen =
ewin->state.inhibit_move || ewin->state.inhibit_resize;
ewin->state.inhibit_change_desk = ewin->state.iconified;
ewin->state.inhibit_close = EwinInhGetApp(ewin, close) ||
EwinInhGetUser(ewin, close);
ewin->state.donthide = ewin->props.donthide ||
ewin->props.skip_ext_task || ewin->props.skip_winlist ||
ewin->props.skip_focuslist;
SnapshotEwinUpdate(ewin, SNAP_USE_FLAGS);
}
static void
AddToFamily(EWin * ewin, EX_Window xwin, XWindowAttributes * pxwa, int startup)
{
XWindowAttributes attr;
EWin *ewin2;
EWin **lst;
int i, k, num, fx, fy, x, y;
char doslide, manplace;
Desk *dsk;
EGrabServer();
if (!pxwa)
{
pxwa = &attr;
if (!EXGetWindowAttributes(xwin, &attr))
goto done;
}
#ifndef __cplusplus
#define c_class class
#endif
if (pxwa->c_class != InputOutput)
goto done;
if (ewin)
EwinCleanup(ewin);
else
ewin = EwinCreate(EWIN_TYPE_NORMAL);
if (!ewin)
goto done;
if (EwinGetAttributes(ewin, NULL, xwin, pxwa))
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("Window is gone %#x\n", xwin);
/* We got here by MapRequest. DestroyNotify should follow. */
goto done;
}
EwinGetHints(ewin);
WindowMatchEwinOps(ewin); /* Window matches */
EwinManage(ewin);
EwinConfigure(ewin);
if (startup)
ewin->state.placed = 1;
/* if it hasn't been planted on a desktop - assign it the current desktop */
dsk = EoGetDesk(ewin);
/* if is an afterstep/windowmaker dock app - dock it */
if (Conf.dock.enable && ewin->state.docked)
DockIt(ewin);
ewin2 = NULL;
if (ewin->icccm.transient)
{
if (ewin->icccm.transient_for == NoXID ||
ewin->icccm.transient_for == WinGetXwin(VROOT))
{
/* Group transient */
ewin->icccm.transient_for = WinGetXwin(VROOT);
#if 0 /* Maybe? */
ewin->layer++;
#endif
/* Don't treat this as a normal transient */
ewin->icccm.transient = -1;
}
else if (ewin->icccm.transient_for == EwinGetClientXwin(ewin))
{
/* Some apps actually do this. Why? */
ewin->icccm.transient = 0;
}
else
{
/* Regular transient */
}
if (ewin->icccm.transient)
{
/* Tag the parent window if this is a transient */
lst = EwinListTransientFor(ewin, &num);
for (i = 0; i < num; i++)
{
lst[i]->icccm.transient_count++;
if (EoGetLayer(ewin) < EoGetLayer(lst[i]))
EoSetLayer(ewin, EoGetLayer(lst[i]));
}
if (lst)
{
ewin2 = lst[0];
EoSetSticky(ewin, EoIsSticky(lst[0]));
Efree(lst);
}
else
{
/* No parents? - not a transient */
ewin->icccm.transient = 0;
}
}
}
x = EoGetX(ewin);
y = EoGetY(ewin);
doslide = manplace = 0;
if (Mode.place.enable_features > 0 && !ewin->state.snapstarted)
{
/* if set for borderless then dont slide it in */
if (Conf.place.slidein &&
!ewin->state.no_border && dsk == DesksGetCurrent())
doslide = 1;
if (Conf.place.manual && !Mode.place.doing_manual &&
!ewin->state.placed && !ewin->icccm.transient)
manplace = 1;
}
if (ewin->icccm.transient && Conf.focus.transientsfollowleader)
{
EWin *const *lst2;
if (!ewin2)
ewin2 = EwinFindByClient(ewin->icccm.group);
if (!ewin2)
{
lst2 = EwinListGetAll(&num);
for (i = 0; i < num; i++)
{
if ((lst2[i]->state.iconified) ||
(ewin->icccm.group != lst2[i]->icccm.group))
continue;
ewin2 = lst2[i];
break;
}
}
if (ewin2)
{
dsk = EoGetDesk(ewin2);
if (!Mode.wm.startup && Conf.focus.switchfortransientmap &&
!ewin->state.iconified)
DeskGotoByEwin(ewin2);
}
}
if (ewin->state.fullscreen)
{
EwinOpFullscreen(ewin, OPSRC_WM, 2);
ewin->state.placed = 1;
doslide = manplace = 0;
x = EoGetX(ewin);
y = EoGetY(ewin);
}
else if (!ewin->state.identified &&
(ewin->state.maximized_horz || ewin->state.maximized_vert))
{
int hor, ver;
/* New client requested maximisation */
hor = ewin->state.maximized_horz;
ver = ewin->state.maximized_vert;
ewin->state.maximized_horz = ewin->state.maximized_vert = 0;
MaxSizeHV(ewin, "absolute", hor, ver);
/* Set old state to current maximized one */
ewin->save_max.x = EoGetX(ewin);
ewin->save_max.y = EoGetY(ewin);
ewin->save_max.w = ewin->client.w;
ewin->save_max.h = ewin->client.h;
ewin->state.placed = 0;
}
else
{
EwinResize(ewin, ewin->client.w, ewin->client.h, 0);
}
/* if the window asked to be iconified at the start */
if (ewin->icccm.start_iconified)
{
EwinMoveToDesktopAt(ewin, dsk, x, y);
ewin->state.state = EWIN_STATE_MAPPED;
EwinIconify(ewin);
ewin->state.state = EWIN_STATE_ICONIC;
goto done;
}
if (manplace && GrabPointerSet(VROOT, ECSR_GRAB, 0) != GrabSuccess)
manplace = 0;
/* if it hasn't been placed yet.... find a spot for it */
if ((!ewin->state.placed) && (!manplace))
{
int cx, cy, sx, sy, sw, sh;
/* Place the window below the mouse pointer */
if (Conf.place.manual_mouse_pointer)
{
/* if the loser has manual placement on and the app asks to be on */
/* a desktop, then send E to that desktop so the user can place */
/* the window there */
DeskGoto(dsk);
EventsUpdateXY(&cx, &cy);
ScreenGetAvailableArea(cx, cy, &sx, &sy, &sw, &sh,
Conf.place.ignore_struts);
/* try to center the window on the mouse pointer */
x = cx - EoGetW(ewin) / 2;
y = cy - EoGetH(ewin) / 2;
/* keep it all on this screen if possible */
x = MIN(x, sx + sw - EoGetW(ewin));
y = MIN(y, sy + sh - EoGetH(ewin));
x = MAX(x, sx);
y = MAX(y, sy);
}
else if (ewin->ewmh.type.b.dialog)
{
/* Center unplaced dialogs on parent(if transient) or root */
Win parent;
ewin2 = NULL;
if (EwinGetTransientFor(ewin) != NoXID)
ewin2 = EwinFindByClient(EwinGetTransientFor(ewin));
parent = (ewin2) ? EoGetWin(ewin2) : VROOT;
cx = WinGetX(parent);
cy = WinGetY(parent);
x = cx + (WinGetW(parent) - EoGetW(ewin)) / 2;
y = cy + (WinGetH(parent) - EoGetH(ewin)) / 2;
ScreenGetAvailableArea(cx, cy, &sx, &sy, &sw, &sh,
Conf.place.ignore_struts);
/* keep it all on this screen if possible */
x = MIN(x, sx + sw - EoGetW(ewin));
y = MIN(y, sy + sh - EoGetH(ewin));
x = MAX(x, sx);
y = MAX(y, sy);
}
else
{
ArrangeEwinXY(ewin, &x, &y);
}
ewin->state.placed = 1;
}
/* if we should slide it in and are not currently in the middle of a slide */
if ((manplace) && (!ewin->state.placed))
{
int cx, cy;
/* if the loser has manual placement on and the app asks to be on */
/* a desktop, then send E to that desktop so the user can place */
/* the window there */
DeskGoto(dsk);
EventsUpdateXY(&cx, &cy);
ewin->state.placed = 1;
x = cx - 8;
y = cy - 8;
GrabPointerSet(VROOT, ECSR_GRAB, 0);
EoSetFloating(ewin, 1); /* Causes reparenting to root */
EwinOpFloatAt(ewin, OPSRC_USER, x, y);
EwinShow(ewin);
Mode.place.doing_manual = 1;
MoveResizeMoveStart(ewin, 0, 0, 0);
goto done;
}
else if (doslide)
{
k = rand() % 4;
if (k == 0)
{
fx = (rand() % (WinGetW(VROOT))) - EoGetW(ewin);
fy = -EoGetH(ewin);
}
else if (k == 1)
{
fx = (rand() % (WinGetW(VROOT)));
fy = WinGetH(VROOT);
}
else if (k == 2)
{
fx = -EoGetW(ewin);
fy = (rand() % (WinGetH(VROOT)));
}
else
{
fx = WinGetW(VROOT);
fy = (rand() % (WinGetH(VROOT))) - EoGetH(ewin);
}
EwinMoveToDesktopAt(ewin, dsk, fx, fy);
EwinShow(ewin);
ewin->req_x = x;
ewin->req_y = y;
EwinSlideTo(ewin, EoGetX(ewin), EoGetY(ewin), ewin->req_x, ewin->req_y,
Conf.place.slidespeedmap, Conf.place.slidemode,
SLIDE_FOCUS | SLIDE_WARP | SLIDE_SOUND);
}
else
{
EwinMoveToDesktopAt(ewin, dsk, x, y);
EwinShow(ewin);
}
done:
EUngrabServer();
}
EWin *
AddInternalToFamily(Win win, const char *bname, int type,
const EWinOps * ops, void *ptr)
{
EWin *ewin;
EGrabServer();
ewin = EwinCreate(type);
if (!ewin)
goto done;
ewin->props.donthide = 1;
EwinGetAttributes(ewin, win, NoXID, NULL);
WindowMatchEwinOps(ewin); /* Window matches */
EwinManage(ewin);
ewin->data = ptr;
ewin->ops = ops;
if (ops && ops->Init)
ops->Init(ewin); /* Type specific initialisation */
if (bname)
ewin->border = BorderFind(bname);
EwinConfigure(ewin);
#if 0
Eprintf("Desk=%d, layer=%d, sticky=%d, floating=%d\n",
EoGetDeskNum(ewin), EoGetLayer(ewin), EoIsSticky(ewin),
EoIsFloating(ewin));
#endif
done:
EUngrabServer();
return ewin;
}
static void
EwinUnmap1(EWin * ewin)
{
/* The client may have been unmapped but the frame is not yet */
Zoom(ewin, 0);
MoveResizeEnd(ewin);
DrawEwinShapeEnd(ewin);
}
static void
EwinUnmap2(EWin * ewin)
{
/* The frame has been unmapped */
FocusToEWin(ewin, FOCUS_EWIN_UNMAP);
if (ewin == Mode.mouse_over_ewin)
Mode.mouse_over_ewin = NULL;
if (ewin == Mode.context_ewin)
Mode.context_ewin = NULL;
ModulesSignal(ESIGNAL_EWIN_UNMAP, ewin);
}
static void
EwinWithdraw(EWin * ewin, Win to)
{
int x, y;
/* Only external clients should go here */
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
EGrabServer();
ESelectInput(EwinGetClientWin(ewin), NoEventMask);
XShapeSelectInput(disp, EwinGetClientXwin(ewin), NoEventMask);
if (EXWindowGetParent(EwinGetClientXwin(ewin)) == EwinGetContainerXwin(ewin))
{
/* Park the client window on the new root */
x = ewin->client.x;
y = ewin->client.y;
ETranslateCoordinates(EwinGetClientWin(ewin), VROOT,
-ewin->border->border.left,
-ewin->border->border.top, &x, &y, NULL);
EReparentWindow(EwinGetClientWin(ewin), to, x, y);
HintsDelWindowHints(ewin);
}
ICCCM_Withdraw(ewin);
ESync(0);
EUngrabServer();
}
static void
EwinEventMapRequest(EWin * ewin, XEvent * ev)
{
EX_Window xwin;
xwin = ev->xmaprequest.window;
if (ewin)
{
if (ewin->state.state == EWIN_STATE_ICONIC)
EwinDeIconify(ewin);
else if (ewin->state.state == EWIN_STATE_WITHDRAWN)
AddToFamily(ewin, xwin, NULL, 0);
else
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s: Already managing %s %#x\n", __func__, "A",
EwinGetClientXwin(ewin));
EReparentWindow(EwinGetClientWin(ewin), EwinGetContainerWin(ewin),
0, 0);
}
}
else
{
/* Check if we are already managing it */
ewin = EwinFindByClient(xwin);
/* Some clients MapRequest more than once ?!? */
if (ewin)
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s: Already managing %s %#x\n", __func__, "B",
EwinGetClientXwin(ewin));
EReparentWindow(EwinGetClientWin(ewin), EwinGetContainerWin(ewin),
0, 0);
EwinShow(ewin);
}
else
AddToFamily(NULL, xwin, NULL, 0);
}
}
static void
EwinEventDestroy(EWin * ewin)
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
EwinDestroy(ewin);
}
static void
EwinEventReparent(EWin * ewin, XEvent * ev)
{
EX_Window parent;
EGrabServer();
parent = EoIsGone(ewin) ? NoXID : ev->xreparent.parent;
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d parent=%#x: %s\n", __func__,
EwinGetClientXwin(ewin), ewin->state.state, parent,
EwinGetTitle(ewin));
if (parent != EwinGetContainerXwin(ewin))
EwinDestroy(ewin);
EUngrabServer();
}
static void
EwinEventMap(EWin * ewin, XEvent * ev)
{
int old_state;
/* Catch clients setting OR without proper withdrawal (just unmap/map) */
if (ev->xmap.override_redirect)
return;
old_state = ewin->state.state;
ewin->state.state = EWIN_STATE_MAPPED;
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
/* If first time we may want to focus it (unless during startup) */
if (old_state == EWIN_STATE_NEW)
FocusToEWin(ewin, FOCUS_EWIN_NEW);
else
FocusToEWin(ewin, FOCUS_SET);
ModulesSignal(ESIGNAL_EWIN_CHANGE, ewin);
}
static void
EwinEventUnmap(EWin * ewin, XEvent * ev)
{
if (EDebug(EDBUG_TYPE_EWINS))
Eprintf("%s %#x st=%d: %s\n", __func__, EwinGetClientXwin(ewin),
ewin->state.state, EwinGetTitle(ewin));
if (ewin->state.state == EWIN_STATE_STARTUP ||
ewin->state.state == EWIN_STATE_NEW)
{
#if 0
/* We get here after reparenting to container and occasionally in
* other(?) situations */
Eprintf("%s %#x: Ignoring bogus Unmap event\n", __func__,
EwinGetClientXwin(ewin));
#endif
return;
}
/* Ignore synthetic events */
if (ev->xany.send_event)
return;
if (ewin->state.state == EWIN_STATE_WITHDRAWN)
return;
if (ewin->state.iconified)
ewin->state.state = EWIN_STATE_ICONIC;
else
ewin->state.state = EWIN_STATE_WITHDRAWN;
EwinUnmap1(ewin);
EWindowSetMapped(EwinGetClientWin(ewin), 0);
EoUnmap(ewin);
EwinUnmap2(ewin);
if (ewin->state.state == EWIN_STATE_ICONIC)
return;
if (EwinIsInternal(ewin))
{
#if 1 /* FIXME - Remove? */
/* We should never get here */
Eprintf("FIXME: This cannot happen (%s)\n", EoGetName(ewin));
#endif
return;
}
if (EoIsGone(ewin))
return;
EwinWithdraw(ewin, VROOT);
}
static void
EwinEventConfigureRequest(EWin * ewin, XEvent * ev)
{
EX_Window winrel;
EWin *ewin2;
int x = 0, y = 0, w = 0, h = 0;
XWindowChanges xwc;
if (ewin)
{
x = EoGetX(ewin);
y = EoGetY(ewin);
w = ewin->client.w;
h = ewin->client.h;
winrel = 0;
/* This is shady - some clients send root coords, some use the
* ICCCM ones sent by us */
if (!EwinInhGetApp(ewin, move))
{
#if 0 /* FIXME - ??? */
if (ev->xconfigurerequest.value_mask & CWX)
x = ev->xconfigurerequest.x;
if (ev->xconfigurerequest.value_mask & CWY)
y = ev->xconfigurerequest.y;
#else
if (ev->xconfigurerequest.value_mask & CWX)
x = ev->xconfigurerequest.x -
(Mode.wm.win_x + EoGetX(EoGetDesk(ewin)));
if (ev->xconfigurerequest.value_mask & CWY)
y = ev->xconfigurerequest.y -
(Mode.wm.win_y + EoGetY(EoGetDesk(ewin)));
#endif
}
if (!EwinInhGetApp(ewin, size))
{
if (ev->xconfigurerequest.value_mask & CWWidth)
w = ev->xconfigurerequest.width;
if (ev->xconfigurerequest.value_mask & CWHeight)
h = ev->xconfigurerequest.height;
}
if (ev->xconfigurerequest.value_mask & CWSibling)
winrel = ev->xconfigurerequest.above;
if (ev->xconfigurerequest.value_mask & CWStackMode)
{
ewin2 = EwinFindByClient(winrel);
if (ewin2)
winrel = EoGetXwin(ewin2);
xwc.sibling = winrel;
xwc.stack_mode = ev->xconfigurerequest.detail;
if (Mode.mode == MODE_NONE)
{
if (xwc.stack_mode == Above)
EwinRaise(ewin);
else if (xwc.stack_mode == Below)
EwinLower(ewin);
}
}
if (ev->xconfigurerequest.value_mask & (CWX | CWY))
{
/* Correct position taking gravity into account */
EwinGetPosition(ewin, x, y, 0, &x, &y);
}
else if (ev->xconfigurerequest.value_mask & (CWWidth | CWHeight))
{
/* Resizing only */
EwinKeepOnScreen(ewin, w, h, &x, &y);
}
EwinMoveResize(ewin, x, y, w, h, MRF_NOCHECK_ONSCREEN);
ReZoom(ewin);
}
else
{
xwc.x = ev->xconfigurerequest.x;
xwc.y = ev->xconfigurerequest.y;
xwc.width = ev->xconfigurerequest.width;
xwc.height = ev->xconfigurerequest.height;
xwc.border_width = ev->xconfigurerequest.border_width;
xwc.sibling = ev->xconfigurerequest.above;
xwc.stack_mode = ev->xconfigurerequest.detail;
XConfigureWindow(disp, ev->xconfigurerequest.window,
ev->xconfigurerequest.value_mask, &xwc);
}
}
static void
EwinEventResizeRequest(EWin * ewin, XEvent * ev)
{
if (ewin)
{
EwinResize(ewin, ev->xresizerequest.width, ev->xresizerequest.height,
0);
ReZoom(ewin);
}
else
{
XResizeWindow(disp, ev->xresizerequest.window,
ev->xresizerequest.width, ev->xresizerequest.height);
}
}
static void
EwinEventCirculateRequest(EWin * ewin, XEvent * ev)
{
if (ewin)
{
if (ev->xcirculaterequest.place == PlaceOnTop)
EwinRaise(ewin);
else
EwinLower(ewin);
}
else
{
if (ev->xcirculaterequest.place == PlaceOnTop)
XRaiseWindow(disp, ev->xcirculaterequest.window);
else
XLowerWindow(disp, ev->xcirculaterequest.window);
}
}
static void
EwinEventPropertyNotify(EWin * ewin, XEvent * ev)
{
if (EwinIsInternal(ewin))
return;
EGrabServer();
EwinChangesStart(ewin);
HintsProcessPropertyChange(ewin, ev);
EwinStateUpdate(ewin);
EwinChangesProcess(ewin);
EUngrabServer();
}
static void
EwinEventShapeChange(EWin * ewin, XEvent * ev)
{
XShapeEvent *se = (XShapeEvent *) ev;
if (EDebug(EX_EVENT_SHAPE_NOTIFY))
Eprintf("%s %#x %s: state.shaped=%d ev->shaped=%d\n", __func__,
EwinGetClientXwin(ewin), EoGetName(ewin), ewin->state.shaped,
se->shaped);
if (!se->shaped && !ewin->state.shaped)
return;
EwinUpdateShapeInfo(ewin);
ewin->update.shape = 1;
EwinPropagateShapes(ewin);
}
static void
EwinEventVisibility(EWin * ewin, int state)
{
ewin->state.visibility = state;
}
void
EwinReparent(EWin * ewin, Win parent)
{
EwinWithdraw(ewin, parent);
}
int
EwinRaise(EWin * ewin)
{
static int call_depth = 0;
EWin **lst;
int i, num, numt;
if (call_depth > 256)
return 0;
call_depth++;
num = EoRaise(ewin);
if (EDebug(EDBUG_TYPE_RAISELOWER))
Eprintf("%s(%d) %#x %s n=%d\n", __func__, call_depth,
EwinGetClientXwin(ewin), EwinGetTitle(ewin), num);
if (num == 0) /* Quit if stacking is unchanged */
goto done;
lst = EwinListTransients(ewin, &numt, 1);
for (i = 0; i < numt; i++)
EwinRaise(lst[i]);
Efree(lst);
if (call_depth == 1)
{
ModulesSignal(ESIGNAL_EWIN_CHANGE, ewin);
ClickGrabsUpdate();
}
done:
call_depth--;
return num;
}
int
EwinLower(EWin * ewin)
{
static int call_depth = 0;
EWin **lst;
int i, num, numt;
if (call_depth > 256)
return 0;
call_depth++;
num = EoLower(ewin);
if (EDebug(EDBUG_TYPE_RAISELOWER))
Eprintf("%s(%d) %#x %s n=%d\n", __func__, call_depth,
EwinGetClientXwin(ewin), EwinGetTitle(ewin), num);
if (num == 0) /* Quit if stacking is unchanged */
goto done;
lst = EwinListTransientFor(ewin, &numt);
for (i = 0; i < numt; i++)
EwinLower(lst[i]);
Efree(lst);
if (call_depth == 1)
{
ModulesSignal(ESIGNAL_EWIN_CHANGE, ewin);
ClickGrabsUpdate();
}
done:
call_depth--;
return num;
}
void
EwinShow(EWin * ewin)
{
if (EoIsShown(ewin))
return;
if (EwinGetClientWin(ewin))
{
EMapWindow(EwinGetClientWin(ewin));
}
if (ewin->update.shape)
{
ewin->o.shown = 1;
EwinPropagateShapes(ewin);
ewin->o.shown = 0;
}
EoMap(ewin, 0);
EwinStateUpdate(ewin);
if (ewin->place.gravity < 0)
EwinSetPlacementGravity(ewin, EoGetX(ewin), EoGetY(ewin));
}
void
EwinHide(EWin * ewin)
{
if (!EwinIsInternal(ewin) && (!EoIsShown(ewin) || !EoIsMapped(ewin)))
return;
EwinUnmap1(ewin);
EUnmapWindow(EwinGetClientWin(ewin));
EoUnmap(ewin);
EwinUnmap2(ewin);
EwinStateUpdate(ewin);
if (!EwinIsInternal(ewin) || ewin->state.iconified)
return;
if (EwinGetClientWin(ewin))
{
ESelectInput(EwinGetClientWin(ewin), NoEventMask);
XShapeSelectInput(disp, EwinGetClientXwin(ewin), NoEventMask);
}
if (ewin->ops && ewin->ops->Close)
ewin->ops->Close(ewin);
EwinDestroy(ewin);
}
void
EwinKill(EWin * ewin)
{
if (EwinIsInternal(ewin))
return;
XKillClient(disp, EwinGetClientXwin(ewin));
#if 0 /* Wait for unmap/destroy for now */
EwinUnmap1(ewin);
EoUnmap(ewin);
EwinUnmap2(ewin);
EwinDestroy(ewin);
#endif
}
void
EwinSetTitle(EWin * ewin, const char *title)
{
HintsSetWindowName(EwinGetClientWin(ewin), title);
_EFDUP(ewin->o.icccm.wm_name, title);
_EFDUP(ewin->ewmh.wm_name, title);
}
void
EwinSetClass(EWin * ewin, const char *name, const char *clss)
{
HintsSetWindowClass(EwinGetClientWin(ewin), name, clss);
_EFDUP(ewin->o.icccm.wm_res_name, name);
_EFDUP(ewin->o.icccm.wm_res_class, clss);
}
const char *
EwinGetTitle(const EWin * ewin)
{
const char *name;
if (!ewin)
return NULL;
name = ewin->ewmh.wm_name;
if (name)
goto done;
name = EwinGetIcccmName(ewin);
if (name)
goto done;
done:
return (name && name[0]) ? name : NULL;
}
#if 0 /* Unused */
const char *
EwinGetIconName(const EWin * ewin)
{
const char *name;
name = ewin->ewmh.wm_icon_name;
if (name)
goto done;
name = ewin->icccm.wm_icon_name;
if (name)
goto done;
return EwinGetTitle(ewin);
done:
return (name && strlen(name)) ? name : NULL;
}
#endif
const char *
EwinBorderGetName(const EWin * ewin)
{
return (ewin->border) ? BorderGetName(ewin->border) : "?";
}
void
EwinBorderGetSize(const EWin * ewin, int *bl, int *br, int *bt, int *bb)
{
const Border *b = ewin->border;
if (!b)
{
*bl = *br = *bt = *bb = 0;
return;
}
*bl = b->border.left;
*br = b->border.right;
*bt = b->border.top;
*bb = b->border.bottom;
}
void
EwinBorderUpdateState(EWin * ewin)
{
EwinBorderDraw(ewin, 0, 0);
}
int
EwinIsOnScreen(const EWin * ewin)
{
int x, y, w, h;
if (EoIsSticky(ewin))
return 1;
if (EoGetDesk(ewin) != DesksGetCurrent())
return 0;
x = EoGetX(ewin);
y = EoGetY(ewin);
w = EoGetW(ewin);
h = EoGetH(ewin);
if (x + w <= 0 || x >= WinGetW(VROOT) || y + h <= 0 || y >= WinGetH(VROOT))
return 0;
return 1;
}
int
EwinIsOnDesktop(const EWin * ewin)
{
int xd, yd, wd, hd;
wd = WinGetW(VROOT);
hd = WinGetH(VROOT);
if (EoIsSticky(ewin))
{
xd = yd = 0;
}
else
{
int ax, ay;
DeskGetArea(EoGetDesk(ewin), &ax, &ay);
xd = -ax * wd;
yd = -ay * hd;
wd *= Conf.desks.areas_nx;
hd *= Conf.desks.areas_ny;
}
return
EoGetX(ewin) + EoGetW(ewin) - 8 >= xd && EoGetX(ewin) + 8 <= xd + wd &&
EoGetY(ewin) + EoGetH(ewin) - 8 >= yd && EoGetY(ewin) + 8 <= yd + hd;
}
/*
* Save current position in absolute viewport coordinates
*/
void
EwinRememberPositionSet(EWin * ewin)
{
int ax, ay;
ewin->req_x = EoGetX(ewin);
ewin->req_y = EoGetY(ewin);
if (!EoIsSticky(ewin))
{
DeskGetArea(EoGetDesk(ewin), &ax, &ay);
ewin->req_x += ax * WinGetW(VROOT);
ewin->req_y += ay * WinGetH(VROOT);
}
}
/*
* Get saved position in relative viewport coordinates
*/
void
EwinRememberPositionGet(EWin * ewin, Desk * dsk, int *px, int *py)
{
int x, y, ax, ay;
x = ewin->req_x;
y = ewin->req_y;
if (!EoIsSticky(ewin))
{
DeskGetArea(dsk, &ax, &ay);
x -= ax * WinGetW(VROOT);
y -= ay * WinGetH(VROOT);
}
*px = x;
*py = y;
}
/*
* Set placement gravity
*/
void
EwinSetPlacementGravity(EWin * ewin, int x, int y)
{
int w, h, ax, ay, wd, hd;
Desk *dsk;
dsk = EoGetDesk(ewin);
wd = EoGetW(dsk);
hd = EoGetH(dsk);
DeskGetArea(dsk, &ax, &ay);
w = EoGetW(ewin);
h = EoGetH(ewin);
/* Get relative area */
ewin->place.ax = ewin->area_x;
ewin->place.ay = ewin->area_y;
ax = ewin->place.ax - ax;
ay = ewin->place.ay - ay;
x -= ax * wd;
y -= ay * hd;
if (x <= (wd - w) / 2)
{
if (y <= (hd - h) / 2)
{
ewin->place.gravity = EWIN_GRAVITY_NW;
ewin->place.gx = x;
ewin->place.gy = y;
}
else
{
ewin->place.gravity = EWIN_GRAVITY_SW;
ewin->place.gx = x;
ewin->place.gy = hd - (y + h);
}
}
else
{
if (y <= (hd - h) / 2)
{
ewin->place.gravity = EWIN_GRAVITY_NE;
ewin->place.gx = wd - (x + w);
ewin->place.gy = y;
}
else
{
ewin->place.gravity = EWIN_GRAVITY_SE;
ewin->place.gx = wd - (x + w);
ewin->place.gy = hd - (y + h);
}
}
#if 0 /* Debug */
Eprintf("Set gravity %d,%d %d,%d %d %d,%d %d,%d: %s\n", ax, ay, x, y,
ewin->place.gravity, ewin->place.ax, ewin->place.ay,
ewin->place.gx, ewin->place.gy, EwinGetTitle(ewin));
#endif
}
void
EwinReposition(EWin * ewin)
{
int wdo, hdo, wdn, hdn;
int x, y, w, h, ax, ay, xn, yn;
wdo = Mode.screen.w_old;
hdo = Mode.screen.h_old;
wdn = WinGetW(VROOT);
hdn = WinGetH(VROOT);
x = EoGetX(ewin);
y = EoGetY(ewin);
w = EoGetW(ewin);
h = EoGetH(ewin);
/* Get relative area */
if (EoIsSticky(ewin))
{
ax = ay = 0;
}
else
{
DeskGetArea(EoGetDesk(ewin), &ax, &ay);
ax = ewin->place.ax - ax;
ay = ewin->place.ay - ay;
}
x -= ax * wdo;
y -= ay * hdo;
/* Reposition to same distance from screen edges determined by
* placement gravity.
* Fall back to left/top if this causes left/top to go offscreen */
switch (ewin->place.gravity)
{
default:
case EWIN_GRAVITY_NW:
case EWIN_GRAVITY_SW:
xn = ewin->place.gx;
break;
case EWIN_GRAVITY_NE:
case EWIN_GRAVITY_SE:
xn = wdn - w - ewin->place.gx;
break;
}
if (x > 0 && xn < 0)
xn = x;
switch (ewin->place.gravity)
{
default:
case EWIN_GRAVITY_NW:
case EWIN_GRAVITY_NE:
yn = ewin->place.gy;
break;
case EWIN_GRAVITY_SW:
case EWIN_GRAVITY_SE:
yn = hdn - h - ewin->place.gy;
break;
}
if (y > 0 && yn < 0)
yn = y;
#if 0 /* Debug */
Eprintf("Reposition %d,%d -> %d,%d: %s\n", x, y, xn, yn, EwinGetTitle(ewin));
#endif
xn += ax * wdn;
yn += ay * hdn;
EwinMove(ewin, xn, yn, 0);
}
void
EwinWarpTo(EWin * ewin, int force)
{
if (!force && ewin == Mode.mouse_over_ewin)
return;
if (ewin->state.iconified)
return;
EWarpPointer(EoGetWin(ewin), EoGetW(ewin) / 2, EoGetH(ewin) / 2);
Mode.mouse_over_ewin = ewin;
}
typedef union {
unsigned int all;
struct {
unsigned char rsvd;
unsigned char inh_app;
unsigned char inh_user;
unsigned char inh_wm;
} f;
} EWinMiscFlags;
typedef union {
unsigned int all;
struct {
unsigned nua:1;
unsigned ctf:1;
unsigned nbg:1;
unsigned autoshade:1;
unsigned ia:1;
unsigned: 3;
unsigned: 8;
unsigned: 8;
unsigned no_fade:1;
unsigned no_shadow:1;
unsigned: 6;
} f;
} EWinMiscFlags2;
void
EwinFlagsEncode(const EWin * ewin, unsigned int *flags)
{
EWinMiscFlags fm;
EWinMiscFlags2 fm2;
fm.all = 0;
fm.f.inh_app = ewin->inh_app.all;
fm.f.inh_user = ewin->inh_user.all;
fm.f.inh_wm = ewin->inh_wm.all;
fm2.all = 0;
fm2.f.ia = ewin->props.ignorearrange;
fm2.f.nua = ewin->props.never_use_area;
fm2.f.ctf = ewin->props.focusclick;
fm2.f.nbg = ewin->props.no_button_grabs;
fm2.f.autoshade = ewin->props.autoshade;
#if USE_COMPOSITE
fm2.f.no_fade = !EoGetFade(ewin);
fm2.f.no_shadow = !EoGetShadow(ewin);
#endif
flags[0] = fm.all;
flags[1] = fm2.all;
}
void
EwinFlagsDecode(EWin * ewin, const unsigned int *flags)
{
EWinMiscFlags fm;
EWinMiscFlags2 fm2;
fm.all = flags[0];
ewin->inh_app.all = fm.f.inh_app;
ewin->inh_user.all = fm.f.inh_user;
ewin->inh_wm.all = fm.f.inh_wm;
fm2.all = flags[1];
ewin->props.ignorearrange = fm2.f.ia;
ewin->props.never_use_area = fm2.f.nua;
ewin->props.focusclick = fm2.f.ctf;
ewin->props.no_button_grabs = fm2.f.nbg;
ewin->props.autoshade = fm2.f.autoshade;
#if USE_COMPOSITE
EoSetFade(ewin, !fm2.f.no_fade);
EoSetShadow(ewin, !fm2.f.no_shadow);
#endif
}
void
EwinUpdateOpacity(EWin * ewin)
{
unsigned int opacity;
opacity = 0;
if (ewin->state.moving || ewin->state.resizing)
opacity = OpacityFromPercent(Conf.opacity.movres);
else if (ewin->state.active)
opacity = ewin->props.focused_opacity;
if (opacity == 0)
opacity = ewin->props.opacity;
if (opacity == 0)
opacity = ewin->state.active ?
OpacityFromPercent(Conf.opacity.focused) :
OpacityFromPercent(Conf.opacity.unfocused);
if (opacity == 0)
opacity = 0xffffffff; /* Fallback */
EoChangeOpacity(ewin, opacity);
}
/*
* Change requests
*/
static struct {
unsigned int flags;
Desk *desk;
} EWinChanges;
void
EwinChange(EWin * ewin __UNUSED__, unsigned int flag)
{
EWinChanges.flags |= flag;
}
static void
EwinChangesStart(EWin * ewin)
{
EWinChanges.flags = 0;
EWinChanges.desk = EoGetDesk(ewin);
}
static void
EwinChangesProcess(EWin * ewin)
{
if (!EWinChanges.flags)
return;
if (EWinChanges.flags & EWIN_CHANGE_NAME)
{
EwinBorderUpdateInfo(ewin);
EwinBorderCalcSizes(ewin, 1);
}
if (EWinChanges.flags & EWIN_CHANGE_DESKTOP)
{
Desk *desk, *pdesk;
desk = EoGetDesk(ewin);
pdesk = EWinChanges.desk;
if (desk != pdesk && !EoIsSticky(ewin))
{
EoSetDesk(ewin, pdesk);
EwinMoveToDesktop(ewin, desk);
}
}
if (EWinChanges.flags & EWIN_CHANGE_ICON_PMAP)
{
ModulesSignal(ESIGNAL_EWIN_CHANGE_ICON, ewin);
}
if (EWinChanges.flags & EWIN_CHANGE_OPACITY)
{
EwinUpdateOpacity(ewin);
HintsSetWindowOpacity(ewin);
SnapshotEwinUpdate(ewin, SNAP_USE_OPACITY);
}
if (EWinChanges.flags & EWIN_CHANGE_ATTENTION)
{
HintsSetWindowState(ewin);
}
EWinChanges.flags = 0;
}
EWin **
EwinListTransients(const EWin * ewin, int *num, int group)
{
EWin *const *ewins, **lst, *ew;
int i, j, n;
j = 0;
lst = NULL;
if (EwinGetTransientCount(ewin) <= 0)
goto done;
ewins = EwinListGetAll(&n);
/* Find regular transients */
for (i = 0; i < n; i++)
{
ew = ewins[i];
/* Skip self-reference */
if (ew == ewin)
continue;
if (EwinGetTransientFor(ew) == EwinGetClientXwin(ewin))
{
lst = EREALLOC(EWin *, lst, j + 1);
lst[j++] = ew;
}
}
if (!group)
goto done;
/* Group transients (if ewin is not a transient) */
if (EwinIsTransient(ewin))
goto done;
for (i = 0; i < n; i++)
{
ew = ewins[i];
/* Skip self-reference */
if (ew == ewin)
continue;
if (EwinGetTransientFor(ew) == WinGetXwin(VROOT) &&
EwinGetWindowGroup(ew) == EwinGetWindowGroup(ewin))
{
lst = EREALLOC(EWin *, lst, j + 1);
lst[j++] = ew;
}
}
done:
*num = j;
return lst;
}
EWin **
EwinListTransientFor(const EWin * ewin, int *num)
{
EWin *const *ewins, **lst, *ew;
int i, j, n;
j = 0;
lst = NULL;
if (!EwinIsTransient(ewin))
goto done;
ewins = EwinListGetAll(&n);
for (i = 0; i < n; i++)
{
ew = ewins[i];
/* Skip self-reference */
if (ew == ewin)
continue;
/* Regular parent or if root trans, top level group members */
if ((EwinGetTransientFor(ewin) == EwinGetClientXwin(ew)) ||
(!EwinIsTransient(ew) &&
EwinGetTransientFor(ewin) == WinGetXwin(VROOT) &&
EwinGetWindowGroup(ew) == EwinGetWindowGroup(ewin)))
{
lst = EREALLOC(EWin *, lst, j + 1);
lst[j++] = ew;
}
}
done:
*num = j;
return lst;
}
static void
EwinsTouch(Desk * dsk)
{
int i, num;
EWin *const *lst, *ewin;
if (!dsk)
lst = EwinListGetAll(&num);
else
lst = EwinListGetForDesk(&num, dsk);
for (i = num - 1; i >= 0; i--)
{
ewin = lst[i];
if (EoIsMapped(ewin) && EwinIsOnScreen(ewin))
EwinMove(ewin, EoGetX(ewin), EoGetY(ewin), 0);
}
}
static void
EwinsReposition(void)
{
int i, num;
EWin *const *lst;
lst = EwinListGetAll(&num);
for (i = num - 1; i >= 0; i--)
EwinReposition(lst[i]);
}
void
EwinsMoveStickyToDesk(Desk * dsk)
{
EWin *const *lst, *ewin;
int i, num;
lst = EwinListStackGet(&num);
for (i = 0; i < num; i++)
{
ewin = lst[num - 1 - i];
if (!EoIsSticky(ewin) && !EoIsFloating(ewin))
continue;
if (EwinIsTransientChild(ewin))
continue;
EwinMoveToDesktop(ewin, dsk);
}
}
void
EwinsManage(void)
{
Window *xwins, par, rt;
EX_Window xwin;
XWindowAttributes attr;
unsigned int i, num;
#ifdef USE_EXT_INIT_WIN
xwin = ExtInitWinGet();
if (xwin)
XRaiseWindow(disp, xwin);
#endif
xwins = NULL;
num = 0;
XQueryTree(disp, WinGetXwin(VROOT), &rt, &par, &xwins, &num);
if (!xwins)
return;
EGrabServer();
for (i = 0; i < num; i++)
{
xwin = xwins[i];
/* Skip if already "known" */
if (EobjListStackFind(xwin))
continue;
if (!EXGetWindowAttributes(xwin, &attr))
continue;
if (attr.map_state == IsUnmapped)
continue;
if (attr.override_redirect)
EobjRegisterOR(xwin, &attr, 1);
else
AddToFamily(NULL, xwin, &attr, 1);
}
EUngrabServer();
XFree(xwins);
}
void
EwinsSetFree(void)
{
int i, num;
EWin *const *lst, *ewin;
if (EDebug(EDBUG_TYPE_SESSION))
Eprintf("%s\n", __func__);
EHintsSetInfoOnAll();
lst = EwinListStackGet(&num);
for (i = num - 1; i >= 0; i--)
{
ewin = lst[i];
if (EwinIsInternal(ewin))
continue;
if (ewin->state.iconified)
ICCCM_DeIconify(ewin);
/* This makes E determine the client window stacking at exit */
EwinInstantUnShade(ewin);
EReparentWindow(EwinGetClientWin(ewin), RROOT,
ewin->client.x, ewin->client.y);
}
}
/*
* Event handlers
*/
#define DEBUG_EWIN_EVENTS 0
static int
ActionsCheck(const char *which, EWin * ewin, XEvent * ev)
{
ActionClass *ac;
ac = ActionclassFind(which);
if (!ac)
return 0;
if (ev->type == ButtonPress)
{
GrabPointerSet(EoGetWin(ewin), ECSR_GRAB, 0);
FocusToEWin(ewin, FOCUS_CLICK);
}
else if (ev->type == ButtonRelease)
{
GrabPointerRelease();
}
return ActionclassEvent(ac, ev, ewin);
}
static EWin *
_EwinEventEwinCheck(const char *txt, XEvent * ev, EWin * ewin)
{
int ser_diff;
ser_diff = (int)(ev->xany.serial - ewin->serial);
if (ser_diff < 0 && ser_diff > -1000)
{
Eprintf("%s: %#lx: Ignore obsolete event %d\n", txt,
ev->xany.window, ev->type);
return NULL;
}
ewin->serial = ev->xany.serial;
return ewin;
}
static EWin *
_EwinEventEwinFind(XEvent * ev, EX_Window xwin)
{
EWin *ewin;
ewin = EwinFindByClient(xwin);
if (!ewin)
return ewin;
return _EwinEventEwinCheck("root", ev, ewin);
}
static int
EwinHandleContainerEvents(EWin * ewin, XEvent * ev)
{
EX_Window xwin = EwinGetClientXwin(ewin);
switch (ev->type)
{
case MapRequest:
if (ev->xmaprequest.window != xwin)
break;
EwinEventMapRequest(ewin, ev);
break;
case ConfigureRequest:
if (ev->xconfigurerequest.window != xwin)
break;
EwinEventConfigureRequest(ewin, ev);
break;
case ResizeRequest:
if (ev->xresizerequest.window != xwin)
break;
EwinEventResizeRequest(ewin, ev);
break;
case CirculateRequest:
if (ev->xcirculaterequest.window != xwin)
break;
EwinEventCirculateRequest(ewin, ev);
break;
case DestroyNotify:
if (ev->xdestroywindow.window != xwin)
break;
EwinEventDestroy(ewin);
break;
case EX_EVENT_UNMAP_GONE:
if (ev->xunmap.window != xwin)
break;
EoSetGone(ewin);
goto do_unmap;
case UnmapNotify:
if (ev->xunmap.window != xwin)
break;
do_unmap:
EwinEventUnmap(ewin, ev);
break;
case MapNotify:
if (ev->xmap.window != xwin)
break;
EwinEventMap(ewin, ev);
break;
case EX_EVENT_REPARENT_GONE:
if (ev->xreparent.window != xwin)
break;
EoSetGone(ewin);
goto do_reparent;
case ReparentNotify:
if (ev->xreparent.window != xwin)
break;
do_reparent:
EwinEventReparent(ewin, ev);
break;
case EX_EVENT_MAP_GONE:
case GravityNotify:
case ConfigureNotify:
break;
default:
return 0; /* Not handled */
}
return 1; /* Handled */
}
static void
EwinHandleEventsToplevel(Win win __UNUSED__, XEvent * ev, void *prm)
{
EWin *ewin = (EWin *) prm;
if (!_EwinEventEwinCheck("frm", ev, ewin))
return;
switch (ev->type)
{
case ButtonPress:
ActionsCheck("BUTTONBINDINGS", ewin, ev);
break;
case ButtonRelease:
ActionsCheck("BUTTONBINDINGS", ewin, ev);
break;
case EnterNotify:
FocusHandleEnter(ewin, ev);
break;
case LeaveNotify:
FocusHandleLeave(ewin, ev);
break;
default:
if (EwinHandleContainerEvents(ewin, ev))
break;
#if DEBUG_EWIN_EVENTS
Eprintf("%s: type=%2d win=%#lx: %s\n", __func__,
ev->type, EwinGetClientXwin(ewin), EwinGetTitle(ewin));
#endif
break;
}
}
#if USE_CONTAINER_WIN
static void
EwinHandleEventsContainer(Win win __UNUSED__, XEvent * ev, void *prm)
{
EWin *ewin = (EWin *) prm;
if (ev->type == ButtonPress)
{
FocusHandleClick(ewin, EwinGetClientConWin(ewin));
return;
}
if (!_EwinEventEwinCheck("cont", ev, ewin))
return;
switch (ev->type)
{
default:
if (EwinHandleContainerEvents(ewin, ev))
break;
#if DEBUG_EWIN_EVENTS
Eprintf("%s: type=%2d win=%#x: %s\n", __func__,
ev->type, EwinGetClientXwin(ewin), EwinGetTitle(ewin));
#endif
break;
}
}
#endif
static void
EwinHandleEventsClient(Win win __UNUSED__, XEvent * ev, void *prm)
{
EWin *ewin = (EWin *) prm;
#if !USE_CONTAINER_WIN
if (ev->type == ButtonPress)
{
FocusHandleClick(ewin, EwinGetClientConWin(ewin));
return;
}
#endif
if (!_EwinEventEwinCheck("cli", ev, ewin))
return;
switch (ev->type)
{
case FocusIn:
case FocusOut:
if (ev->xfocus.detail == NotifyInferior)
break;
if (ewin->border->aclass)
ActionclassEvent(ewin->border->aclass, ev, ewin);
FocusHandleChange(ewin, ev);
break;
case ConfigureNotify:
case GravityNotify:
break;
case VisibilityNotify:
EwinEventVisibility(ewin, ev->xvisibility.state);
break;
case PropertyNotify:
EwinEventPropertyNotify(ewin, ev);
break;
case ClientMessage:
HintsProcessClientClientMessage(ewin, &(ev->xclient));
break;
case EX_EVENT_SHAPE_NOTIFY:
EwinEventShapeChange(ewin, ev);
break;
default:
#if DEBUG_EWIN_EVENTS
Eprintf("%s: type=%2d win=%#x: %s\n", __func__,
ev->type, EwinGetClientXwin(ewin), EwinGetTitle(ewin));
#endif
break;
}
}
static void
EwinHandleEventsRoot(Win win __UNUSED__, XEvent * ev, void *prm __UNUSED__)
{
EWin *ewin;
switch (ev->type)
{
case MapRequest:
EwinEventMapRequest(NULL, ev);
break;
case ConfigureRequest:
#if 0
Eprintf("%s ConfigureRequest %#x\n", __func__,
ev->xconfigurerequest.window);
#endif
ewin = EwinFindByClient(ev->xconfigurerequest.window);
EwinEventConfigureRequest(ewin, ev);
break;
case ResizeRequest:
#if 0
Eprintf("%s ResizeRequest %#x\n", __func__, ev->xresizerequest.window);
#endif
ewin = EwinFindByClient(ev->xresizerequest.window);
EwinEventResizeRequest(ewin, ev);
break;
case CirculateRequest:
#if 0
Eprintf("%s CirculateRequest %#x\n", __func__,
ev->xcirculaterequest.window);
#endif
EwinEventCirculateRequest(NULL, ev);
break;
case UnmapNotify:
case EX_EVENT_UNMAP_GONE:
/* Catch clients unmapped after MapRequest but before being reparented */
ewin = _EwinEventEwinFind(ev, ev->xunmap.window);
if (!ewin)
break;
if (ev->type == EX_EVENT_UNMAP_GONE)
EoSetGone(ewin);
EwinEventUnmap(ewin, ev);
break;
case DestroyNotify:
/* Catch clients destroyed after MapRequest but before being reparented */
ewin = _EwinEventEwinFind(ev, ev->xdestroywindow.window);
if (!ewin)
break;
EwinEventDestroy(ewin);
break;
case ReparentNotify:
case EX_EVENT_REPARENT_GONE:
ewin = _EwinEventEwinFind(ev, ev->xreparent.window);
if (!ewin)
break;
if (ev->type == EX_EVENT_REPARENT_GONE)
EoSetGone(ewin);
EwinEventReparent(ewin, ev);
break;
case ClientMessage:
HintsProcessRootClientMessage(&(ev->xclient));
break;
default:
#if 0
Eprintf("%s: type=%2d win=%#x\n", __func__, ev->type, ev->xany.window);
#endif
break;
}
}
static void
EwinsInit(void)
{
EventCallbackRegister(VROOT, EwinHandleEventsRoot, NULL);
}
/*
* Ewins module
* This is the WM.
*/
static void
EwinsSighan(int sig, void *prm)
{
switch (sig)
{
case ESIGNAL_INIT:
EwinsInit();
break;
#if 0
case ESIGNAL_START:
EwinsManage();
break;
#endif
case ESIGNAL_DESK_RESIZE:
EwinsReposition();
break;
case ESIGNAL_THEME_TRANS_CHANGE:
EwinsTouch(DesksGetCurrent());
break;
case ESIGNAL_BACKGROUND_CHANGE:
EwinsTouch((Desk *) prm);
break;
}
}
/*
* Module descriptor
*/
extern const EModule ModEwins;
const EModule ModEwins = {
"ewins", NULL,
EwinsSighan,
{0, NULL},
{0, NULL}
};
Reference in New Issue View Git Blame Copy Permalink