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

Go to the documentation of this file.

/*
 * Occupation handling bits
 *
 * This is in fact pretty tightly tied and extremely similar to the
 * handling of the WorkSpaceManager in workmgr.c, and used to be there.
 * It makes sense to consider them together (and indeed, many of the
 * configs that affect how this works are really WorkSpaceManager* or
 * WMgr* commands.  But having them crammed together in one file is
 * unwieldy.
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include <X11/Xatom.h>
 
#include "add_window.h"
#include "ctwm_atoms.h"
#include "drawing.h"
#include "events.h"
#include "iconmgr.h"
#include "list.h"
#include "screen.h"
#include "occupation.h"
#include "otp.h"
#include "util.h"
#include "vscreen.h"
#include "win_iconify.h"
#include "win_regions.h"
#include "win_utils.h"
#include "workspace_manager.h"
#include "workspace_utils.h"
 
 
static int GetMaskFromResource(TwmWindow *win, char *res);
static char *mk_nullsep_string(const char *prop, int len);
 
static bool CanChangeOccupation(TwmWindow **twm_winp);
 
int fullOccupation = 0;
 
/*
 * The window whose occupation is currently being manipulated.
 *
 * XXX Should probably be static, but currently needed in
 * WMapRemoveWindow().  Revisit.
 */
TwmWindow *occupyWin = NULL;
 
 
/* XXX Share with captive.c? */
static XrmOptionDescRec table [] = {
    {"-xrm",            NULL,           XrmoptionResArg, (XPointer) NULL},
};
 
 
 
 
/*
 ****************************************************************
 *
 * First, funcs related to setting and changing a window's occupation.
 *
 ****************************************************************
 */
 
 
/*
 * Setup the occupation of a TwmWindow.  Called as part of the
 * AddWindow() process.
 *
 * XXX The logic flow in this is kinda weird, and it's not at all clear
 * to what extent it's really doing the right on on what should override
 * what, or which things should expand/contract on others...
 */
void
SetupOccupation(TwmWindow *twm_win, int occupation_hint)
{
    char      **cliargv = NULL;
    int       cliargc;
    WorkSpace *ws;
 
    /* If there aren't any config'd workspaces, there's only 0 */
    if(! Scr->workSpaceManagerActive) {
        twm_win->occupation = 1 << 0;   /* occupy workspace #0 */
        /* more?... */
 
        return;
    }
 
    /* Workspace manager window doesn't get futzed with */
    if(twm_win->iswspmgr) {
        return;
    }
 
    /*twm_win->occupation = twm_win->iswinbox ? fullOccupation : 0;*/
    twm_win->occupation = 0;
 
    /* Specified in any Occupy{} config params? */
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        if(LookInList(ws->clientlist, twm_win->name, &twm_win->class)) {
            twm_win->occupation |= 1 << ws->number;
        }
    }
 
    /* OccupyAll{} */
    if(LookInList(Scr->OccupyAll, twm_win->name, &twm_win->class)) {
        twm_win->occupation = fullOccupation;
    }
 
    /* See if it specified in -xrm stuff */
    if(XGetCommand(dpy, twm_win->w, &cliargv, &cliargc)) {
        Bool status;
        char *str_type;
        XrmValue value;
        XrmDatabase db = NULL;
 
        XrmParseCommand(&db, table, 1, "ctwm", &cliargc, cliargv);
        XFreeStringList(cliargv);
        status = XrmGetResource(db, "ctwm.workspace", "Ctwm.Workspace",
                                &str_type, &value);
        if((status == True) && (value.size != 0)) {
            /* Copy the value.addr because it's in XRM memory not ours */
            char wrkSpcList[512];
            safe_strncpy(wrkSpcList, value.addr, MIN(value.size, 512));
 
            twm_win->occupation = GetMaskFromResource(twm_win, wrkSpcList);
        }
        XrmDestroyDatabase(db);
    }
 
    /* Does it have a property telling us */
    if(RestartPreviousState) {
        Atom actual_type;
        int actual_format;
        unsigned long nitems, bytesafter;
        unsigned char *prop;
 
        if(XGetWindowProperty(dpy, twm_win->w, XA_WM_OCCUPATION, 0L, 2500, False,
                              XA_STRING, &actual_type, &actual_format, &nitems,
                              &bytesafter, &prop) == Success) {
            if(nitems != 0) {
                twm_win->occupation = GetMaskFromProperty(prop, nitems);
                XFree(prop);
            }
        }
    }
 
#ifdef EWMH
    /* Maybe EWMH has something to tell us? */
    if(twm_win->occupation == 0) {
        twm_win->occupation = EwmhGetOccupation(twm_win);
    }
