/usr/src/RPM/BUILD/ctwm-4.1.0/win_utils.c

Go to the documentation of this file.

/*
 * Window-handling utility funcs
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#include <X11/Xatom.h>
 
#include "add_window.h" // NoName
#include "ctwm_atoms.h"
#include "drawing.h"
#include "events.h"
#include "event_internal.h" // Temp?
#ifdef EWMH
# include "ewmh_atoms.h"
#endif
#include "icons.h"
#include "list.h"
#include "occupation.h"
#include "otp.h"
#include "r_area.h"
#include "r_area_list.h"
#include "r_layout.h"
#include "screen.h"
#include "util.h"
#include "win_decorations.h"
#include "win_ops.h"
#include "win_utils.h"
#include "workspace_utils.h"
 
 
/*
 * Fill in size hints for a window from WM_NORMAL_HINTS prop.
 *
 * Formerly in add_window.c
 */
void
GetWindowSizeHints(TwmWindow *tmp)
{
    long supplied = 0;
    XSizeHints *hints = &tmp->hints;
 
    if(!XGetWMNormalHints(dpy, tmp->w, hints, &supplied)) {
        hints->flags = 0;
    }
 
    if(hints->flags & PResizeInc) {
        if(hints->width_inc == 0) {
            hints->width_inc = 1;
        }
        if(hints->height_inc == 0) {
            hints->height_inc = 1;
        }
    }
 
    if(!(supplied & PWinGravity) && (hints->flags & USPosition)) {
        static int gravs[] = { SouthEastGravity, SouthWestGravity,
                               NorthEastGravity, NorthWestGravity
                             };
        int right =  tmp->attr.x + tmp->attr.width + 2 * tmp->old_bw;
        int bottom = tmp->attr.y + tmp->attr.height + 2 * tmp->old_bw;
        hints->win_gravity =
                gravs[((Scr->rooth - bottom <
                        tmp->title_height + 2 * tmp->frame_bw3D) ? 0 : 2) |
                      ((Scr->rootw - right   <
                        tmp->title_height + 2 * tmp->frame_bw3D) ? 0 : 1)];
        hints->flags |= PWinGravity;
    }
 
    /* Check for min size < max size */
    if((hints->flags & (PMinSize | PMaxSize)) == (PMinSize | PMaxSize)) {
        if(hints->max_width < hints->min_width) {
            if(hints->max_width > 0) {
                hints->min_width = hints->max_width;
            }
            else if(hints->min_width > 0) {
                hints->max_width = hints->min_width;
            }
            else {
                hints->max_width = hints->min_width = 1;
            }
        }
 
        if(hints->max_height < hints->min_height) {
            if(hints->max_height > 0) {
                hints->min_height = hints->max_height;
            }
            else if(hints->min_height > 0) {
                hints->max_height = hints->min_height;
            }
            else {
                hints->max_height = hints->min_height = 1;
            }
        }
    }
}
 
 
/*
 * Fill in info from WM_PROTOCOLS property
 *
 * Formerly in add_window.c
 */
void
FetchWmProtocols(TwmWindow *tmp)
{
    unsigned long flags = 0L;
    Atom *protocols = NULL;
    int n;
 
    if(XGetWMProtocols(dpy, tmp->w, &protocols, &n)) {
        int i;
        Atom *ap;
 
        for(i = 0, ap = protocols; i < n; i++, ap++) {
            if(*ap == XA_WM_TAKE_FOCUS) {
                flags |= DoesWmTakeFocus;
            }
            if(*ap == XA_WM_SAVE_YOURSELF) {
                flags |= DoesWmSaveYourself;
            }
            if(*ap == XA_WM_DELETE_WINDOW) {
                flags |= DoesWmDeleteWindow;
            }
        }
        if(protocols) {
            XFree(protocols);
        }
    }
    tmp->protocols = flags;
}
 
 
/*
 * Figure signs for calculating location offsets for a window dependent
 * on its gravity.
 *
 * Depending on how its gravity is set, offsets to window coordinates for
 * e.g. border widths may need to move either down (right) or up (left).
 * Or possibly not at all.  So we write multipliers into passed vars for
 * callers.
 *
 * Formerly in add_window.c
 */
void
GetGravityOffsets(TwmWindow *tmp, int *xp, int *yp)
{
    static struct _gravity_offset {
        int x, y;
    } gravity_offsets[] = {
        [ForgetGravity]    = {  0,  0 },
        [NorthWestGravity] = { -1, -1 },
        [NorthGravity]     = {  0, -1 },
        [NorthEastGravity] = {  1, -1 },
        [WestGravity]      = { -1,  0 },
        [CenterGravity]    = {  0,  0 },
        [EastGravity]      = {  1,  0 },
        [SouthWestGravity] = { -1,  1 },
        [SouthGravity]     = {  0,  1 },
        [SouthEastGravity] = {  1,  1 },
        [StaticGravity]    = {  0,  0 },
    };
    int g = ((tmp->hints.flags & PWinGravity)
             ? tmp->hints.win_gravity : NorthWestGravity);
 
    if(g < ForgetGravity || g > StaticGravity) {
        *xp = *yp = 0;
    }
    else {
        *xp = gravity_offsets[g].x;
        *yp = gravity_offsets[g].y;
    }
}
 
 
/*
 * Finds the TwmWindow structure associated with a Window (if any), or
 * NULL.
 *
 * This is a relatively cheap function since it does not involve
 * communication with the server. Probably faster than walking the list
 * of TwmWindows, since the lookup is by a hash table.
 *
 * Formerly in add_window.c
 */
