/**
 * $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 __OUTPUTENUMS_H
#define __OUTPUTENUMS_H


#include <ostream>
extern "C" {
#include <stdint.h>
}


namespace iwear {
namespace output {

/**
 * This file defines all the enumerations needed for the namespace 'output'.
 */


    /**
     * Event Type
     */
    // ON_CHANGED
    // ON_PRESSED
    // ON_

    enum EVENT_TYPE{
	EVENT_PRESS,
	EVENT_RELEASE,
	EVENT_FOCUS,
	EVENT_CHANGE,     
    };

    /**
     * LISTEN_ON
     */
    enum LISTEN_ON{
	LISTEN_OPTIONS,
	LISTEN_CONTENT
    };





/**
 * Defining the diffferent types of widgets
 */
    enum WIDGET_TYPE{
	ARROW,
	BATTERY_STATE,
	SIGNAL_STRENGTH,
	INFORM_MSG,
	WARN_MSG,
	ERROR_MSG,
	REQUEST_MSG,
	PROGRESS_INDICATOR,
	num_WIDGET_TYPE
    };

 inline const char* to_string (WIDGET_TYPE enumtype){
     switch(enumtype){
     case ARROW:
	 return "iwear::output::WIDGET_TYPE::ARROW";
	 break;
     case BATTERY_STATE:
	 return "iwear::output::WIDGET_TYPE::BATTERY_STATE";
	 break; 
     case SIGNAL_STRENGTH:
	 return "iwear::output::WIDGET_TYPE::SIGNAL_STRENGTH";
	 break;
     case INFORM_MSG:
	 return "iwear::output::WIDGET_TYPE::INFORM_MSG";
	 break;	 
     case WARN_MSG:
	 return "iwear::output::WIDGET_TYPE::WARN_MSG";
	 break;	 
     case ERROR_MSG:
	 return "iwear::output::WIDGET_TYPE::ERROR_MSG";
	 break;	 
     case REQUEST_MSG:
	 return "iwear::output::WIDGET_TYPE::REQUEST_MSG";
	 break;	 
     case PROGRESS_INDICATOR:
	 return "iwear::output::WIDGET_TYPE::PROGRESS_INDICATOR";
	 break;	 
     case num_WIDGET_TYPE:
	 return "iwear::output::WIDGET_TYPE::num_WIDGET_TYPE";
	 break;	
     default:
	 return "iwear::output::WIDGET_TYPE::<invalid value>";
	 break;	  
     }
 }


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

/**
 * Defining the position of the widgets
 */
enum WIDGET_POSITION{
	NORTH,
	SOUTH,
	WEST,
	EAST,
	NORTHWEST,
	NORTHEAST,
	SOUTHWEST,
	SOUTHEAST,
	CENTER,
	num_WIDGET_POSITION
};
 
 inline const char* to_string (WIDGET_POSITION enumtype){
     switch(enumtype){
     case NORTH:
	 return "iwear::output::WIDGET_POSITION::NORTH";
	 break;
     case SOUTH:
	 return "iwear::output::WIDGET_POSITION::SOUTH";
	 break;
     case WEST:
	 return "iwear::output::WIDGET_POSITION::WEST";
	 break;
     case EAST:
	 return "iwear::output::WIDGET_POSITION::EAST";
	 break;
     case NORTHWEST:
	 return "iwear::output::WIDGET_POSITION::NORTHWEST";
	 break;
     case NORTHEAST:
	 return "iwear::output::WIDGET_POSITION::NORTHEAST";
	 break;
     case SOUTHWEST:
	 return "iwear::output::WIDGET_POSITION::SOUTHWEST";
	 break;
     case SOUTHEAST:
	 return "iwear::output::WIDGET_POSITION::SOUTHEAST";
	 break;
     case CENTER:
	 return "iwear::output::WIDGET_POSITION::CENTER";
	 break;
     case num_WIDGET_POSITION:
	 return "iwear::output::WIDGET_POSITION::num_WIDGET_POSITION";
	 break;
     default:
	 return "iwear::output::WIDGET_POSITION::<invalid type>";
	 break;
     }
 }

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