#endif /* EWMH */
 
    /* Icon Managers shouldn't get altered */
    /* XXX Should this be up near the top? */
    if(twm_win->isiconmgr) {
        return;        /* someone tried to modify occupation of icon managers */
    }
 
 
    /*
     * Transient-ish things go with their parents unless
     * TransientHasOccupation set in the config.
     */
    if(! Scr->TransientHasOccupation) {
        TwmWindow *t;
 
        if(twm_win->istransient) {
            t = GetTwmWindow(twm_win->transientfor);
            if(t != NULL) {
                twm_win->occupation = t->occupation;
            }
        }
        else if(twm_win->group != 0) {
            t = GetTwmWindow(twm_win->group);
            if(t != NULL) {
                twm_win->occupation = t->occupation;
            }
        }
    }
 
 
    /* If we were told something specific, go with that */
    if(occupation_hint != 0) {
        twm_win->occupation = occupation_hint;
    }
 
    /* If it's apparently-nonsensical, put it in its vs's workspace */
    if((twm_win->occupation & fullOccupation) == 0) {
        twm_win->occupation = 1 << twm_win->vs->wsw->currentwspc->number;
    }
 
    /*
     * If the occupation would not show it in the current vscreen,
     * make it vanish.
     *
     * If it could be shown in one of the other vscreens, change the vscreen.
     */
    if(!OCCUPY(twm_win, twm_win->vs->wsw->currentwspc)) {
 
        twm_win->vs = NULL;
 
#ifdef VSCREEN
        if(Scr->numVscreens > 1) {
            VirtualScreen *vs;
            for(vs = Scr->vScreenList; vs != NULL; vs = vs->next) {
                if(OCCUPY(twm_win, vs->wsw->currentwspc)) {
                    twm_win->vs = vs;
                    twm_win->parent_vs = vs;
                    break;
                }
            }
        }
#endif
    }
 
 
    /* Set the property for the occupation */
    {
        long eventMask;
        char *wsstr;
        int  len;
 
        /* Ignore the PropertyChange we're about to do */
        if((eventMask = mask_out_event(twm_win->w, PropertyChangeMask)) < 0) {
            /* Window is horked, not much we can do */
            return;
        }
 
        /* Set the property for the occupation */
        len = GetPropertyFromMask(twm_win->occupation, &wsstr);
        XChangeProperty(dpy, twm_win->w, XA_WM_OCCUPATION, XA_STRING, 8,
                        PropModeReplace, (unsigned char *) wsstr, len);
        free(wsstr);
 
#ifdef EWMH
        EwmhSet_NET_WM_DESKTOP(twm_win);
#endif
 
        /* Restore event mask */
        restore_mask(twm_win->w, eventMask);
    }
 
    /* Set WM_STATE prop */
    {
        int state = NormalState;
        Window icon;
 
        if(!(RestartPreviousState
                        && GetWMState(twm_win->w, &state, &icon)
                        && (state == NormalState || state == IconicState
                            || state == InactiveState))) {
            if(twm_win->wmhints->flags & StateHint) {
                state = twm_win->wmhints->initial_state;
            }
        }
        if(visible(twm_win)) {
            if(state == InactiveState) {
                SetMapStateProp(twm_win, NormalState);
            }
        }
        else {
            if(state == NormalState) {
                SetMapStateProp(twm_win, InactiveState);
            }
        }
    }
}
 
 
/*
 * Make sure a window is marked in a given workspace.  f.addtoworkspace.
 * Also gets called as part of the process of mapping a window; if we're
 * mapping it here, it should know that it's here.  And Xinerama magic
 * moves.
 */
void
AddToWorkSpace(char *wname, TwmWindow *twm_win)
{
    WorkSpace *ws;
    int newoccupation;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
    ws = GetWorkspace(wname);
    if(!ws) {
        return;
    }
 
    if(twm_win->occupation & (1 << ws->number)) {
        return;
    }
    newoccupation = twm_win->occupation | (1 << ws->number);
    ChangeOccupation(twm_win, newoccupation);
}
 
 
/*
 * Converse of the above.  f.removefromworkspace, also called from
 * Xinerama-related magic.
 */
void
RemoveFromWorkSpace(char *wname, TwmWindow *twm_win)
{
    WorkSpace *ws;
    int newoccupation;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
    ws = GetWorkspace(wname);
    if(!ws) {
        return;
    }
 
    newoccupation = twm_win->occupation & ~(1 << ws->number);
    if(!newoccupation) {
        return;
    }
    ChangeOccupation(twm_win, newoccupation);
}
 
 
/* f.toggleoccupation - flip setting for [current] workspace */
void
ToggleOccupation(char *wname, TwmWindow *twm_win)
{
    WorkSpace *ws;
    int newoccupation;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
    ws = GetWorkspace(wname);
    if(!ws) {
        return;
    }
 
    newoccupation = twm_win->occupation ^ (1 << ws->number);
    if(!newoccupation) {
        /* Don't allow de-occupying _every_ ws */
        return;
    }
    ChangeOccupation(twm_win, newoccupation);
}
 
 
/* f.movetonextworkspace */
void
MoveToNextWorkSpace(VirtualScreen *vs, TwmWindow *twm_win)
{
    WorkSpace *wlist1, *wlist2;
    int newoccupation;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    wlist1 = vs->wsw->currentwspc;
    wlist2 = wlist1->next;
    wlist2 = wlist2 ? wlist2 : Scr->workSpaceMgr.workSpaceList;
 
    /* Out of (here), into (here+1) */
    newoccupation = (twm_win->occupation ^ (1 << wlist1->number))
                    | (1 << wlist2->number);
    ChangeOccupation(twm_win, newoccupation);
}
 
 
/* f.movetonextworkspaceandfollow */
void
MoveToNextWorkSpaceAndFollow(VirtualScreen *vs, TwmWindow *twm_win)
{
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    MoveToNextWorkSpace(vs, twm_win);
    GotoNextWorkSpace(vs);
#if 0
    OtpRaise(twm_win, WinWin);  /* XXX really do this? */
#endif
}
 
 
/* f.movetoprevworkspaceand */
void
MoveToPrevWorkSpace(VirtualScreen *vs, TwmWindow *twm_win)
{
    WorkSpace *wlist1, *wlist2;
    int newoccupation;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    wlist1 = Scr->workSpaceMgr.workSpaceList;
    wlist2 = vs->wsw->currentwspc;
    if(wlist1 == NULL) {
        return;
    }
 
    while(wlist1->next != wlist2 && wlist1->next != NULL) {
        wlist1 = wlist1->next;
    }
 
    /* Out of (here), into (here-1) */
    newoccupation = (twm_win->occupation ^ (1 << wlist2->number))
                    | (1 << wlist1->number);
    ChangeOccupation(twm_win, newoccupation);
}
 
 
/* f.movetoprevworkspaceandfollow */
void
MoveToPrevWorkSpaceAndFollow(VirtualScreen *vs, TwmWindow *twm_win)
{
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    MoveToPrevWorkSpace(vs, twm_win);
    GotoPrevWorkSpace(vs);
#if 0
    OtpRaise(twm_win, WinWin);          /* XXX really do this? */
#endif
}
 
 
/*
 * Set the occupation based on the window name.  This is called if
 * AutoOccupy is set, when we get a notification about a window name
 * change.
 */