TwmWindow *
GetTwmWindow(Window w)
{
    TwmWindow *twmwin;
    int stat;
 
    stat = XFindContext(dpy, w, TwmContext, (XPointer *)&twmwin);
    if(stat == XCNOENT) {
        twmwin = NULL;
    }
 
    return twmwin;
}
 
 
/***********************************************************************
 *
 *  Procedure:
 *      GetWMPropertyString - Get Window Manager text property and
 *                              convert it to a string.
 *
 *  Returned Value:
 *      (char *) - pointer to the malloc'd string or NULL
 *
 *  Inputs:
 *      w       - the id of the window whose property is to be retrieved
 *      prop    - property atom (typically WM_NAME or WM_ICON_NAME)
 *
 ***********************************************************************
 *
 * Formerly in util.c
 */
char *
GetWMPropertyString(Window w, Atom prop)
{
    XTextProperty       text_prop;
    char                *stringptr;
 
    XGetTextProperty(dpy, w, &text_prop, prop);
    if(text_prop.value == NULL) {
        return NULL;
    }
 
    if(text_prop.encoding == XA_STRING
                    || text_prop.encoding == XA_UTF8_STRING
                    || text_prop.encoding == XA_COMPOUND_TEXT) {
        /* property is encoded as compound text - convert to locale string */
        char **text_list;
        int  text_list_count;
        int status;
 
        /* Check historical strictness */
        if(Scr->StrictWinNameEncoding) {
            bool fail = false;
 
            if((prop == XA_WM_NAME || prop == XA_WM_ICON_NAME)
                            && text_prop.encoding != XA_STRING
                            && text_prop.encoding != XA_COMPOUND_TEXT) {
                fail = true;
            }
 
#ifdef EWMH
            if((prop == XA__NET_WM_NAME || prop == XA__NET_WM_ICON_NAME)
                            && text_prop.encoding != XA_UTF8_STRING) {
                fail = true;
            }
#endif // EWMH
 
            if(fail) {
                fprintf(stderr, "%s: Invalid encoding for property %s "
                        "of window 0x%lx\n", ProgramName,
                        XGetAtomName(dpy, prop), w);
                XFree(text_prop.value);
                return NULL;
            }
        }
 
 
        status = XmbTextPropertyToTextList(dpy, &text_prop, &text_list,
                                           &text_list_count);
        if(text_list_count == 0
                        || text_list == NULL
                        || text_list[0] == NULL) {
            // Got nothing
            XFree(text_prop.value);
            return NULL;
        }
        else if(status < 0 || text_list_count < 0) {
            // Got an error statuf
            switch(status) {
                case XConverterNotFound:
                    fprintf(stderr,
                            "%s: Converter not found; unable to convert property %s of window ID %lx.\n",
                            ProgramName, XGetAtomName(dpy, prop), w);
                    break;
                case XNoMemory:
                    fprintf(stderr,
                            "%s: Insufficient memory; unable to convert property %s of window ID %lx.\n",
                            ProgramName, XGetAtomName(dpy, prop), w);
                    break;
                case XLocaleNotSupported:
                    fprintf(stderr,
                            "%s: Locale not supported; unable to convert property %s of window ID %lx.\n",
                            ProgramName, XGetAtomName(dpy, prop), w);
                    break;
            }
            stringptr = NULL;
            /*
               don't call XFreeStringList - text_list appears to have
               invalid address if status is bad
               XFreeStringList(text_list);
            */
        }
        else {
            // Actually got the data!
            stringptr = strdup(text_list[0]);
            XFreeStringList(text_list);
        }
    }
    else {
        /* property is encoded in a format we don't understand */
        fprintf(stderr,
                "%s: Encoding not STRING or COMPOUND_TEXT; unable to decode property %s of window ID %lx.\n",
                ProgramName, XGetAtomName(dpy, prop), w);
        stringptr = NULL;
    }
    XFree(text_prop.value);
 
    return stringptr;
}
 
 
/*
 * Cleanup something stored that we got from the above originally.
 *
 * Formerly in util.c
 */
void
FreeWMPropertyString(char *prop)
{
    if(prop && prop != NoName) {
        free(prop);
    }
}
 
 
/*
 * Window mapped on some virtual screen?
 *
 * Formerly in util.c
 */
bool
visible(const TwmWindow *tmp_win)
{
    return (tmp_win->vs != NULL);
}
 
 
/*
 * Various code paths do a dance of "mask off notifications of event type
 * ; do something that triggers that event (but we're doing it, so we
 * don't need the notification) ; restore previous mask".  So have some
 * util funcs to make it more visually obvious.
 *
 * e.g.:
 *     long prev_mask = mask_out_event(w, PropertyChangeMask);
 *     do_something_that_changes_properties();
 *     restore_mask(prev_mask);
 *
 * We're cheating a little with the -1 return on mask_out_event(), as
 * that's theoretically valid for the data type.  It's not as far as I
 * can tell for X or us though; having all the bits set (well, I guess
 * I'm assuming 2s-complement too) is pretty absurd, and there are only
 * 25 defined bits in Xlib, so even on 32-bit systems, it shouldn't fill
 * up long.
 */
