MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setAttribute(Qt::WA_AcceptTouchEvents);
installEventFilter(ui->btn_left);
installEventFilter(ui->btn_right);
installEventFilter(ui->btn_up);
connect(ui->btn_left, SIGNAL(Pressed()), this, SLOT(ClickLeft()));
connect(ui->btn_left, SIGNAL(Released()), this, SLOT(ReleaseLeftRight()));
connect(ui->btn_right, SIGNAL(Pressed()), this, SLOT(ClickRight()));
connect(ui->btn_right, SIGNAL(Released()), this, SLOT(ReleaseLeftRight()));
connect(ui->btn_up, SIGNAL(Pressed()), this, SLOT(ClickUp()));
connect(ui->btn_up, SIGNAL(Released()), this, SLOT(ReleaseUp()));
ui->btn_left->RotateImage(90);
ui->btn_right->RotateImage(-90);
ui->btn_up->RotateImage(180);
engine = new GameEngine(this);
engine->setCamera(ui->graphicsView);
engine->InitScene(":/map/map_tank.tmx");
ui->summary->setVisible(false);
ui->summary->setText("Tanque\tDisparo\tAcerto\tMorte");
connect(ui->toolButton, SIGNAL(pressed()), this, SLOT(SwapSummary()));
}
//! Send a byte (effective for serial TX only)
PortUX::PortAccessStatus PortUX::PTx(wxUint8 pValue)
{
if (Released()) return IPAC_PortReleased;
m_lastError = IPAC_Success;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported; return m_lastError; // ERROR EXIT
}
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface; return m_lastError; // ERROR EXIT
}
wxUint8 szBuf = pValue;
ssize_t dwOutgoingWriteSize;
// we have non blocking IO - check if we can write
dwOutgoingWriteSize = ::write(m_SerialPort_Handle, &szBuf, 1); // write bytewise
// writesize can be:
// >0 (a caracter is written)
// =0 (end of file - note this is true only once the it becomes <0 !!)
// <0 (an error condition)
if(dwOutgoingWriteSize > 0) {
wxASSERT(dwOutgoingWriteSize == 1); // hmmm expected only one char ???!
}
else {
// this indicated EOF - which is a closed FD of a tty device
// must close this connection
m_lastError = IPAC_PutFailed;
}
return m_lastError;
}
//! Receive a byte (effective for serial RX only)
PortUX::PortAccessStatus PortUX::PRx(wxUint8& pValue)
{
if (Released()) return IPAC_PortReleased;
m_lastError = IPAC_Success;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported; return m_lastError; // ERROR EXIT
}
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface; return m_lastError; // ERROR EXIT
}
// read one character
wxUint8 szBuf;
ssize_t dwIncommingReadSize;
// we have non blocking IO - check for data available
dwIncommingReadSize = ::read(m_SerialPort_Handle, &szBuf, 1); // read bytewise
// readsize can be:
// >0 (a caracter is read)
// =0 (end of file - note this is true only once the it becomes <0 !!)
// <0 (an error condition)
if(dwIncommingReadSize > 0) {
wxASSERT(dwIncommingReadSize == 1); // hmmm expected only one char ???!
pValue = szBuf;
}
else {
// this is timeout 'cause of any reason
m_lastError = IPAC_GetFailed;
}
return m_lastError;
}
//-----------------------------------------------------------------------------
// Name : HandleMouse()
//-----------------------------------------------------------------------------
bool CSliderUI::HandleMouse( HWND hWnd, UINT uMsg, POINT mousePoint, INPUT_STATE inputstate, CTimer* timer )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if ( Pressed(hWnd, mousePoint, inputstate, timer))
return true;
}break;
case WM_LBUTTONUP:
{
if ( Released(hWnd, mousePoint))
return true;
}break;
case WM_MOUSEMOVE:
{
if ( Dragged(mousePoint))
return true;
}break;
case WM_MOUSEWHEEL:
{
if ( Scrolled( inputstate.nScrollAmount ) )
return true;
}break;
};
return false;
}
//! Set the ports handshake (effective for serial RX/TX only)
PortUX::PortAccessStatus PortUX::PSetHandshake(EHandshake handshake)
{
if (Released()) return IPAC_PortReleased;
m_lastError = IPAC_Success;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported; return m_lastError; // ERROR EXIT
}
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface; return m_lastError; // ERROR EXIT
}
wxPort::SetHandshake(handshake); //BM must persist here...
// a quick check wether the COM is available at all
struct termios mode;
::memset(&mode, 0, sizeof(mode));
if (::tcgetattr(m_SerialPort_Handle, &mode) != 0) {
m_lastError = IPAC_CommSetupFailed; return m_lastError; // ERROR EXIT
}
// just translate into UX handshake
switch (handshake) {
case ELD_None:
mode.c_iflag &= ~IXON; // Enable XON/XOFF flow control on output.
mode.c_iflag &= ~IXOFF; // Enable XON/XOFF flow control on input
mode.c_cflag &= ~CRTSCTS; // Not RTS CTS
break;
case ELD_SW:
mode.c_iflag |= IXON; // Enable XON/XOFF flow control on output.
mode.c_iflag |= IXOFF; // Enable XON/XOFF flow control on input
mode.c_cflag &= ~CRTSCTS; // Not RTS CTS
break;
case ELD_HW:
mode.c_iflag &= ~IXON; // Enable XON/XOFF flow control on output.
mode.c_iflag &= ~IXOFF; // Enable XON/XOFF flow control on input
mode.c_cflag |= CRTSCTS; // Not RTS CTS
break;
case ELD_LAST:
default:
m_lastError = IPAC_CommSetupFailed; return m_lastError; // ERROR EXIT
}// switch
// now set the mode
::tcflush(m_SerialPort_Handle, TCIOFLUSH);
if (::tcsetattr(m_SerialPort_Handle, TCSANOW, &mode) == 0) {
; //OK
}
else {
m_lastError = IPAC_CommSetupFailed;
}
return m_lastError;
}
/*!
\brief Overriden to catch mouseReleaseEvents and to stop the internal timer.
*/
void RenderWindowInteractor::mouseReleaseEvent( QMouseEvent *event ) {
if( this->mouseEventActive ) {
this->stepTimer->stop();
this->mouseEventActive = false;
QObject::disconnect( this->stepTimer, 0, this, 0 );
}
emit( Released(event->x(), this->height() - event->y()) );
}
/////////////////////////////////////////////////////////////////////////////
//
// Sets the Byte at port portAddress
//
PortUX::PortAccessStatus PortUX::put_port(wxUint8 outByte)
{
if (Released()) return IPAC_PortReleased;
if ( ! IsPortParallel() ) {
m_lastError = IPAC_NotSupported;
}
if ( IsPortParallel() ) {
m_lastError = IPAC_Success;
if (m_ParallelPort_Handle <0) {
m_lastError = IPAC_NoInterface;
return m_lastError;
}
int iocMode;
iocMode = 0; // null = Forward Direction
if ( xioctl(m_ParallelPort_Handle, PPDATADIR, &iocMode) <0 ) {
m_lastError = IPAC_PutFailed;
}
else {
if ( xioctl(m_ParallelPort_Handle, PPWDATA, &outByte) <0) {
m_lastError = IPAC_PutFailed;
}
}
}
else if (IsPortGPUSB()) {
m_lastError = IPAC_Success;
if (m_pGpUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
m_pGpUsb->SetValue((unsigned short)(outByte));
}
else if (IsPortLXUSB()) {
m_lastError = IPAC_Success;
if (m_pLxUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
m_pLxUsb->SetValue((unsigned short)(outByte));
}
else {
// other ports
m_lastError = IPAC_NotSupported;
}
return m_lastError;
}
/////////////////////////////////////////////////////////////////////////////
//
// Sets the Byte at port portAddress
//
// returns:
// S_OK
// E_NOINTERFACE if access was not started or failed
// E_FAIL if something went wrong
//
PortW32::PortAccessStatus PortW32::put_port(wxUint8 outByte)
{
if (Released()) return IPAC_PortReleased;
if ( IsPortParallel() ) {
m_lastError = IPAC_Success;
if (m_PortTalk_Handle == INVALID_HANDLE_VALUE) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
if (m_portAddress == 0) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
if (m_ProtectedOS) {
BOOL success;
BYTE buffer[3];
PUSHORT pmyPort = (PUSHORT)&buffer[0];
PBYTE pmyByte = (PBYTE)&buffer[2];
DWORD bytesReturned;
*pmyPort = (USHORT)m_portAddress;
*pmyByte = outByte;
success = DeviceIoControl(m_PortTalk_Handle,
(DWORD)IOCTL_WRITE_PORT_UCHAR,
&buffer, sizeof(buffer),
NULL, 0, &bytesReturned,
NULL);
if (!success)
//printf("Error occured during inportb while talking to PortTalk driver %d\n",GetLastError());
m_lastError = IPAC_PutFailed;
}
else {
// raw port access
USHORT myPort = (USHORT)m_portAddress;
BYTE myByte = outByte;
__asm
{
mov al, myByte
mov dx, myPort
out dx, al
}
}
}
else if (IsPortGPUSB()) {
void PortUX::DTR(wxUint8 outByte)
{
if (Released()) return;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported;
}
m_lastError = IPAC_Success;
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface;
return;
}
int ioctx = TIOCM_DTR; // which one
int iocmd = (outByte==0) ? TIOCMBIC : TIOCMBIS; // Clear or Set bit
if ( xioctl( m_SerialPort_Handle, iocmd, &ioctx )<0 ) {
m_lastError = IPAC_CommLineStatFailed;
}
}
//! Set the rw timeout (if supported)
PortUX::PortAccessStatus PortUX::PSetTimeout(long toInMS, long toOutMS)
{
if (Released()) return IPAC_PortReleased;
m_lastError = IPAC_Success;
if ( IsPortSerial() ) {
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface; return m_lastError; // ERROR EXIT
}
// a quick check wether the COM is available at all
termios mode;
::memset(&mode, 0, sizeof(mode));
if (::tcgetattr(m_SerialPort_Handle, &mode) != 0) {
m_lastError = IPAC_CommSetupFailed; return m_lastError; // ERROR EXIT
}
cc_t vt = (cc_t)(toInMS/100); vt = (vt<1)?1:vt;
mode.c_cc[VMIN] = 0;
mode.c_cc[VTIME] = vt; // *.1 sec
// If MIN = 0 and TIME > 0, TIME serves as a timeout value.
// The read will be satisfied if a single character is read, or TIME is exceeded (t = TIME *0.1 s).
// If TIME is exceeded, no character will be returned.
// now set the mode
::tcflush(m_SerialPort_Handle, TCIOFLUSH);
if (::tcsetattr(m_SerialPort_Handle, TCSANOW, &mode) == 0) {
; //OK
}
else {
m_lastError = IPAC_CommSetupFailed;
}
}
else if ( IsPortParallel() ) {
// not avail - just exit with success
}
return m_lastError;
}
wxUint8 PortUX::RING()
{
if (Released()) return 0;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported;
}
m_lastError = IPAC_Success;
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface;
return 0;
}
int ioctx;
if ( xioctl( m_SerialPort_Handle, TIOCMGET, &ioctx )<0 ) {
m_lastError = IPAC_CommLineStatFailed;
return 0;
}
else {
return ((ioctx & TIOCM_RNG)==TIOCM_RNG) ? 1 : 0;
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Returns the Byte at port portAddress
//
PortW32::PortAccessStatus PortW32::get_port(wxUint8& inByte)
{
if (Released()) return IPAC_PortReleased;
if ( IsPortParallel() ) {
m_lastError = IPAC_Success;
if (m_PortTalk_Handle == INVALID_HANDLE_VALUE) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
if (m_portAddress == 0) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
if (m_ProtectedOS) {
BOOL success;
USHORT myPort = (USHORT)m_portAddress;
BYTE myByte = 0;
DWORD bytesReturned;
success = DeviceIoControl(m_PortTalk_Handle,
(DWORD)IOCTL_READ_PORT_UCHAR,
&myPort, sizeof(myPort), /*in data*/
&myByte, sizeof(myByte), &bytesReturned, /*out data*/
NULL);
if (!success)
//printf("Error occured during inportb while talking to PortTalk driver %d\n",GetLastError());
m_lastError = IPAC_GetFailed;
else
inByte = myByte;
}
else {
// raw port access
USHORT myPort = (USHORT)m_portAddress;
BYTE myByte = 0;
__asm
{
mov dx, myPort
in al, dx
mov myByte, al
}
inByte = myByte;
}
}
else if (IsPortGPUSB()) {
m_lastError = IPAC_Success;
if (m_pGpUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
unsigned short val;
m_pGpUsb->GetValue(val);
inByte = wxUint8(val & 0xff);
}
else if (IsPortLXUSB()) {
m_lastError = IPAC_Success;
if (m_pLxUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
unsigned short val;
m_pLxUsb->GetValue(val);
inByte = wxUint8(val & 0xff);
}
else {
// other ports
m_lastError = IPAC_NotSupported;
}
return m_lastError;
}//END Get
/////////////////////////////////////////////////////////////////////////////
//
// Returns the outgoing Byte at port portAddress
PortUX::PortAccessStatus PortUX::get_port(wxUint8 &inByte)
{
inByte=0; // default
if (Released()) return IPAC_PortReleased;
if ( IsPortParallel() ) {
m_lastError = IPAC_Success;
if (m_ParallelPort_Handle <0) {
m_lastError = IPAC_NoInterface;
return m_lastError;
}
int iocMode;
wxUint8 cIn;
iocMode = 0; // null = Forward Direction registers
if ( xioctl(m_ParallelPort_Handle, PPDATADIR, &iocMode) <0 ) {
m_lastError = IPAC_GetFailed;
}
else {
if ( xioctl(m_ParallelPort_Handle, PPRDATA, &cIn) <0) {
m_lastError = IPAC_GetFailed;
}
else {
inByte = cIn;
}
}
}
else if (IsPortGPUSB()) {
m_lastError = IPAC_Success;
if (m_pGpUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
unsigned short val;
m_pGpUsb->GetValue(val);
inByte = wxUint8(val & 0xff);
}
else if (IsPortLXUSB()) {
m_lastError = IPAC_Success;
if (m_pLxUsb == NULL) {
m_lastError = IPAC_NoInterface;
return m_lastError; // ERROR EXIT
}
unsigned short val;
m_pLxUsb->GetValue(val);
inByte = wxUint8(val & 0xff);
}
else {
// other ports
m_lastError = IPAC_NotSupported;
}
return m_lastError;
}
void GamepadInputDevice::OnReleased(InputDeviceButton button)
{
Released(button);
}
//! Set the ports bauderate (effective for serial RX/TX only)
PortUX::PortAccessStatus PortUX::PSetBaudrate(EBaudRate baudrate)
{
if (Released()) return IPAC_PortReleased;
m_lastError = IPAC_Success;
if ( ! IsPortSerial() ) {
m_lastError = IPAC_NotSupported; return m_lastError; // ERROR EXIT
}
if (m_SerialPort_Handle <0) {
m_lastError = IPAC_NoInterface; return m_lastError; // ERROR EXIT
}
wxPort::SetBaudRate(baudrate); //BM must persist here...
// a quick check wether the COM is available at all
termios mode;
::memset(&mode, 0, sizeof(mode));
if (::tcgetattr(m_SerialPort_Handle, &mode) != 0) {
m_lastError = IPAC_CommSetupFailed; return m_lastError; // ERROR EXIT
}
// just translate into UX Baudrate
switch (baudrate) {
case EBR_1200:
::cfsetispeed(&mode, B1200);
::cfsetospeed(&mode, B1200);
break;
case EBR_2400:
::cfsetispeed(&mode, B2400);
::cfsetospeed(&mode, B2400);
break;
case EBR_4800:
::cfsetispeed(&mode, B4800);
::cfsetospeed(&mode, B4800);
break;
case EBR_9600:
::cfsetispeed(&mode, B9600);
::cfsetospeed(&mode, B9600);
break;
case EBR_19200:
::cfsetispeed(&mode, B19200);
::cfsetospeed(&mode, B19200);
break;
case EBR_38400:
::cfsetispeed(&mode, B38400);
::cfsetospeed(&mode, B38400);
break;
case EBR_LAST:
default:
m_lastError = IPAC_CommSetupFailed; return m_lastError; // ERROR EXIT
}// switch
// now set the mode
::tcflush(m_SerialPort_Handle, TCIOFLUSH);
if (::tcsetattr(m_SerialPort_Handle, TCSANOW, &mode) == 0) {
; //OK
}
else {
m_lastError = IPAC_CommSetupFailed;
}
return m_lastError;
}
void KeyboardInputDevice::OnReleased(InputDeviceKey key)
{
Released(key);
}
void GuiButton::Update(GuiTrigger * t)
{
if(state == STATE_DISABLED || !t || (this->IsAnimated() && (this->GetEffect() != EFFECT_PULSE)))
return;
else if(parentElement && ((parentElement->GetState() == STATE_DISABLED) || parentElement->IsAnimated()))
return;
#ifdef HW_RVL
// cursor
if(t->wpad->ir.valid && t->chan >= 0)
{
if(this->IsInside(t->wpad->ir.x, t->wpad->ir.y))
{
if(state == STATE_DEFAULT || (state == STATE_SELECTED && t->chan != stateChan)) // we weren't on the button before!
{
this->SetState(STATE_SELECTED, t->chan);
if(this->Rumble())
RequestRumble(t->chan);
if(soundOver)
soundOver->Play();
if(tooltip)
SelectTimer.reset();
if(effectsOver && !effects)
{
// initiate effects
effects = effectsOver;
effectAmount = effectAmountOver;
effectTarget = effectTargetOver;
}
}
}
else
{
if(state == STATE_SELECTED && (stateChan == t->chan || stateChan == -1))
this->ResetState();
if(effectTarget == effectTargetOver && effectAmount == effectAmountOver)
{
// initiate effects (in reverse)
effects = effectsOver;
effectAmount = -effectAmountOver;
effectTarget = 100;
}
}
}
#endif
// button triggers
if(clickable)
{
u32 wm_btns = t->wpad->btns_d;
for(int i = 0; i < 6; i++)
{
if(trigger[i] && (trigger[i]->chan == -1 || trigger[i]->chan == t->chan))
{
if((wm_btns & trigger[i]->wpad->btns_d) || (t->pad.btns_d & trigger[i]->pad.btns_d))
{
if(state == STATE_SELECTED)
{
if(!t->wpad->ir.valid || this->IsInside(t->wpad->ir.x, t->wpad->ir.y))
{
if(soundClick)
soundClick->Play();
POINT p = {0, 0};
if (userInput[t->chan].wpad && userInput[t->chan].wpad->ir.valid)
{
p.x = userInput[t->chan].wpad->ir.x;
p.y = userInput[t->chan].wpad->ir.y;
}
Clicked(this, t->chan, p);
ClickAndHold = true;
return;
}
}
else if(trigger[i]->type == TRIGGER_BUTTON_ONLY)
{
POINT p = {0, 0};
if (userInput[t->chan].wpad)
{
if (userInput[t->chan].wpad->ir.valid)
{
p.x = userInput[t->chan].wpad->ir.x;
p.y = userInput[t->chan].wpad->ir.y;
}
}
Clicked(this, t->chan, p);
return;
}
}
}
}
}
if(holdable)
{
bool held = false;
for(int i = 0; i < 6; i++)
{
//! if already found a trigger that takes effect stop searching
if(held || !trigger[i])
continue;
if((t->wpad->btns_h & trigger[i]->wpad->btns_h) || (t->pad.btns_h & trigger[i]->pad.btns_h))
{
//! TRIGGER_BUTTON_ONLY_HELD is executed on every chan
if(trigger[i]->type == TRIGGER_BUTTON_ONLY_HELD)
{
held = true;
if(state != STATE_HELD)
this->SetState(STATE_HELD, t->chan);
}
//! TRIGGER_HELD is executed only if holding the button
else if( (trigger[i]->type == TRIGGER_HELD)
&& ( (trigger[i]->chan == -1)
|| (trigger[i]->chan == t->chan)))
{
held = ClickAndHold;
if(held && (state != STATE_HELD) && (state == STATE_SELECTED))
this->SetState(STATE_HELD, t->chan);
}
}
}
if(held && (state == STATE_HELD) && (stateChan == t->chan))
{
POINT p = {0, 0};
if (userInput[t->chan].wpad && userInput[t->chan].wpad->ir.valid)
{
p.x = userInput[t->chan].wpad->ir.x;
p.y = userInput[t->chan].wpad->ir.y;
}
Held(this, t->chan, p);
return;
}
else if(!held && (state == STATE_HELD) && (stateChan == t->chan))
{
POINT p = {0, 0};
if (userInput[t->chan].wpad && userInput[t->chan].wpad->ir.valid)
{
p.x = userInput[t->chan].wpad->ir.x;
p.y = userInput[t->chan].wpad->ir.y;
}
this->ResetState();
Released(this, t->chan, p);
ClickAndHold = false;
return;
}
}
}
