Cppcheck report - Fission: libs/fsAppCore/impl/axmol/fsCInputManager.cpp

#include "fsCInputManager.h"

#include <base/Director.h>
#include <base/EventDispatcher.h>
#include <base/Utils.h>

#include <fsPlatform/system/fsCSystem.h>
#if defined fsDesktop
	#include <base/EventMouse.h>
#endif

#include <base/Controller.h>
#include <fsCore/fsIHardware.h>
#include <fsCore/src/fsNMaths.h>

#include "../../src/fsCInputPoint.h"


void fsCInputManager::pollKeys()
{
    if (!fsCPlatformSystem::getInstance()->isFireTV())
    {
        return;
    }
    static const auto repeatDelay(0);
	const auto timeMs = axmol::utils::getTimeInMilliseconds();

	std::for_each(std::begin(mKeysDown), std::end(mKeysDown),
	              [&](std::pair<const fsS32, fsS64>& press)
				  {
					  if (timeMs - press.second >= repeatDelay)
					  {
						  if (DPADKey(press.first))
						  {
							  mDPADPresses.push_back(fsIInputManager::sDPADMsgParam(fsPoint(0, 0), press.first,
																					true));
						  }
                          else
						  {
							  mTypedChars.push_back(press.first);
							  press.second = timeMs;
						  }
					  }
				  });
}

fsBool fsCInputManager::hasPhysicalKeyboardGet() const
{
#if (defined(fsDesktop) || defined(fsWeb))
	return true;
#else
	return false;
#endif
}

fsS32 fsCInputManager::pointerTypeGet() const
{
#if (defined(fsDesktop) || defined(fsWeb))
	return ePOINTER_TYPE_MOUSE;
#else
	return ePOINTER_TYPE_MULTI_TOUCH;
#endif
}

#if (defined(fsDesktop) || defined(fsWeb))

fsBool fsCInputManager::mouseButtonDownEventCallback(axmol::EventMouse* pEvent)
{
	axmol::EventMouse* const mouseEvent = static_cast<axmol::EventMouse*>(pEvent);
	if (static_cast<fsS32>(mouseEvent->getMouseButton()) < 2)
	{
		mInputPoints[static_cast<fsS32>(mouseEvent->getMouseButton())]->onUpDownEvent(
			fsPoint(mouseEvent->getLocation().x, mouseEvent->getLocation().y), true);
	}
	return true;
}

fsBool fsCInputManager::mouseButtonUpEventCallback(axmol::EventMouse* pEvent)
{
	axmol::EventMouse* const mouseEvent = static_cast<axmol::EventMouse*>(pEvent);
	if (static_cast<fsS32>(mouseEvent->getMouseButton()) < 2)
	{
		mInputPoints[static_cast<fsS32>(mouseEvent->getMouseButton())]->onUpDownEvent(
			fsPoint(mouseEvent->getLocation().x, mouseEvent->getLocation().y), false);
	}
	return true;
}

fsBool fsCInputManager::mouseMoveEventCallback(axmol::EventMouse* pEvent)
{
	axmol::EventMouse* const mouseEvent = static_cast<axmol::EventMouse*>(pEvent);
	mInputPoints[0]->onMoveEvent(fsPoint(mouseEvent->getLocation().x, mouseEvent->getLocation().y));
	return true;
}

#endif

fsBool fsCInputManager::touchStartEventCallback(axmol::Touch* pTouch, axmol::Event* pEvent)
{
	mInputPoints[pTouch->getID()]->onUpDownEvent(fsPoint(pTouch->getLocation().x, pTouch->getLocation().y), true);
	return true;
}

void fsCInputManager::touchEndEventCallback(axmol::Touch* pTouch, axmol::Event* pEvent)
{
	mInputPoints[pTouch->getID()]->onUpDownEvent(fsPoint(pTouch->getLocation().x, pTouch->getLocation().y), false);
}

void fsCInputManager::touchMoveEventCallback(axmol::Touch* pTouch, axmol::Event* pEvent)
{
	mInputPoints[pTouch->getID()]->onMoveEvent(fsPoint(pTouch->getLocation().x, pTouch->getLocation().y));
}