long
mask_out_event(Window w, long ignore_event)
{
    XWindowAttributes wattr;
 
    /* Get current mask */
    if(XGetWindowAttributes(dpy, w, &wattr) == 0) {
        return -1;
    }
 
    /*
     * If we're ignoring nothing, nothing to do.  This is probably not
     * strictly speaking a useful thing to ask for in general, but it's
     * the right thing for us to do if we're asked to do nothing.
     */
    if(ignore_event == 0) {
        return wattr.your_event_mask;
    }
 
    /* Delegate */
    return mask_out_event_mask(w, ignore_event, wattr.your_event_mask);
}
 
long
mask_out_event_mask(Window w, long ignore_event, long curmask)
{
    /* Set to the current, minus what we're wanting to ignore */
    XSelectInput(dpy, w, (curmask & ~ignore_event));
 
    /* Return what it was */
    return curmask;
}
 
int
restore_mask(Window w, long restore)
{
    return XSelectInput(dpy, w, restore);
}
 
 
/*
 * Setting and getting WM_STATE property.
 *
 * x-ref ICCCM section 4.1.3.1
 * https://tronche.com/gui/x/icccm/sec-4.html#s-4.1.3.1
 *
 * XXX These should probably be named more alike, as they're
 * complementary ops.
 */
void
SetMapStateProp(TwmWindow *tmp_win, int state)
{
    unsigned long data[2];              /* "suggested" by ICCCM version 1 */
 
    data[0] = (unsigned long) state;
    data[1] = (unsigned long)(tmp_win->iconify_by_unmapping ? None :
                              (tmp_win->icon ? tmp_win->icon->w : None));
 
    XChangeProperty(dpy, tmp_win->w, XA_WM_STATE, XA_WM_STATE, 32,
                    PropModeReplace, (unsigned char *) data, 2);
}
 
 
bool
GetWMState(Window w, int *statep, Window *iwp)
{
    Atom actual_type;
    int actual_format;
    unsigned long nitems, bytesafter;
    unsigned long *datap = NULL;
    bool retval = false;
 
    if(XGetWindowProperty(dpy, w, XA_WM_STATE, 0L, 2L, False, XA_WM_STATE,
                          &actual_type, &actual_format, &nitems, &bytesafter,
                          (unsigned char **) &datap) != Success || !datap) {
        return false;
    }
 
    if(nitems <= 2) {                   /* "suggested" by ICCCM version 1 */
        *statep = (int) datap[0];
        *iwp = (Window) datap[1];
        retval = true;
    }
 
    XFree(datap);
    return retval;
}
 
 
/*
 * Display a window's position in the dimensions window.  This is used
 * during various window positioning (during new window popups, moves,
 * etc).
 *
 * This reuses the same window for the position as is used during
 * resizing for the dimesions of the window in DisplaySize().  The
 * innards of the funcs can probably be collapsed together a little, and
 * the higher-level knowledge of Scr->SizeWindow (e.g., for unmapping
 * after ths op is done) should probably be encapsulated a bit better.
 */
void
DisplayPosition(const TwmWindow *_unused_tmp_win, int x, int y)
{
    char str [100];
    char signx = '+';
    char signy = '+';
 
    if(x < 0) {
        x = -x;
        signx = '-';
    }
    if(y < 0) {
        y = -y;
        signy = '-';
    }
    sprintf(str, " %c%-4d %c%-4d ", signx, x, signy, y);
    XRaiseWindow(dpy, Scr->SizeWindow);
 
    Draw3DBorder(Scr->SizeWindow, 0, 0,
                 Scr->SizeStringOffset + Scr->SizeStringWidth + SIZE_HINDENT,
                 Scr->SizeFont.height + SIZE_VINDENT * 2,
                 2, Scr->DefaultC, off, false, false);
 
    FB(Scr->DefaultC.fore, Scr->DefaultC.back);
    XmbDrawImageString(dpy, Scr->SizeWindow, Scr->SizeFont.font_set,
                       Scr->NormalGC, Scr->SizeStringOffset,
                       Scr->SizeFont.ascent + SIZE_VINDENT, str, 13);
}
 
void
MoveResizeSizeWindow(int x, int y, unsigned int width, unsigned int height)
{
    XResizeWindow(dpy, Scr->SizeWindow, width, height);
 
    if(Scr->CenterFeedbackWindow) {
        RArea monitor = RLayoutGetAreaAtXY(Scr->BorderedLayout, x, y);
 
        XMoveWindow(dpy, Scr->SizeWindow,
                    monitor.x + monitor.width / 2 - width / 2,
                    monitor.y + monitor.height / 2 - height / 2);
    }
}
 
 
/*
 * Various funcs for adjusting coordinates for windows based on
 * resistances etc.
 *
 * XXX In desperate need of better commenting.
 */