void
WmgrRedoOccupation(TwmWindow *win)
{
    WorkSpace *ws;
    int       newoccupation;
 
    if(LookInList(Scr->OccupyAll, win->name, &win->class)) {
        newoccupation = fullOccupation;
    }
    else {
        newoccupation = 0;
        for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
            if(LookInList(ws->clientlist, win->name, &win->class)) {
                newoccupation |= 1 << ws->number;
            }
        }
    }
    if(newoccupation != 0) {
        ChangeOccupation(win, newoccupation);
    }
}
 
 
/* f.vanish */
void
WMgrRemoveFromCurrentWorkSpace(VirtualScreen *vs, TwmWindow *win)
{
    WorkSpace *ws;
    int       newoccupation;
 
    ws = vs->wsw->currentwspc;
    if(!ws) {
        /* Impossible? */
        return;
    }
    if(! OCCUPY(win, ws)) {
        return;
    }
 
    newoccupation = win->occupation & ~(1 << ws->number);
    if(newoccupation == 0) {
        return;
    }
 
    ChangeOccupation(win, newoccupation);
}
 
 
/* f.warphere */
void
WMgrAddToCurrentWorkSpaceAndWarp(VirtualScreen *vs, char *winname)
{
    TwmWindow *tw;
    int       newoccupation;
 
    /* Find named window on this screen */
    for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {
        if(match(winname, tw->name)) {
            break;
        }
    }
 
    /* Didn't find it by name?  Try by class */
    if(!tw) {
        for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {
            if(match(winname, tw->class.res_name)) {
                break;
            }
        }
    }
    if(!tw) {
        for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {
            if(match(winname, tw->class.res_class)) {
                break;
            }
        }
    }
 
    /* Still didn't find?  Beep at the user and bail. */
    if(!tw) {
        XBell(dpy, 0);
        return;
    }
 
    /* If WarpUnmapped isn't set and this isn't mapped, beep and bail */
    if((! Scr->WarpUnmapped) && (! tw->mapped)) {
        XBell(dpy, 0);
        return;
    }
 
    /* Move it here if it's not */
    if(! OCCUPY(tw, vs->wsw->currentwspc)) {
        newoccupation = tw->occupation | (1 << vs->wsw->currentwspc->number);
        ChangeOccupation(tw, newoccupation);
    }
 
    /* If we get here, WarpUnmapped is set, so map it if we need to */
    if(! tw->mapped) {
        DeIconify(tw);
    }
 
    /* And go */
    WarpToWindow(tw, Scr->RaiseOnWarp);
}
 
 
/* f.occupyall backend */
void
OccupyAll(TwmWindow *twm_win)
{
    IconMgr *save;
 
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    /*
     * Temporarily alter Scr->iconmgr because stuff down in
     * ChangeOccupation winds up adding/removing bits, and that doesn't
     * work right when we're setting all?  XXX Investigate further.
     */
    save = Scr->iconmgr;
    Scr->iconmgr = Scr->workSpaceMgr.workSpaceList->iconmgr;
    ChangeOccupation(twm_win, fullOccupation);
    Scr->iconmgr = save;
}
 
 
 
/*
 ****************************************************************
 *
 * Pieces related to the Occupy window
 *
 ****************************************************************
 */
 
static ColorPair occupyButtoncp;
 
static char *ok_string         = "OK",
             *cancel_string     = "Cancel",
              *everywhere_string = "All";
 
/*
 * Create the Occupy window.  Part of startup process.
 *
 * Do not do the layout of the parts, only calculate the initial total
 * size. For the layout, call ResizeOccupyWindow() at the end.
 *
 * There is only one Occupy window (per Screen), it is reparented to each
 * virtual screen as needed.
 */