/**
 * The direction the ARROW_WIDGET points to
 */
enum ARROW_DIRECTION{
	LEFT,
	RIGHT,
	UP,
	DOWN,
	num_ARROW_DIRECTION
};
 

 inline const char* to_string (ARROW_DIRECTION enumtype){
     switch(enumtype){
     case LEFT:
	 return "iwear::output::ARROW_DIRECTION::LEFT";
	 break;
     case RIGHT:
	 return "iwear::output::ARROW_DIRECTION::RIGHT";
	 break;
     case UP:
	 return "iwear::output::ARROW_DIRECTION::UP";
	 break;
     case DOWN:
	 return "iwear::output::ARROW_DIRECTION::DOWN";
	 break;
     case num_ARROW_DIRECTION:
	 return "iwear::output::ARROW_DIRECTION::num_ARROW_DIRECTION";
	 break;
     default:
	 return "iwear::output::ARROW_DIRECTION::<invalid value>";
     }
 }


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



 /**
  * Defining the different purposes of options.
  */
 enum OPTION_PURPOSE{
     VISIBILITY,	// is this element visible
     INTENSITY,		// volume, brightness, size, ...
     IMPORTANCE,	// relevance, how important the display of this data is
     OUTPUTMODULE,      // which display type is preferred
     FINISHED,          // Finished displaying
     num_OPTION_PURPOSE
};
 
 inline const char* to_string (OPTION_PURPOSE enumtype){
     switch(enumtype){
     case VISIBILITY:
	 return "iwear::output::OPTION_PURPOSE::VISIBILITY";
	 break;
     case INTENSITY:
	 return "iwear::output::OPTION_PURPOSE::INTENSITY";
	 break;	 
     case IMPORTANCE:
	 return "iwear::output::OPTION_PURPOSE::IMPORTANCE";
	 break;
     case OUTPUTMODULE:
	 return "iwear::output::OPTION_PURPOSE::OUTPUTMODULE";
	 break;
     case num_OPTION_PURPOSE:
	 return "iwear::output::OPTION_PURPOSE::num_OPTION_PURPOSE";
	 break;
     default:
	 return "iwear::output::OPTION_PURPOSE::<invalid type>";
     }
 }


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

 
 /**
  * Defining the types of actions that could occur when something is done with
  * an eventable.
  */
 enum ACTION_TYPE{
     FOCUS,		 // on menus
     CHANGE_IS_ACTIVE,   // on menu
     PRESS,              // on button
     RELEASE,		 // on buttons
     CHANGE_VALUE,	 // on options
     WIDGET_CHANGE,	 // on widgets
     num_ACTION_TYPE
 }; 
 
 inline const char* to_string (ACTION_TYPE enumtype){
     switch(enumtype){
     case FOCUS:
	 return "iwear::output::ACTION_TYPE::FOCUS";
	 break;
     case CHANGE_IS_ACTIVE:
	 return "iwear::output::ACTION_TYPE::CHANGE_IS_ACTIVE";
	 break;
     case PRESS:
	 return "iwear::output::ACTION_TYPE::PRESS";
	 break;
     case RELEASE:
	 return "iwear::output::ACTION_TYPE::RELEASE";
	 break;
     case CHANGE_VALUE:
	 return "iwear::output::ACTION_TYPE::CHANGE_VALUE";
	 break;
     case WIDGET_CHANGE:
	 return "iwear::output::ACTION_TYPE::WIDGET_CHANGE";
	 break;
     case num_ACTION_TYPE:
	 return "iwear::output::ACTION_TYPE::num_ACTION_TYPE";
	 break;
     default:
	 return "iwear::output::ACTION_TYPE::<invalid type>";
     }
 }
 

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