static void
_tryToPack(RArea *final, const RArea *cur_win)
{
    if(final->x >= cur_win->x + cur_win->width) {
        return;
    }
    if(final->y >= cur_win->y + cur_win->height) {
        return;
    }
    if(final->x + final->width <= cur_win->x) {
        return;
    }
    if(final->y + final->height <= cur_win->y) {
        return;
    }
 
    if(final->x + Scr->MovePackResistance > cur_win->x +
                    cur_win->width) {  /* left */
        final->x = MAX(final->x, cur_win->x + cur_win->width);
        return;
    }
    if(final->x + final->width < cur_win->x +
                    Scr->MovePackResistance) {  /* right */
        final->x = MIN(final->x, cur_win->x - final->width);
        return;
    }
    if(final->y + Scr->MovePackResistance > cur_win->y +
                    cur_win->height) {  /* top */
        final->y = MAX(final->y, cur_win->y + cur_win->height);
        return;
    }
    if(final->y + final->height < cur_win->y +
                    Scr->MovePackResistance) {  /* bottom */
        final->y = MIN(final->y, cur_win->y - final->height);
    }
}
 
static bool
_tryToPackVsEachMonitor(const RArea *monitor_area, void *vfinal)
{
    _tryToPack((RArea *)vfinal, monitor_area);
    return false;
}
 
void
TryToPack(TwmWindow *tmp_win, int *x, int *y)
{
    TwmWindow   *t;
    RArea cur_win;
    RArea final = RAreaNew(*x, *y,
                           tmp_win->frame_width  + 2 * tmp_win->frame_bw,
                           tmp_win->frame_height + 2 * tmp_win->frame_bw);
 
    /* Global layout is not a single rectangle, check against the
     * monitor borders */
    if(Scr->BorderedLayout->horiz->len > 1) {
        RAreaListForeach(
                Scr->BorderedLayout->monitors, _tryToPackVsEachMonitor, &final);
    }
 
    for(t = Scr->FirstWindow; t != NULL; t = t->next) {
        if(t == tmp_win) {
            continue;
        }
#ifdef WINBOX
        if(t->winbox != tmp_win->winbox) {
            continue;
        }
#endif
        if(t->vs != tmp_win->vs) {
            continue;
        }
        if(!t->mapped) {
            continue;
        }
 
        cur_win = RAreaNew(t->frame_x, t->frame_y,
                           t->frame_width  + 2 * t->frame_bw,
                           t->frame_height + 2 * t->frame_bw);
 
        _tryToPack(&final, &cur_win);
    }
 
    *x = final.x;
    *y = final.y;
}
 
 
/*
 * Directionals for TryToPush_be().  These differ from the specs for
 * jump/pack/fill in functions. because there's an indeterminate option.
 */
typedef enum {
    PD_ANY,
    PD_BOTTOM,
    PD_LEFT,
    PD_RIGHT,
    PD_TOP,
} PushDirection;
static void TryToPush_be(TwmWindow *tmp_win, int x, int y, PushDirection dir);
 
void
TryToPush(TwmWindow *tmp_win, int x, int y)
{
    TryToPush_be(tmp_win, x, y, PD_ANY);
}
 