void
CreateOccupyWindow(void)
{
    int           width; // Caculated and altered, unlike most others
    int           Dummy = 1;
    TwmWindow     *tmp_win;
    /* Shorthands for the Occupy window */
    OccupyWindow  *occwin = Scr->workSpaceMgr.occupyWindow;
    Window        w; // occwin->w
    /* Misc other shorthands */
    const int lines   = Scr->workSpaceMgr.lines;
    const int columns = Scr->workSpaceMgr.columns;
    const int bwidth  = Scr->vScreenList->wsw->bwidth;
    const int bheight = Scr->vScreenList->wsw->bheight;
    const int vspace = occwin->vspace;
    const int hspace = occwin->hspace;
    const int height = ((bheight + vspace) * lines) + bheight + (2 * vspace);
 
    /* Struct embedded in [struct embedded in] Scr, so memory's waiting */
 
    /* There isn't anything we should do without workspaces... */
    if(!Scr->workSpaceManagerActive) {
        return;
    }
 
    /* Initialize font and colorpair bits */
    occwin->font     = Scr->IconManagerFont;
    occwin->cp       = Scr->IconManagerC;
#ifdef COLOR_BLIND_USER
    occwin->cp.shadc = Scr->White;
    occwin->cp.shadd = Scr->Black;
#else
    if(!Scr->BeNiceToColormap) {
        GetShadeColors(&occwin->cp);
    }
#endif
 
    /* We already know that these should be too */
    occwin->lines   = lines;
    occwin->columns = columns;
 
 
    /*
     * Work out the necessary size of the OK/Cancel/All buttons at the
     * bottom.
     */
    {
        XRectangle inc_rect;
        XRectangle logical_rect;
        MyFont font = occwin->font;
        int bbwidth;  // Bottom button width
        /* Window min width based on bottom vs. workspace btns */
        int bb_width, ws_width;
 
        /* Buttons gotta be as wide as the biggest of the three strings */
        XmbTextExtents(font.font_set, ok_string, strlen(ok_string),
                       &inc_rect, &logical_rect);
        bbwidth = logical_rect.width;
 
        XmbTextExtents(font.font_set, cancel_string, strlen(cancel_string),
                       &inc_rect, &logical_rect);
        bbwidth = MAX(bbwidth, logical_rect.width);
 
        XmbTextExtents(font.font_set, everywhere_string,
                       strlen(everywhere_string),
                       &inc_rect, &logical_rect);
        bbwidth = MAX(bbwidth, logical_rect.width);
 
        /* Plus the padding width */
        bbwidth += hspace;
 
        /*
         * So, the final width of those bottom buttons is that, plus the
         * 3d button look extra on both sides, plus a little extra.  I
         * guess that extra + 2 is similar to TitlePadding or
         * ButtonIndent on titlebars, but we don't have a config param
         * for it on the workspace manager (which is the config used for
         * the occupy window), so leave it as a magic constant for now.
         */
        occwin->owidth = bbwidth + 2 * Scr->WMgrButtonShadowDepth + 2;
 
        /*
         * The whole thing has to be at least triple the min width of
         * those bottom buttons, since there are three of them.  The
         * layout is "hspace button hspace button [...] hspace", to pad
         * between and on both sides.
         */
        bb_width = 3 * (bbwidth + hspace) + hspace;
 
        /*
         * It also has to be the width of our per-WS buttons.  Per-ws
         * buttons are sized the same as in the button-state WSM, and
         * then we add the padding to them as above.
         */
        ws_width = columns * (bwidth + hspace) + hspace;
 
        /* So the window has to be as wide as the wider of those */
        width = MAX(bb_width, ws_width);
    }
 
 
    /* Now we know the size, so make the window */
    w = occwin->w = XCreateSimpleWindow(dpy, Scr->Root, 0, 0, width, height,
                                        1, Scr->Black, occwin->cp.back);
 
    /* Take those base sizes as a minimum */
    occwin->minwidth  = width;
    occwin->minheight = height;
 
 
    /*
     * Make subwindows as buttons for the workspaces.  They're laid out
     * in a grid mirroring the workspace manager's.
     */
    {
        int i = 0, j = 0;
        WorkSpace *ws;
 
        occwin->obuttonw = calloc(Scr->workSpaceMgr.count, sizeof(Window));
 
        for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
            int idx = (j * columns) + i;
 
            /*
             * Make and map.  Note that we're not setting the size or
             * location at all here; ResizeOccupyWindow() does all that.
             * We just make 'em.
             */
            occwin->obuttonw[idx] = XCreateSimpleWindow(dpy, w,
                                    Dummy /* x */,
                                    Dummy /* y */,
                                    Dummy /* width */,
                                    Dummy /* height */,
                                    0, Scr->Black, ws->cp.back);
            XMapWindow(dpy, occwin->obuttonw[idx]);
 
            /* Inc around to the next location */
            i++;
            if(i == columns) {
                i = 0;
                j++;
            }
        }
    }
 
 
    /*
     * Now start putting together the OK/Cancel/All buttons
     */
 
    /* Background for them is hardcoded */
    GetColor(Scr->Monochrome, &(occupyButtoncp.back), "gray50");
 
    /* Foreground (not used here) is too */
    occupyButtoncp.fore = Scr->White;
 
    /* Override (probably historical */
    if(!Scr->BeNiceToColormap) {
        GetShadeColors(&occupyButtoncp);
    }
 
    /* Make 'em */
    {
        Window tw;
 
        tw = XCreateSimpleWindow(dpy, w, Dummy, Dummy, Dummy, Dummy, 0,
                                 Scr->Black, occupyButtoncp.back);
        XMapWindow(dpy, tw);
        occwin->OK = tw;
 
        tw = XCreateSimpleWindow(dpy, w, Dummy, Dummy, Dummy, Dummy, 0,
                                 Scr->Black, occupyButtoncp.back);
        XMapWindow(dpy, tw);
        occwin->cancel = tw;
 
        tw = XCreateSimpleWindow(dpy, w, Dummy, Dummy, Dummy, Dummy, 0,
                                 Scr->Black, occupyButtoncp.back);
        XMapWindow(dpy, tw);
        occwin->allworkspc = tw;
    }
 
 
    /* Setup various window properties */
    {
        XSizeHints sizehints;
        XWMHints wmhints;
 
        sizehints.flags       = PBaseSize | PMinSize | PMaxSize;
        sizehints.min_width   = width;
        sizehints.min_height  = height;
        sizehints.base_width  = width;
        sizehints.base_height = height;
        sizehints.max_width   = width;
        sizehints.max_height  = height;
 
        wmhints.flags         = InputHint | StateHint;
        wmhints.input         = True;
        wmhints.initial_state = NormalState;
 
        XmbSetWMProperties(dpy, w, occwin->name, occwin->icon_name,
                           NULL, 0, &sizehints, &wmhints, NULL);
    }
 
 
    /*
     * Create the TwmWindow wrapping around it, with decorations etc.  We
     * do this so early in startup that we're not listening for window
     * creation events yet.
     */
    tmp_win = AddWindow(w, AWT_OCCUPY, Scr->iconmgr, Scr->currentvs);
    if(! tmp_win) {
        fprintf(stderr, "cannot create occupy window, exiting...\n");
        exit(1);
    }
    tmp_win->vs = NULL;
    tmp_win->occupation = 0;
 
    /* tmp_win is more convenient the rest of the func, but put in place */
    occwin->twm_win = tmp_win;
 
 
    /*
     * Setup the window to have a button-pushing cursor and listen for
     * clicks.
     */
    {
        unsigned long attrmask;
        XSetWindowAttributes attr;
        XWindowAttributes wattr;
 
        attr.cursor = Scr->ButtonCursor;
        attrmask = CWCursor;
        XChangeWindowAttributes(dpy, w, attrmask, &attr);
 
        XGetWindowAttributes(dpy, w, &wattr);
        attrmask = wattr.your_event_mask | KeyPressMask | KeyReleaseMask
                   | ExposureMask;
        XSelectInput(dpy, w, attrmask);
    }
 
 
    /*
     * Now for each of the buttons (workspaces + OK/Cancel/All), we mark
     * them as listening to click and exposure events.  We also stash
     * away the screen and wrapping TwmWindow in contexts so other code
     * can dredge them up.
     */
#define EVT (ButtonPressMask | ButtonReleaseMask | ExposureMask)
#define BTN_IPT_CTX(win) \
        XSelectInput(dpy, (win), EVT); \
        XSaveContext(dpy, (win), TwmContext, (XPointer) tmp_win); \
        XSaveContext(dpy, (win), ScreenContext, (XPointer) Scr);
 
    for(WorkSpace *ws = Scr->workSpaceMgr.workSpaceList
                        ; ws != NULL ; ws = ws->next) {
        BTN_IPT_CTX(occwin->obuttonw[ws->number]);
    }
 
    BTN_IPT_CTX(occwin->OK);
    BTN_IPT_CTX(occwin->cancel);
    BTN_IPT_CTX(occwin->allworkspc);
 
