fixing up of layer code

1 files changed, 142 insertions, 61 deletions

diff --git a/src/FbTk/XLayer.cc b/src/FbTk/XLayer.cc
index 6b1791f..b5e9756 100644
--- a/src/FbTk/XLayer.cc
+++ b/src/FbTk/XLayer.cc
@@ -20,7 +20,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-// $Id: XLayer.cc,v 1.4 2003/02/03 13:45:23 fluxgen Exp $
+// $Id: XLayer.cc,v 1.5 2003/02/09 14:11:14 rathnor Exp $
 
 #include "XLayer.hh"
 #include "XLayerItem.hh"
@@ -44,15 +44,24 @@ void XLayer::restack() {
     // 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;
-    for (size_t window=0; it != it_end; ++it, window++) {
-        winlist[window] = (*it)->window();
+    
+    // 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, j++) {
+            winlist[j] = (*wit);
+        }
     }
 
     XRestackWindows(FbTk::App::instance()->display(), winlist, num_windows);
 
     delete [] winlist;
+
 }
 
 int XLayer::countWindows() {
@@ -60,70 +69,80 @@ int XLayer::countWindows() {
     iterator it = itemList().begin();
     iterator it_end = itemList().end();
     for (size_t i=0; it != it_end; ++it, i++) {
-        num_windows ++; // one window per item
+        num_windows += (*it)->numWindows();
     }
     return num_windows;
 }
 
 
+// Stack all windows associated with 'item' below the 'above' item
 void XLayer::stackBelowItem(XLayerItem *item, XLayerItem *above) {
-    //!! What????
 
-    // little optimisation
-    /*    Window *winlist;
-    size_t i, size, num = item->numWindows();
+    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
         XRaiseWindow(FbTk::App::instance()->display(), item->getWindows().front());
+
+        // 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) {
-            i = 0;
+            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
 
-        i=1;
-        // stack relative to one above
-
+        // 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];
-        winlist[0] = above->getWindows().front();
+        winlist[0] = above->getWindows().back();
     }
 
+    // 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, i++) {
-        winlist[i] = (*it);
+    for (; it != it_end; ++it, winnum++) {
+        winlist[winnum] = (*it);
     }
 
+    // stack the windows
     XRestackWindows(FbTk::App::instance()->display(), winlist, size);
 
     delete [] winlist;
-    */
+    
 }
 
 XLayer::iterator XLayer::insert(XLayerItem &item, unsigned int pos) {
 #ifdef DEBUG
-    if (pos != 0)//!! Why????
+    // 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
-    //    item.setLayerIterator(itemList().begin());
     stackBelowItem(&item, m_manager.getLowestItemAboveLayer(m_layernum));
     return itemList().begin();
 }
 
-void XLayer::remove(XLayerItem &item) {    
+void XLayer::remove(XLayerItem &item) {
     iterator it = itemList().begin();
     iterator it_end = itemList().end();
     for (; it != it_end; ++it) {
-        if (*it == &item)
+        if (*it == &item) {
             itemList().erase(it);
+            break;
+        }
     }
 }
 
@@ -141,7 +160,8 @@ void XLayer::cycleUp() {
 }
 
 void XLayer::cycleDown() {
-    // need to find highest visible window, and move it to bottom
+    // 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()) 
@@ -159,80 +179,136 @@ void XLayer::stepUp(XLayerItem &item) {
     if (&item == itemList().front()) 
         return; // nothing to do
 
-    //!! better stable and slow than buggy!
-    /*
     // TODO: is there a better way of doing this?
-    iterator it = item.getLayerIterator();
-    it--;
-    while ((*it) != itemList().front() && !(*it)->visible()) 
+
+    // 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().front() && !(*it)->visible()) {
+    if (it == itemList().begin() && !(*it)->visible()) {
         // reached front item, but it wasn't visible, therefore it was already raised
-        //moveToBottom(item);
     } else {
         // it is the next visible item down, we need to be above it.
-        itemList().erase(item.getLayerIterator());
-        //itemList().insert(it, item);
-        item.setLayerIterator(it = itemList().insert(it, &item));
-        if (*it == itemList().front()) {
+        // 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 {
-            it--;
+            // 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
 
-    //!! better stable and slow than buggy!
-    /*    iterator it = item.getLayerIterator();
+    // 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;
+        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
 
-    //    itemList().erase(item.getLayerIterator());
+    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);
-    //    item.setLayerIterator(itemList().begin());
     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
 
-    //!! better stable and slow than buggy!
-    /*
-    itemList().erase(item.getLayerIterator());
+    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);
-    iterator it = itemList().end();
-    it--;
-    item.setLayerIterator(it);
+
+    // 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--;
-    stackBelowItem(&item, *it); // must exist, otherwise item must == itemList().back()
-    */
+    
+    // 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;
@@ -241,22 +317,27 @@ XLayerItem *XLayer::getLowestItem() {
 }
 
 XLayerItem *XLayer::getItemBelow(XLayerItem &item) {
-    //!! better stable and slow than buggy!
-    /*    iterator it = item.getLayerIterator();
-    if (it == itemList().begin())
-        return 0;
-    else
-        return *(--it);
-    */
-}
+    // get our iterator
+    iterator it = std::find(itemList().begin(), itemList().end(), &item);
 
-XLayerItem *XLayer::getItemAbove(XLayerItem &item) {
-    //!! better stable and slow than buggy!
-    /*    iterator it = item.getLayerIterator();
+    // 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);
 }