/**
 * $Id$
 * $Revision$
 * $Author$
 * $Date$
 *
 * This file is part of The iWear Framework.
 * In particular this file is part of the Framework Output
 *
 * The iWear Framework 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 as in version 2 of the License.

 * 
 * The iWear Framework 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
 * The iWear Framework; if not, write to the Free Software Foundation, Inc., 59
 * Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __MENUFUNCTOR_H
#define __MENUFUNCTOR_H

// Standard includes
#include <stdint.h>
#include <iostream>
#include <iwear/debugstream.h>

// iWear includes
#ifndef __ATOMICCOUNTER_H
#include <iwear/atomiccounter.h>
#endif

namespace iwear {
namespace uiservices {

// Enum for state changes
enum MENU_EVENT{
    MENU_ELEMENT_ADDED,
    MENU_ELEMENT_REMOVED,
    MENU_ELEMENT_SELECTED,
    MENU_ELEMENT_ACTIVATED,
    MENU_EVENT_JUMP,
    MENU_EVENT_SWITCH,
    MENU_EVENT_QUIT,
    num_MENU_EVENT
};


// Enum for direction information
enum MENU_EVENT_INFORMATION{
    MENU_EVENT_MOVED_UP,
    MENU_EVENT_MOVED_DOWN,
    MENU_EVENT_MOVED_LEFT,
    MENU_EVENT_MOVED_RIGHT,
    num_MENU_EVENT_INFORMATION
};


/**
 * to_string() method for MENU_EVENT_INFORMATION changes 
 */
inline const char* to_string(MENU_EVENT menu_event){
    switch(menu_event){
    case MENU_ELEMENT_ADDED:
	return "MENU_EVENT::MENU_ELEMENT_ADDED";
	break;
    case MENU_ELEMENT_REMOVED:
	return "MENU_EVENT::MENU_ELEMENT_REMOVED";
	break;
    case MENU_ELEMENT_SELECTED:
	return "MENU_EVENT::MENU_ELEMENT_SELECTED";
	break;
    case MENU_ELEMENT_ACTIVATED:
	return "MENU_EVENT::MENU_ELEMENT_ACTIVATED";
	break;
    case MENU_EVENT_JUMP:
	return "MENU_EVENT::MENU_EVENT_JUMP";
	break;
    case MENU_EVENT_SWITCH:
	return "MENU_EVENT::MENU_EVENT_SWITCH";
	break;
    case MENU_EVENT_QUIT:
	return "MENU_EVENT::MENU_EVENT_QUIT";
	break;
    case num_MENU_EVENT:
	return "MENU_EVENT::num_MENU_EVENT";
	break;
    default:
	return "MENU_EVENT::<invalid_information>";
    }
}


/**
 * to_string() method for MENU_EVENT_INFORMATION changes 
 */
inline const char* to_string(MENU_EVENT_INFORMATION menu_event_information){
    switch(menu_event_information){
    case MENU_EVENT_MOVED_UP:
	return "MENU_EVENT_INFORMATION::MENU_EVENT_MOVED_UP";
	break;
    case MENU_EVENT_MOVED_DOWN:
	return "MENU_EVENT_INFORMATION::MENU_EVENT_MOVED_DOWN";
	break;
    case MENU_EVENT_MOVED_LEFT:
	return "MENU_EVENT_INFORMATION::MENU_EVENT_MOVED_LEFT";
	break;
    case MENU_EVENT_MOVED_RIGHT:
	return "MENU_EVENT_INFORMATION::MENU_EVENT_MOVED_RIGHT";
	break;
    case num_MENU_EVENT_INFORMATION:
	return "MENU_EVENT_INFORMATION::num_MENU_EVENT_INFORMATION";
	break;
    default:
	return "MENU_EVENT_INFORMATION::<invalid_information>";
    }
}

inline std::ostream& operator<<(std::ostream& os, MENU_EVENT enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}


inline std::ostream& operator<<(std::ostream& os, MENU_EVENT_INFORMATION enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}


/**
 *  @author Carsten Rachuy
 */
class MenuFunctor {
    
 public:

    /**
     * Constructor
     */
    MenuFunctor(void);
    
    /**
     * Destructor
     */   
    virtual ~MenuFunctor(void);

    virtual void set_parameters(uint32_t element_id, 
			MENU_EVENT menu_status, 
			MENU_EVENT_INFORMATION menu_event_information){
	//d_dbg << ANSI_BG_RED << "[MenuFunctor::set_parameters] - called" << ANSI_NORMAL << endl;
	this->element_id = element_id;
	this->menu_status = menu_status;
	this->menu_event_information = menu_event_information;
    }

    /**
     * Called by the event dipatcher
     */
    virtual void operator()(void);

    AtomicCounter<uint32_t>& get_counter(void) const{
	return *this->counter;
    }
    
    void set_counter(AtomicCounter<uint32_t>& counter) const{
	this->counter = &counter;
    }

 protected:

    /**
     * If an element is added
     */
    virtual void on_element_added(void);

    /**
     * If an element is removed
     */
    virtual void on_element_removed(void);

    /**
     * If an element is selected
     */
    virtual void on_element_selected(void);

    /**
     * If an element is activated
     */
    virtual void on_element_activated(void);

    /**
     * If a jump event is called
     */
    virtual void on_event_jump(void);

    /**
     * If a switch event is called
     */
    virtual void on_event_switch(void);

    /**
     * If a quit event is called
     */
    virtual void on_event_quit(void);
    
    /**
     * The id (as an uint32_t) of the menu element on which something happend
     */
    uint32_t element_id;

    /**
     * The event which occurred
     */
    MENU_EVENT menu_status;

    /**
     * The additional information
     */
    MENU_EVENT_INFORMATION menu_event_information;

    /**
     * @return The uid of the menu element on which something
     *         happened
     */
    inline const uint32_t get_element_id(void) const {
    	return this->element_id;
    }

    /**
     * @return The event
     */
    inline const MENU_EVENT get_menu_event(void) const {
    	return this->menu_status;
    }

    /**
     * @return The event information
     */
    inline const MENU_EVENT_INFORMATION get_menu_event_information(void) const {
    	return this->menu_event_information;
    }

private:

    mutable AtomicCounter<uint32_t>* counter;
    
};

} // namespace uiservices
} // namespace iwear

#endif // __MENUFUNCTOR_H