static void
TryToPush_be(TwmWindow *tmp_win, int x, int y, PushDirection dir)
{
    TwmWindow   *t;
    int         newx, newy, ndir;
    bool        move;
    int         w, h;
    int         winw = tmp_win->frame_width  + 2 * tmp_win->frame_bw;
    int         winh = tmp_win->frame_height + 2 * tmp_win->frame_bw;
 
    for(t = Scr->FirstWindow; t != NULL; t = t->next) {
        if(t == tmp_win) {
            continue;
        }
#ifdef WINBOX
        if(t->winbox != tmp_win->winbox) {
            continue;
        }
#endif
        if(t->vs != tmp_win->vs) {
            continue;
        }
        if(!t->mapped) {
            continue;
        }
 
        w = t->frame_width  + 2 * t->frame_bw;
        h = t->frame_height + 2 * t->frame_bw;
        if(x >= t->frame_x + w) {
            continue;
        }
        if(y >= t->frame_y + h) {
            continue;
        }
        if(x + winw <= t->frame_x) {
            continue;
        }
        if(y + winh <= t->frame_y) {
            continue;
        }
 
        move = false;
        if((dir == PD_ANY || dir == PD_LEFT) &&
                        (x + Scr->MovePackResistance > t->frame_x + w)) {
            newx = x - w;
            newy = t->frame_y;
            ndir = PD_LEFT;
            move = true;
        }
        else if((dir == PD_ANY || dir == PD_RIGHT) &&
                        (x + winw < t->frame_x + Scr->MovePackResistance)) {
            newx = x + winw;
            newy = t->frame_y;
            ndir = PD_RIGHT;
            move = true;
        }
        else if((dir == PD_ANY || dir == PD_TOP) &&
                        (y + Scr->MovePackResistance > t->frame_y + h)) {
            newx = t->frame_x;
            newy = y - h;
            ndir = PD_TOP;
            move = true;
        }
        else if((dir == PD_ANY || dir == PD_BOTTOM) &&
                        (y + winh < t->frame_y + Scr->MovePackResistance)) {
            newx = t->frame_x;
            newy = y + winh;
            ndir = PD_BOTTOM;
            move = true;
        }
        if(move) {
            TryToPush_be(t, newx, newy, ndir);
            TryToPack(t, &newx, &newy);
            ConstrainByBorders(tmp_win,
                               &newx, t->frame_width  + 2 * t->frame_bw,
                               &newy, t->frame_height + 2 * t->frame_bw);
            SetupWindow(t, newx, newy, t->frame_width, t->frame_height, -1);
        }
    }
}
 
 
void
TryToGrid(TwmWindow *tmp_win, int *x, int *y)
{
    int w    = tmp_win->frame_width  + 2 * tmp_win->frame_bw;
    int h    = tmp_win->frame_height + 2 * tmp_win->frame_bw;
    int grav = ((tmp_win->hints.flags & PWinGravity)
                ? tmp_win->hints.win_gravity : NorthWestGravity);
 
    switch(grav) {
        case ForgetGravity :
        case StaticGravity :
        case NorthWestGravity :
        case NorthGravity :
        case WestGravity :
        case CenterGravity :
            *x = ((*x - Scr->BorderLeft) / Scr->XMoveGrid) * Scr->XMoveGrid
                 + Scr->BorderLeft;
            *y = ((*y - Scr->BorderTop) / Scr->YMoveGrid) * Scr->YMoveGrid
                 + Scr->BorderTop;
            break;
        case NorthEastGravity :
        case EastGravity :
            *x = (((*x + w - Scr->BorderLeft) / Scr->XMoveGrid) *
                  Scr->XMoveGrid) - w + Scr->BorderLeft;
            *y = ((*y - Scr->BorderTop) / Scr->YMoveGrid) *
                 Scr->YMoveGrid + Scr->BorderTop;
            break;
        case SouthWestGravity :
        case SouthGravity :
            *x = ((*x - Scr->BorderLeft) / Scr->XMoveGrid) * Scr->XMoveGrid
                 + Scr->BorderLeft;
            *y = (((*y + h - Scr->BorderTop) / Scr->YMoveGrid) * Scr->YMoveGrid)
                 - h + Scr->BorderTop;
            break;
        case SouthEastGravity :
            *x = (((*x + w - Scr->BorderLeft) / Scr->XMoveGrid) *
                  Scr->XMoveGrid) - w + Scr->BorderLeft;
            *y = (((*y + h - Scr->BorderTop) / Scr->YMoveGrid) *
                  Scr->YMoveGrid) - h + Scr->BorderTop;
            break;
    }
}
 
 
 
#ifdef WINBOX
/*
 * Functions related to keeping windows from being placed off-screen (or
 * off-screen too far).  Involved in handling of params like DontMoveOff
 * and MoveOffResistance, etc.
 */
static void ConstrainLeftTop(int *value, int border);
static void ConstrainRightBottom(int *value, int size1, int border, int size2);
#endif
 
bool
ConstrainByLayout(RLayout *layout, int move_off_res, int *left, int width,
                  int *top, int height)
{
    RArea area = RAreaNew(*left, *top, width, height);
    int limit;
    bool clipped = false;
 
    limit = RLayoutFindBottomEdge(layout, &area) - height + 1;
    if(area.y > limit) {
        if(move_off_res >= 0 && area.y >= limit + move_off_res) {
            area.y -= move_off_res;
        }
        else {
            area.y = limit;
            clipped = true;
        }
    }
 
    limit = RLayoutFindRightEdge(layout, &area) - width + 1;
    if(area.x > limit) {
        if(move_off_res >= 0 && area.x >= limit + move_off_res) {
            area.x -= move_off_res;
        }
        else {
            area.x = limit;
            clipped = true;
        }
    }
 
    limit = RLayoutFindLeftEdge(layout, &area);
    if(area.x < limit) {
        if(move_off_res >= 0 && area.x <= limit - move_off_res) {
            area.x += move_off_res;
        }
        else {
            area.x = limit;
            clipped = true;
        }
    }
 
    limit = RLayoutFindTopEdge(layout, &area);
    if(area.y < limit) {
        if(move_off_res >= 0 && area.y <= limit - move_off_res) {
            area.y += move_off_res;
        }
        else {
            area.y = limit;
            clipped = true;
        }
    }
 
    *left = area.x;
    *top = area.y;
 
    return clipped;
}
 
void
ConstrainByBorders1(int *left, int width, int *top, int height)
{
    ConstrainByLayout(Scr->BorderedLayout, Scr->MoveOffResistance,
                      left, width, top, height);
}
 
void
ConstrainByBorders(TwmWindow *twmwin, int *left, int width,
                   int *top, int height)
{
    if(false) {
        // Dummy
    }
#ifdef WINBOX
    else if(twmwin->winbox) {
        XWindowAttributes attr;
        XGetWindowAttributes(dpy, twmwin->winbox->window, &attr);
        ConstrainRightBottom(left, width, 0, attr.width);
        ConstrainLeftTop(left, 0);
        ConstrainRightBottom(top, height, 0, attr.height);
        ConstrainLeftTop(top, 0);
    }
#endif
    else {
        ConstrainByBorders1(left, width, top, height);
    }
}
 