#undef BTN_IPT_CTX
#undef EVT
 
 
    /* Mark that we're not mapped */
    SetMapStateProp(tmp_win, WithdrawnState);
 
    /* Now call that func that sizes all the buttons */
    ResizeOccupyWindow(tmp_win);
}
 
 
/*
 * Slightly misleading name: layout the internals of the Occupy window
 * based on its current size.  That does happen when it's resized, but
 * also when it's initially created.  I guess you could call "creation" a
 * resize of a sort...
 */
void
ResizeOccupyWindow(TwmWindow *win)
{
    int        bwidth, bheight, owidth, oheight;
    int        hspace, vspace;
    int        lines, columns;
    int        neww, newh;
    WorkSpace  *ws;
    int        i, j, x, y;
    OccupyWindow *occwin = Scr->workSpaceMgr.occupyWindow;
 
    /* Floor at the original size */
    neww = MAX(win->attr.width,  occwin->minwidth);
    newh = MAX(win->attr.height, occwin->minheight);
    if(occwin->width == neww && occwin->height == newh) {
        return;
    }
 
    /* Space between WS buttons.  From WMgr{Horiz,Vert}ButtonIndent. */
    hspace  = occwin->hspace;
    vspace  = occwin->vspace;
 
    /* Lines/cols in the layout.  Same as WorkspaceManager's */
    lines   = Scr->workSpaceMgr.lines;
    columns = Scr->workSpaceMgr.columns;
 
    /* Width/height of each button, based on the above and window size */
    bwidth  = (neww -  columns    * hspace) / columns;
    bheight = (newh - (lines + 2) * vspace) / (lines + 1);
 
    /* Width/height of the OK/Cancel/All buttons */
    owidth  = occwin->owidth;
    oheight = bheight;
 
 
    /*
     * Lay out the workspace buttons
     */
    i = 0;
    j = 0;
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        XMoveResizeWindow(dpy, occwin->obuttonw [j * columns + i],
                          i * (bwidth  + hspace) + (hspace / 2),
                          j * (bheight + vspace) + (vspace / 2),
                          bwidth, bheight);
        i++;
        if(i == columns) {
            i = 0;
            j++;
        }
    }
 
 
    /*
     * Now the action buttons
     */
    hspace = (neww - 3 * owidth) / 4;  // Padding between
    x = hspace;
    y = ((bheight + vspace) * lines) + ((3 * vspace) / 2);
    XMoveResizeWindow(dpy, occwin->OK, x, y, owidth, oheight);
    x += owidth + hspace;
    XMoveResizeWindow(dpy, occwin->cancel, x, y, owidth, oheight);
    x += owidth + hspace;
    XMoveResizeWindow(dpy, occwin->allworkspc, x, y, owidth, oheight);
 
 
    /* Save all those dimensions we figured */
    occwin->width   = neww;
    occwin->height  = newh;
    occwin->bwidth  = bwidth;
    occwin->bheight = bheight;
    occwin->owidth  = owidth;
 
    /* Don't need to repaint it; it'll get expose events */
}
 
 
/*
 * Draw the window when we need to (e.g., on expose)
 */
void
PaintOccupyWindow(void)
{
    WorkSpace    *ws;
    OccupyWindow *occwin;
    int          width, height;
 
    occwin = Scr->workSpaceMgr.occupyWindow;
    width  = occwin->width;
    height = occwin->height;
 
    Draw3DBorder(occwin->w, 0, 0, width, height, 2, occwin->cp, off, true, false);
 
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        Window bw = occwin->obuttonw [ws->number];
        ButtonState bs = (occwin->tmpOccupation & (1 << ws->number)) ? on : off;
 
        PaintWsButton(OCCUPYWINDOW, NULL, bw, ws->label, ws->cp, bs);
    }
    PaintWsButton(OCCUPYBUTTON, NULL, occwin->OK,         ok_string,
                  occupyButtoncp, off);
    PaintWsButton(OCCUPYBUTTON, NULL, occwin->cancel,     cancel_string,
                  occupyButtoncp, off);
    PaintWsButton(OCCUPYBUTTON, NULL, occwin->allworkspc, everywhere_string,
                  occupyButtoncp, off);
}
 
 
/*
 * Somebody clicked in the Occupy window
 */
void
OccupyHandleButtonEvent(XEvent *event)
{
    WorkSpace    *ws;
    OccupyWindow *occupyW;
    Window       buttonW;
 
    /*
     * Doesn't make sense that this can even happen if there are no
     * workspaces...
     */
    if(! Scr->workSpaceManagerActive) {
        return;
    }
 
    /* ... or if there's no Occupy window up for anything */
    if(occupyWin == NULL) {
        return;
    }
 
    /* Which sub-window (button) was clicked */
    buttonW = event->xbutton.window;
    if(buttonW == 0) {
        return;        /* icon */
    }
 
    /* Grab onto the pointer for the duration of our action */
    XGrabPointer(dpy, Scr->Root, True,
                 ButtonPressMask | ButtonReleaseMask,
                 GrabModeAsync, GrabModeAsync,
                 Scr->Root, None, CurrentTime);
 
    /* Find the workspace button that was clicked */
    occupyW = Scr->workSpaceMgr.occupyWindow;
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        if(occupyW->obuttonw [ws->number] == buttonW) {
            break;
        }
    }
 
    if(ws != NULL) {
        /* If one was, toggle it */
        int mask = 1 << ws->number;
        ButtonState bs = (occupyW->tmpOccupation & mask) ? off : on;
 
        PaintWsButton(OCCUPYWINDOW, NULL, occupyW->obuttonw [ws->number],
                      ws->label, ws->cp, bs);
        occupyW->tmpOccupation ^= mask;
    }
    else if(buttonW == occupyW->OK) {
        /* Else if we clicked OK, set things and close the window */
        if(occupyW->tmpOccupation == 0) {
            return;
        }
        ChangeOccupation(occupyWin, occupyW->tmpOccupation);
        XUnmapWindow(dpy, occupyW->twm_win->frame);
        occupyW->twm_win->mapped = false;
        occupyW->twm_win->occupation = 0;
        occupyWin = NULL;
        XSync(dpy, 0);
    }
    else if(buttonW == occupyW->cancel) {
        /* Or cancel, do nothing and close the window */
        XUnmapWindow(dpy, occupyW->twm_win->frame);
        occupyW->twm_win->mapped = false;
        occupyW->twm_win->occupation = 0;
        occupyWin = NULL;
        XSync(dpy, 0);
    }
    else if(buttonW == occupyW->allworkspc) {
        /* Or All, set 'em all */
        for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
            PaintWsButton(OCCUPYWINDOW, NULL, occupyW->obuttonw [ws->number],
                          ws->label, ws->cp, on);
        }
        occupyW->tmpOccupation = fullOccupation;
    }
 
    /* Release the pointer, if ??? */
    if(ButtonPressed == -1) {
        XUngrabPointer(dpy, CurrentTime);
    }
}
 
 
/*
 * f.occupy backend - pop up Occupy control for some window
 */
