Menu.cpp

#include <Interface/Menu/Menu.hpp>
#include <Misc/Utils.hpp>
#include <Config/Globals.hpp>
#include <Flow/InputManager.hpp>
 
Menu::Menu(int x, int y, int width, int height):
    current(NULL),
    currentIndex(0),
    x(x),
    y(y),
    width(width),
    height(height),
    selected(false),
    selectedItem(NULL)
{ }
Menu::~Menu()
{
    for (unsigned int i = 0; i < (this->item.size()); i++)
        SAFE_DELETE(this->item[i]);
 
    this->item.clear();
}
void Menu::add(MenuItem* item)
{
    this->item.push_back(item);
 
    // Means we're the first item being added!
    if (this->item.size() == 1)
    {
        this->current      = this->item.back();
        this->currentIndex = this->item.size() - 1;
    }
 
    // Means we're the first non-nil item being added!
    unsigned int i = 0;
    for (i = 0; i < (this->item.size()); i++)
        if (this->item[i])
            break;
 
    this->current      = this->item[i];
    this->currentIndex = i;
}
void Menu::addBlank()
{
    this->item.push_back(NULL);
}
void Menu::removeByID(int id)
{
    std::vector<MenuItem*>::iterator it = this->item.begin();
 
    while (it != this->item.end())
    {
        if (!(*it))
            ++it;
 
        if ((*it)->id == id)
        {
            if (this->current == *it)
            {
                this->goNext();
                this->currentIndex--;
            }
 
            this->item.erase(it);
            return;
        }
        else
            ++it;
    }
}
void Menu::removeByLabel(std::string label)
{
    std::vector<MenuItem*>::iterator it = this->item.begin();
 
    while (it != this->item.end())
    {
        if (!(*it))
            ++it;
 
        if ((*it)->label == label)
        {
            if (this->current == *it)
            {
                this->goNext();
                this->currentIndex--;
            }
 
            this->item.erase(it);
            return;
        }
        else
            ++it;
    }
}
void Menu::draw(Window* window)
{
    // If we have more Items than we can draw, we need to
    // ask the user to scroll.
 
    // So these are the indexes of the items we'll actually
    // show on the screen.
    unsigned int draw_begin = 0;
    unsigned int draw_end   = this->item.size();
 
    if (this->height < (int)this->item.size())
    {
        if ((int)this->currentIndex <= this->height/2)
        {
            draw_end = this->height - 1;
        }
        else if ((int)this->currentIndex < ((int)this->item.size() - this->height/2) - 1)
        {
            draw_begin = this->currentIndex - this->height/2;
            draw_end   = this->currentIndex + this->height/2;
        }
        else
        {
            draw_begin = this->item.size() - this->height;
        }
    }
 
    // `i` is the index of the item to draw
    for (unsigned int curitem = draw_begin, yoffset = 0;
         curitem < draw_end;
         curitem++, yoffset++)
    {
        // Menu is big and needs scrolling,
        // we need to show (more) on the top
        if ((curitem == draw_begin) && (curitem != 0))
        {
            window->print("(more)",
                          this->x + this->width/2 - 3,
                          this->y + yoffset,
                          Colors::pair(COLOR_WHITE, COLOR_DEFAULT));
            continue;
        }
        // Menu is big and needs scrolling,
        // we need to show (more) on the end
        if ((curitem == draw_end - 1) && (curitem != this->item.size() - 1))
        {
            window->print("(more)",
                          this->x + this->width/2 - 3,
                          this->y + yoffset + 1,
                          Colors::pair(COLOR_WHITE, COLOR_DEFAULT));
            continue;
        }
 
        // <rant>
        // THIS IS VERY UGLY
        // HOW CAN I LAY DOWN A CLASS HIERARCHY
        // AND OVERRIDE PARENT FUNCTIONS ON CHILD CLASSES
        // IF WHEN I HAVE A PARENT POINTER I CANT LET THE
        // COMPILER DECIDE WETHER TO CALL PARENT OR CHILD
        // FUNCTIONS?
        // </rant>
 
//      MenuItemCheckbox* pCheckbox = dynamic_cast<MenuItemCheckbox*>a
 
        // Blank Menu Item, will show horizontal line
        if (! this->item[curitem])
        {
            for (int j = 0; j < (this->width); j++)
                window->printChar(((Globals::Screen::fancy_borders) ?
                                   ACS_HLINE :
                                   '-'),
                                  this->x + j,
                                  this->y + yoffset,
                                  Colors::pair(COLOR_WHITE, COLOR_DEFAULT));
        }
        else
        {
            this->item[curitem]->draw(window,
                                      this->x,
                                      this->y + yoffset,
                                      this->width,
 
                                      // Highlighting current item if
                                      // it's the current.
                                      (this->item[curitem] == this->current));
        }
    }
}
void Menu::handleInput()
{
    if (InputManager::noKeyPressed())
        return;
 
    if (InputManager::isPressed("down") || // user-defined
        InputManager::isPressed(KEY_DOWN) ||
        InputManager::isPressed('\t'))
        this->goNext();
 
    else if (InputManager::isPressed("up") ||
             InputManager::isPressed(KEY_UP) ||
             InputManager::isPressed(KEY_BTAB))
        this->goPrevious();
 
    else if (InputManager::isPressed(KEY_HOME) ||
             InputManager::isPressed(KEY_PPAGE))
        this->goFirst();
 
    else if (InputManager::isPressed(KEY_END) ||
             InputManager::isPressed(KEY_NPAGE))
        this->goLast();
 
    else if (InputManager::isPressed(KEY_ENTER) ||
             InputManager::isPressed('\n'))
    {
        // Will only quit if the selected item is a simple
        // item or label - more complex ones doesn't quit.
        if (this->current->type == MenuItem::ITEM ||
            this->current->type == MenuItem::LABEL)
        {
            this->selected = true;
            this->selectedItem = this->current;
        }
        else
            this->current->handleInput();
    }
    else
    {
        if (this->current)
            this->current->handleInput();
    }
}
void Menu::goNext()
{
    // Empty element, piece of cake
    if (this->item.size() == 0)
        return;
 
    // Empty element, also piece of cake
    if (this->item.size() == 1)
    {
        this->current = *(this->item.begin());
        this->currentIndex = 0;
        return;
    }
 
    // Last element...
    // Well, if the last element is nil then we have
    // a problem.
    if (this->current == this->item.back())
    {
        // Assuming we're not nil, things will go smooth
        if (this->currentIndex == (this->item.size() - 1))
        {
            this->goFirst();
            return;
        }
    }
 
    this->currentIndex++;
    this->current = this->item[this->currentIndex];
 
    if (! this->current)
        this->goNext();
}
void Menu::goPrevious()
{
    if (this->item.size() == 0)
        return;
 
    if (this->item.size() == 1)
    {
        this->current = this->item.front();
        this->currentIndex = 0;
        return;
    }
 
    if (this->current == this->item.front())
    {
        if (this->currentIndex == 0)
        {
            this->goLast();
            return;
        }
    }
 
    this->currentIndex--;
    this->current = this->item[this->currentIndex];
 
    if (! this->current)
        this->goPrevious();
}
void Menu::goFirst()
{
    if (this->item.size() == 0)
        return;
 
    if (this->item.size() == 1)
    {
        this->current = this->item.front();
        this->currentIndex = 0;
        return;
    }
 
    this->current = this->item.front();
    this->currentIndex = 0;
 
    if (! this->current)
        this->goNext();
}
void Menu::goLast()
{
    if (this->item.size() == 0)
        return;
 
    if (this->item.size() == 1)
    {
        this->current = this->item.front();
        this->currentIndex = 0;
        return;
    }
 
    this->current = this->item.back();
    this->currentIndex = (this->item.size() - 1);
 
    if (! this->current)
        this->goPrevious();
}
void Menu::goRandom()
{
    if (this->item.size() == 0)
        return;
 
    this->currentIndex = Utils::Random::between(0, this->item.size() - 1);
    this->current      = this->item[this->currentIndex];
}
bool Menu::willQuit()
{
    // Will only quit if the user selected an item
    // and the item selected is valid.
    return (this->selected && this->selectedItem);
}
std::string Menu::currentLabel()
{
    if (! this->current)
        this->goNext();
 
    return (this->current->label);
}
int Menu::currentID()
{
    if (! this->current)
        this->goNext();
 
    return (this->current->id);
}
bool Menu::getBool(int id)
{
    for (unsigned int i = 0; i < (this->item.size()); i++)
    {
        if (! this->item[i])
            continue;
 
        if (this->item[i]->id == id)
        {
            // Either the type got messed up or we have
            // two items with the same id.
            if (this->item[i]->type != MenuItem::CHECKBOX)
                return false;
 
            // This cast may be dangerous if the type was
            // somehow changed.
            MenuItemCheckbox* c = (MenuItemCheckbox*)this->item[i];
            return c->isChecked();
        }
    }
    return false;
}
int Menu::getInt(int id)
{
    for (unsigned int i = 0; i < (this->item.size()); i++)
    {
        if (! this->item[i])
            continue;
 
        if (this->item[i]->id == id)
        {
            // Either the type got messed up or we have
            // two items with the same id.
            if (this->item[i]->type != MenuItem::NUMBERBOX)
                return -1;
 
            // This cast may be dangerous if the type was
            // somehow changed.
            MenuItemNumberbox* c = (MenuItemNumberbox*)this->item[i];
            return c->current;
        }
    }
    return -1;
}
std::string Menu::getString(int id)
{
    for (unsigned int i = 0; i < (this->item.size()); i++)
    {
        if (! this->item[i])
            continue;
 
        if (this->item[i]->id == id)
        {
            // Either the type got messed up or we have
            // two items with the same id.
            if (this->item[i]->type == MenuItem::TEXTBOX)
            {
                MenuItemTextbox* c = (MenuItemTextbox*)this->item[i];
                return c->currentText;
            }
            else if (this->item[i]->type == MenuItem::TEXTLIST)
            {
                MenuItemTextlist* c = (MenuItemTextlist*)this->item[i];
                return c->currentText();
            }
            else
                return "";
 
            // This cast may be dangerous if the type was
            // somehow changed.
        }
    }
    return "";
}
void Menu::reset()
{
    this->selected = false;
    this->selectedItem = NULL;
}