#ifdef WINBOX
static void
ConstrainLeftTop(int *value, int border)
{
    if(*value < border) {
        if(Scr->MoveOffResistance < 0 ||
                        *value > border - Scr->MoveOffResistance) {
            *value = border;
        }
        else if(Scr->MoveOffResistance > 0 &&
                        *value <= border - Scr->MoveOffResistance) {
            *value = *value + Scr->MoveOffResistance;
        }
    }
}
 
static void
ConstrainRightBottom(int *value, int size1, int border, int size2)
{
    if(*value + size1 > size2 - border) {
        if(Scr->MoveOffResistance < 0 ||
                        *value + size1 < size2 - border + Scr->MoveOffResistance) {
            *value = size2 - size1 - border;
        }
        else if(Scr->MoveOffResistance > 0 &&
                        *value + size1 >= size2 - border + Scr->MoveOffResistance) {
            *value = *value - Scr->MoveOffResistance;
        }
    }
}
#endif
 
 
/*
 * Zoom over to a particular window.
 */
void
WarpToWindow(TwmWindow *t, bool must_raise)
{
    int x, y;
 
    if(t->ring.cursor_valid) {
        x = t->ring.curs_x;
        y = t->ring.curs_y;
#ifdef DEBUG
        fprintf(stderr, "WarpToWindow: cursor_valid; x == %d, y == %d\n", x, y);
#endif
 
        /*
         * XXX is this correct with 3D borders? Easier check possible?
         * frame_bw is for the left border.
         */
        if(x < t->frame_bw) {
            x = t->frame_bw;
        }
        if(x >= t->frame_width + t->frame_bw) {
            x  = t->frame_width + t->frame_bw - 1;
        }
        if(y < t->title_height + t->frame_bw) {
            y = t->title_height + t->frame_bw;
        }
        if(y >= t->frame_height + t->frame_bw) {
            y  = t->frame_height + t->frame_bw - 1;
        }
#ifdef DEBUG
        fprintf(stderr, "WarpToWindow: adjusted    ; x := %d, y := %d\n", x, y);
#endif
    }
    else {
        x = t->frame_width / 2;
        y = t->frame_height / 2;
#ifdef DEBUG
        fprintf(stderr, "WarpToWindow: middle; x := %d, y := %d\n", x, y);
#endif
    }
#if 0
    int dest_x, dest_y;
    Window child;
 
    /*
     * Check if the proposed position actually is visible. If not, raise the window.
     * "If the coordinates are contained in a mapped
     * child of dest_w, that child is returned to child_return."
     * We'll need to check for the right child window; the frame probably.
     * (What about XXX window boxes?)
     *
     * Alternatively, use XQueryPointer() which returns the root window
     * the pointer is in, but XXX that won't work for VirtualScreens.
     */
    if(XTranslateCoordinates(dpy, t->frame, Scr->Root, x, y, &dest_x, &dest_y,
                             &child)) {
        if(child != t->frame) {
            must_raise = true;
        }
    }
#endif
    if(t->auto_raise || must_raise) {
        AutoRaiseWindow(t);
    }
    if(! visible(t)) {
        WorkSpace *wlist;
 
        for(wlist = Scr->workSpaceMgr.workSpaceList; wlist != NULL;
                        wlist = wlist->next) {
            if(OCCUPY(t, wlist)) {
                break;
            }
        }
        if(wlist != NULL) {
            GotoWorkSpace(Scr->currentvs, wlist);
        }
    }
 
    XWarpPointer(dpy, None, Scr->Root, 0, 0, 0, 0, x + t->frame_x, y + t->frame_y);
    SetFocus(t, EventTime);
 
#ifdef DEBUG
    {
        Window root_return;
        Window child_return;
        int root_x_return;
        int root_y_return;
        int win_x_return;
        int win_y_return;
        unsigned int mask_return;
 
        if(XQueryPointer(dpy, t->frame, &root_return, &child_return, &root_x_return,
                         &root_y_return, &win_x_return, &win_y_return, &mask_return)) {
            fprintf(stderr,
                    "XQueryPointer: root_return=%x, child_return=%x, root_x_return=%d, root_y_return=%d, win_x_return=%d, win_y_return=%d\n",
                    root_return, child_return, root_x_return, root_y_return, win_x_return,
                    win_y_return);
        }
    }
#endif
}
 
 
/*
 * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
 * client messages will have the following form:
 *
 *     event type       ClientMessage
 *     message type     XA_WM_PROTOCOLS
 *     window           tmp->w
 *     format           32
 *     data[0]          message atom
 *     data[1]          time stamp
 */
void
send_clientmessage(Window w, Atom a, Time timestamp)
{
    XClientMessageEvent ev;
 
    ev.type = ClientMessage;
    ev.window = w;
    ev.message_type = XA_WM_PROTOCOLS;
    ev.format = 32;
    ev.data.l[0] = a;
    ev.data.l[1] = timestamp;
    XSendEvent(dpy, w, False, 0L, (XEvent *) &ev);
}
 
 
/*
 * Create synthetic WM_HINTS info for windows.  When a window specifies
 * stuff, we should probably pay attention to it (though we don't
 * always; x-ref comments in AddWindow() especially about focus).
 * However, when it doesn't tell us anything at all, we should assume
 * something useful.  "Window managers are free to assume convenient
 * values for all fields of the WM_HINTS property if a window is mapped
 * without one."  (ICCCM Ch. 4,
 * <https://www.x.org/releases/X11R7.7/doc/xorg-docs/icccm/icccm.html#Client_Properties>).
 *
 * Specifically, we assume it wants us to give it focus.  It's fairly
 * bogus for a window not to tell us anything, but e.g current versions
 * of Chrome do (don't do) just that.  So we better make up something
 * useful.
 *
 * Should probably be some configurability for this, so make the func
 * take the window, even though we don't currently do anything useful
 * with it...
 */