void
Occupy(TwmWindow *twm_win)
{
    int          x, y;
    unsigned int width, height;
    Window       w;
    struct OccupyWindow    *occupyWindow;
    TwmWindow *occupy_twm;
 
    /* Don't pop up on stuff we can't change */
    if(!CanChangeOccupation(&twm_win)) {
        return;
    }
 
    /* Grab our one screen-wide f.occupy window */
    occupyWindow = Scr->workSpaceMgr.occupyWindow;
    occupyWindow->tmpOccupation = twm_win->occupation;
    w = occupyWindow->w;
 
    /* Figure where to put it so it's centered on the cursor */
    XGetGeometry(dpy, w, &JunkRoot, &JunkX, &JunkY, &width, &height,
                 &JunkBW, &JunkDepth);
    XQueryPointer(dpy, Scr->Root, &JunkRoot, &JunkRoot, &JunkX, &JunkY,
                  &x, &y, &JunkMask);
 
    occupy_twm = occupyWindow->twm_win;
    occupy_twm->occupation = twm_win->occupation;
 
    width += 2 * (occupy_twm->frame_bw3D + occupy_twm->frame_bw);
    height += 2 * (occupy_twm->frame_bw3D + occupy_twm->frame_bw);
    x -= (width  / 2);
    y -= (height / 2);
 
    /* Clip to screen */
    ConstrainByLayout(Scr->BorderedLayout, -1, &x, width, &y, height);
 
    /* Move the occupy window to where it should be */
    if(occupy_twm->parent_vs != twm_win->parent_vs) {
        occupy_twm->vs = twm_win->parent_vs;
        occupy_twm->frame_x = x;
        occupy_twm->frame_y = y;
        /*
         * XXX Should this be using DisplayWin() like everything else,
         * rather than manually grubbing beneath it?
         */
        ReparentFrameAndIcon(occupy_twm);
    }
    else {
        XMoveWindow(dpy, occupyWindow->twm_win->frame, x, y);
    }
 
    /* And show it */
    SetMapStateProp(occupy_twm, NormalState);
    XMapWindow(dpy, occupyWindow->w);
    XMapWindow(dpy, occupy_twm->frame);
 
    /* XXX Must be a better way to express "all the way on top" */
    OtpSetPriority(occupy_twm, WinWin, 0, Above);
 
    /* Mark it shown, and stash what window we're showing it for */
    occupyWindow->twm_win->mapped = true;
    occupyWin = twm_win;
}
 
 
 
 
/*
 ****************************************************************
 *
 * Backend and misc
 *
 ****************************************************************
 */
 
 
/*
 * The actual meat of occupation-changing; [re-]set the occupation for
 * the window.  This is the func that actually sets and saves the new
 * occupation, moves the window where it should be, etc.  Should maybe be
 * called something more like "SetOccupation()".
 */
