input.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program 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; either version 2
        of the License, or (at your option) any later version.

        This program 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.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include "3d.h"
#include "input.h"

// StateMouse ********************************************************************************
        
StateMouse::StateMouse()
{
        pos.Zero();
        leftBtn=FALSE;
        rightBtn=FALSE;
        midBtn=FALSE;
        wheelVal=0;
        wheelDelta=0;
}

void StateMouse::operator= (StateMouse &src)
{
        pos=src.pos;
        leftBtn=src.leftBtn;
        rightBtn=src.rightBtn;
        midBtn=src.midBtn;
        wheelVal=src.wheelVal;
        wheelDelta=src.wheelDelta;
}

int StateMouse::GetNbButtonPush()
{
        return leftBtn+midBtn+rightBtn;
}

StateMouse * StateMouse::GetDelta(StateMouse *second) // delta = second-this
{
        static StateMouse delta;
        delta.pos = second->pos-pos;
        delta.leftBtn = second->leftBtn-leftBtn;
        delta.midBtn = second->midBtn-midBtn;
        delta.rightBtn = second->rightBtn-rightBtn;
        delta.wheelVal = second->wheelVal-wheelVal;
        delta.wheelDelta = second->wheelDelta-wheelDelta;
        return δ
}


void StateMouse::ToString(MyString &str)
{
        str.AddFormat("x:%d y:%d leftBtn:%d rightBtn:%d midBtn:%d wheelVal:%d wheelDelta:%d",pos.x,pos.y,leftBtn,rightBtn,midBtn,wheelVal,wheelDelta);
}

// StateKey ********************************************************************************
        
StateKey::StateKey()
{
        letter='\0';
        code=0;
        isPush=FALSE;
        SaveDelayAndRepeate();
}

StateKey::~StateKey()
{
        RestoreDelayAndRepeate();
}

void StateKey::operator= (StateKey &src)
{
        letter=src.letter;
        code=src.code;
        isPush=src.isPush;
}

void StateKey::ToString(MyString &str)
{
        str.AddFormat("letter: %c code:%d isPush:%d",letter,code,isPush);
}

BOOL StateKey::GetState(int code)
{
        // autre solution ou BOOL isUp = GetAsyncKeyState(code) & 0x8000 
        SHORT result = GetKeyState(code);
        /*
        The return value specifies the status of the specified virtual key, as follows: 
        If the high-order bit is 1, the key is down; otherwise, it is up.
        If the low-order bit is 1, the key is toggled. 
        A key, such as the CAPS LOCK key, is toggled if it is turned on. 
        The key is off and untoggled if the low-order bit is 0. 
        A toggle key's indicator light (if any) on the keyboard will be on when the key is toggled, and off when the key is untoggled.
        */
        BOOL isUp=(result&0x0100)==0x0100;
        BOOL isToggled=(result&0x0001)==0x0001;
        return isUp;
}

void StateKey::SetDelayAndRepeate(int delay,int repeate)
{
        SystemParametersInfo(SPI_SETKEYBOARDDELAY,delay,NULL,0);
        SystemParametersInfo(SPI_SETKEYBOARDSPEED,repeate,NULL,0);
}
void StateKey::SaveDelayAndRepeate()
{
        SystemParametersInfo(SPI_GETKEYBOARDDELAY,0,&oldDelay,0);
        SystemParametersInfo(SPI_GETKEYBOARDSPEED,0,&oldRepeate,0);
}

void StateKey::RestoreDelayAndRepeate()
{
        SetDelayAndRepeate(oldDelay,oldRepeate);
}


// EventMouse ********************************************************************************

/* // voir ci cela est necessaire
void EventMouse::operator=(MouseEvent &src)
{
        left=src.left;
        right=src.right;
        mid=src.mid;
}
*/

BOOL Timer::Init(HWND _hWnd)
{
        hWnd=_hWnd;
        return QueryPerformanceFrequency(&frecTimer);
}

Timer::Timer()
{
        insideList=FALSE;
        id=nextFreeId;
        nextFreeId++; // attention au bout d'un momenet les numeros d'id seron depasser, programmer un "garbage collector"
        isRuning = FALSE;
}

Timer::~Timer()
{
        Stop(id,FALSE); // suprime l'event de la list d'instanciation
}

Timer * Timer::Find(int idToFind)
{
        for (list.i=0;list.i.More();list.i++)
        {
                Timer *event = list.i.GetElem();
                if (event->id==idToFind) return event;
        }
        return NULL;
}

BOOL Timer::Call(int idToFind)
{
        Timer *timer;
        timer = Find(idToFind);
        if (timer) 
        {
                timer->onTimer(timer);
                return TRUE;
        }
        return FALSE;
}

BOOL Timer::Stop()
{       
        return Stop(id,FALSE);
}

BOOL Timer::StopAndUnBind()
{
        return Stop(id,TRUE);
}
BOOL Timer::Stop(int idToFind,BOOL unBind)
{
        Timer *event = Find(idToFind);
        if (event) 
        {
                isRuning = FALSE;
                if (!KillTimer(hWnd,idToFind)) return FALSE;
                if (unBind) onTimer.disconnect_all();
                event->insideList=FALSE;
                list.i.Supr(); // car find place sur le current
                return TRUE;
        }
        return FALSE;
}

BOOL Timer::Start()
{
        Start(1000);
        return Pause();
}

BOOL Timer::Start(int freq)
{
        frequency=freq;
        QueryPerformanceCounter(&beginTime);
        if (!insideList) { list.i+=this; insideList=TRUE; }
        if(!SetTimer(hWnd,id,frequency,NULL)) return NULL;
        isRuning = TRUE;
        return TRUE;
}

BOOL Timer::Pause()
{
        if (!isRuning) return FALSE;
        return SetTimer(hWnd,id,0x7fffffff,NULL)?TRUE:FALSE; // valeur max d'un timeout que donne 1 ?
}

BOOL Timer::Resume()
{
        if (!isRuning) return FALSE;
        return SetTimer(hWnd,id,frequency,NULL)?TRUE:FALSE;
}

double Timer::GetDeltaTime(BOOL reset)
{
        if (!insideList) isRuning = TRUE; // en mode simple cronos definis le runing
        return GetDeltaTime(reset,&beginTime);
}

double Timer::GetDeltaTime(BOOL reset,LARGE_INTEGER *referenceTime)
{
        if (!referenceTime) return -1;
        LARGE_INTEGER currentTime;
        QueryPerformanceCounter(&currentTime);  
        double delta = ((double)((UINT)currentTime.LowPart  - (UINT)(*referenceTime).LowPart) / frecTimer.LowPart);
        if (reset) *referenceTime=currentTime;
        return delta;
}

BOOL Timer::IsRuning()
{
        return isRuning;
}

// ********************************************************************************

---