// XLayer.cc for FbTk - fluxbox toolkit // Copyright (c) 2003 Henrik Kinnunen (fluxgen at users.sourceforge.net) // and Simon Bowden (rathnor at users.sourceforge.net) // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. // $Id: XLayer.cc,v 1.6 2003/02/18 15:08:12 rathnor Exp $ #include "XLayer.hh" #include "XLayerItem.hh" #include "App.hh" #include <iostream> using namespace std; using namespace FbTk; XLayer::XLayer(MultLayers &manager, int layernum): m_manager(manager), m_layernum(layernum) { } XLayer::~XLayer() { } void XLayer::restack() { int num_windows = countWindows(); // each LayerItem can contain several windows iterator it = itemList().begin(); iterator it_end = itemList().end(); it = itemList().begin(); it_end = itemList().end(); Window *winlist = new Window[num_windows]; size_t j=0; // add all the windows from each item for (size_t i=0; it != it_end; ++it, i++) { XLayerItem::Windows::const_iterator wit = (*it)->getWindows().begin(); XLayerItem::Windows::const_iterator wit_end = (*it)->getWindows().end(); for (; wit != wit_end; ++wit) { if ((*wit)->window()) winlist[j++] = (*wit)->window(); } } XRestackWindows(FbTk::App::instance()->display(), winlist, j); delete [] winlist; } int XLayer::countWindows() { int num_windows = 0; iterator it = itemList().begin(); iterator it_end = itemList().end(); for (size_t i=0; it != it_end; ++it, i++) { num_windows += (*it)->numWindows(); } return num_windows; } // Stack all windows associated with 'item' below the 'above' item void XLayer::stackBelowItem(XLayerItem *item, XLayerItem *above) { Window *winlist; size_t winnum, size, num = item->numWindows(); // if there are no windows provided for above us, // then we must have to go right to the top of the stack if (!above) { // must need to go right to top if (item->getWindows().front()->window()) XRaiseWindow(FbTk::App::instance()->display(), item->getWindows().front()->window()); // if this XLayerItem has more than one window, // then we'll stack the rest in under the front one too // our size needs to be the number of windows in the group, since there isn't one above. if (num > 1) { winnum = 0; // stack relative to top one (just raised) size = num; winlist = new Window[size]; } else { // we've raised the window, nothing else to do return; } } else { // We do have a window to stack below // so we put it on top, and fill the rest of the array with the ones to go below it. winnum = 1; size = num+1; winlist = new Window[size]; // assume that above's window exists winlist[0] = above->getWindows().back()->window(); } // fill the rest of the array XLayerItem::Windows::iterator it = item->getWindows().begin(); XLayerItem::Windows::iterator it_end = item->getWindows().end(); for (; it != it_end; ++it) { if ((*it)->window()) winlist[winnum++] = (*it)->window(); } // stack the windows XRestackWindows(FbTk::App::instance()->display(), winlist, winnum); delete [] winlist; } XLayer::iterator XLayer::insert(XLayerItem &item, unsigned int pos) { #ifdef DEBUG // at this point we don't support insertions into a layer other than at the top if (pos != 0) cerr<<__FILE__<<"("<<__LINE__<<"): Insert using non-zero position not valid in XLayer"<<endl; #endif // DEBUG itemList().push_front(&item); // restack below next window up stackBelowItem(&item, m_manager.getLowestItemAboveLayer(m_layernum)); return itemList().begin(); } void XLayer::remove(XLayerItem &item) { iterator it = itemList().begin(); iterator it_end = itemList().end(); for (; it != it_end; ++it) { if (*it == &item) { itemList().erase(it); break; } } } void XLayer::cycleUp() { // need to find highest visible window, and move it to bottom iterator it = itemList().begin(); iterator it_end = itemList().end(); while (it != it_end && !(*it)->visible()) ++it; // if there is something to do if (it != it_end) lower(**it); } void XLayer::cycleDown() { // need to find lowest visible window, and move it to top // so use a reverse iterator, and the same logic as cycleUp() reverse_iterator it = itemList().rbegin(); reverse_iterator it_end = itemList().rend(); while (it != it_end && !(*it)->visible()) ++it; // if there is something to do if (it != it_end) raise(**it); } void XLayer::stepUp(XLayerItem &item) { // need to find next visible window upwards, and put it above that if (&item == itemList().front()) return; // nothing to do // TODO: is there a better way of doing this? // get our item iterator myit = std::find(itemList().begin(), itemList().end(), &item); iterator it = myit; // go to the one above it in our layer (top is front, so we decrement) --it; // keep going until we find one that is currently visible to the user while (it != itemList().begin() && !(*it)->visible()) --it; if (it == itemList().begin() && !(*it)->visible()) { // reached front item, but it wasn't visible, therefore it was already raised } else { // it is the next visible item down, we need to be above it. // remove that item from the list and add it back to before it (the one we want to go above) itemList().erase(myit); itemList().insert(it, &item); // if we've reached the top of the layer, we need to stack below the next one up if (it == itemList().begin()) { stackBelowItem(&item, m_manager.getLowestItemAboveLayer(m_layernum)); } else { // otherwise go up one in this layer (i.e. above the one we want to go above) --it; // and stack below that. stackBelowItem(&item, *it); } } } void XLayer::stepDown(XLayerItem &item) { // need to find next visible window down, and put it below that // if we're already the bottom of the layer if (&item == itemList().back()) return; // nothing to do // get our position iterator myit = std::find(itemList().begin(), itemList().end(), &item); iterator it = myit; // go one below it (top is front, so we must increment) it++; iterator it_end = itemList().end(); // keep going down until we find a visible one while (it != it_end && !(*it)->visible()) it++; // if we didn't reach the end, then stack below the // item that we found. if (it != it_end) stackBelowItem(&item, *it); // if we did reach the end, then there are no visible windows, so we don't do anything } void XLayer::raise(XLayerItem &item) { // assume it is already in this layer if (&item == itemList().front()) return; // nothing to do iterator it = std::find(itemList().begin(), itemList().end(), &item); if (it != itemList().end()) itemList().erase(it); #ifdef DEBUG else { cerr<<__FILE__<<"("<<__LINE__<<"): WARNING: raise on item not in layer["<<m_layernum<<"]"<<endl; return; } #endif // DEBUG itemList().push_front(&item); stackBelowItem(&item, m_manager.getLowestItemAboveLayer(m_layernum)); } void XLayer::lower(XLayerItem &item) { // assume already in this layer // is it already the lowest? if (&item == itemList().back()) return; // nothing to do iterator it = std::find(itemList().begin(), itemList().end(), &item); if (it != itemList().end()) // remove this item itemList().erase(it); #ifdef DEBUG else { cerr<<__FILE__<<"("<<__LINE__<<"): WARNING: lower on item not in layer"<<endl; return; } #endif // DEBUG // add it to the bottom itemList().push_back(&item); // find the item we need to stack below // start at the end it = itemList().end(); // go up one so we have an object (which must exist, since at least this item is in the layer) it--; // go down another one // must exist, otherwise our item must == itemList().back() it--; // and restack our window below that one. stackBelowItem(&item, *it); } void XLayer::raiseLayer(XLayerItem &item) { m_manager.raiseLayer(item); } void XLayer::lowerLayer(XLayerItem &item) { m_manager.lowerLayer(item); } void XLayer::moveToLayer(XLayerItem &item, int layernum) { m_manager.moveToLayer(item, layernum); } XLayerItem *XLayer::getLowestItem() { if (itemList().empty()) return 0; else return itemList().back(); } XLayerItem *XLayer::getItemBelow(XLayerItem &item) { // get our iterator iterator it = std::find(itemList().begin(), itemList().end(), &item); // go one lower it++; // if one lower is the end, there is no item below, otherwise we've got it if (it == itemList().end()) return 0; else return *it; } XLayerItem *XLayer::getItemAbove(XLayerItem &item) { // get our iterator iterator it = std::find(itemList().begin(), itemList().end(), &item); // if this is the beginning (top-most item), do nothing, otherwise give the next one up // the list (which must be there since we aren't the beginning) if (it == itemList().begin()) return 0; else return *(--it); }