void
ChangeOccupation(TwmWindow *tmp_win, int newoccupation)
{
    TwmWindow *t;
    WorkSpace *ws;
    int oldoccupation;
    int changedoccupation;
 
    if((newoccupation == 0)
                    || (newoccupation == tmp_win->occupation)) {
        /*
         * occupation=0 we interpret as "leave it alone".  == current,
         * ditto.  Go ahead and re-set the WM_OCCUPATION property though,
         * in case it's been broken by another client.
         */
        char *namelist;
        int  len;
        long eventMask;
 
        /* Mask out the PropertyChange events while we change the prop */
        eventMask = mask_out_event(tmp_win->w, PropertyChangeMask);
 
        len = GetPropertyFromMask(tmp_win->occupation, &namelist);
        XChangeProperty(dpy, tmp_win->w, XA_WM_OCCUPATION, XA_STRING, 8,
                        PropModeReplace, (unsigned char *) namelist, len);
        free(namelist);
#ifdef EWMH
        EwmhSet_NET_WM_DESKTOP(tmp_win);
#endif
 
        /* Reset event mask */
        restore_mask(tmp_win->w, eventMask);
        return;
    }
 
    /*
     * OK, there's something to change.  Stash the current state.
     */
    oldoccupation = tmp_win->occupation;
 
    /*
     * Add it to IconManager in the new WS[en], remove from old.  We have
     * to do the rather odd dance because AddIconManager() loops through
     * workspaces, and will add it to any workspaces it occupies (even if
     * it's already there).  RemoveIconManager() goes over the window's
     * list of what icon managers it's on and removes it from any that
     * don't match the current occupation, so it can just be told "here's
     * where I should be".
     */
    tmp_win->occupation = newoccupation & ~oldoccupation;
    AddIconManager(tmp_win);
    tmp_win->occupation = newoccupation;
    RemoveIconManager(tmp_win);
 
    /* If it shouldn't be "here", vanish it */
    if(tmp_win->vs && !OCCUPY(tmp_win, tmp_win->vs->wsw->currentwspc)) {
        Vanish(tmp_win->vs, tmp_win);
    }
 
    /*
     * Try to find an(other) virtual screen which shows a workspace
     * where the window has occupation, so that the window can be shown
     * there now.
     */
    if(!tmp_win->vs) {
        VirtualScreen *vs;
        for(vs = Scr->vScreenList; vs != NULL; vs = vs->next) {
            if(OCCUPY(tmp_win, vs->wsw->currentwspc)) {
                DisplayWin(vs, tmp_win);
                break;
            }
        }
    }
 
    /*
     * Loop over workspaces.  Find the first one that it used to be in.
     * If it's not there anymore, take it out of the WindowRegion there
     * (RWFR() silently returns if we're not using WindowRegion's), and
     * add it the WindowRegion in the first WS it now occupies.
     *
     * XXX I'm not sure this is entirely sensible; it seems like just
     * unconditionally Remove/Place'ing would have the same effect?
     */
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        int mask = 1 << ws->number;
        if(oldoccupation & mask) {
            if(!(newoccupation & mask)) {
                int final_x, final_y;
                RemoveWindowFromRegion(tmp_win);
                if(PlaceWindowInRegion(tmp_win, &final_x, &final_y)) {
                    XMoveWindow(dpy, tmp_win->frame, final_x, final_y);
                }
            }
            break;
        }
    }
 
    /* Now set the WM_OCCUPATION property */
    {
        char *namelist;
        int  len;
        long eventMask;
 
        eventMask = mask_out_event(tmp_win->w, PropertyChangeMask);
 
        len = GetPropertyFromMask(newoccupation, &namelist);
        XChangeProperty(dpy, tmp_win->w, XA_WM_OCCUPATION, XA_STRING, 8,
                        PropModeReplace, (unsigned char *) namelist, len);
        free(namelist);
#ifdef EWMH
        EwmhSet_NET_WM_DESKTOP(tmp_win);
#endif
 
        restore_mask(tmp_win->w, eventMask);
    }
 
 
    /*
     * Handle showing it up in the workspace map in the appropriate
     * places.
     *
     * Note that this whole block messes with the {new,old}occupation
     * vars.  That's "safe" because they're no longer used for their
     * original purposes, only for the WSmap changes, but it's still
     * kinda fugly.  Change to local vars at the drop of a hat with later
     * changes...
     */
    if(!WMapWindowMayBeAdded(tmp_win)) {
        /* Not showing in the map, so pretend it's nowhere */
        newoccupation = 0;
    }
    if(Scr->workSpaceMgr.noshowoccupyall) {
        /*
         * Don't show OccupyAll.  Note that this means both OccupyAll
         * window, AND windows manually set to occupy everything.  We
         * don't have to adjust newoccupation, because the above
         * conditional would have caught it, so we only need to edit old.
         */
        if(oldoccupation == fullOccupation) {
            oldoccupation = 0;
        }
    }
 
    /* Flip the ones that need flipping */
    changedoccupation = oldoccupation ^ newoccupation;
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        int mask = 1 << ws->number;
        if(changedoccupation & mask) {
            if(newoccupation & mask) {
                /* Add to WS */
                WMapAddWindowToWorkspace(tmp_win, ws);
            }
            else {
                /*
                 * Remove from WS.  We have to take it out of saved focus
                 * if it were there.  Maybe there are other places we
                 * might need to remove it from (warpring?)?
                 */
                WMapRemoveWindowFromWorkspace(tmp_win, ws);
                if(Scr->SaveWorkspaceFocus && ws->save_focus == tmp_win) {
                    ws->save_focus = NULL;
                }
            }
        }
    }
 
 
    /*
     * If transients don't have their own occupation, find any transients
     * of this window and move them with it.
     */
    if(! Scr->TransientHasOccupation) {
        for(t = Scr->FirstWindow; t != NULL; t = t->next) {
            if(t != tmp_win &&
                            ((t->istransient && t->transientfor == tmp_win->w) ||
                             t->group == tmp_win->w)) {
                ChangeOccupation(t, tmp_win->occupation);
            }
        }
    }
 
    /* All done */
    return;
}
 
 
/*
 * There are various reasons you might not be able to change the
 * occupation of a window (either due to attributes of it, or the state
 * of your session/WM), so provide a function to check them all when we
 * try a change.
 *
 * Note that this is _not_ called from ChangeOccupation(); only from
 * other things that wrap it.  Since CO() gets called from states where
 * this would [falsely] fail, it would be a bad idea to put it there.
 */
static bool
CanChangeOccupation(TwmWindow **twm_winp)
{
    TwmWindow *twm_win;
 
    /* No workspaces config'd?  Changing is nonsensical. */
    if(!Scr->workSpaceManagerActive) {
        return false;
    }
 
    /*
     * f.occupy window up?  Can't change in the middle of changing.
     * Though if it's not mapped, still pull it up, else iconifying the
     * occupy window breaks it forever.
     */
    if(occupyWin != NULL && Scr->workSpaceMgr.occupyWindow->twm_win->mapped) {
        return false;
    }
 
    /* XXX Can we jut do this in the init?  Check all callers. */
    twm_win = *twm_winp;
 
    /* Don't change occupation of icon managers */
    if(twm_win->isiconmgr) {
        return false;
    }
 
    /* XXX Should check iswspmgr here too? */
 
    /*
     * If transients don't have their own occupation, check
     * transient/group bits.
     */
    if(!Scr->TransientHasOccupation) {
        if(twm_win->istransient) {
            return false;
        }
        if(twm_win->group != (Window) 0 && twm_win->group != twm_win->w) {
            /*
             * When trying to modify a group member window,
             * operate on the group leader instead
             * (and thereby on all group member windows as well).
             * If we can't find the group leader, pretend it isn't set.
             */
            twm_win = GetTwmWindow(twm_win->group);
            if(!twm_win) {
                return true;
            }
            *twm_winp = twm_win;
        }
    }
 
    /* Sure, go ahead, change it */
    return true;
}
 
 
/*
 * Add a client name to a list determining which workspaces it will
 * occupy.  Used in handling the Occupy { } block in config file.
 */