XWMHints *
gen_synthetic_wmhints(TwmWindow *win)
{
    XWMHints *hints;
 
    hints = XAllocWMHints();
    if(!hints) {
        return NULL;
    }
 
    /*
     * Reasonable defaults.  Takes input, in normal state.
     *
     * XXX Make configurable?
     */
    hints->flags = InputHint | StateHint;
    hints->input = True;
    hints->initial_state = NormalState;
 
    return hints;
}
 
 
/**
 * Perform whatever adaptations of WM_HINTS info we do.
 *
 * Most of these relate to focus, but we also fiddle with group
 * membership.
 */
XWMHints *
munge_wmhints(TwmWindow *win, XWMHints *hints)
{
    /*
     * If we have WM_HINTS, but they don't tell us anything about focus,
     * force it to true for our purposes.
     *
     * CL: Having with not willing focus cause problems with AutoSqueeze
     * and a few others things. So I suppress it. And the whole focus
     * thing is buggy anyway.
     */
    if(!(hints->flags & InputHint)) {
        hints->input = True;
    }
 
    /*
     * Now we're expecting to give the window focus if it asked for it
     * via WM_HINTS, if it didn't say anything one way or the other in
     * WM_HINTS, or if it didn't give us any WM_HINTS at all.  But if it
     * explicitly asked not to, we don't give it unless overridden by
     * config.
     */
    if(Scr->ForceFocus || IsInList(Scr->ForceFocusL, win)) {
        hints->input = True;
    }
 
 
    /* Setup group bits */
    if(hints->flags & WindowGroupHint) {
        win->group = hints->window_group;
        if(win->group) {
            /*
             * GTK windows often have a spurious "group leader" window which is
             * never reported to us and therefore does not really exist.  This
             * is annoying because we treat group members a lot like transient
             * windows.  Look for that here. It is in fact a duplicate of the
             * WM_CLIENT_LEADER property.
             */
            if(win->group != win->w && !GetTwmWindow(win->group)) {
                win->group = 0;
            }
        }
    }
    else {
        win->group = 0;
    }
 
    return hints;
}
 
 
/**
 * [Re]set a window's name.  This goes over the available naming sources
 * for the window and points the TwmWindow::name at the appropriate one.
 * It may also set a property to signal other EWMH-aware clients when
 * we're naming it a way they can't see themselves.
 *
 * \note This should rarely be called directly; apply_window_name()
 * should be used instead.  It's split out because we need to do this
 * step individually in AddWindow().
 *
 * \note Note also that we never need to worry about freeing the
 * TwmWindow::name; it always points to one of the TwmWindow::names
 * values (which are free'd by the event handler when they change) or to
 * NoName (which is static).  So we can just casually flip it around at
 * will.
 */
bool
set_window_name(TwmWindow *win)
{
    char *newname = NULL;
#define TRY(fld) { \
                if(newname == NULL && win->names.fld != NULL) { \
                        newname = win->names.fld; \
                } \
        }
    TRY(ctwm_wm_name)
#ifdef EWMH
    TRY(net_wm_name)
#endif
    TRY(wm_name)
#undef TRY
 
    if(newname == NULL) {
        newname = NoName;
    }
    if(win->name == newname) {
        return false; // Nothing to do
    }
 
    // Now we know what to call it
    win->name = newname;
 
#ifdef EWMH
    // EWMH says we set an additional property on any windows where what
    // we consider the name isn't what's in _NET_WM_NAME, so pagers etc
    // can call it the same as we do.
    //
    // The parts of the text describing it conflict a little; at one
    // place, it implies this should be set unless we're using
    // _NET_WM_NAME, in another it seems to suggest WM_NAME should be
    // considered applicable too.  I choose to implement it excluding
    // both, so this only gets set if we're overriding either standard
    // naming (probably rare).
    if(win->name != win->names.net_wm_name && win->name != win->names.wm_name) {
        // XXX We're not doing any checking of the encoding here...  I
        // don't see that Xlib helps us any, so we probably have to fall
        // back to iconv?  That came into the base in POSIX 2008, but was
        // in XSI back into the 90's I believe?
        XChangeProperty(dpy, win->w, XA__NET_WM_VISIBLE_NAME, XA_UTF8_STRING,
                        8, PropModeReplace, (unsigned char *)win->name,
                        strlen(win->name));
    }
    else {
        XDeleteProperty(dpy, win->w, XA__NET_WM_VISIBLE_NAME);
    }
#endif // EWMH
 
    // We set a name
    return true;
}
 
 
/**
 * [Re]set and apply changes to a window's name.  This is called after
 * we've received a new WM_NAME (or other name-setting) property, to
 * update our titlebars, icon managers, etc.
 */