void fsCInputManager::controllerKeyUpEventCallback(ax::Controller* pController, int pKeyCode, axmol::Event* pEvent)<--- Either there is a missing 'override', or the member function 'fsCInputManager::controllerKeyUpEventCallback' can be static.<--- Either there is a missing 'override', or the member function 'fsCInputManager::controllerKeyUpEventCallback' can be static.
{
}

void fsCInputManager::controllerKeyDownEventCallback(ax::Controller* pController, int pKeyCode, axmol::Event* pEvent)<--- Either there is a missing 'override', or the member function 'fsCInputManager::controllerKeyDownEventCallback' can be static.<--- Either there is a missing 'override', or the member function 'fsCInputManager::controllerKeyDownEventCallback' can be static.
{
}

fsBool fsCInputManager::keyDecodeDo(fsS32& pKeyCode)
{
	if ((pKeyCode >= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_CAPITAL_A) &&
		pKeyCode <= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_CAPITAL_Z)))
	{
		pKeyCode = pKeyCode - static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_CAPITAL_A) + 'A';
	}

	if ((pKeyCode >= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_A) &&
		pKeyCode <= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_Z)))
	{
		pKeyCode = pKeyCode - static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_A) + (mShiftKeyDown ? 'A' : 'a');
	}
	else if ((pKeyCode >= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_0) &&
		pKeyCode <= static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_9)))
	{
		pKeyCode = pKeyCode - static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_0) + '0';
	}
	else if (static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_ENTER) == pKeyCode)
	{
		pKeyCode = eKEY_CODE_ENTER;
	}
	else if (static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_BACKSPACE) == pKeyCode)
	{
		pKeyCode = eKEY_CODE_BACKSPACE;
	}
	else if (static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_LEFT_ARROW) <= pKeyCode
		&& static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_DOWN_ARROW) >= pKeyCode)
	{
	}
    else if (static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_DPAD_LEFT) <= pKeyCode &&
            static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_DPAD_CENTER) >= pKeyCode)
    {
			pKeyCode = pKeyCode - (static_cast<fsS32>(axmol::EventKeyboard::KeyCode::KEY_DPAD_LEFT) -
				static_cast<fsS32>(eKEY_DPAD_LEFT));
    }
	else
	{
		return false; // ignore all other keys
	}

	return true;
}

void fsCInputManager::keyDownEventCallback(axmol::EventKeyboard::KeyCode pKeyCode, axmol::Event* pEvent)
{
	sKeyboardMsgParam keyboard_msg(
		static_cast<fsS32>(pKeyCode),
		true,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_ALT,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_RIGHT_SHIFT ||
			pKeyCode == axmol::EventKeyboard::KeyCode::KEY_LEFT_SHIFT,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_HYPER,
		axmol::utils::getTimeInMilliseconds());

	keyDownEvent(keyboard_msg);
}

void fsCInputManager::keyUpEventCallback(axmol::EventKeyboard::KeyCode pKeyCode, axmol::Event* pEvent)
{
	sKeyboardMsgParam keyboard_msg(
		static_cast<fsS32>(pKeyCode),
		false,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_ALT,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_RIGHT_SHIFT ||
			pKeyCode == axmol::EventKeyboard::KeyCode::KEY_LEFT_SHIFT,
		pKeyCode == axmol::EventKeyboard::KeyCode::KEY_HYPER,
		axmol::utils::getTimeInMilliseconds());
	keyUpEvent(keyboard_msg);
}


#if (defined(fsDesktop) || defined(fsWeb))

void fsCInputManager::mouseListenerCreate()
{
	mMouseListener = axmol::EventListenerMouse::create();
	mMouseListener->onMouseDown = AX_CALLBACK_1(fsCInputManager::mouseButtonDownEventCallback, this);
	mMouseListener->onMouseUp = AX_CALLBACK_1(fsCInputManager::mouseButtonUpEventCallback, this);
	mMouseListener->onMouseMove = AX_CALLBACK_1(fsCInputManager::mouseMoveEventCallback, this);
	axmol::Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(mMouseListener, 1);
}

