menu.cc

/***
 * This file is part of OpenHome, an open source home automation system.
 * Copyright (C) 2003 Jan Klötzke
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <avr/pgmspace.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include "net/presentation.h"
#include "main/menu.h"
#include "main/rom.h"
#include "main/lcd.h"
#include "main/keys.h"
#include "utils.h"

#include "main/switch.h"
#include "main/dimmer.h"

#define MAX_CHILDS      8

class Label : public VisibleObject {
private:
        char *text;

public: 
        bool Activate(void);
        void Display(void);
        void LoadProperties(uint8_t tag);
};


class Icon : public VisibleObject {
private:
        PGM_VOID_P image;

public:
        bool Activate(void);
        void Display(void);
        void LoadProperties(uint8_t tag);
};


static VisibleObject* root;
static VisibleObject* callbacks[6];

static VisibleObject* menu_factory(uint8_t id)
{
        switch (id) {
                case 0: return new Container;
                case 1: return new Label;
                case 2: return new Icon;
                case 3: return new Switch;
                case 4: return new Dimmer;
                default: return NULL;
        }
}

/*******************************************************************************
 * VisibleObject
 */

bool VisibleObject::Activate(void)
{
        active = 1;
        return true;
}

void VisibleObject::Deactivate(void)
{
        active = 0;
}

void VisibleObject::LoadProperties(uint8_t tag)
{
        switch (tag) {
                case P_TAG_X|P_TYPE_CHAR:
                        x = prs_get_char();
                        break;
                case P_TAG_Y|P_TYPE_CHAR:
                        y = prs_get_char();
                        break;
                default:
                        prs_skip(tag);
                        break;
        }
}

bool VisibleObject::Shift(uint8_t dir)
{
        return false;
}

void VisibleObject::KeyCallback(uint8_t key)
{
}

/*******************************************************************************
 * Container
 */

Container::Container(void)
{
        childs = new (VisibleObject*)[MAX_CHILDS]; // malloc(MAX_CHILDS*2);
}

bool Container::Activate(void)
{
        // only call if child exists
        if (count > 0) {
                if (childs[current]->Activate()) {
                        return VisibleObject::Activate();
                } else {
                        return false;
                }
        } else {
                return false;
        }
}

void Container::Deactivate(void)
{
        VisibleObject::Deactivate();

        // only call if child exists
        if (count > 0) childs[current]->Deactivate();
}

void Container::Display(void)
{
        uint8_t n = count;
        VisibleObject **child = childs;

        while (n > 0) {
                (*child)->Display();
                child++;
                n--;
        }
}

void Container::LoadProperties(uint8_t tag)
{
        if ((tag&P_TYPE_MASK) == P_TYPE_COMPOUND_OPEN) {
                VisibleObject *newObj;

                // create new object
                newObj = menu_factory(tag>>3);
                AddChild(newObj);

                // feed new object with it's properties
                while (((tag = prs_get_tag()) & P_TYPE_MASK) != P_TYPE_COMPOUND_CLOSE)
                        newObj->LoadProperties(tag);
        } else {
                // tag not handled here
                VisibleObject::LoadProperties(tag);
        }
}

bool Container::Shift(uint8_t dir)
{
        VisibleObject *child;
        uint8_t ind;

        // call child
        child = childs[current];
        if (child->Shift(dir)) return true;

        // change focus locally or revert to higher level
        ind = current;
        child->Deactivate();
        child->Display();
        do {
                if (dir) {
                        if (ind >= count-1) {
                                child = childs[current];
                                child->Activate();
                                child->Display();
                                return false;
                        } else {
                                ind++;
                        }
                } else {
                        if (ind == 0) {
                                child = childs[current];
                                child->Activate();
                                child->Display();
                                return false;
                        } else {
                                ind--;
                        }
                }
                child = childs[ind];
        } while (!child->Activate());

        child->Display();
        current = ind;
        return true;
}

void Container::AddChild(VisibleObject *child)
{
        childs[count++] = child;
}

/*******************************************************************************
 * Label
 */

bool Label::Activate(void)
{
        return false;
}

void Label::Display(void)
{
        if (text != NULL) lcd_print(x, y, 0, text);
}

void Label::LoadProperties(uint8_t tag)
{
        if (tag == (P_TAG_DEFAULT|P_TYPE_STRING)) {
                if (text != NULL) free(text);
                text = (char*)malloc(strlen(prs_get_str())+1);
                strcpy(text, prs_get_str());
        } else {
                VisibleObject::LoadProperties(tag);
        }
}

/*******************************************************************************
 * Icon
 */

bool Icon::Activate(void)
{
        return false;
}

void Icon::Display(void)
{
        if (image != NULL) lcd_put_image(x, y, (PGM_P)image);
}

void Icon::LoadProperties(uint8_t tag)
{
        if (tag == (P_TAG_IMAGE|P_TYPE_CHAR)) {
                switch (prs_get_char()) {
                        case 0: image = &i_main_menu; break;
                }
        } else {
                VisibleObject::LoadProperties(tag);
        }
}

/*******************************************************************************
 * Global functions.
 */

extern "C" void menu_init(void)
{
        uint8_t *buf;
        uint8_t tag;

        buf = (uint8_t*)malloc(255);
        memcpy_P(buf, &e_menu, 255);
        prs_init(buf, 255);

        // create new root object
        tag = prs_get_tag();
        root = menu_factory(tag>>3);
        while (((tag = prs_get_tag()) & P_TYPE_MASK) != P_TYPE_COMPOUND_CLOSE)
                root->LoadProperties(tag);

        free(buf);

        lcd_put_image(0, 0, i_main_menu);
        if (!root->Activate()) root->Shift(1);
        root->Display();
}

extern "C" void menu_process(void)
{
        if (keys_key_pressed()) {
                uint8_t key = keys_get_key();
                switch (key) {
                        case KEY_FUNC_1:
                                if (callbacks[0] != NULL)
                                        callbacks[0]->KeyCallback(0);
                                break;
                        case KEY_FUNC_2:
                                if (callbacks[1] != NULL)
                                        callbacks[1]->KeyCallback(1);
                                break;
                        case KEY_FUNC_3:
                                if (callbacks[2] != NULL)
                                        callbacks[2]->KeyCallback(2);
                                break;
                        case KEY_FUNC_4:
                                if (callbacks[3] != NULL)
                                        callbacks[3]->KeyCallback(3);
                                break;
                        case KEY_FUNC_5:
                                if (callbacks[4] != NULL)
                                        callbacks[4]->KeyCallback(4);
                                break;
                        case KEY_FUNC_6:
                                if (callbacks[5] != NULL)
                                        callbacks[5]->KeyCallback(5);
                                break;
                        case KEY_MENU_UP:
                                root->Shift(0);
                                break;
                        case KEY_MENU_DOWN:
                                root->Shift(1);
                                break;
                }
        }
}

void menu_set_hook(uint8_t index, PGM_VOID_P image, VisibleObject* obj)
{
        callbacks[index] = obj;
        lcd_put_image(8+index*20, 56, (PGM_P)image);
}

void menu_remove_hook(uint8_t index)
{
        callbacks[index] = NULL;
        lcd_put_image(8+index*20, 56, i_tray_empty);
}

---