void
apply_window_name(TwmWindow *win)
{
    /* [Re]set ->name */
    if(set_window_name(win) == false) {
        // No change
        return;
    }
    win->nameChanged = true;
 
 
    /* Update the active name */
    {
        XRectangle inc_rect;
        XRectangle logical_rect;
 
        XmbTextExtents(Scr->TitleBarFont.font_set,
                       win->name, strlen(win->name),
                       &inc_rect, &logical_rect);
        win->name_width = logical_rect.width;
    }
 
    /* recompute the priority if necessary */
    if(Scr->AutoPriority) {
        OtpRecomputePrefs(win);
    }
 
    SetupWindow(win, win->frame_x, win->frame_y,
                win->frame_width, win->frame_height, -1);
 
    if(win->title_w) {
        XClearArea(dpy, win->title_w, 0, 0, 0, 0, True);
    }
    if(Scr->AutoOccupy) {
        WmgrRedoOccupation(win);
    }
 
#if 0
    /* Experimental, not yet working. */
    {
        ColorPair cp;
        int f, b;
 
        f = GetColorFromList(Scr->TitleForegroundL, win->name,
                             &win->class, &cp.fore);
        b = GetColorFromList(Scr->TitleBackgroundL, win->name,
                             &win->class, &cp.back);
        if(f || b) {
            if(Scr->use3Dtitles  && !Scr->BeNiceToColormap) {
                GetShadeColors(&cp);
            }
            win->title = cp;
        }
        f = GetColorFromList(Scr->BorderColorL, win->name,
                             &win->class, &cp.fore);
        b = GetColorFromList(Scr->BorderColorL, win->name,
                             &win->class, &cp.back);
        if(f || b) {
            if(Scr->use3Dborders && !Scr->BeNiceToColormap) {
                GetShadeColors(&cp);
            }
            win->borderC = cp;
        }
 
        f = GetColorFromList(Scr->BorderTileForegroundL, win->name,
                             &win->class, &cp.fore);
        b = GetColorFromList(Scr->BorderTileBackgroundL, win->name,
                             &win->class, &cp.back);
        if(f || b) {
            if(Scr->use3Dborders && !Scr->BeNiceToColormap) {
                GetShadeColors(&cp);
            }
            win->border_tile = cp;
        }
    }
#endif
 
    /*
     * If we haven't set a separate icon name, we use the window name, so
     * we need to update it.
     */
    if(win->names.icon_set == false) {
        apply_window_icon_name(win);
    }
    AutoPopupMaybe(win);
 
    return;
}
 
 
/**
 * [Re]set a window's icon name.  As with the window name version in
 * set_window_name(), this is mostly separate so the AddWindow() process
 * can call it.
 *
 * \note As with TwmWindow::name, we never want to try free()'ing or the
 * like TwmWindow::icon_name.
 *
 * \sa set_window_name() for details; this is just the icon name
 * equivalent of it.
 */
bool
set_window_icon_name(TwmWindow *win)
{
    char *newname = NULL;
#define TRY(fld) { \
                if(newname == NULL && win->names.fld != NULL) { \
                        newname = win->names.fld; \
                        win->names.icon_set = true; \
                } \
        }
    TRY(ctwm_wm_icon_name)
#ifdef EWMH
    TRY(net_wm_icon_name)
#endif
    TRY(wm_icon_name)
#undef TRY
 
    // Our fallback for icon names is the window name.  Flag when we're
    // doing that, so the window name handler can know when it needs to
    // call us.
    if(newname == NULL) {
        newname = win->name;
        win->names.icon_set = false;
    }
    if(win->icon_name == newname) {
        return false; // Nothing to do
    }
 
    // A name is chosen
    win->icon_name = newname;
 
#ifdef EWMH
    // EWMH asks for _NET_WM_VISIBLE_ICON_NAME in various cases where
    // we're not using 'standard' properties' values.  x-ref comments above in
    // set_window_name() about the parallel property for the window name
    // for various caveats.
    if(win->icon_name != win->names.net_wm_icon_name
                    && win->icon_name != win->names.wm_icon_name) {
        // XXX Still encoding questionable; x-ref above.
        XChangeProperty(dpy, win->w, XA__NET_WM_VISIBLE_ICON_NAME,
                        XA_UTF8_STRING,
                        8, PropModeReplace, (unsigned char *)win->icon_name,
                        strlen(win->icon_name));
    }
    else {
        XDeleteProperty(dpy, win->w, XA__NET_WM_VISIBLE_ICON_NAME);
    }
#endif // EWMH
 
    // Did it
    return true;
}
 
 
/**
 * [Re]set and apply changes to a window's icon name.  This is called
 * after we've received a new WM_ICON_NAME (or other name-setting)
 * property, to update our titlebars, icon managers, etc.
 *
 * \sa apply_window_name() which does the same for the window title.
 */
void
apply_window_icon_name(TwmWindow *win)
{
    /* [Re]set ->icon_name */
    if(set_window_icon_name(win) == false) {
        // No change
        return;
    }
 
 
    /* Lot less to do for icons... */
    RedoIcon(Tmp_win);
    AutoPopupMaybe(Tmp_win);
 
    return;
}