path: root/src/FloorControl.cpp

/* $Id: FloorControl.cpp,v 1.9 2007/01/07 05:00:56 whot Exp $ */

/*--
 --*/

#include "FloorControl.h"

FloorControl::FloorControl(Manager* manager, WMWindow* client, XConn* x11)
{
    this->manager = manager;
    this->client = client;
    this->x11 = x11;
}

FloorControl::~FloorControl()
{
    XDestroyWindow(x11->dpy, root->fcwin);
    freeSubNodes(root);
    delete root;
}

/**
 * Frees all subnodes of a node (recursively). 
 * Does NOT release the memory for the node itself.
 */
void FloorControl::freeSubNodes(WinTreeNodePtr node)
{
    vector<WinTreeNodePtr>::iterator it = node->children.begin();
    while(it != node->children.end())
    {
        freeSubNodes(*it);
        delete (*it);
        it++;
    }
}

/**
 * Queries a WinTreeNode's window for the subchildren and fills the data into
 * the node. This works recursively.
 */
bool FloorControl::getChildren(WinTreeNodePtr node)
{
    Window root_return, parent_return;
    Window* children;
    unsigned int no_children;
    unsigned int i;

    XQueryTree(x11->dpy, node->win, &root_return, &parent_return, &children, &no_children);

    if (!no_children)
    {
        node->children.clear();
        return false;
    }

    i = 0;
    while (i < no_children)
    {
        WinTreeNodePtr kidnode;
        kidnode = new WinTreeNode;
        memset(kidnode, 0, sizeof(WinTreeNode));
        kidnode->win = children[i];
        kidnode->parent = node;

        XGetWindowAttributes(x11->dpy, kidnode->win, &kidnode->attr);

        node->children.push_back(kidnode);
        i++;
    }
    XFree(children);
    return true;
}

/**
 * Initialises internal structures. This means querying the client window for
 * child windows and building up the hierarchy.
 */

void FloorControl::init()
{
    WinTreeNodePtr node = NULL;

    // list of windows that have not been queried for children yet.
    deque<WinTreeNodePtr> unqueried;

    root = new WinTreeNode;
    root->win = client->getClientWindow();
    root->parent = NULL;

    XGetWindowAttributes(x11->dpy, root->win, &root->attr);

    unqueried.push_back(root);

    do {
        node = unqueried[0];
        unqueried.pop_front();

        getChildren(node);

        if (!node->children.empty())
        {
            vector<WinTreeNodePtr>::iterator it = node->children.begin();
            while(it != node->children.end())
            {
                unqueried.push_back(*it);
                it++;
            }
        }
    } while(!unqueried.empty());
}


/**
 * For each window in the hierarchy starting with the given parent window do
 * the following:
 *  - create a new window in exactly the same place.
 *  - set the window to listen to button events.
 *  - call the method for all childs.
 *  This builds up a simple rebuilt GUI of the underlying client.
 */
void FloorControl::buildNodeGUI(WinTreePtr node, Window parent)
{
    if (node->attr.map_state != IsViewable)
        return;
    
    node->fcwin = XCreateSimpleWindow(x11->dpy, parent, node->attr.x, node->attr.y,
                                      node->attr.width - 2, node->attr.height - 2, 1,
                                      BlackPixel(x11->dpy, 0), WhitePixel(x11->dpy, 0));

    TRACE("Floor control creating window %x\n", (int)node->fcwin);

    XSelectInput(x11->dpy, node->fcwin, EnterWindowMask | LeaveWindowMask);
    manager->setButtonPressMask(node->fcwin);
    XMapWindow(x11->dpy, node->fcwin);
    XFlush(x11->dpy);

    vector<WinTreePtr>::iterator it = node->children.begin();

    while(it != node->children.end())
    {
        buildNodeGUI(*it, node->fcwin);
        it++;
    }
}



/**
 * Display floor control overlay windows.
 */
void FloorControl::display()
{
    buildNodeGUI(root, client->getContainer());
    XFlush(x11->dpy);
}


/**
 * Returns true if the floor control window has the given window.
 */
bool FloorControl::hasWindow(Window win)
{
    return nodeHasWindow(root, win);
}

/**
 * Returns true if the node or any of its subnodes contains the given window.
 */
bool FloorControl::nodeHasWindow(WinTreeNodePtr node, Window win)
{
    if (node->fcwin == win)
        return true;

    vector<WinTreeNodePtr>::iterator it = node->children.begin();

    while(it != node->children.end())
    {
        if (nodeHasWindow(*it, win))
            return true;
        it++;
    }
    return false;
}

/**
 * Handles enter/leave events. These events occur when a mouse moves over one
 * of the floor control windows.
 */
void FloorControl::handleEnterLeave(XCrossingEvent* ev)
{
    WinTreeNodePtr node = getNodeByWindow(ev->window);
    if (!node)
        return;

    XSetWindowAttributes attr;

    if (ev->type == EnterNotify)
        attr.background_pixel = BlackPixel(x11->dpy, 0);
    else
        attr.background_pixel = WhitePixel(x11->dpy, 0);


    XChangeWindowAttributes(x11->dpy, node->fcwin, CWBackPixel, &attr);
    XClearWindow(x11->dpy, node->fcwin);
    XFlush(x11->dpy);
}


WinTreeNodePtr FloorControl::getNodeByWindow(Window win)
{
    return findNodeForWindow(root, win);
}

WinTreeNodePtr FloorControl::findNodeForWindow(WinTreeNodePtr node, Window win)
{
    if (node->fcwin == win)
        return node;

    vector<WinTreeNodePtr>::iterator it = node->children.begin();
    while(it != node->children.end())
    {
        WinTreeNodePtr kidnode;
        kidnode = findNodeForWindow(*it, win);
        if (kidnode)
            return kidnode;
        it++;
    }

    return NULL;
}

void FloorControl::handleButtonPress(XDeviceButtonEvent* ev, PointerDevice* dev)
{
    WinTreeNodePtr node = getNodeByWindow(ev->window);
    int id = dev->getID();

    if (node)
    {
        XID *permdevs, 
             *denydevs;
        int nperm, ndeny, rule;

        XQueryWindowAccess(x11->dpy, client->getClientWindow(), &rule, 
                           &permdevs, &nperm, &denydevs, &ndeny);

        if (ev->state & Button1Mask)
        {
            int i;
            for (i = 0; i < nperm; i++)
            {
                if (permdevs[i] == (XID)id)
                    break;
            }

            if (i >= nperm)
            {
                permdevs = (XID*)realloc(permdevs, (ndeny + 1) * sizeof(XID));
                denydevs[ndeny++] = (char)id;
                XPermitDevices(x11->dpy, client->getClientWindow(), permdevs, nperm);
            }
        }
        else if (ev->state & Button3Mask)
        {
            for (int i = 0; i < nperm; i++)
            {
                if (permdevs[i] == (XID)id)
                {
                    if (i + 1 < nperm)
                        memmove(&permdevs[i], &permdevs[i+1], nperm - i - 1);
                    nperm--;
                    XPermitDevices(x11->dpy, client->getClientWindow(), permdevs, nperm);
                    break;
                }
            }
        }


        free(permdevs);
        free(denydevs);
    }
}