/**
 * $Id$
 * $Revision$
 * $Author$
 * $Date$
 *
 * This file is part of The iWear Framework.
 * In particular this file is part of the Framework Input
 *
 * 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 __INPUTENUMS_H
#define __INPUTENUMS_H


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

namespace iwear {
namespace input {

    // {{{ InputEventTypes

/** The types of the InputEvents which can be managed by the system.
 *
 */
enum InputEventType {
  INPUT_KEY_EVENT,
  INPUT_MOUSE_EVENT,
  INPUT_JOYSTICK_EVENT,
  INPUT_SIGNAL_EVENT,
  num_InputEventType
  };

 /** Returnes a c-string representation of an InputEventType.
  * @return A c-string of the InputEventType.
  */
 inline const char* to_string (InputEventType enumtype){
     switch(enumtype){
     case INPUT_KEY_EVENT:
	 return "iwear::input::InputEventType::INPUT_KEY_EVENT";
	 break; 
     case INPUT_MOUSE_EVENT:
	 return "iwear::input::InputEventType::INPUT_MOUSE_EVENT";
	 break; 
     case INPUT_JOYSTICK_EVENT:
	 return "iwear::input::InputEventType::INPUT_JOYSTICK_EVENT";
	 break; 
     case INPUT_SIGNAL_EVENT:
	 return "iwear::input::InputEventType::INPUT_SIGNAL_EVENT";
	 break; 
     case num_InputEventType:
	 return "iwear::input::InputEventType::num_InputEventType";
	 break; 
     default:
	 return "iwear::input::InputEventType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of InputEventType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a InputEventType. 
 */
inline std::ostream& operator<<(std::ostream& os, InputEventType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}
    // }}}

    // {{{ KeyModifierType

    /** The modifiers (state) of a key event.
     *
     */
    enum KeyModifierType {
	KEY_SHIFT = 1,
	KEY_CAPS_LOCK = 2,
	KEY_CONTROL = 4,
	KEY_ALT = 8, // ALT = META
	KEY_ALTGR = 128,
	num_KeyModifierType
    };

 /** Returnes a c-string representation of an KeyInputEventType.
  * @return A c-string of the KeyInputEventType.
  */
 inline const char* to_string (KeyModifierType enumtype){
     switch(enumtype){
     case KEY_SHIFT:
	 return "iwear::input::KeyModifierType::KEY_SHIFT";
	 break; 
     case KEY_CAPS_LOCK:
	 return "iwear::input::KeyModifierType::KEY_CAPS_LOCK";
	 break; 
     case KEY_CONTROL:
	 return "iwear::input::KeyModifierType::KEY_CONTROL";
	 break; 
     case KEY_ALT:
	 return "iwear::input::KeyModifierType::KEY_ALT";
	 break; 
     case KEY_ALTGR:
	 return "iwear::input::KeyModifierType::KEY_ALTGR";
	 break; 
     default:
	 return "iwear::input::KeyModifierType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of KeyModifierType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a KeyModifierType. 
 */
inline std::ostream& operator<<(std::ostream& os, KeyModifierType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}

    // }}}


    // {{{ KeyEventTypes

    /** The types of keyboard events which can be fired by an InputModule.
     *
     */
    enum KeyInputEventType {
	INPUT_KEY,
	INPUT_KEY_DOWN,
	INPUT_KEY_PRESSED,
	INPUT_KEY_UP,
	num_KeyInputEventType
    };
    
 /** Returnes a c-string representation of an KeyInputEventType.
  * @return A c-string of the KeyInputEventType.
  */
 inline const char* to_string (KeyInputEventType enumtype){
     switch(enumtype){
     case INPUT_KEY:
	 return "iwear::input::KeyInputEventType::INPUT_KEY";
	 break; 
     case INPUT_KEY_DOWN:
	 return "iwear::input::KeyInputEventType::INPUT_KEY_DOWN";
	 break; 
     case INPUT_KEY_PRESSED:
	 return "iwear::input::KeyInputEventType::INPUT_KEY_PRESSED";
	 break; 
     case INPUT_KEY_UP:
	 return "iwear::input::KeyInputEventType::INPUT_KEY_UP";
	 break; 
     case num_KeyInputEventType:
	 return "iwear::input::KeyInputEventType::num_KeyInputEventType";
	 break; 
     default:
	 return "iwear::input::KeyInputEventType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of KeyInputEventType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a KeyInputEventType. 
 */
inline std::ostream& operator<<(std::ostream& os, KeyInputEventType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}

    // }}}

    // {{{ InputMouseKeys

    /** Enum of all mousekeys */
    enum MouseKey {
	MOUSE_BUTTON_LEFT,
	MOUSE_BUTTON_RIGHT,
	MOUSE_BUTTON_MIDDLE,
	MOUSE_BUTTON_WHEEL_UP,
	MOUSE_BUTTON_WHEEL_DOWN,
	MOUSE_BUTTON_6,
	MOUSE_BUTTON_7,
	num_MouseKey
    };

    /** Is used to return the c-string representation of MouseKey.
     * @return Returnes a c-string of a MouseKey. 
     */
    inline const char* to_string (MouseKey enumtype){
	switch(enumtype){
	case MOUSE_BUTTON_LEFT:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_LEFT";
	    break; 
	case MOUSE_BUTTON_RIGHT:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_RIGHT";
	    break; 
	case MOUSE_BUTTON_MIDDLE:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_MIDDLE";
	    break; 
	case MOUSE_BUTTON_WHEEL_UP:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_WHEEL_UP";
	    break; 
	case MOUSE_BUTTON_WHEEL_DOWN:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_WHEEL_DOWN";
	    break; 
	case MOUSE_BUTTON_6:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_6";
	    break; 
	case MOUSE_BUTTON_7:
	    return "iwear::input::MouseKey::MOUSE_BUTTON_7";
	    break; 
	case num_MouseKey:
	    return "iwear::input::MouseKey::num_MouseKey";
	    break; 
	default:
	    return "iwear::input::MouseKey::<invalid calue>";
	}
    }
    
    /** Is used to return the c-string representation of
     * MouseKey with the << operator.
     * This can by usefull for couts.
     * @return Returnes a c-string of a MouseKey. */
    inline std::ostream& operator<<(std::ostream& os, MouseKey enumtype){
	os << to_string(enumtype);
	os << "(";
	os << (uint32_t)enumtype << ")";
	return os;
    }
    // }}}

    // {{{ MouseEventTypes

/** The types of mouse events which can be fired by an InputModule.
 *
 */
enum MouseInputEventType {
  INPUT_MOUSE,
  INPUT_MOUSE_MOVED,
  INPUT_MOUSE_BUTTON_DOWN,
  INPUT_MOUSE_BUTTON_PRESSED,
  INPUT_MOUSE_BUTTON_UP,
  INPUT_MOUSE_BUTTON_CLICK,
  num_MouseInputEventType
  };

 /** Returnes a c-string representation of an MouseInputEventType.
  * @return A c-string of the MouseInputEventType.
  */
 inline const char* to_string (MouseInputEventType enumtype){
     switch(enumtype){
     case INPUT_MOUSE:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE";
	 break; 
     case INPUT_MOUSE_MOVED:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE_MOVED";
	 break; 
     case INPUT_MOUSE_BUTTON_DOWN:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE_BUTTON_DOWN";
	 break; 
     case INPUT_MOUSE_BUTTON_PRESSED:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE_BUTTON_PRESSED";
	 break; 
     case INPUT_MOUSE_BUTTON_UP:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE_BUTTON_UP";
	 break; 
     case INPUT_MOUSE_BUTTON_CLICK:
	 return "iwear::input::MouseInputEventType::INPUT_MOUSE_BUTTON_CLICK";
	 break; 
     case num_MouseInputEventType:
	 return "iwear::input::MouseInputEventType::num_MouseInputEventType";
	 break; 
     default:
	 return "iwear::input::MouseInputEventType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of MouseInputEventType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a MouseInputEventType. 
 */
inline std::ostream& operator<<(std::ostream& os, MouseInputEventType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}
    
    // }}}

    // {{{ InputSignal

    /** Enum of all signals */
    enum InputSignal {
	INPUT_SIGNAL_0,
	INPUT_SIGNAL_1,
	INPUT_SIGNAL_2,
	INPUT_SIGNAL_3,
	INPUT_SIGNAL_4,
	INPUT_SIGNAL_5,
	INPUT_SIGNAL_6,
	num_InputSignal
    };

    /** Is used to return the c-string representation of InputSignal.
     * @return Returnes a c-string of a MouseKey. 
     */
    inline const char* to_string (InputSignal enumtype){
	switch(enumtype){
	case INPUT_SIGNAL_0:
	    return "iwear::input::InputSignal::INPUT_SINGAL_0";
	    break; 
	case INPUT_SIGNAL_1:
	    return "iwear::input::InputSignal::INPUT_SINGAL_1";
	    break; 
	case INPUT_SIGNAL_2:
	    return "iwear::input::InputSignal::INPUT_SINGAL_2";
	    break; 
	case INPUT_SIGNAL_3:
	    return "iwear::input::InputSignal::INPUT_SINGAL_3";
	    break; 
	case INPUT_SIGNAL_4:
	    return "iwear::input::InputSignal::INPUT_SINGAL_4";
	    break; 
	case INPUT_SIGNAL_5:
	    return "iwear::input::InputSignal::INPUT_SINGAL_5";
	    break; 
	case INPUT_SIGNAL_6:
	    return "iwear::input::InputSignal::INPUT_SINGAL_6";
	    break; 
	case num_InputSignal:
	    return "iwear::input::InputSignal::num_InputSignal";
	    break; 
	default:
	    return "iwear::input::InputSignal::<invalid calue>";
	}
    }
    
    /** Is used to return the c-string representation of
     * InputSignal with the << operator.
     * This can by usefull for couts.
     * @return Returnes a c-string of a Signalstates. */
    inline std::ostream& operator<<(std::ostream& os, InputSignal enumtype){
	os << to_string(enumtype);
	os << "(";
	os << (uint32_t)enumtype << ")";
	return os;
    }
    
    // }}}

    // {{{ Signal Modifiers

    /** Enum of all signal modifiers */
    enum InputSignalModifier {
	INPUT_SIGNAL_MODIFIER_0,
	INPUT_SIGNAL_MODIFIER_1,
	INPUT_SIGNAL_MODIFIER_2,
	INPUT_SIGNAL_MODIFIER_3,
	INPUT_SIGNAL_MODIFIER_4,
	INPUT_SIGNAL_MODIFIER_5,
	INPUT_SIGNAL_MODIFIER_6,
	num_InputSignalModifier
    };

    /** Is used to return the c-string representation of InputSignalModifier.
     * @return Returnes a c-string of a MouseKey. 
     */
    inline const char* to_string (InputSignalModifier enumtype){
	switch(enumtype){
	case INPUT_SIGNAL_MODIFIER_0:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_0";
	    break; 
	case INPUT_SIGNAL_MODIFIER_1:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_1";
	    break; 
	case INPUT_SIGNAL_MODIFIER_2:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_2";
	    break; 
	case INPUT_SIGNAL_MODIFIER_3:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_3";
	    break; 
	case INPUT_SIGNAL_MODIFIER_4:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_4";
	    break; 
	case INPUT_SIGNAL_MODIFIER_5:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_5";
	    break; 
	case INPUT_SIGNAL_MODIFIER_6:
	    return "iwear::input::InputSignalModifier::INPUT_SINGAL_MODIFIER_6";
	    break; 
	case num_InputSignalModifier:
	    return "iwear::input::InputSignalModifier::num_InputSignalModifier";
	    break; 
	default:
	    return "iwear::input::InputSignalModifier::<invalid calue>";
	}
    }
    
    /** Is used to return the c-string representation of
     * InputSignalModifier with the << operator.
     * This can by usefull for couts.
     * @return Returnes a c-string of a Signalstates. */
    inline std::ostream& operator<<(std::ostream& os, 
				    InputSignalModifier enumtype){
	os << to_string(enumtype);
	os << "(";
	os << (uint32_t)enumtype << ")";
	return os;
    }
    
    // }}}


    // {{{ SignalEventTypes

/** The types of signal events which can be fired by an InputModule.
 *
 */
enum SignalInputEventType {
    INPUT_SIGNAL,
    INPUT_SIGNAL_PRE_ACTIVATION,
    INPUT_SIGNAL_ACTIVATED,
    INPUT_SIGNAL_PRE_DEACTIVATION,
    INPUT_SIGNAL_DEACTIVATED,
    num_SignalInputEventType
  };

 /** Returnes a c-string representation of an SignalInputEventType.
  * @return  A c-string of the SignalInputEventType.
  */
 inline const char* to_string (SignalInputEventType enumtype){
     switch(enumtype){
     case INPUT_SIGNAL:
	 return "iwear::input::SignalInputEventType::INPUT_SIGNAL";
	 break; 
     case INPUT_SIGNAL_PRE_ACTIVATION:
	 return "iwear::input::SignalInputEventType::INPUT_SIGNAL_PRE_ACTIVATION";
	 break; 
     case INPUT_SIGNAL_ACTIVATED:
	 return "iwear::input::SignalInputEventType::INPUT_SIGNAL_ACTIVATED";
	 break; 
     case INPUT_SIGNAL_PRE_DEACTIVATION:
	 return "iwear::input::SignalInputEventType::INPUT_SIGNAL_PRE_DEACTIVATION";
	 break; 
     case INPUT_SIGNAL_DEACTIVATED:
	 return "iwear::input::SignalInputEventType::INPUT_SIGNAL_DEACTIVATED";
	 break; 
     case num_SignalInputEventType:
	 return "iwear::input::MouseInputEventType::num_SignalInputEventType";
	 break; 
     default:
	 return "iwear::input::MouseInputEventType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of SignalInputEventType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a SignalInputEventType. 
 */
inline std::ostream& operator<<(std::ostream& os, SignalInputEventType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}

    // }}}


    // {{{ InputJoystickButttons

    /** Enum of all joystick buttons */
    enum JoystickButton {
	JOYSTICK_BUTTON_PRIMARY,
	JOYSTICK_BUTTON_SECONDARY,
	JOYSTICK_BUTTON_3,
	JOYSTICK_BUTTON_4,
	JOYSTICK_BUTTON_5,
	JOYSTICK_BUTTON_6,
	JOYSTICK_BUTTON_7,
	JOYSTICK_BUTTON_8,
	JOYSTICK_BUTTON_HEAD_UP,
	JOYSTICK_BUTTON_HEAD_DOWN,
	JOYSTICK_BUTTON_HEAD_LEFT,
	JOYSTICK_BUTTON_HEAD_RIGHT,
	num_JoystickButton
    };

    /** Is used to return the c-string representation of JoystickButton.
     * @return Returnes a c-string of a JoystickButton. 
     */
    inline const char* to_string (JoystickButton enumtype){
	switch(enumtype){
	case JOYSTICK_BUTTON_PRIMARY:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_PRIMARY";
	    break; 
	case JOYSTICK_BUTTON_SECONDARY:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_SECONDARY";
	    break; 
	case JOYSTICK_BUTTON_3:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_3";
	    break; 
	case JOYSTICK_BUTTON_4:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_4";
	    break; 
	case JOYSTICK_BUTTON_5:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_5";
	    break; 
	case JOYSTICK_BUTTON_6:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_6";
	    break; 
	case JOYSTICK_BUTTON_7:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_7";
	    break; 
	case JOYSTICK_BUTTON_8:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_8";
	    break; 
	case JOYSTICK_BUTTON_HEAD_UP:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_HEAD_UP";
	    break; 
	case JOYSTICK_BUTTON_HEAD_DOWN:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_HEAD_DOWN";
	    break; 
	case JOYSTICK_BUTTON_HEAD_LEFT:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_HEAD_LEFT";
	    break; 
	case JOYSTICK_BUTTON_HEAD_RIGHT:
	    return "iwear::input::JoystickButton::JOYSTICK_BUTTON_HEAD_RIGHT";
	    break; 
	case num_JoystickButton:
	    return "iwear::input::InputSignal::num_JoystickButton";
	    break; 
	default:
	    return "iwear::input::JoystickButton::<invalid calue>";
	}
    }
    
    /** Is used to return the c-string representation of
     * JoystickButton with the << operator.
     * This can by usefull for couts.
     * @return Returnes a c-string of a JoystickButton. */
    inline std::ostream& operator<<(std::ostream& os, JoystickButton enumtype){
	os << to_string(enumtype);
	os << "(";
	os << (uint32_t)enumtype << ")";
	return os;
    }
    
    // }}}

    // {{{ JoystickEventTypes

    /** The types of joystick events which can be fired by an InputModule.
     *
     */
    enum JoystickInputEventType {
	INPUT_JOYSTICK,
	INPUT_JOYSTICK_MOVED,
	INPUT_JOYSTICK_BUTTON,
	INPUT_JOYSTICK_BUTTON_DOWN,
	INPUT_JOYSTICK_BUTTON_PRESSED,
	INPUT_JOYSTICK_BUTTON_UP,
	INPUT_JOYSTICK_BUTTON_CLICK,
	num_JoystickInputEventType
    };
    
 /** Returnes a c-string representation of an JoystickInputEventType.
  * @return  A c-string of the JoystickInputEventType.
  */
 inline const char* to_string (JoystickInputEventType enumtype){
     switch(enumtype){
     case INPUT_JOYSTICK:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK";
	 break; 
     case INPUT_JOYSTICK_MOVED:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_MOVED";
	 break; 
     case INPUT_JOYSTICK_BUTTON:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_BUTTON";
	 break; 
     case INPUT_JOYSTICK_BUTTON_DOWN:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_BUTTON_DOWN";
	 break; 
     case INPUT_JOYSTICK_BUTTON_PRESSED:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_BUTTON_PRESSED";
	 break; 
     case INPUT_JOYSTICK_BUTTON_UP:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_BUTTON_UP";
	 break; 
     case INPUT_JOYSTICK_BUTTON_CLICK:
	 return "iwear::input::JoystickInputEventType::INPUT_JOYSTICK_BUTTON_CLICK";
	 break; 
     case num_JoystickInputEventType:
	 return "iwear::input::JoystickInputEventType::num_JoystickInputEventType";
	 break; 
     default:
	 return "iwear::input::JoystickInputEventType::<invalid calue>";
     }
}

/** Is used to return the c-string representation of JoystickInputEventType with the
 * << operator.
 * This can by usefull for couts.
 * @return Returnes a c-string of a JoystickInputEventType. 
 */
inline std::ostream& operator<<(std::ostream& os, JoystickInputEventType enumtype){
    os << to_string(enumtype);
    os << "(";
    os << (uint32_t)enumtype << ")";
    return os;
}

    // }}}



} // namespace input
} // namespace iwear

#endif // __INPUTENUMS_H