src/container.h

Go to the documentation of this file.

// Copyright (c) 2003 - 2004 Anselm R. Garbe <anselmg at t-online.de>
// See ../LICENSE.txt for license details.
//
// $Id: container.h 7 2007-05-24 11:03:53Z eg1981 $

#ifndef __CONTAINER_H
#define __CONTAINER_H

#include "kernel.h"
#include "util.h" // also includes ncwm.h

template <class P, class LT, class LTI, class T>
    class Container
{
public:

    Container(P *parent, T *child = 0) {
        parent_ = parent;
        child_ = child;
    };

    ~Container() {
        Util::destroy<LT, LTI, T *>
                 (&childs_, childs_.begin(), childs_.end());
    };

    bool contains(T *child) {
        return Util::contains<LT, LTI, T>(&childs_, child);
    };

    unsigned int size() {
        return childs_.size();
    };

    LTI begin() {
        return childs_.begin();
    };

    LTI end() {
        return childs_.end();
    };

    P *attached() const {
        return parent_;
    };

    void setAttached(P *parent) {
        parent_ = parent;
    };

    T *focused() const {
        return child_;
    };

    void focus(T *child) {
        if (child && KERNEL->isStackedTabbing()) {
            if (childs_.size()) {
                T *foc = childs_.front();
                if (foc != child) {
                    childs_.remove(foc);
                    childs_.push_back(foc);
                }
            }
            childs_.remove(child);
            childs_.push_front(child);
        }
        child_ = child;
    };

    void attach(T *child) {
        if (child && !contains(child)) {
            childs_.push_back(child);
            focus(child);
        }
    };

    T *detach(T *child) {

        if (child_ == child) {
            // cycle to prev child
            focus(prev());
        }
        childs_.remove(child);

        if (childs_.size() < 1) {
            child_ = 0;
        }
        return child_;
    };

    T *prev() {

        if (childs_.size() < 1) {
            return 0;
        }
        else if (childs_.size() < 2) {
            return child_;
        }

        if (KERNEL->isStackedTabbing()) {
            return childs_.back();
        }
        else {
            for (LTI it = childs_.begin();
                    it != childs_.end(); it++)
            {
                if (child_ == *it) {
                    if (it != childs_.begin()) {
                        it--;
                        return *it;
                    }
                    else {
                        break;
                    }
                }
            }
            return childs_.back();
        }
    }


    T *next() {
        if (childs_.size() < 1) {
            return 0;
        }
        else if (childs_.size() < 2) {
            return child_;
        }

        if (KERNEL->isStackedTabbing()) {
            LTI it = childs_.begin();
            it++;
            return *it;
        }
        else {
            for (LTI it = childs_.begin();
                    it != childs_.end(); it++)
            {
                if (child_ == *it) {
                    it++;
                    if (it != childs_.end()) {
                        return *it;
                    }
                    else {
                        break;
                    }
                }
            }
            return childs_.front();
        }
    };

    LT *childs() {
        return &childs_;
    }


private:

    P *parent_;
    T *child_;
    LT childs_;
};

#endif // __CONTAINER_H

---