#endif

void fsCInputManager::keyboardListenerCreate()
{
	mKeyboardListener = axmol::EventListenerKeyboard::create();
	mKeyboardListener->onKeyPressed = AX_CALLBACK_2(fsCInputManager::keyDownEventCallback, this);
	mKeyboardListener->onKeyReleased = AX_CALLBACK_2(fsCInputManager::keyUpEventCallback, this);
	axmol::Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(mKeyboardListener, 1);
}

void fsCInputManager::touchListenerCreate()
{
	mTouchListener = axmol::EventListenerTouchOneByOne::create();
	mTouchListener->onTouchBegan = AX_CALLBACK_2(fsCInputManager::touchStartEventCallback, this);
	mTouchListener->onTouchEnded = AX_CALLBACK_2(fsCInputManager::touchEndEventCallback, this);
	mTouchListener->onTouchMoved = AX_CALLBACK_2(fsCInputManager::touchMoveEventCallback, this);
	axmol::Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(mTouchListener, 1);
}

void fsCInputManager::gamePadListenerCreate()
{
	axmol::Controller::startDiscoveryController();
	// auto controllers = axmol::Controller::getAllController();
	// mGamePadListener = axmol::EventListenerController::create();
    // mGamePadListener->onKeyDown = AX_CALLBACK_3(fsCInputManager::controllerKeyDownEventCallback, this);
    // mGamePadListener->onKeyRepeat = AX_CALLBACK_3(fsCInputManager::controllerKeyDownEventCallback, this);
	// mGamePadListener->onKeyUp = AX_CALLBACK_3(fsCInputManager::controllerKeyUpEventCallback, this);
	// axmol::Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(mGamePadListener, 1);
}


void fsCInputManager::initialiseDo()
{
	mMaxInputPoints = 2;

#if (defined(fsDesktop) || defined(fsWeb))
	mouseListenerCreate();
#endif

	keyboardListenerCreate();
	touchListenerCreate();
//	gamePadListenerCreate();

	// 	if(hasPhysicalKeyboardGet())
	// 	{
	// 		s3eKeyboardRegister( S3E_KEYBOARD_KEY_EVENT, keyUpDownEventCallback, this );
	// 		s3eKeyboardSetInt( S3E_KEYBOARD_GET_CHAR, 1 );
	// 		s3eKeyboardRegister( S3E_KEYBOARD_CHAR_EVENT, typedCharEventCallback, this );
	// 	}
}

void fsCInputManager::uninitialiseDo()
{
	// 	s3ePointerUnRegister( S3E_POINTER_BUTTON_EVENT, mouseButtonEventCallback );
	// 	s3ePointerUnRegister( S3E_POINTER_MOTION_EVENT, mouseMoveEventCallback );
	// 	s3ePointerUnRegister( S3E_POINTER_TOUCH_EVENT, touchUpDownEventCallback );
	// 	s3ePointerUnRegister( S3E_POINTER_TOUCH_MOTION_EVENT, touchMoveEventCallback );
	// 	s3eKeyboardUnRegister( S3E_KEYBOARD_KEY_EVENT, keyUpDownEventCallback );
	// 	s3eKeyboardUnRegister( S3E_KEYBOARD_CHAR_EVENT, typedCharEventCallback );
}

fsCInputManager::fsCInputManager():
#if (defined(fsDesktop) || defined(fsWeb))
	mMouseListener(nullptr),
#endif
	mKeyboardListener(nullptr),
	mTouchListener(nullptr),
    mGamePadListener(nullptr)
{
}

fsCInputManager::~fsCInputManager()
{
#if (defined(fsDesktop) || defined(fsWeb))
	axmol::Director::getInstance()->getEventDispatcher()->removeEventListener(mMouseListener);
#endif
	axmol::Director::getInstance()->getEventDispatcher()->removeEventListener(mKeyboardListener);
    axmol::Director::getInstance()->getEventDispatcher()->removeEventListener(mTouchListener);
//    axmol::Director::getInstance()->getEventDispatcher()->removeEventListener(mGamePadListener);
}