/** 
 * Defining the type of the eventable. 
 * Currently buttons and submenus are implemented as well as both types
 * of options and widgets.
 */
 enum EVENTABLE_TYPE{
     BUTTON,
     SUBMENU,
     BOOLEAN_OPTION,
     VALUE_OPTION,
     OUTPUTMODULE_OPTION,
     ARROW_WIDGET,
     BATTERY_STATE_WIDGET,
     SIGNAL_STRENGTH_WIDGET,
     INFORM_MSG_WIDGET,
     WARN_MSG_WIDGET,
     ERROR_MSG_WIDGET,
     REQUEST_MSG_WIDGET,
     PROGRESS_INDICATOR_WIDGET,
     AUDIO_EVENT,
     num_EVENTABLE_TYPE
 };
 
 inline const char* to_string (EVENTABLE_TYPE enumtype){
     switch(enumtype){
     case BUTTON:
	 return "iwear::output::EVENTABLE_TYPE::BUTTON";
	 break;
     case SUBMENU:
	 return "iwear::output::EVENTABLE_TYPE::SUBMENU";
	 break;
     case BOOLEAN_OPTION:
	 return "iwear::output::EVENTABLE_TYPE::BOOLEAN_OPTION";
	 break;
     case VALUE_OPTION:
	 return "iwear::output::EVENTABLE_TYPE::VALUE_OPTION";
	 break;
     case OUTPUTMODULE_OPTION:
	 return "iwear::output::EVENTABLE_TYPE::OUTPUTMODULE_OPTION";
	 break;
     case ARROW_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::ARROW_WIDGET";
	 break;
     case BATTERY_STATE_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::BATTERY_STATE_WIDGET";
	 break;
     case SIGNAL_STRENGTH_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::SIGNAL_STRENGTH_WIDGET";
	 break;
     case INFORM_MSG_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::INFORM_MSG_WIDGET";
	 break;
     case WARN_MSG_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::WARN_MSG_WIDGET";
	 break;
     case ERROR_MSG_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::ERROR_MSG_WIDGET";
	 break;
     case REQUEST_MSG_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::REQUEST_MSG_WIDGET";
	 break;
     case PROGRESS_INDICATOR_WIDGET:
	 return "iwear::output::EVENTABLE_TYPE::PROGRESS_INDICATOR_WIDGET";
	 break;
     case AUDIO_EVENT:
	 return "iwear::output::EVENTABLE_TYPE::AUDIO_EVENT";
	 break;
     case num_EVENTABLE_TYPE:
	 return "iwear::output::EVENTABLE_TYPE::num_EVENTABLE_TYPE";
	 break;
     default:
	 return "iwear::output::EVENTABLE_TYPE::<invalid type>";
     }
 }

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

 /**
  * Defines what kind of listener is implemented.
  * Currently general, button and submenulisteners are implemented.
  */
enum LISTENER_TYPE{
    UNDEFINED_LISTENER, // error value
    GENERAL_LISTENER,   // listens on everything
    BUTTON_LISTENER,	// listens only on buttons
    SUBMENU_LISTENER,	// listens only on submenus
    OPTION_LISTENER,	// listens only to options
    WIDGET_LISTENER,	// listens only to widgets 
    num_LISTENER_TYPE
};

 inline const char* to_string (LISTENER_TYPE enumtype){
     switch(enumtype){
     case UNDEFINED_LISTENER:
	 return "iwear::output::LISTENER_TYPE::UNDEFINED_LISTENER";
	 break; 
     case GENERAL_LISTENER:
	 return "iwear::output::LISTENER_TYPE::GENERAL_LISTENER";
	 break;
     case BUTTON_LISTENER:
	 return "iwear::output::LISTENER_TYPE::BUTTON_LISTENER";
	 break;
     case SUBMENU_LISTENER:
	 return "iwear::output::LISTENER_TYPE::SUBMENNU_LISTENER";
	 break;
     case OPTION_LISTENER:
	 return "iwear::output::LISTENER_TYPE::OPTION_LISTENER";
	 break;
     case WIDGET_LISTENER:
	 return "iwear::output::LISTENER_TYPE::WIDGET_LISTENER";
	 break;
     case num_LISTENER_TYPE:
	 return "iwear::output::LISTENER_TYPE::num_LISTENER_TYPE";
	 break;
     default:
	 return "iwear::output::LISTENER_TYPE::<invalid type>";
     }
 }
 
inline std::ostream& operator<<(std::ostream& os, LISTENER_TYPE enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}