bool
AddToClientsList(char *workspace, char *client)
{
    WorkSpace *ws;
 
    /* "all" is a magic workspace value which makes it occupy anywhere */
    if(strcmp(workspace, "all") == 0) {
        for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
            AddToList(&ws->clientlist, client, "");
        }
        return true;
    }
 
    /* If prefixed with "ws:", strip the prefix and lookup by WS name */
    if(strncmp(workspace, "ws:", 3) == 0) {
        if((ws = GetWorkspace(workspace + 3)) != NULL) {
            AddToList(&ws->clientlist, client, "");
            return true;
        }
    }
 
    /* Else find that named workspace and all this to it */
    if((ws = GetWorkspace(workspace)) != NULL) {
        AddToList(&ws->clientlist, client, "");
        return true;
    }
 
    /* Couldn't figure where to put it */
    return false;
}
 
 
/*
 * Turn a ctwm.workspace resource string into an occupation mask.  n.b.;
 * this changes the 'res' arg in-place.
 */
static int
GetMaskFromResource(TwmWindow *win, char *res)
{
    WorkSpace *ws;
    int       mask;
    enum { O_SET, O_ADD, O_REM } mode;
    char *wrkSpcName, *tokst;
 
    /*
     * This can set the occupation to a specific set of workspaces ("ws1
     * ws3"), add to the set it woudl have otherwise ("+ws1 ws3"), or
     * remove from the set it would otherwise ("-ws1 ws3").  The +/-
     * apply to the whole expression, not to the individual entries in
     * it.  So first, figure out what we're doing.
     */
    mode = O_SET;
    if(*res == '+') {
        mode = O_ADD;
        res++;
    }
    else if(*res == '-') {
        mode = O_REM;
        res++;
    }
 
    /*
     * Walk through the string adding the workspaces specified into the
     * mask of what we're doing.
     */
    mask = 0;
    for(wrkSpcName = strtok_r(res, " ", &tokst) ; wrkSpcName
                    ; wrkSpcName = strtok_r(NULL, " ", &tokst)) {
        if(strcmp(wrkSpcName, "all") == 0) {
            mask = fullOccupation;
            break;
        }
        if(strcmp(wrkSpcName, "current") == 0) {
            VirtualScreen *vs = Scr->currentvs;
            if(vs) {
                mask |= (1 << vs->wsw->currentwspc->number);
            }
            continue;
        }
 
        ws = GetWorkspace(wrkSpcName);
        if(ws != NULL) {
            mask |= (1 << ws->number);
        }
        else {
            fprintf(stderr, "unknown workspace : %s\n", wrkSpcName);
        }
    }
 
    /*
     * And return that mask, with necessary alterations depending on +/-
     * specified.
     */
    switch(mode) {
        case O_SET:
            return (mask);
        case O_ADD:
            return (mask | win->occupation);
        case O_REM:
            return (win->occupation & ~mask);
    }
 
    /* Can't get here */
    fprintf(stderr, "%s(): Unreachable.\n", __func__);
    return 0;
}
 
 
/*
 * Turns a \0-separated buffer of workspace names into an occupation
 * bitmask.
 */
unsigned int
GetMaskFromProperty(unsigned char *_prop, unsigned long len)
{
    char         wrkSpcName[256];
    WorkSpace    *ws;
    unsigned int mask;
    int          l;
    char         *prop;
 
    mask = 0;
    l = 0;
    prop = (char *) _prop;
    while(l < len) {
        /* If you have WS names longer than 256 chars, that's just Too Bad */
        safe_strncpy(wrkSpcName, prop, 256);
        l    += strlen(prop) + 1;
        prop += strlen(prop) + 1;
        if(strcmp(wrkSpcName, "all") == 0) {
            mask = fullOccupation;
            break;
        }
 
        ws = GetWorkspace(wrkSpcName);
        if(ws != NULL) {
            mask |= (1 << ws->number);
        }
        else {
            fprintf(stderr, "unknown workspace : %s\n", wrkSpcName);
        }
    }
 
#if 0
    {
        char *dbs = mk_nullsep_string((char *)_prop, len);
        fprintf(stderr, "%s('%s') -> 0x%x\n", __func__, dbs, mask);
        free(dbs);
    }
#endif
 
    return (mask);
}
 
 
/*
 * Turns an occupation mask into a \0-separated buffer (not really a
 * string) of the workspace names.
 */
int
GetPropertyFromMask(unsigned int mask, char **prop)
{
    WorkSpace *ws;
    int       len;
    char      *wss[MAXWORKSPACE];
    int       i;
 
    /* If it's everything, just say 'all' */
    if(mask == fullOccupation) {
        *prop = strdup("all");
        return 3;
    }
 
    /* Stash up pointers to all the labels for WSen it's in */
    memset(wss, 0, sizeof(wss));
    i = 0;
    len = 0;
    for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {
        if(mask & (1 << ws->number)) {
            wss[i++] = ws->label;
            len += strlen(ws->label) + 1;
        }
    }
 
    /* Assemble them into \0-separated string */
    *prop = malloc(len);
    len = 0;
    for(i = 0 ; wss[i] != NULL ; i++) {
        strcpy((*prop + len), wss[i]);
        len += strlen(wss[i]) + 1; // Skip past \0
    }
 
#if 0
    {
        char *dbs = mk_nullsep_string(*prop, len);
        fprintf(stderr, "%s(0x%x) -> %d:'%s'\n", __func__, mask, len, dbs);
        free(dbs);
    }
#endif
 
    return len;
}
 
 
/*
 * Generate a printable variant of the null-separated strings we use for
 * stashing in XA_WM_OCCUPATION.  Used for debugging
 * Get{Property,Mask}From{Mask,Property}().
 */
#ifdef __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-function"
#endif
static char *
mk_nullsep_string(const char *prop, int len)
{
    char *dbs;
    int i, j;
 
    /*
     * '\0' => "\\0" means we need longer than input; *2 is overkill,
     * but always sufficient, and it's cheap.
     */
    dbs = malloc(len * 2);
    i = j = 0;
    while(i < len) {
        size_t slen = strlen(prop + i);
 
        strcpy(dbs + j, (prop + i));
        i += slen + 1;
        strcpy(dbs + j + slen, "\\0");
        j += slen + 2;
    }
 
    return dbs;
}
#ifdef __GNUC__
# pragma GCC diagnostic pop
#endif