ceInputCoreImpl.h

Go to the documentation of this file.

/* --- Source License
 * Author  : FX Programmer.
 * Contact : CorEngine@gmail.com
 *
 * Copyright (c) 2010 by FX Programmer.
 *
 * This source code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This source code 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 Lesser General Public
 * License for more details.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgement in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be clearly marked as such, and must not
 *       be misrepresented as being the original software.
 *    3. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this source code; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
 */

 #ifndef _CE_INPUTCORE_IMPL_H_
 #define _CE_INPUTCORE_IMPL_H_ 0x1 
 #ifndef __cplusplus
 #error ceInputCoreImpl.h requires C++ compilation (use a .cpp suffix)
 #endif

 #if __GNUC__ >= 0x3
 #pragma GCC system_header
 #endif

 #if _MSC_VER > 1000
 #pragma once
 #pragma warning(disable: 4100)
 #endif

 #include "ceInputCore.h"

 namespace ce {

// ---                                          class IInputManagerImpl --- */

 #define CE_INPUT_VERIFY 0x1

 template <class T>
 class IInputManagerImpl :
  protected IKeyboardEvent,
  protected IMouseEvent,
  protected IJoystickEvent
 {
  public:

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    IInputManagerImpl(void)
    {
      this -> pT = static_cast<T*>(this);

      this -> pT -> Input = CreateInputManager();
      if (!this -> pT -> Input) return;

      #ifndef CE_WITHOUT_KEYBOARD
      this -> pT -> Keyboard = this -> pT -> Input -> GetKeyboardDevice();
      this -> pT -> Keyboard -> SetKeyboardEvent(this -> pT);
      #endif
      #ifndef CE_WITHOUT_MOUSE
      this -> pT -> Mouse = this -> pT -> Input -> GetMouseDevice();
      this -> pT -> Mouse -> SetMouseEvent(this -> pT);
      #endif
      #ifndef CE_WITHOUT_JOYSTICK
      this -> pT -> Joystick = this -> pT -> Input -> GetJoystickDevice();
      this -> pT -> Joystick -> SetJoystickEvent(this -> pT);
      #endif
    };

    virtual ~IInputManagerImpl(void)
    { DestroyInputManager(&this -> pT -> Input); };
    #endif

    #ifdef CE_INPUT_VERIFY

    inline const short APICALL
      VerifyInputManager(void) const
    {
      if (!this -> pT -> Input) return FALSE;
      #ifndef CE_WITHOUT_KEYBOARD
      if (!this -> pT -> Keyboard) return FALSE;
      #endif
      #ifndef CE_WITHOUT_MOUSE
      if (!this -> pT -> Mouse) return FALSE;
      #endif
      #ifndef CE_WITHOUT_JOYSTICK
      if (!this -> pT -> Joystick) return FALSE;
      #endif
      return TRUE;
    };
    #endif

      inline short APICALL
      SetInputDriver(const EInputDriver driver = InputDriver_Null) const
    { return this -> pT -> Input -> SetInputDriver(driver); };

      inline EInputDriver APICALL
      GetDriverType(void) const
    { return this -> pT -> Input -> GetDriverType(); };

      inline IInputDevice* APICALL
      GetInputDevice(const EInputDevice device) const
    { return this -> pT -> Input -> GetInputDevice(device); };

      inline void APICALL
      Update(void) const
    { this -> pT -> Input -> Update(); };

    #ifndef CE_WITHOUT_KEYBOARD

      inline IKeyboardDevice* APICALL
      GetKeyboardDevice(void) const
    { return this -> pT -> Input -> GetKeyboardDevice(); };

      inline void APICALL
      UpdateKeyboar(void) const
    { this -> pT -> Input -> UpdateKeyboar(); };
    #endif

    #ifndef CE_WITHOUT_MOUSE

      inline IMouseDevice* APICALL
      GetMouseDevice(void) const
    { return this -> pT -> Input -> GetMouseDevice(); };

      inline void APICALL
      UpdateMouse(void) const
    { this -> pT -> Input -> UpdateMouse(); };
    #endif

    #ifndef CE_WITHOUT_JOYSTICK

      inline IJoystickDevice* APICALL
      GetJoystickDevice(void) const
    { return this -> pT -> Input -> GetJoystickDevice(); };

      inline void APICALL
      UpdateJoystick(void) const
    { this -> pT -> Input -> UpdateJoystick(); };
    #endif

  protected:

    IInputManager *Input; 

    #ifndef CE_WITHOUT_KEYBOARD
    IKeyboardDevice *Keyboard; 

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline void APICALL
      OnKeyPressed(const IKeyboardDevice *Owner,
        const int key, const int buffer[256]) { };

    inline void APICALL
      OnKeyReleased(const IKeyboardDevice *Owner,
        const int key, const int buffer[256]) { };

    inline void APICALL
      OnKeyEvent(const IKeyboardDevice *Owner, const int buffer[256]) { };
    #endif // DOXYGEN_SHOULD_SKIP_THIS
    #endif // CE_WITHOUT_KEYBOARD

    #ifndef CE_WITHOUT_MOUSE
    IMouseDevice *Mouse; 

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline void APICALL
      OnButtonPressed(const IMouseDevice *Owner,
        const int button, const SMouseState &State) { };

    inline void APICALL
      OnButtonReleased(const IMouseDevice *Owner,
        const int button, const SMouseState &State) { };

    inline void APICALL
      OnMouseEvent(const IMouseDevice *Owner, const SMouseState &State) { };
    #endif // DOXYGEN_SHOULD_SKIP_THIS
    #endif // CE_WITHOUT_MOUSE

    #ifndef CE_WITHOUT_JOYSTICK
    IJoystickDevice *Joystick; 

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline void APICALL
      OnJoyButtonPressed(const IJoystickDevice *Owner, const int joyid,
        const unsigned int button, const SJoystickState &State) { };

    inline void APICALL
      OnJoyButtonReleased(const IJoystickDevice *Owner, const int joyid,
        const unsigned int button, const SJoystickState &State) { };

    inline void APICALL
      OnJoystickEvent(const IJoystickDevice *Owner,
        const int joyid, const SJoystickState &State) { };
    #endif // DOXYGEN_SHOULD_SKIP_THIS
    #endif // CE_WITHOUT_JOYSTICK

  private:

    T *pT;

    DISALLOW_COPY_AND_ASSIGN(IInputManagerImpl);
 };

// ---                                                                  --- */

 } // end namespace ce

 #if _MSC_VER > 1000
 #pragma warning(default:4100)
 #endif

 #endif // _CE_INPUTCORE_IMPL_H_