/**
 * The audio types which can be processed by our system.
 */


 

/**
 * The image types which can be processed by our system.
 */
enum IMAGE_TYPE{
	BMP,
	JPG,
	PNG,
	num_IMAGE_TYPE
};

 inline const char* to_string (IMAGE_TYPE enumtype){
     switch(enumtype){
     case BMP:
	 return "iwear::output::IMAGE_TYPE::BMP";
	 break;
     case JPG:
	 return "iwear::output::IMAGE_TYPE::JPG";
	 break;
     case PNG:
	 return "iwear::output::IMAGE_TYPE::PNG";
	 break;
     case num_IMAGE_TYPE:
	 return "iwear::output::IMAGE_TYPE::num_IMAGE_TYPE";
	 break; 
     default:
	 return "iwear::output::IMAGE_TYPE::<undefined value>";
     }
 }
	

 inline std::ostream& operator<<(std::ostream& os, IMAGE_TYPE enumtype){
     os << to_string(enumtype);
     os << "(";
     os << (uint32_t)enumtype << ")";
     return os;
 }
 
/** 
 * Describes which subclasses of output data are implemented and ready to use.
 */
enum OUTPUT_DATA_TYPE{
    IMAGE_DATA,
    AUDIO_DATA,
    RAW_TEXT_DATA,
    MENU_DATA,
    WIDGET_DATA,
    num_OUTPUT_DATA_TYPE
};

 inline const char* to_string (OUTPUT_DATA_TYPE enumtype){
     switch(enumtype){
     case IMAGE_DATA:
	 return "iwear::output::OUTPUT_DATA_TYPE::IMAGE_DATA";
	 break; 
     case AUDIO_DATA:
	 return "iwear::output::OUTPUT_DATA_TYPE::AUDIO_DATA";
	 break; 
     case RAW_TEXT_DATA:
	 return "iwear::output::OUTPUT_DATA_TYPE::RAW_TEXT_DATA";
	 break; 
     case MENU_DATA:
	 return "iwear::output::OUTPUT_DATA_TYPE::MENU_DATA";
	 break; 
     case WIDGET_DATA:
	 return "iwear::output::OUTPUT_DATA_TYPE::WIDGET_DATA";
	 break; 
     case num_OUTPUT_DATA_TYPE:
	 return "iwear::output::OUTPUT_DATA_TYPE::num_OUTPUT_DATA_TYPE";
	 break; 
     default:
	 return "iwear::output::OUTPUT_DATA_TYPE::<invalid calue>";
     }
}

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


/**
 * temporarly as a typedef - later maybe directy changed in all using classes
 */
typedef OUTPUT_DATA_TYPE output_module_type;
/*
  enum output_module_type{
  OUTPUT_AUDIO,
  OUTPUT_TEXT,
  OUTPUT_GRAPHICS,
  OUTPUT_VIDEO,
  OUTPUT_SIGNAL
  };
*/


/**
 * Because the above output_module_type defines the types of OutputData (and therefore 
 * also the OutputModules 's return a list of the types they can display) we need a
 * type information for each OutputModule that is unique - this functionality is
 * required by the class Manager we inherit from.
 */
/*enum outputmodule_type{
    RAW_TEXT_CONSOLE,
    GRIFFIN,
    AUDIO_OUTPUT,
    num_outputmodule_type
};

 inline const char* to_string (outputmodule_type enumtype){
     switch(enumtype){
     case RAW_TEXT_CONSOLE:
	 return "iwear::output::outputmodule_type::RAW_TEXT_CONSOLE";
	 break;
     case GRIFFIN:
	 return "iwear::output::outputmodule_type::GRIFFIN";
	 break;
     case AUDIO_OUTPUT:
	 return "iwear::output::outputmodule_type::AUDIO_OUTPUT";
	 break;
     case num_outputmodule_type:
	 return "iwear::output::outputmodule_type::num_outputmodule_type";
	 break;
     default:
	 return "iwear::output::outputmodule_type::<invalid type>";
	 break;
     }
}


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

} // namespace output
} // namespace iwear

#endif