GUIList.h

Zobrazit dokumentaci tohoto souboru.

#ifndef _CGUILIST_
#define _CGUILIST_

#include "GUIFrame.h"
#include "GUIListOption.h"

template<typename T>
class CGUIList: public CGUIFrame {

public:
        CGUIList();

        int getActive() {
                return m_active;
        }

        T getActiveValue() {

                if (m_active >= 0) {
                        return dynamic_cast<CGUIListOption<CGUIList, T>*> (this->get(
                                        m_active))->getValue();
                }

                return 0;
        }

        void setActive(int id) {

                if (id >= this->size() || id < 0) {
                        return;
                }

                if (m_active >= 0) {
                        dynamic_cast<CGUIListOption<CGUIList, T>*> (this->get(m_active))->nonactive();
                }

                dynamic_cast<CGUIListOption<CGUIList, T>*> (this->get(id))->active();

                m_active = id;

        }

        void setCountVisible(int count) {
                m_countVisible = count;
        }

        int getCountVisible() {
                return m_countVisible;
        }

        void scrollUp();

        void scrollDown();

        void mouseButtons(int button, int state, int x, int y) {
                CGUIFrame::mouseButtons(button, state, x, y);
                buttonUp.mouseButtons(button, state, x, y);
                buttonDown.mouseButtons(button, state, x, y);
        }

        void addOption(CGUIListOption<CGUIList, T>* option) {

                this->addChild(option);
                option->setPosition(getPositionX(),
                                getPositionY() + getLineHeight() * this->size());
                option->setID(this->size() - 1);
                option->setParent(this);
                option->setParentOnActivated(&CGUIList::setActive);

                this->setHeight(this->getLineHeight());

        }

        void removeOption(int index) {
                if (this->removeChild()) {
                        if (index == getActive()) {
                                setActive(-1);
                        }
                }
        }

        void addOption(T value, string label) {
                CGUIListOption<CGUIList, T>* option = new CGUIListOption<CGUIList, T> ;
                option->setValue(value);
                option->setString(label);
                addOption(option);
        }

        void render() {

                CGUIElement* curr = NULL;

                for (int i = m_start; i < m_start + m_countVisible; i++) {
                        if ((curr = getChild(i)) != NULL) {
                                curr->setPosition(getPositionX(),
                                                getPositionY() + getLineHeight() * (i - m_start));
                                curr->render();
                        }
                }

                buttonUp.setPositionY(getPositionY());
                buttonUp.render();

                buttonDown.setPositionY(getPositionY());
                buttonDown.render();
        }

        void mouseMove(int x, int y) {
                CGUIFrame::mouseMove(x, y);
                buttonUp.mouseMove(x, y);
                buttonDown.mouseMove(x, y);
        }

        void centered();

protected:
        int m_active;

        int m_start;
        int m_countVisible;

        CGUIButton<CGUIList> buttonUp;
        CGUIButton<CGUIList> buttonDown;

};

template<typename T>
CGUIList<T>::CGUIList() {
        m_active = -1;
        m_countVisible = 2;
        m_start = 0;

        setDimension(100, 50);

        buttonUp.setString("UP");
        buttonDown.setString("DOWN");

        buttonUp.setDimension(20, 20);
        buttonDown.setDimension(40, 20);

        buttonUp.setCallback(this, &CGUIList::scrollUp, NULL);
        buttonDown.setCallback(this, &CGUIList::scrollDown, NULL);
}

template<typename T>
void CGUIList<T>::scrollUp() {
        if (m_start > 0) {
                m_start--;
        }
}

template<typename T>
void CGUIList<T>::scrollDown() {
        if (m_start + m_countVisible < this->size()) {
                m_start++;
        }
}

template<typename T>
void CGUIList<T>::centered() {

        GLint viewport[4]; // informace o viewportu
        glGetIntegerv(GL_VIEWPORT, viewport); // ziskame informace o VP

        GLfloat positionX = (viewport[2] / 2) - (this->getWidth() / 2);
        GLfloat positionY = (viewport[3] / 2) - (this->getHeight() / 2);

        this->setPosition(positionX, positionY);

        this->buttonUp.setPosition(this->getPositionX() - buttonUp.getWidth() - 10,
                        positionY);
        this->buttonDown.setPosition(this->getPositionX() + this->getWidth(),
                        positionY);

        CGUIElement* curr = NULL;

        for (int i = 1; i < size(); i++) {
                if ((curr = getChild(i)) != NULL) {
                        GLfloat px = positionX + (getWidth() / 2) - curr->getWidth() / 2;
                        curr->setPositionX(px);
                        curr->setPositionY(getPositionY() + getLineHeight() * i);
                }
        }

}

#endif

---