Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 800 → Rev 801

/QMK-Groundstation/Release/QMK-Tools-v1.3.0.tgz
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/Release/QMK-Tools-v1.3.0.tgz
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerIP/HandlerIP.cpp
0,0 → 1,30
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "HandlerIP.h"
 
HandlerIP::HandlerIP()
{
}
 
// IP-Datenpacket zusammenbauen
// todo: CRC einbauen
QString HandlerIP::make_Frame(int t_ID, int t_CMD, QString t_Data)
{
return QString(QString("$:%1").arg(t_ID) + QString(":%1:").arg(t_CMD) + t_Data + ":0\r");
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerIP/HandlerIP.h
0,0 → 1,35
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef HANDLERIP_H
#define HANDLERIP_H
 
#include <QString>
 
static const int ID_COMMUNICATOR = 1;
static const int ID_SCOPE = 11;
static const int ID_SETTINGS = 12;
 
class HandlerIP
{
public:
HandlerIP();
static QString make_Frame(int t_ID, int t_CMD, QString t_Data);
};
 
#endif // HANDLERIP_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerKML/HandlerKML.cpp
0,0 → 1,65
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
 
#include "HandlerKML.h"
 
HandlerKML::HandlerKML()
{
}
 
QString HandlerKML::get_Header(QString Name)
{
QString block;
block = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<kml xmlns=\"http://earth.google.com/kml/2.2\">\n"
" <Document>\n"
" <name>" + Name + "</name>\n"
" <Style id=\"MK_gps-style\">\n"
" <LineStyle>\n"
" <color>ff0000ff</color>\n"
" <width>2</width>\n"
" </LineStyle>\n"
" </Style>\n"
" <Placemark>\n"
" <LookAt>\n"
" <range>400</range>\n"
" <tilt>45</tilt>\n"
" </LookAt>\n"
" <name>Flight</name>\n"
" <styleUrl>#MK_gps-style</styleUrl>\n"
" <LineString>\n"
" <extrude>1</extrude>\n"
" <tessellate>1</tessellate>\n"
" <altitudeMode>absolute</altitudeMode>\n"
" <coordinates>\n";
 
return block;
}
 
QString HandlerKML::get_Footer()
{
QString block;
block = " </coordinates>\n"
" </LineString>\n"
" </Placemark>\n"
" </Document>\n"
"</kml>\n";
 
return block;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerKML/HandlerKML.h
0,0 → 1,34
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
 
#ifndef HANDLERKML_H
#define HANDLERKML_H
 
#include <QString>
 
class HandlerKML
{
public:
HandlerKML();
 
static QString get_Header(QString Name = "Mikrokopter");
static QString get_Footer();
};
 
#endif // HANDLERKML_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerMK/HandlerMK.cpp
0,0 → 1,232
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "HandlerMK.h"
 
HandlerMK::HandlerMK()
{
}
 
// Datensatz nach 16bit Integer
int HandlerMK::Data2Int(unsigned char Data[150] , int Start, bool is_signed)
{
int Out = (Data[Start+1]<<8) | (Data[Start+0]);
 
if ((Out > 32767) && (is_signed))
Out = Out - 65536;
 
return Out;
 
}
 
// Datensatz nach QString
QString HandlerMK::Data2QString(unsigned char Data[150], int Start, int End)
{
char String[150];
for (int a = Start; a < End; a++)
{
String[a - Start] = Data[a];
}
String[End - Start] = '\0';
 
return QString(String);
}
 
double HandlerMK::Int2Double(int32_t Wert, int Count)
{
QString Temp, s_Wert;
 
s_Wert = QString("%1").arg(Wert);
 
Temp = s_Wert.left(s_Wert.length() - Count) + QString(".") + s_Wert.right(Count);
 
return Temp.toDouble();
}
 
QString HandlerMK::add_CRC(QString TXString)
{
unsigned int tmpCRC = 0;
 
char *TXBuff;
char CRC[2];
 
TXBuff = TXString.toLatin1().data();
 
for(int i = 0; i < TXString.length(); i++)
{
tmpCRC += TXBuff[i];
}
 
tmpCRC %= 4096;
 
CRC[0] = '=' + tmpCRC / 64;
CRC[1] = '=' + tmpCRC % 64;
CRC[2] = '\0';
 
QString Return = TXString + QString(CRC);
 
return Return;
}
 
bool HandlerMK::Check_CRC(char *t_InData, int Length)
{
int CRC = 0;
 
if (t_InData[1] == 127)
t_InData[1] = 0;
 
for(int i=0; i < Length-2; i++)
CRC+=t_InData[i];
 
CRC = CRC % 4096;
 
if(t_InData[Length - 2] != ('=' + (CRC / 64)))
return false;
 
if(t_InData[Length - 1] != ('=' + CRC % 64))
return false;
 
return true;
}
 
int HandlerMK::Decode_64(char *t_InData, int Length, unsigned char *t_OutData)
{
unsigned char a,b,c,d;
unsigned char ptr = 0;
unsigned char x,y,z;
 
int Offset = 3;
 
if (t_InData[Offset] == 0)
{
return 0;
}
 
while(Length != 0)
{
a = t_InData[Offset++] - '=';
b = t_InData[Offset++] - '=';
c = t_InData[Offset++] - '=';
d = t_InData[Offset++] - '=';
 
// if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
 
x = (a << 2) | (b >> 4);
y = ((b & 0x0f) << 4) | (c >> 2);
z = ((c & 0x03) << 6) | d;
 
if(Length--) t_OutData[ptr++] = x; else break;
if(Length--) t_OutData[ptr++] = y; else break;
if(Length--) t_OutData[ptr++] = z; else break;
}
 
return ptr;
}
 
// Base64 Encoder
QString HandlerMK::Encode64(char Data[150],unsigned int Length)
{
unsigned int pt = 0;
unsigned char a,b,c;
unsigned char ptr = 0;
 
char TX_Buff[150];
 
while(Length > 0)
{
if(Length) { a = Data[ptr++]; Length--;} else a = 0;
if(Length) { b = Data[ptr++]; Length--;} else b = 0;
if(Length) { c = Data[ptr++]; Length--;} else c = 0;
 
TX_Buff[pt++] = '=' + (a >> 2);
TX_Buff[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
TX_Buff[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
TX_Buff[pt++] = '=' + ( c & 0x3f);
}
TX_Buff[pt] = 0;
 
return QString(TX_Buff);
}
 
QString HandlerMK::make_Frame(char t_CMD, int t_Adress, char t_Data[150], unsigned int t_Length)
{
QString tx_Data = Encode64(t_Data, t_Length);
 
tx_Data = add_CRC(QString("#" + QString('a' + t_Adress) + QString(t_CMD) + tx_Data)) + "\r";
 
return tx_Data;
}
 
QString HandlerMK::get_SelectNC()
{
char t_Data[6];
 
t_Data[0] = 0x1B;
t_Data[1] = 0x1B;
t_Data[2] = 0x55;
t_Data[3] = 0xAA;
t_Data[4] = 0x00;
t_Data[5] = '\r';
 
QString tx_Data = QString(t_Data);
 
return tx_Data;
}
 
QString HandlerMK::get_SelectFC()
{
char t_Data[1];
 
t_Data[0] = 0;
 
QString tx_Data = Encode64(t_Data, 1);
 
tx_Data = add_CRC(QString("#" + QString('a' + ADDRESS_NC) + QString("u") + tx_Data)) + "\r";
 
return tx_Data;
}
 
QString HandlerMK::get_SelectMK3MAG()
{
char t_Data[1];
 
t_Data[0] = 1;
 
QString tx_Data = Encode64(t_Data, 1);
 
tx_Data = add_CRC(QString("#" + QString('a' + ADDRESS_NC) + QString("u") + tx_Data)) + "\r";
 
return tx_Data;
}
 
s_Hardware HandlerMK::parse_Version(unsigned char *t_Data, int Adress)
{
s_Hardware t_Hardware;
 
t_Hardware.ID = Adress;
t_Hardware.VERSION_MAJOR = t_Data[0];
t_Hardware.VERSION_MINOR = t_Data[1];
t_Hardware.VERSION_PATCH = t_Data[4];
t_Hardware.VERSION_SERIAL_MAJOR = t_Data[2];
t_Hardware.VERSION_SERIAL_MINOR = t_Data[3];
t_Hardware.Hardware = HardwareType[t_Hardware.ID];
t_Hardware.Version = QString("%1").arg(t_Data[0]) + "." + QString("%1").arg(t_Data[1]) + QString(t_Data[4] + 'a');
t_Hardware.VersionShort = QString("%1").arg(t_Data[0]) + QString("%1").arg(t_Data[1]) + QString(t_Data[4] + 'a');
 
return t_Hardware;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_HandlerMK/HandlerMK.h
0,0 → 1,65
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef HANDLERMK_H
#define HANDLERMK_H
 
#include <QString>
 
#include "../Kopter.h"
#include "../MK_Datatypes.h"
 
struct s_Hardware
{
int ID;
int VERSION_MAJOR;
int VERSION_MINOR;
int VERSION_PATCH;
int VERSION_SERIAL_MAJOR;
int VERSION_SERIAL_MINOR;
QString Hardware;
QString Version;
QString VersionShort;
};
 
 
class HandlerMK
{
public:
HandlerMK();
 
static int Data2Int(unsigned char Data[150], int Start, bool is_signed = true);
static QString Data2QString(unsigned char Data[150], int Start, int End);
 
static QString add_CRC(QString TXString);
static bool Check_CRC(char *t_InData, int Length);
 
static int Decode_64(char *t_InData, int Length, unsigned char *t_OutData);
static QString Encode64(char Data[150],unsigned int Length);
static QString make_Frame(char t_CMD, int t_Adress, char t_Data[150], unsigned int t_Length);
 
static QString get_SelectFC();
static QString get_SelectNC();
static QString get_SelectMK3MAG();
 
static s_Hardware parse_Version(unsigned char *t_Data, int Adress);
 
static double Int2Double(int32_t Wert, int Count);
};
 
#endif // HANDLERMK_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input.cpp
0,0 → 1,60
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "Input.h"
 
void Input::Init()
{
}
 
bool Input::Open(set_Input s_Input)
{
s_Input = s_Input;
return false;
}
 
bool Input::IsOpen()
{
return false;
}
 
bool Input::Close()
{
return false;
}
 
void Input::send_Data(QString t_Data, int ID)
{
t_Data = t_Data;
ID = ID;
}
 
void Input::send_RawData(char *t_Data)
{
t_Data = t_Data;
}
 
void Input::stop_Resend(int ID)
{
ID = ID;
}
 
eMode Input::Mode()
{
return NONE;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input.h
0,0 → 1,65
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef INPUT_H
#define INPUT_H
 
#include <QObject>
 
enum eMode {NONE, TCP, TTY};
 
struct set_Input
{
QString Main;
QString Sub;
};
 
struct s_Resend
{
bool ID;
QString Data;
};
 
static const int CLOSED = 0;
static const int REFUSED = 1;
static const int REMOTECLOSED = 2;
 
static const int MAX_Confirm = 11;
 
class Input : public QObject
{
Q_OBJECT
 
public:
virtual void Init();
virtual bool Open(set_Input s_Input);
virtual bool IsOpen();
virtual bool Close();
virtual void send_Data(QString t_Data, int ID = 0);
virtual void send_RawData(char *t_Data);
virtual void stop_Resend(int ID);
virtual eMode Mode();
 
signals:
virtual void sig_NewData(QString Data);
 
// private:
 
};
 
#endif // INPUT_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input_TCP.cpp
0,0 → 1,198
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "Input_TCP.h"
 
void Input_TCP::Init()
{
b_Open = false;
Timer = new QTimer();
connect(Timer, SIGNAL(timeout()), this, SLOT(slot_Timer()));
 
for (int z = 0; z < MAX_Confirm; z++)
{
Confirm[z].ID = false;
}
}
 
bool Input_TCP::Open(set_Input s_Input)
{
TCP_Socket = new(QTcpSocket);
TCP_Socket->connectToHost (s_Input.Main, s_Input.Sub.toInt());
 
connect(TCP_Socket, SIGNAL(connected()), this, SLOT(slot_TCP_Connected()) );
connect(TCP_Socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slot_TCP_Error(QAbstractSocket::SocketError)));
 
return true;
}
 
bool Input_TCP::IsOpen()
{
return b_Open;
}
 
bool Input_TCP::Close()
{
TCP_Socket->disconnectFromHost();
disconnect(TCP_Socket, SIGNAL(connected()), 0, 0);
disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
 
b_Open = false;
Timer->stop();
 
return true;
}
 
void Input_TCP::send_Data(QString t_Data, int ID)
{
if ((ID > 0) && (ID < MAX_Confirm))
{
Timer->start(2500);
Confirm[ID].ID = true;
Confirm[ID].Data = t_Data;
}
 
if (b_Open)
{
usleep(50000);
 
if (t_Data[t_Data.length() - 1] != '\r')
{
t_Data = t_Data + "\r";
}
 
QByteArray Temp;
Temp = QByteArray(t_Data.toAscii());
 
TCP_Socket->write(Temp);
 
// qDebug(t_Data.toLatin1().data());
}
}
 
void Input_TCP::send_RawData(char *t_Data)
{
t_Data = t_Data;
}
 
void Input_TCP::stop_Resend(int ID)
{
if ((ID > 0) && (ID < MAX_Confirm))
{
Confirm[ID].ID = false;
Confirm[ID].Data = "";
}
}
 
void Input_TCP::slot_Timer()
{
bool Active = false;
 
for (int x = 0; x < MAX_Confirm; x++)
{
if (Confirm[x].ID)
{
Active = true;
send_Data(Confirm[x].Data);
}
}
 
if (Active == false)
{
Timer->stop();
}
}
 
void Input_TCP::slot_TCP_Connected()
{
b_Open = true;
connect(TCP_Socket, SIGNAL(readyRead()), SLOT(slot_TCP_ReadLine()));
connect(TCP_Socket, SIGNAL(disconnected()),TCP_Socket, SLOT(deleteLater()));
connect(TCP_Socket, SIGNAL(disconnected()),this, SLOT(slot_TCP_Disconnect()));
 
emit sig_Connected();
}
 
void Input_TCP::slot_TCP_Disconnect()
{
disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
// emit sig_Disconnected(1);
}
 
void Input_TCP::slot_TCP_ReadLine()
{
// if (TCP_Socket->canReadLine())
{
QString t_Data = QString(TCP_Socket->readLine(TCP_Socket->bytesAvailable())).remove(QChar('\n'));
 
if ((t_Data.length() > 3) && (t_Data[t_Data.length() - 1] == '\r'))
{
emit(sig_NewData(t_Data));
}
}
 
 
/* int Len = Input.length();
 
for (int z = 0; z < Len; z++)
{
if (Input[z] == '\r')
{
new_Data(QString(""));
RxData.String = QString("");
}
else
{
RxData.String = RxData.String + Input[z];
}
}
*/
}
 
void Input_TCP::slot_TCP_Error(QAbstractSocket::SocketError Error)
{
b_Open = false;
 
disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
disconnect(TCP_Socket, SIGNAL(error(QAbstractSocket::SocketError)), 0, 0);
disconnect(TCP_Socket, SIGNAL(connected()), 0, 0);
disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
 
// qDebug("Error");
switch (Error)
{
case QAbstractSocket::ConnectionRefusedError:
emit sig_Disconnected(REFUSED);
break;
case QAbstractSocket::RemoteHostClosedError:
emit sig_Disconnected(REMOTECLOSED);
break;
default:
emit sig_Disconnected(CLOSED);
break;
}
// emit sig_Disconnected(CLOSED);
}
 
eMode Input_TCP::Mode()
{
return TCP;
}
 
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input_TCP.h
0,0 → 1,65
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef INPUT_TCP_H
#define INPUT_TCP_H
 
#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>
#include <QTimer>
 
#include "Input.h"
 
class Input_TCP : public Input
{
Q_OBJECT
 
public:
void Init();
bool Open(set_Input s_Input);
bool IsOpen();
bool Close();
void send_Data(QString t_Data, int ID = 0);
void send_RawData(char *t_Data);
void stop_Resend(int ID);
eMode Mode();
 
private:
// TCP Server und Socket.
QTcpServer *TCP_Server;
QTcpSocket *TCP_Socket;
QTimer *Timer;
bool b_Open;
s_Resend Confirm[MAX_Confirm];
 
private slots:
// void slot_newDataReceived(const QByteArray &dataReceived);
void slot_TCP_Connected();
void slot_TCP_Disconnect();
void slot_TCP_ReadLine();
void slot_TCP_Error(QAbstractSocket::SocketError Error);
void slot_Timer();
 
signals:
void sig_NewData(QString);
void sig_Disconnected(int);
void sig_Connected();
};
 
#endif // INPUT_TCP_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input_TTY.cpp
0,0 → 1,160
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "Input_TTY.h"
 
void Input_TTY::Init()
{
Timer = new QTimer();
connect(Timer, SIGNAL(timeout()), this, SLOT(slot_Timer()));
 
for (int z = 0; z < MAX_Confirm; z++)
{
Confirm[z].ID = false;
}
}
 
bool Input_TTY::Open(set_Input s_Input)
{
o_TTY = new ManageSerialPort;
 
o_TTY->setBaudRate(BAUD57600); //BaudRate
o_TTY->setDataBits(DATA_8); //DataBits
o_TTY->setParity(PAR_NONE); //Parity
o_TTY->setStopBits(STOP_1); //StopBits
o_TTY->setFlowControl(FLOW_OFF); //FlowControl
 
o_TTY->setTimeout(0, 10);
o_TTY->enableSending();
o_TTY->enableReceiving();
 
o_TTY->setPort(s_Input.Main); //Port
o_TTY->open();
 
if (o_TTY->isOpen())
{
connect(o_TTY, SIGNAL(newDataReceived(const QByteArray &)), this, SLOT(slot_Receive(const QByteArray &)));
 
o_TTY->receiveData();
// qDebug(QString("Open Input-TTY " + s_Input.Main).toLatin1().data());
 
return true;
}
return false;
}
 
bool Input_TTY::IsOpen()
{
return o_TTY->isOpen();
}
 
bool Input_TTY::Close()
{
o_TTY->close();
 
disconnect(o_TTY, SIGNAL(newDataReceived(const QByteArray &)), this, 0);
 
Timer->stop();
 
return o_TTY->isOpen();
}
 
void Input_TTY::send_Data(QString t_Data, int ID)
{
if ((ID > 0) && (ID < MAX_Confirm))
{
Timer->start(2500);
Confirm[ID].ID = true;
Confirm[ID].Data = t_Data;
}
 
if (o_TTY->isOpen())
{
if (t_Data[t_Data.length() - 1] != '\r')
{
t_Data = t_Data + "\r";
}
 
QByteArray Temp;
 
Temp = QByteArray(t_Data.toAscii());
 
o_TTY->sendData(Temp);
 
// qDebug(t_Data.toLatin1().data());
}
}
 
void Input_TTY::send_RawData(char *t_Data)
{
t_Data = t_Data;
}
 
void Input_TTY::slot_Receive(const QByteArray &dataReceived)
{
const char *RX;
RX = dataReceived.data();
int a = 0;
 
while (RX[a] != '\0')
{
if (RX[a] == '\r')
{
emit(sig_NewData(s_RX));
s_RX = QString("");
}
else
{
s_RX = s_RX + QString(RX[a]);
}
a++;
}
}
 
void Input_TTY::stop_Resend(int ID)
{
if ((ID > 0) && (ID < MAX_Confirm))
{
Confirm[ID].ID = false;
Confirm[ID].Data = "";
}
}
 
void Input_TTY::slot_Timer()
{
bool Active = false;
 
for (int x = 0; x < MAX_Confirm; x++)
{
if (Confirm[x].ID)
{
Active = true;
send_Data(Confirm[x].Data);
}
}
 
if (Active == false)
{
Timer->stop();
}
}
 
eMode Input_TTY::Mode()
{
return TTY;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_Input/Input_TTY.h
0,0 → 1,57
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef INPUT_TTY_H
#define INPUT_TTY_H
 
#include <QObject>
#include <QTimer>
 
#include "Input.h"
#include "../Class_SerialPort/ManageSerialPort.h"
 
class Input_TTY : public Input
{
Q_OBJECT
 
public:
void Init();
bool Open(set_Input s_Input);
bool IsOpen();
bool Close();
void send_Data(QString t_Data, int ID = 0);
void send_RawData(char *t_Data);
void stop_Resend(int ID);
eMode Mode();
 
private:
ManageSerialPort *o_TTY;
QString s_RX;
QTimer *Timer;
s_Resend Confirm[MAX_Confirm];
 
private slots:
void slot_Receive(const QByteArray &dataReceived);
void slot_Timer();
 
signals:
void sig_NewData(QString Data);
 
};
 
#endif // INPUT_TTY_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/circlepoint.cpp
0,0 → 1,72
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "circlepoint.h"
namespace qmapcontrol
{
CirclePoint::CirclePoint(qreal x, qreal y, int radius, QString name, Alignment alignment, QPen* pen)
: Point(x, y, name, alignment)
{
size = QSize(radius, radius);
mypixmap = new QPixmap(radius+1, radius+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
if (pen != 0)
{
painter.setPen(*pen);
}
painter.drawEllipse(0,0,radius, radius);
}
 
CirclePoint::CirclePoint(qreal x, qreal y, QString name, Alignment alignment, QPen* pen)
: Point(x, y, name, alignment)
{
int radius = 10;
size = QSize(radius, radius);
mypixmap = new QPixmap(radius+1, radius+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
if (pen != 0)
{
painter.setPen(*pen);
}
painter.drawEllipse(0,0,radius, radius);
}
 
CirclePoint::~CirclePoint()
{
delete mypixmap;
}
 
void CirclePoint::setPen(QPen* pen)
{
mypen = pen;
mypixmap = new QPixmap(size.width()+1, size.height()+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
painter.setPen(*pen);
painter.drawEllipse(0,0, size.width(), size.height());
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/circlepoint.h
0,0 → 1,77
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef CIRCLEPOINT_H
#define CIRCLEPOINT_H
 
#include "point.h"
 
namespace qmapcontrol
{
//! Draws a circle into the map
/*! This is a conveniece class for Point.
* It configures the pixmap of a Point to draw a circle.
* A QPen could be used to change the color or line-width of the circle
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class CirclePoint : public Point
{
public:
//!
/*!
*
* @param x longitude
* @param y latitude
* @param name name of the circle point
* @param alignment alignment (Middle or TopLeft)
* @param pen QPen for drawing
*/
CirclePoint(qreal x, qreal y, QString name = QString(), Alignment alignment = Middle, QPen* pen=0);
 
//!
/*!
*
* @param x longitude
* @param y latitude
* @param radius the radius of the circle
* @param name name of the circle point
* @param alignment alignment (Middle or TopLeft)
* @param pen QPen for drawing
*/
CirclePoint(qreal x, qreal y, int radius = 10, QString name = QString(), Alignment alignment = Middle, QPen* pen=0);
virtual ~CirclePoint();
 
//! sets the QPen which is used for drawing the circle
/*!
* A QPen can be used to modify the look of the drawn circle
* @param pen the QPen which should be used for drawing
* @see http://doc.trolltech.com/4.3/qpen.html
*/
virtual void setPen(QPen* pen);
 
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/curve.cpp
0,0 → 1,41
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "curve.h"
namespace qmapcontrol
{
Curve::Curve(QString name)
: Geometry(name)
{
}
 
 
Curve::~Curve()
{
}
}
// Geometry Curve::Clone(){}
 
// QRectF Curve::GetBoundingBox(){}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/curve.h
0,0 → 1,65
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef CURVE_H
#define CURVE_H
 
#include "geometry.h"
#include "point.h"
 
namespace qmapcontrol
{
//! A Curve Geometry, implemented to fullfil OGC Spec
/*!
* The Curve class is used by LineString as parent class.
* This class could not be used directly.
*
* From the OGC Candidate Implementation Specification:
* "A Curve is a 1-dimensional geometric object usually stored as a sequence of Points, with the subtype of Curve
* specifying the form of the interpolation between Points. This specification defines only one subclass of Curve,
* LineString, which uses a linear interpolation between Points."
* @author Kai Winter <kaiwinter@gmx.de>
*/
class Curve : public Geometry
{
Q_OBJECT
public:
virtual ~Curve();
 
double Length;
 
// virtual Geometry Clone();
// virtual QRectF GetBoundingBox();
 
// virtual Point EndPoint() = 0;
// virtual Point StartPoint() = 0;
// virtual Point Value() = 0;
 
protected:
Curve(QString name = QString());
virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset) = 0;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/emptymapadapter.cpp
0,0 → 1,117
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "emptymapadapter.h"
namespace qmapcontrol
{
EmptyMapAdapter::EmptyMapAdapter(int tileSize, int minZoom, int maxZoom)
:MapAdapter("", "", 256, minZoom, maxZoom)
{
PI = acos(-1.0);
 
numberOfTiles = tilesonzoomlevel(minZoom);
}
 
EmptyMapAdapter::~EmptyMapAdapter()
{
}
 
void EmptyMapAdapter::zoom_in()
{
if (current_zoom < max_zoom)
{
current_zoom = current_zoom + 1;
}
numberOfTiles = tilesonzoomlevel(current_zoom);
}
 
void EmptyMapAdapter::zoom_out()
{
if (current_zoom > min_zoom)
{
current_zoom = current_zoom - 1;
}
numberOfTiles = tilesonzoomlevel(current_zoom);
}
 
qreal EmptyMapAdapter::deg_rad(qreal x) const
{
return x * (PI/180.0);
}
qreal EmptyMapAdapter::rad_deg(qreal x) const
{
return x * (180/PI);
}
 
QString EmptyMapAdapter::query(int x, int y, int z) const
{
return "";
}
 
QPoint EmptyMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
{
qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
qreal y = (1-(log(tan(PI/4+deg_rad(coordinate.y())/2)) /PI)) /2 * (numberOfTiles*mytilesize);
 
return QPoint(int(x), int(y));
}
 
QPointF EmptyMapAdapter::displayToCoordinate(const QPoint& point) const
{
qreal longitude = (point.x()*(360/(numberOfTiles*mytilesize)))-180;
qreal latitude = rad_deg(atan(sinh((1-point.y()*(2/(numberOfTiles*mytilesize)))*PI)));
 
return QPointF(longitude, latitude);
 
}
 
bool EmptyMapAdapter::isValid(int x, int y, int z) const
{
if (max_zoom < min_zoom)
{
z= min_zoom - z;
}
 
if (x<0 || x>pow(2,z)-1 ||
y<0 || y>pow(2,z)-1)
{
return false;
}
return true;
 
}
int EmptyMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
return int(pow(2, zoomlevel));
}
int EmptyMapAdapter::xoffset(int x) const
{
return x;
}
int EmptyMapAdapter::yoffset(int y) const
{
return y;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/emptymapadapter.h
0,0 → 1,73
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef EMPTYMAPADAPTER_H
#define EMPTYMAPADAPTER_H
 
#include "mapadapter.h"
 
namespace qmapcontrol
{
//! MapAdapter which do not load map tiles.
/*!
* The EmptyMapAdapter can be used if QMapControl should not load any map tiles. This is useful if you
* only want to display an image through a FixedImageOverlay e.g.
* @author Kai Winter <kaiwinter@gmx.de>
*/
class EmptyMapAdapter : public MapAdapter
{
Q_OBJECT
public:
//! Constructor.
/*!
* @param tileSize This parameter seems unnecessary for this type of MapAdaper on first sight. But since
* this parameter defines the size of the offscreen image it could be used for a little performance
* tuning (larger offscreen-images have to be redrawed less times).
* @param minZoom the minimum zoom level
* @param maxZoom the maximum zoom level
*/
EmptyMapAdapter(int tileSize = 256, int minZoom = 0, int maxZoom = 17);
 
virtual ~EmptyMapAdapter();
 
virtual QPoint coordinateToDisplay(const QPointF&) const;
virtual QPointF displayToCoordinate(const QPoint&) const;
 
qreal PI;
 
protected:
qreal rad_deg(qreal) const;
qreal deg_rad(qreal) const;
 
virtual bool isValid(int x, int y, int z) const;
virtual void zoom_in();
virtual void zoom_out();
virtual QString query(int x, int y, int z) const;
virtual int tilesonzoomlevel(int zoomlevel) const;
virtual int xoffset(int x) const;
virtual int yoffset(int y) const;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/fixedimageoverlay.cpp
0,0 → 1,69
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2009 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "fixedimageoverlay.h"
namespace qmapcontrol
{
FixedImageOverlay::FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QString filename, QString name)
: ImagePoint(x_upperleft, y_upperleft, filename, name, TopLeft),
x_lowerright(x_lowerright), y_lowerright(y_lowerright)
{
//qDebug() << "loading image: " << filename;
mypixmap = new QPixmap(filename);
size = mypixmap->size();
//qDebug() << "image size: " << size;
}
 
FixedImageOverlay::FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QPixmap* pixmap, QString name)
: ImagePoint(x_upperleft, y_upperleft, pixmap, name, TopLeft),
x_lowerright(x_lowerright), y_lowerright(y_lowerright)
{
mypixmap = pixmap;
size = mypixmap->size();
}
 
void FixedImageOverlay::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)
{
if (!visible)
return;
 
if (mypixmap !=0)
{
const QPointF c = QPointF(X, Y);
QPoint topleft = mapadapter->coordinateToDisplay(c);
 
const QPointF c2 = QPointF(x_lowerright, y_lowerright);
QPoint lowerright = mapadapter->coordinateToDisplay(c2);
 
painter->drawPixmap(topleft.x(), topleft.y(), lowerright.x()-topleft.x(), lowerright.y()-topleft.y(), *mypixmap);
}
 
 
}
 
FixedImageOverlay::~FixedImageOverlay()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/fixedimageoverlay.h
0,0 → 1,80
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2009 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef FIXEDIMAGEOVERLAY_H
#define FIXEDIMAGEOVERLAY_H
 
#include "imagepoint.h"
 
namespace qmapcontrol
{
 
//! Draws a fixed image into the map.
/*!
* This class draws a image overlay onto a map, whose upper left and lower
* right corners lay always on the given coordinates. The methods
* setBaselevel, setMaxsize and setMinsize have no effect for this class.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class FixedImageOverlay : public ImagePoint
{
public:
//! Creates an image overlay which loads and displays the given image file
/*!
* Use this contructor to load the given image file and let the point
* display it.
* When you want multiple points to display the same image, use the
* other contructor and pass a pointer to that image.
* @param x_upperleft the coordinate of the upper left corner where the image should be aligned
* @param y_upperleft the coordinate of the upper left corner where the image should be aligned
* @param x_lowerright the coordinate of the lower right corner where the image should be aligned
* @param y_lowerright the coordinate of the lower right corner where the image should be aligned
* @param filename the file which should be loaded and displayed
* @param name the name of the image point
*/
FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QString filename, QString name = QString());
 
//! Creates an image overlay which displays the given image
/*!
* Use this contructor to display the given image.
* @param x_upperleft the coordinate of the upper left corner where the image should be aligned
* @param y_upperleft the coordinate of the upper left corner where the image should be aligned
* @param x_lowerright the coordinate of the lower right corner where the image should be aligned
* @param y_lowerright the coordinate of the lower right corner where the image should be aligned
* @param pixmap pointer to the image pixmap
* @param name the name of the image point
*/
FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QPixmap* pixmap, QString name = QString());
 
virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset);
virtual ~FixedImageOverlay();
 
private:
qreal x_lowerright;
qreal y_lowerright;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/geometry.cpp
0,0 → 1,88
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "geometry.h"
namespace qmapcontrol
{
Geometry::Geometry(QString name)
: GeometryType("Geometry"), myparentGeometry(0), mypen(0), visible(true), myname(name)
{
}
 
 
Geometry::~Geometry()
{
}
 
QString Geometry::name() const
{
return myname;
}
Geometry* Geometry::parentGeometry() const
{
return myparentGeometry;
}
void Geometry::setParentGeometry(Geometry* geom)
{
myparentGeometry = geom;
}
bool Geometry::hasPoints() const
{
return false;
}
bool Geometry::hasClickedPoints() const
{
return false;
}
QList<Geometry*> Geometry::clickedPoints()
{
QList<Geometry*> tmp;
return tmp;
}
 
bool Geometry::isVisible() const
{
return visible;
}
void Geometry::setVisible(bool visible)
{
this->visible = visible;
emit(updateRequest(boundingBox()));
}
 
void Geometry::setName(QString name)
{
myname = name;
}
 
void Geometry::setPen(QPen* pen)
{
mypen = pen;
}
QPen* Geometry::pen() const
{
return mypen;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/geometry.h
0,0 → 1,154
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef GEOMETRY_H
#define GEOMETRY_H
#include <QObject>
#include <QPainter>
#include <QDebug>
#include "mapadapter.h"
 
namespace qmapcontrol
{
class Point;
//! Main class for objects that should be painted in maps
/*!
* Geometry is the root class of the hierarchy. Geometry is an abstract (non-instantiable) class.
*
* This class and the derived classes Point, Curve and LineString are leant on the Simple
* Feature Specification of the Open Geospatial Consortium.
* @see www.opengeospatial.com
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class Geometry : public QObject
{
friend class LineString;
Q_OBJECT
public:
explicit Geometry(QString name = QString());
virtual ~Geometry();
 
QString GeometryType;
 
//!
/*! returns true if the given Geometry is equal to this Geometry
* not implemented yet!
* @param geom The Geometry to be tested
* @return true if the given Geometry is equal to this
*/
bool Equals(Geometry* geom);
 
//! returns a String representation of this Geometry
/*!
* not implemented yet!
* @return a String representation of this Geometry
*/
QString toString();
 
//! returns the name of this Geometry
/*!
* @return the name of this Geometry
*/
QString name() const;
 
//! returns the parent Geometry of this Geometry
/*!
* A LineString is a composition of many Points. This methods returns the parent (the LineString) of a Point
* @return the parent Geometry of this Geometry
*/
Geometry* parentGeometry() const;
 
//! returns true if this Geometry is visible
/*!
* @return true if this Geometry is visible
*/
bool isVisible() const;
 
//! sets the name of the geometry
/*!
* @param name the new name of the geometry
*/
void setName(QString name);
 
//! returns the QPen which is used on drawing
/*!
* The pen is set depending on the Geometry. A CirclePoint for example takes one with the constructor.
* @return the QPen which is used for drawing
*/
QPen* pen() const;
 
//! returns the BoundingBox
/*!
* The bounding box in world coordinates
* @return the BoundingBox
*/
virtual QRectF boundingBox()=0;
virtual bool Touches(Point* geom, const MapAdapter* mapadapter)=0;
virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)=0;
virtual bool hasPoints() const;
virtual bool hasClickedPoints() const;
virtual void setPen(QPen* pen);
virtual QList<Geometry*> clickedPoints();
virtual QList<Point*> points()=0;
 
private:
Geometry* myparentGeometry;
Geometry(const Geometry& old);
Geometry& operator=(const Geometry& rhs);
 
protected:
QPen* mypen;
bool visible;
QString myname;
void setParentGeometry(Geometry* geom);
 
signals:
void updateRequest(Geometry* geom);
void updateRequest(QRectF rect);
//! This signal is emitted when a Geometry is clicked
/*!
* A Geometry is clickable, if the containing layer is clickable.
* The objects emits a signal if it gets clicked
* @param geometry The clicked Geometry
* @param point -unused-
*/
void geometryClicked(Geometry* geometry, QPoint point);
 
//! A Geometry emits this signal, when its position gets changed
/*!
* @param geom the Geometry
*/
void positionChanged(Geometry* geom);
 
public slots:
//! if visible is true, the layer is made visible
/*!
* @param visible if the layer should be visible
*/
virtual void setVisible(bool visible);
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/geometrylayer.cpp
0,0 → 1,38
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "geometrylayer.h"
namespace qmapcontrol
{
GeometryLayer::GeometryLayer(QString layername, MapAdapter* mapadapter, bool takeevents)
: Layer(layername, mapadapter, Layer::GeometryLayer, takeevents)
{
}
 
 
GeometryLayer::~GeometryLayer()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/geometrylayer.h
0,0 → 1,65
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef GEOMETRYLAYER_H
#define GEOMETRYLAYER_H
 
#include "layer.h"
 
namespace qmapcontrol
{
//! GeometryLayer class
/*!
* There are two different layer types:
* - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
* - GeometryLayer: Only displays Geometry objects.
*
* MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
* added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
* not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
* position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
* are repainted immediately on changes.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class GeometryLayer : public Layer
{
Q_OBJECT
 
public:
//! GeometryLayer constructor
/*!
* This is used to construct a map layer.
*
* @param layername The name of the Layer
* @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
* @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
* be something like a "speed up hint"
*/
GeometryLayer(QString layername, MapAdapter* mapadapter, bool takeevents=true);
virtual ~GeometryLayer();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/googlemapadapter.cpp
0,0 → 1,38
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "googlemapadapter.h"
namespace qmapcontrol
{
GoogleMapAdapter::GoogleMapAdapter()
: TileMapAdapter("mt2.google.com", "/mt?n=404&x=%2&y=%3&zoom=%1", 256, 17, 0)
//: TileMapAdapter("tile.openstreetmap.org", "/%1/%2/%3.png", 256, 0, 17)
{
}
 
GoogleMapAdapter::~GoogleMapAdapter()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/googlemapadapter.h
0,0 → 1,51
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef GOOGLEMAPADAPTER_H
#define GOOGLEMAPADAPTER_H
 
#include "tilemapadapter.h"
 
namespace qmapcontrol
{
//! MapAdapter for Google
/*!
* This is a conveniece class, which extends and configures a TileMapAdapter
* @author Kai Winter <kaiwinter@gmx.de>
*/
class GoogleMapAdapter : public TileMapAdapter
{
Q_OBJECT
 
public:
//! constructor
/*!
* This construct a Google Adapter
*/
GoogleMapAdapter();
virtual ~GoogleMapAdapter();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/googlesatmapadapter.cpp
0,0 → 1,181
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "googlesatmapadapter.h"
 
#include <math.h>
namespace qmapcontrol
{
GoogleSatMapAdapter::GoogleSatMapAdapter()
: TileMapAdapter("kh.google.com", "/kh?n=404&v=8&t=trtqtt", 256, 0, 19)
{
// name = "googlesat";
 
numberOfTiles = pow(2, current_zoom+0.0);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
 
GoogleSatMapAdapter::~GoogleSatMapAdapter()
{
}
 
QString GoogleSatMapAdapter::getHost() const
{
int random = qrand() % 4;
return QString("kh%1.google.com").arg(random);
}
 
QPoint GoogleSatMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
{
//double x = ((coordinate.x()+180)*(tilesize*numberOfTiles/360));
//double y = (((coordinate.y()*-1)+90)*(tilesize*numberOfTiles/180));
 
qreal x = (coordinate.x()+180.) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
//double y = -1*(coordinate.y()-90) * (numberOfTiles*tilesize)/180.; // coord to pixel!
qreal y = (getMercatorYCoord(coordinate.y())-M_PI) * -1 * (numberOfTiles*mytilesize)/(2*M_PI); // coord to pixel!
return QPoint(int(x), int(y));
}
 
QPointF GoogleSatMapAdapter::displayToCoordinate(const QPoint& point) const
{
//double lon = ((point.x()/tilesize*numberOfTiles)*360)-180;
//double lat = (((point.y()/tilesize*numberOfTiles)*180)-90)*-1;
 
qreal lon = (point.x()*(360./(numberOfTiles*mytilesize)))-180.;
//double lat = -(point.y()*(180./(numberOfTiles*tilesize)))+90;
//qreal lat = getMercatorLatitude(point.y()*-1*(2*M_PI/(numberOfTiles*tilesize)) + M_PI);
qreal lat = lat *180./M_PI;
return QPointF(lon, lat);
}
 
qreal GoogleSatMapAdapter::getMercatorLatitude(qreal YCoord) const
{
//http://welcome.warnercnr.colostate.edu/class_info/nr502/lg4/projection_mathematics/converting.html
if (YCoord > M_PI) return 9999.;
if (YCoord < -M_PI) return -9999.;
 
qreal t = atan(exp(YCoord));
qreal res = (2.*(t))-(M_PI/2.);
return res;
}
 
qreal GoogleSatMapAdapter::getMercatorYCoord(qreal lati) const
{
qreal lat = lati;
 
// conversion degre=>radians
qreal phi = M_PI * lat / 180;
 
qreal res;
//double temp = Math.Tan(Math.PI / 4 - phi / 2);
//res = Math.Log(temp);
res = 0.5 * log((1 + sin(phi)) / (1 - sin(phi)));
 
return res;
}
 
void GoogleSatMapAdapter::zoom_in()
{
current_zoom+=1;
numberOfTiles = pow(2, current_zoom+0.0);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
 
void GoogleSatMapAdapter::zoom_out()
{
current_zoom-=1;
numberOfTiles = pow(2, current_zoom+0.0);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
 
bool GoogleSatMapAdapter::isValid(int x, int y, int z) const
{
if ((x>=0 && x < numberOfTiles) && (y>=0 && y < numberOfTiles) && z>=0)
{
return true;
}
return false;
}
QString GoogleSatMapAdapter::query(int i, int j, int z) const
{
return getQ(-180+i*coord_per_x_tile,
90-(j+1)*coord_per_y_tile, z);
}
 
QString GoogleSatMapAdapter::getQ(qreal longitude, qreal latitude, int zoom) const
{
qreal xmin=-180;
qreal xmax=180;
qreal ymin=-90;
qreal ymax=90;
 
qreal xmoy=0;
qreal ymoy=0;
QString location="t";
 
//Google uses a latitude divided by 2;
qreal halflat = latitude;
 
for (int i = 0; i < zoom; i++)
{
xmoy = (xmax + xmin) / 2;
ymoy = (ymax + ymin) / 2;
if (halflat >= ymoy) //upper part (q or r)
{
ymin = ymoy;
if (longitude < xmoy)
{ /*q*/
location+= "q";
xmax = xmoy;
}
else
{/*r*/
location+= "r";
xmin = xmoy;
}
}
else //lower part (t or s)
{
ymax = ymoy;
if (longitude < xmoy)
{ /*t*/
 
location+= "t";
xmax = xmoy;
}
else
{/*s*/
location+= "s";
xmin = xmoy;
}
}
}
return QString("/kh?n=404&v=24&t=%1").arg(location);
}
}
 
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/googlesatmapadapter.h
0,0 → 1,74
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef GOOGLESATMAPADAPTER_H
#define GOOGLESATMAPADAPTER_H
 
#include "tilemapadapter.h"
namespace qmapcontrol
{
//! MapAdapter for Google
/*!
* This is a conveniece class, which extends and configures a TileMapAdapter
* @author Kai Winter <kaiwinter@gmx.de>
*/
class GoogleSatMapAdapter : public TileMapAdapter
{
Q_OBJECT
public:
//! constructor
/*!
* This construct a Google Adapter
*/
GoogleSatMapAdapter();
virtual ~GoogleSatMapAdapter();
 
virtual QPoint coordinateToDisplay(const QPointF&) const;
virtual QPointF displayToCoordinate(const QPoint&) const;
 
//! returns the host of this MapAdapter
/*!
* @return the host of this MapAdapter
*/
QString getHost () const;
 
 
protected:
virtual void zoom_in();
virtual void zoom_out();
virtual QString query(int x, int y, int z) const;
virtual bool isValid(int x, int y, int z) const;
 
private:
virtual QString getQ(qreal longitude, qreal latitude, int zoom) const;
qreal getMercatorLatitude(qreal YCoord) const;
qreal getMercatorYCoord(qreal lati) const;
 
qreal coord_per_x_tile;
qreal coord_per_y_tile;
int srvNum;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/gps_position.cpp
0,0 → 1,33
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "gps_position.h"
namespace qmapcontrol
{
GPS_Position::GPS_Position(float time, float longitude, QString longitude_dir, float latitude, QString latitude_dir)
:time(time), longitude(longitude), latitude(latitude), longitude_dir(longitude_dir), latitude_dir(latitude_dir)
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/gps_position.h
0,0 → 1,52
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef GPS_POSITION_H
#define GPS_POSITION_H
 
#include <QString>
 
namespace qmapcontrol
{
//! Represents a coordinate from a GPS receiver
/*!
* This class is used to represent a coordinate which has been parsed from a NMEA string.
* This is not fully integrated in the API. An example which uses this data type can be found under Samples.
* @author Kai Winter
*/
class GPS_Position
{
public:
GPS_Position(float time, float longitude, QString longitude_dir, float latitude, QString latitude_dir);
float time; /*!< time of the string*/
float longitude; /*!< longitude coordinate*/
float latitude; /*!< latitude coordinate*/
 
private:
QString longitude_dir;
QString latitude_dir;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/imagemanager.cpp
0,0 → 1,182
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "imagemanager.h"
namespace qmapcontrol
{
ImageManager* ImageManager::m_Instance = 0;
ImageManager::ImageManager(QObject* parent)
:QObject(parent), emptyPixmap(QPixmap(1,1)), net(new MapNetwork(this)), doPersistentCaching(false)
{
emptyPixmap.fill(Qt::transparent);
 
if (QPixmapCache::cacheLimit() <= 20000)
{
QPixmapCache::setCacheLimit(20000); // in kb
}
}
 
 
ImageManager::~ImageManager()
{
if (ImageManager::m_Instance != 0)
{
delete ImageManager::m_Instance;
}
delete net;
}
 
QPixmap ImageManager::getImage(const QString& host, const QString& url)
{
//qDebug() << "ImageManager::getImage";
QPixmap pm;
//pm.fill(Qt::black);
 
//is image cached (memory) or currently loading?
if (!QPixmapCache::find(url, pm) && !net->imageIsLoading(url))
// if (!images.contains(url) && !net->imageIsLoading(url))
{
//image cached (persistent)?
if (doPersistentCaching && tileExist(url))
{
loadTile(url,pm);
QPixmapCache::insert(url.toAscii().toBase64(), pm);
}
else
{
//load from net, add empty image
net->loadImage(host, url);
//QPixmapCache::insert(url, emptyPixmap);
return emptyPixmap;
}
}
return pm;
}
 
QPixmap ImageManager::prefetchImage(const QString& host, const QString& url)
{
#ifdef Q_WS_QWS
// on mobile devices we don´t want the display resfreshing when tiles are received which are
// prefetched... This is a performance issue, because mobile devices are very slow in
// repainting the screen
prefetch.append(url);
#endif
return getImage(host, url);
}
 
void ImageManager::receivedImage(const QPixmap pixmap, const QString& url)
{
//qDebug() << "ImageManager::receivedImage";
QPixmapCache::insert(url, pixmap);
//images[url] = pixmap;
 
// needed?
if (doPersistentCaching && !tileExist(url) )
saveTile(url,pixmap);
 
//((Layer*)this->parent())->imageReceived();
 
if (!prefetch.contains(url))
{
emit(imageReceived());
}
else
{
 
#ifdef Q_WS_QWS
prefetch.remove(prefetch.indexOf(url));
#endif
}
}
 
void ImageManager::loadingQueueEmpty()
{
emit(loadingFinished());
//((Layer*)this->parent())->removeZoomImage();
//qDebug() << "size of image-map: " << images.size();
//qDebug() << "size: " << QPixmapCache::cacheLimit();
}
 
void ImageManager::abortLoading()
{
net->abortLoading();
}
void ImageManager::setProxy(QString host, int port)
{
net->setProxy(host, port);
}
 
void ImageManager::setCacheDir(const QDir& path)
{
doPersistentCaching = true;
cacheDir = path;
if (!cacheDir.exists())
{
cacheDir.mkpath(cacheDir.absolutePath());
}
}
 
bool ImageManager::saveTile(QString tileName,QPixmap tileData)
{
tileName.replace("/","-");
 
QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
 
//qDebug() << "writing: " << file.fileName();
if (!file.open(QIODevice::ReadWrite )){
qDebug()<<"error reading file";
return false;
}
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
tileData.save(&buffer, "PNG");
 
file.write(bytes);
file.close();
return true;
}
bool ImageManager::loadTile(QString tileName,QPixmap &tileData)
{
tileName.replace("/","-");
QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
if (!file.open(QIODevice::ReadOnly )) {
return false;
}
tileData.loadFromData( file.readAll() );
 
file.close();
return true;
}
bool ImageManager::tileExist(QString tileName)
{
tileName.replace("/","-");
QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
if (file.exists())
return true;
else
return false;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/imagemanager.h
0,0 → 1,125
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef IMAGEMANAGER_H
#define IMAGEMANAGER_H
 
#include <QObject>
#include <QPixmapCache>
#include <QDebug>
#include <QMutex>
#include <QFile>
#include <QBuffer>
#include <QDir>
#include "mapnetwork.h"
 
namespace qmapcontrol
{
class MapNetwork;
/**
@author Kai Winter <kaiwinter@gmx.de>
*/
class ImageManager : public QObject
{
Q_OBJECT;
 
public:
static ImageManager* instance()
{
if(!m_Instance)
{
m_Instance = new ImageManager;
}
return m_Instance;
}
 
~ImageManager();
//! returns a QPixmap of the asked image
/*!
* If this component doesn´t have the image a network query gets started to load it.
* @param host the host of the image
* @param path the path to the image
* @return the pixmap of the asked image
*/
QPixmap getImage(const QString& host, const QString& path);
 
QPixmap prefetchImage(const QString& host, const QString& path);
 
void receivedImage(const QPixmap pixmap, const QString& url);
 
/*!
* This method is called by MapNetwork, after all images in its queue were loaded.
* The ImageManager emits a signal, which is used in MapControl to remove the zoom image.
* The zoom image should be removed on Tile Images with transparency.
* Else the zoom image stay visible behind the newly loaded tiles.
*/
void loadingQueueEmpty();
 
/*!
* Aborts all current loading threads.
* This is useful when changing the zoom-factor, though newly needed images loads faster
*/
void abortLoading();
 
//! sets the proxy for HTTP connections
/*!
* This method sets the proxy for HTTP connections.
* This is not provided by the current Qtopia version!
* @param host the proxy´s hostname or ip
* @param port the proxy´s port
*/
void setProxy(QString host, int port);
 
//! sets the cache directory for persistently saving map tiles
/*!
*
* @param path the path where map tiles should be stored
* @todo add maximum size
*/
void setCacheDir(const QDir& path);
 
private:
ImageManager(QObject* parent = 0);
ImageManager(const ImageManager&);
ImageManager& operator=(const ImageManager&);
QPixmap emptyPixmap;
MapNetwork* net;
QVector<QString> prefetch;
QDir cacheDir;
bool doPersistentCaching;
 
static ImageManager* m_Instance;
 
bool saveTile(QString tileName,QPixmap tileData);
bool loadTile(QString tileName,QPixmap &tileData);
bool tileExist(QString tileName);
 
signals:
void imageReceived();
void loadingFinished();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/imagepoint.cpp
0,0 → 1,49
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "imagepoint.h"
namespace qmapcontrol
{
ImagePoint::ImagePoint(qreal x, qreal y, QString filename, QString name, Alignment alignment)
: Point(x, y, name, alignment)
{
//qDebug() << "loading image: " << filename;
mypixmap = new QPixmap(filename);
size = mypixmap->size();
//qDebug() << "image size: " << size;
}
 
ImagePoint::ImagePoint(qreal x, qreal y, QPixmap* pixmap, QString name, Alignment alignment)
: Point(x, y, name, alignment)
{
mypixmap = pixmap;
size = mypixmap->size();
}
 
 
ImagePoint::~ImagePoint()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/imagepoint.h
0,0 → 1,70
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef IMAGEPOINT_H
#define IMAGEPOINT_H
 
#include "point.h"
 
namespace qmapcontrol
{
 
//! Draws an image into the map
/*! This is a convenience class for Point.
* It configures the pixmap of a Point to draw the given image.
* The image will be loaded from the given path and written in the points pixmap.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class ImagePoint : public Point
{
public:
//! Creates a point which loads and displays the given image file
/*!
* Use this contructor to load the given image file and let the point display it.
* When you want multiple points to display the same image, use the other contructor and pass a pointer to that image.
* @param x longitude
* @param y latitude
* @param filename the file which should be loaded and displayed
* @param name the name of the image point
* @param alignment alignment (Middle or TopLeft)
*/
ImagePoint(qreal x, qreal y, QString filename, QString name = QString(), Alignment alignment = Middle);
 
//! Creates a point which displays the given image
/*!
* Use this contructor to display the given image.
* You have to load that image yourself, but can use it for multiple points.
* @param x longitude
* @param y latitude
* @param pixmap pointer to the image pixmap
* @param name the name of the image point
* @param alignment alignment (Middle or TopLeft)
*/
ImagePoint(qreal x, qreal y, QPixmap* pixmap, QString name = QString(), Alignment alignment = Middle);
virtual ~ImagePoint();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/layer.cpp
0,0 → 1,307
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "layer.h"
namespace qmapcontrol
{
Layer::Layer(QString layername, MapAdapter* mapadapter, enum LayerType layertype, bool takeevents)
:visible(true), mylayername(layername), mylayertype(layertype), mapAdapter(mapadapter), takeevents(takeevents), myoffscreenViewport(QRect(0,0,0,0))
{
//qDebug() << "creating new Layer: " << layername << ", type: " << contents;
//qDebug() << this->layertype;
}
 
Layer::~Layer()
{
delete mapAdapter;
}
 
void Layer::setSize(QSize size)
{
this->size = size;
screenmiddle = QPoint(size.width()/2, size.height()/2);
//QMatrix mat;
//mat.translate(480/2, 640/2);
//mat.rotate(45);
//mat.translate(-480/2,-640/2);
//screenmiddle = mat.map(screenmiddle);
}
 
QString Layer::layername() const
{
return mylayername;
}
 
const MapAdapter* Layer::mapadapter() const
{
return mapAdapter;
}
 
void Layer::setVisible(bool visible)
{
this->visible = visible;
emit(updateRequest());
}
 
void Layer::addGeometry(Geometry* geom)
{
//qDebug() << geom->getName() << ", " << geom->getPoints().at(0)->getWidget();
 
geometries.append(geom);
emit(updateRequest(geom->boundingBox()));
//a geometry can request a redraw, e.g. when its position has been changed
connect(geom, SIGNAL(updateRequest(QRectF)),
this, SIGNAL(updateRequest(QRectF)));
}
void Layer::removeGeometry(Geometry* geometry)
{
for (int i=0; i<geometries.count(); i++)
{
if (geometry == geometries.at(i))
{
disconnect(geometry);
geometries.removeAt(i);
//delete geometry;
}
}
}
 
void Layer::clearGeometries()
{
foreach(Geometry *geometry, geometries){
disconnect(geometry);
}
geometries.clear();
}
 
bool Layer::isVisible() const
{
return visible;
}
void Layer::zoomIn() const
{
mapAdapter->zoom_in();
}
void Layer::zoomOut() const
{
mapAdapter->zoom_out();
}
 
void Layer::mouseEvent(const QMouseEvent* evnt, const QPoint mapmiddle_px)
{
if (takesMouseEvents())
{
if (evnt->button() == Qt::LeftButton && evnt->type() == QEvent::MouseButtonPress)
{
// check for collision
QPointF c = mapAdapter->displayToCoordinate(QPoint(evnt->x()-screenmiddle.x()+mapmiddle_px.x(),
evnt->y()-screenmiddle.y()+mapmiddle_px.y()));
Point* tmppoint = new Point(c.x(), c.y());
for (int i=0; i<geometries.count(); i++)
{
if (geometries.at(i)->isVisible() && geometries.at(i)->Touches(tmppoint, mapAdapter))
 
//if (geometries.at(i)->Touches(c, mapAdapter))
{
emit(geometryClicked(geometries.at(i), QPoint(evnt->x(), evnt->y())));
}
}
delete tmppoint;
}
}
}
 
bool Layer::takesMouseEvents() const
{
return takeevents;
}
 
void Layer::drawYourImage(QPainter* painter, const QPoint mapmiddle_px) const
{
if (mylayertype == MapLayer)
{
//qDebug() << ":: " << mapmiddle_px;
//QMatrix mat;
//mat.translate(480/2, 640/2);
//mat.rotate(45);
//mat.translate(-480/2,-640/2);
 
//mapmiddle_px = mat.map(mapmiddle_px);
//qDebug() << ":: " << mapmiddle_px;
_draw(painter, mapmiddle_px);
}
 
drawYourGeometries(painter, QPoint(mapmiddle_px.x()-screenmiddle.x(), mapmiddle_px.y()-screenmiddle.y()), myoffscreenViewport);
}
void Layer::drawYourGeometries(QPainter* painter, const QPoint mapmiddle_px, QRect viewport) const
{
QPoint offset;
if (mylayertype == MapLayer)
offset = mapmiddle_px;
else
offset = mapmiddle_px-screenmiddle;
 
painter->translate(-mapmiddle_px+screenmiddle);
for (int i=0; i<geometries.count(); i++)
{
geometries.at(i)->draw(painter, mapAdapter, viewport, offset);
}
painter->translate(mapmiddle_px-screenmiddle);
 
}
void Layer::_draw(QPainter* painter, const QPoint mapmiddle_px) const
{
// screen middle rotieren...
 
int tilesize = mapAdapter->tilesize();
int cross_x = int(mapmiddle_px.x())%tilesize; // position on middle tile
int cross_y = int(mapmiddle_px.y())%tilesize;
//qDebug() << screenmiddle << " - " << cross_x << ", " << cross_y;
 
// calculate how many surrounding tiles have to be drawn to fill the display
int space_left = screenmiddle.x() - cross_x;
int tiles_left = space_left/tilesize;
if (space_left>0)
tiles_left+=1;
 
int space_above = screenmiddle.y() - cross_y;
int tiles_above = space_above/tilesize;
if (space_above>0)
tiles_above+=1;
 
int space_right = screenmiddle.x() - (tilesize-cross_x);
int tiles_right = space_right/tilesize;
if (space_right>0)
tiles_right+=1;
 
int space_bottom = screenmiddle.y() - (tilesize-cross_y);
int tiles_bottom = space_bottom/tilesize;
if (space_bottom>0)
tiles_bottom+=1;
 
//int tiles_displayed = 0;
int mapmiddle_tile_x = mapmiddle_px.x()/tilesize;
int mapmiddle_tile_y = mapmiddle_px.y()/tilesize;
 
const QPoint from = QPoint((-tiles_left+mapmiddle_tile_x)*tilesize, (-tiles_above+mapmiddle_tile_y)*tilesize);
const QPoint to = QPoint((tiles_right+mapmiddle_tile_x+1)*tilesize, (tiles_bottom+mapmiddle_tile_y+1)*tilesize);
 
myoffscreenViewport = QRect(from, to);
 
// for the EmptyMapAdapter no tiles should be loaded and painted.
if (mapAdapter->host() == "")
{
return;
}
 
if (mapAdapter->isValid(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom()))
{
painter->drawPixmap(-cross_x+size.width(),
-cross_y+size.height(),
ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom())));
}
 
for (int i=-tiles_left+mapmiddle_tile_x; i<=tiles_right+mapmiddle_tile_x; i++)
{
for (int j=-tiles_above+mapmiddle_tile_y; j<=tiles_bottom+mapmiddle_tile_y; j++)
{
// check if image is valid
if (!(i==mapmiddle_tile_x && j==mapmiddle_tile_y))
if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
{
 
painter->drawPixmap(((i-mapmiddle_tile_x)*tilesize)-cross_x+size.width(),
((j-mapmiddle_tile_y)*tilesize)-cross_y+size.height(),
ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom())));
//if (QCoreApplication::hasPendingEvents())
// QCoreApplication::processEvents();
}
}
}
 
 
// PREFETCHING
int upper = mapmiddle_tile_y-tiles_above-1;
int right = mapmiddle_tile_x+tiles_right+1;
int left = mapmiddle_tile_x-tiles_right-1;
int lower = mapmiddle_tile_y+tiles_bottom+1;
 
int j = upper;
for (int i=left; i<=right; i++)
{
if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
}
j = lower;
for (int i=left; i<=right; i++)
{
if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
}
int i = left;
for (int j=upper+1; j<=lower-1; j++)
{
if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
}
i = right;
for (int j=upper+1; j<=lower-1; j++)
{
if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
}
}
 
QRect Layer::offscreenViewport() const
{
return myoffscreenViewport;
}
 
void Layer::moveWidgets(const QPoint mapmiddle_px) const
{
for (int i=0; i<geometries.count(); i++)
{
const Geometry* geom = geometries.at(i);
if (geom->GeometryType == "Point")
{
if (((Point*)geom)->widget()!=0)
{
QPoint topleft_relative = QPoint(mapmiddle_px-screenmiddle);
((Point*)geom)->drawWidget(mapAdapter, topleft_relative);
}
}
}
}
Layer::LayerType Layer::layertype() const
{
return mylayertype;
}
 
void Layer::setMapAdapter(MapAdapter* mapadapter)
{
 
mapAdapter = mapadapter;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/layer.h
0,0 → 1,182
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef LAYER_H
#define LAYER_H
 
#include <QObject>
#include <QDebug>
#include <QPainter>
#include <QMouseEvent>
 
#include "mapadapter.h"
#include "layermanager.h"
#include "geometry.h"
#include "point.h"
 
#include "wmsmapadapter.h"
#include "tilemapadapter.h"
 
namespace qmapcontrol
{
//! Layer class
/*!
* There are two different layer types:
* - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
* - GeometryLayer: Only displays Geometry objects.
*
* MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
* added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
* not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
* position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
* are repainted immediately on changes.
* You can either use this class and give a layertype on creation or you can use the classes MapLayer and GeometryLayer.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class Layer : public QObject
{
Q_OBJECT
 
public:
friend class LayerManager;
 
//! sets the type of a layer, see Layer class doc for further information
enum LayerType
{
MapLayer, /*!< uses the MapAdapter to display maps, only gets refreshed when a new offscreen image is needed */
GeometryLayer /*!< gets refreshed everytime when a geometry changes */
};
 
//! Layer constructor
/*!
* This is used to construct a layer.
*
* @param layername The name of the Layer
* @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
* @param layertype The above explained LayerType
* @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
* be something like a "speed up hint"
*/
Layer(QString layername, MapAdapter* mapadapter, enum LayerType layertype, bool takeevents=true);
virtual ~Layer();
 
//! returns the layer's name
/*!
* @return the name of this layer
*/
QString layername() const;
 
//! returns the layer´s MapAdapter
/*!
* This method returns the MapAdapter of this Layer, which can be useful
* to do coordinate transformations.
* @return the MapAdapter which us used by this Layer
*/
const MapAdapter* mapadapter() const;
 
//! adds a Geometry object to this Layer
/*!
* Please notice the different LayerTypes (MapLayer and GeometryLayer) and the differences
* @param geometry the new Geometry
*/
void addGeometry(Geometry* geometry);
 
//! removes the Geometry object from this Layer
/*!
* This method removes a Geometry object from this Layer.
*/
void removeGeometry(Geometry* geometry);
 
//! removes all Geometry objects from this Layer
/*!
* This method removes all Geometry objects from this Layer.
*/
void clearGeometries();
 
//! return true if the layer is visible
/*!
* @return if the layer is visible
*/
bool isVisible() const;
 
//! returns the LayerType of the Layer
/*!
* There are two LayerTypes: MapLayer and GeometryLayer
* @return the LayerType of this Layer
*/
Layer::LayerType layertype() const;
 
void setMapAdapter(MapAdapter* mapadapter);
 
Layer& operator=(const Layer& rhs);
Layer(const Layer& old);
 
private:
void moveWidgets(const QPoint mapmiddle_px) const;
void drawYourImage(QPainter* painter, const QPoint mapmiddle_px) const;
void drawYourGeometries(QPainter* painter, const QPoint mapmiddle_px, QRect viewport) const;
void setSize(QSize size);
QRect offscreenViewport() const;
bool takesMouseEvents() const;
void mouseEvent(const QMouseEvent*, const QPoint mapmiddle_px);
void zoomIn() const;
void zoomOut() const;
void _draw(QPainter* painter, const QPoint mapmiddle_px) const;
 
bool visible;
QString mylayername;
LayerType mylayertype;
QSize size;
QPoint screenmiddle;
 
QList<Geometry*> geometries;
MapAdapter* mapAdapter;
bool takeevents;
mutable QRect myoffscreenViewport;
 
signals:
//! This signal is emitted when a Geometry is clicked
/*!
* A Geometry is clickable, if the containing layer is clickable.
* The layer emits a signal for every clicked geometry
* @param geometry The clicked Geometry
* @param point The coordinate (in widget coordinates) of the click
*/
void geometryClicked(Geometry* geometry, QPoint point);
 
void updateRequest(QRectF rect);
void updateRequest();
 
public slots:
//! if visible is true, the layer is made visible
/*!
* @param visible if the layer should be visible
*/
void setVisible(bool visible);
 
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/layermanager.cpp
0,0 → 1,456
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "layermanager.h"
namespace qmapcontrol
{
LayerManager::LayerManager(MapControl* mapcontrol, QSize size)
:mapcontrol(mapcontrol), scroll(QPoint(0,0)), size(size), whilenewscroll(QPoint(0,0))
{
// genauer berechnen?
offSize = size *2;
composedOffscreenImage = QPixmap(offSize);
composedOffscreenImage2 = QPixmap(offSize);
zoomImage = QPixmap(size);
zoomImage.fill(Qt::white);
screenmiddle = QPoint(size.width()/2, size.height()/2);
}
 
 
LayerManager::~LayerManager()
{
mylayers.clear();
}
 
QPointF LayerManager::currentCoordinate() const
{
return mapmiddle;
}
 
QPixmap LayerManager::getImage() const
{
return composedOffscreenImage;
}
 
Layer* LayerManager::layer() const
{
Q_ASSERT_X(mylayers.size()>0, "LayerManager::getLayer()", "No layers were added!");
return mylayers.first();
}
 
Layer* LayerManager::layer(const QString& layername) const
{
QListIterator<Layer*> layerit(mylayers);
while (layerit.hasNext())
{
Layer* l = layerit.next();
if (l->layername() == layername)
return l;
}
return 0;
}
 
QList<QString> LayerManager::layers() const
{
QList<QString> keys;
QListIterator<Layer*> layerit(mylayers);
while (layerit.hasNext())
{
keys.append(layerit.next()->layername());
}
return keys;
}
 
 
void LayerManager::scrollView(const QPoint& point)
{
scroll += point;
zoomImageScroll+=point;
mapmiddle_px += point;
 
mapmiddle = layer()->mapadapter()->displayToCoordinate(mapmiddle_px);
if (!checkOffscreen())
{
newOffscreenImage();
}
else
{
moveWidgets();
}
}
 
void LayerManager::moveWidgets()
{
QListIterator<Layer*> it(mylayers);
while (it.hasNext())
{
it.next()->moveWidgets(mapmiddle_px);
}
}
 
void LayerManager::setView(const QPointF& coordinate)
{
mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(coordinate);
mapmiddle = coordinate;
 
//TODO: muss wegen moveTo() raus
if (!checkOffscreen())
{
newOffscreenImage();
}
else
{
//TODO:
// verschiebung ausrechnen
// oder immer neues offscreenimage
newOffscreenImage();
}
}
 
void LayerManager::setView(QList<QPointF> coordinates)
{
setMiddle(coordinates);
// mapcontrol->update();
}
 
void LayerManager::setViewAndZoomIn(const QList<QPointF> coordinates)
{
while (containsAll(coordinates))
{
setMiddle(coordinates);
zoomIn();
}
 
 
if (!containsAll(coordinates))
{
zoomOut();
}
 
mapcontrol->update();
}
 
void LayerManager::setMiddle(QList<QPointF> coordinates)
{
int sum_x = 0;
int sum_y = 0;
for (int i=0; i<coordinates.size(); i++)
{
// mitte muss in px umgerechnet werden, da aufgrund der projektion die mittebestimmung aus koordinaten ungenau ist
QPoint p = layer()->mapadapter()->coordinateToDisplay(coordinates.at(i));
sum_x += p.x();
sum_y += p.y();
}
QPointF middle = layer()->mapadapter()->displayToCoordinate(QPoint(sum_x/coordinates.size(), sum_y/coordinates.size()));
// middle in px rechnen!
 
setView(middle);
}
 
bool LayerManager::containsAll(QList<QPointF> coordinates) const
{
QRectF bb = getViewport();
bool containsall = true;
for (int i=0; i<coordinates.size(); i++)
{
if (!bb.contains(coordinates.at(i)))
return false;
}
return containsall;
}
QPoint LayerManager::getMapmiddle_px() const
{
return mapmiddle_px;
}
 
QRectF LayerManager::getViewport() const
{
QPoint upperLeft = QPoint(mapmiddle_px.x()-screenmiddle.x(), mapmiddle_px.y()+screenmiddle.y());
QPoint lowerRight = QPoint(mapmiddle_px.x()+screenmiddle.x(), mapmiddle_px.y()-screenmiddle.y());
 
QPointF ulCoord = layer()->mapadapter()->displayToCoordinate(upperLeft);
QPointF lrCoord = layer()->mapadapter()->displayToCoordinate(lowerRight);
 
QRectF coordinateBB = QRectF(ulCoord, QSizeF( (lrCoord-ulCoord).x(), (lrCoord-ulCoord).y()));
return coordinateBB;
}
 
void LayerManager::addLayer(Layer* layer)
{
mylayers.append(layer);
 
layer->setSize(size);
 
connect(layer, SIGNAL(updateRequest(QRectF)),
this, SLOT(updateRequest(QRectF)));
connect(layer, SIGNAL(updateRequest()),
this, SLOT(updateRequest()));
 
if (mylayers.size()==1)
{
setView(QPointF(0,0));
}
}
 
void LayerManager::newOffscreenImage(bool clearImage, bool showZoomImage)
{
// qDebug() << "LayerManager::newOffscreenImage()";
whilenewscroll = mapmiddle_px;
 
if (clearImage)
{
composedOffscreenImage2.fill(Qt::white);
}
 
QPainter painter(&composedOffscreenImage2);
if (showZoomImage)
{
painter.drawPixmap(screenmiddle.x()-zoomImageScroll.x(), screenmiddle.y()-zoomImageScroll.y(),zoomImage);
}
//only draw basemaps
for (int i=0; i<mylayers.count(); i++)
{
Layer* l = mylayers.at(i);
if (l->isVisible())
{
if (l->layertype() == Layer::MapLayer)
{
l->drawYourImage(&painter, whilenewscroll);
}
}
}
 
composedOffscreenImage = composedOffscreenImage2;
scroll = mapmiddle_px-whilenewscroll;
 
mapcontrol->update();
}
 
void LayerManager::zoomIn()
{
QCoreApplication::processEvents();
 
ImageManager::instance()->abortLoading();
// layer rendern abbrechen?
zoomImageScroll = QPoint(0,0);
 
zoomImage.fill(Qt::white);
QPixmap tmpImg = composedOffscreenImage.copy(screenmiddle.x()+scroll.x(),screenmiddle.y()+scroll.y(), size.width(), size.height());
 
QPainter painter(&zoomImage);
painter.translate(screenmiddle);
painter.scale(2, 2);
painter.translate(-screenmiddle);
 
painter.drawPixmap(0,0,tmpImg);
 
QListIterator<Layer*> it(mylayers);
//TODO: remove hack, that mapadapters wont get set zoom multiple times
QList<const MapAdapter*> doneadapters;
while (it.hasNext())
{
Layer* l = it.next();
if (!doneadapters.contains(l->mapadapter()))
{
l->zoomIn();
doneadapters.append(l->mapadapter());
}
}
mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(mapmiddle);
whilenewscroll = mapmiddle_px;
 
newOffscreenImage();
 
}
 
bool LayerManager::checkOffscreen() const
{
// calculate offscreenImage dimension (px)
QPoint upperLeft = mapmiddle_px - screenmiddle;
QPoint lowerRight = mapmiddle_px + screenmiddle;
QRect viewport = QRect(upperLeft, lowerRight);
 
QRect testRect = layer()->offscreenViewport();
 
if (!testRect.contains(viewport))
{
return false;
}
 
return true;
}
void LayerManager::zoomOut()
{
QCoreApplication::processEvents();
ImageManager::instance()->abortLoading();
zoomImageScroll = QPoint(0,0);
zoomImage.fill(Qt::white);
QPixmap tmpImg = composedOffscreenImage.copy(screenmiddle.x()+scroll.x(),screenmiddle.y()+scroll.y(), size.width(), size.height());
QPainter painter(&zoomImage);
painter.translate(screenmiddle);
painter.scale(0.500001,0.500001);
painter.translate(-screenmiddle);
painter.drawPixmap(0,0,tmpImg);
 
painter.translate(screenmiddle);
painter.scale(2,2);
painter.translate(-screenmiddle);
 
QListIterator<Layer*> it(mylayers);
//TODO: remove hack, that mapadapters wont get set zoom multiple times
QList<const MapAdapter*> doneadapters;
while (it.hasNext())
{
Layer* l = it.next();
if (!doneadapters.contains(l->mapadapter()))
{
l->zoomOut();
doneadapters.append(l->mapadapter());
}
}
mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(mapmiddle);
whilenewscroll = mapmiddle_px;
newOffscreenImage();
}
 
void LayerManager::setZoom(int zoomlevel)
{
int current_zoom;
if (layer()->mapadapter()->minZoom() < layer()->mapadapter()->maxZoom())
{
current_zoom = layer()->mapadapter()->currentZoom();
}
else
{
current_zoom = layer()->mapadapter()->minZoom() - layer()->mapadapter()->currentZoom();
}
 
 
if (zoomlevel < current_zoom)
{
for (int i=current_zoom; i>zoomlevel; i--)
{
zoomOut();
}
}
else
{
for (int i=current_zoom; i<zoomlevel; i++)
{
zoomIn();
}
}
}
 
void LayerManager::mouseEvent(const QMouseEvent* evnt)
{
QListIterator<Layer*> it(mylayers);
while (it.hasNext())
{
Layer* l = it.next();
if (l->isVisible())
{
l->mouseEvent(evnt, mapmiddle_px);
}
}
}
 
void LayerManager::updateRequest(QRectF rect)
{
const QPoint topleft = mapmiddle_px - screenmiddle;
 
QPointF c = rect.topLeft();
 
if (getViewport().contains(c) || getViewport().contains(rect.bottomRight()))
{
// QPoint point = getLayer()->getMapAdapter()->coordinateToDisplay(c);
// QPoint finalpoint = point-topleft;
// QRect rect_px = QRect(int(finalpoint.x()-(rect.width()-1)/2), int(finalpoint.y()-(rect.height()-1)/2),
// int(rect.width()+1), int(rect.height()+1));
//
// mapcontrol->updateRequest(rect_px);
mapcontrol->update();
// newOffscreenImage();
}
}
void LayerManager::updateRequest()
{
newOffscreenImage();
}
void LayerManager::forceRedraw()
{
newOffscreenImage();
}
void LayerManager::removeZoomImage()
{
zoomImage.fill(Qt::white);
forceRedraw();
}
 
void LayerManager::drawGeoms(QPainter* painter)
{
QListIterator<Layer*> it(mylayers);
while (it.hasNext())
{
Layer* l = it.next();
if (l->layertype() == Layer::GeometryLayer && l->isVisible())
{
l->drawYourGeometries(painter, mapmiddle_px, layer()->offscreenViewport());
}
}
}
void LayerManager::drawImage(QPainter* painter)
{
painter->drawPixmap(-scroll.x()-screenmiddle.x(),
-scroll.y()-screenmiddle.y(),
composedOffscreenImage);
}
 
int LayerManager::currentZoom() const
{
return layer()->mapadapter()->currentZoom();
}
 
void LayerManager::resize(QSize newSize)
{
size = newSize;
offSize = newSize *2;
composedOffscreenImage = QPixmap(offSize);
composedOffscreenImage2 = QPixmap(offSize);
zoomImage = QPixmap(newSize);
zoomImage.fill(Qt::white);
 
screenmiddle = QPoint(newSize.width()/2, newSize.height()/2);
 
QListIterator<Layer*> it(mylayers);
while (it.hasNext())
{
Layer* l = it.next();
l->setSize(newSize);
}
 
newOffscreenImage();
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/layermanager.h
0,0 → 1,211
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef LAYERMANAGER_H
#define LAYERMANAGER_H
 
#include <QObject>
#include <QMap>
#include <QListIterator>
#include "layer.h"
#include "mapadapter.h"
#include "mapcontrol.h"
 
namespace qmapcontrol
{
class Layer;
class MapAdapter;
class MapControl;
 
class LayerManager;
 
//! Handles Layers and viewport related settings
/*!
* This class handles internally all layers which were added to the MapControl.
* It also stores values for scrolling.
* It initiates the creation of a new offscreen image and on zooming the zoom images gets here created.
* @author Kai Winter <kaiwinter@gmx.de>
*/
class LayerManager : public QObject
{
Q_OBJECT
 
public:
LayerManager(MapControl*, QSize);
~LayerManager();
 
//! returns the coordinate of the center of the map
/*!
* @return returns the coordinate of the middle of the screen
*/
QPointF currentCoordinate() const;
 
//! returns the current offscreen image
/*!
* @return the current offscreen image
*/
QPixmap getImage() const;
 
//! returns the layer with the given name
/*!
* @param layername name of the wanted layer
* @return the layer with the given name
*/
Layer* layer(const QString&) const;
 
//! returns the base layer
/*!
* This will return the base layer of the LayerManager.
* The base layer is the one which is used to do internal coordinate calculations.
* @return the base layer
*/
Layer* layer() const;
 
//! returns the names of all layers
/*!
* @return returns a QList with the names of all layers
*/
QList<QString> layers() const;
 
//! sets the middle of the map to the given coordinate
/*!
* @param coordinate the coordinate which the view´s middle should be set to
*/
void setView(const QPointF& coordinate);
 
//! sets the view, so all coordinates are visible
/*!
* @param coordinates the Coorinates which should be visible
*/
void setView(const QList<QPointF> coordinates);
 
//! sets the view and zooms in, so all coordinates are visible
/*!
* The code of setting the view to multiple coordinates is "brute force" and pretty slow.
* Have to be reworked.
* @param coordinates the Coorinates which should be visible
*/
void setViewAndZoomIn (const QList<QPointF> coordinates);
 
//! zooms in one step
void zoomIn();
 
//! zooms out one step
void zoomOut();
 
//! sets the given zoomlevel
/*!
* @param zoomlevel the zoomlevel
*/
void setZoom(int zoomlevel);
 
//! The Viewport of the display
/*!
* Returns the visible viewport in world coordinates
* @return the visible viewport in world coordinates
*/
QRectF getViewport() const;
 
//! scrolls the view
/*!
* Scrolls the view by the given value in pixels and in display coordinates
* @param offset the distance which the view should be scrolled
*/
void scrollView(const QPoint& offset);
 
//! forwards mouseevents to the layers
/*!
* This method is invoked by the MapControl which receives Mouse Events.
* These events are forwarded to the layers, so they can check for clicked geometries.
* @param evnt the mouse event
*/
void mouseEvent(const QMouseEvent* evnt);
 
//! returns the middle of the map in projection coordinates
/*!
*
* @return the middle of the map in projection coordinates
*/
QPoint getMapmiddle_px() const;
 
void forceRedraw();
void removeZoomImage();
 
//! adds a layer
/*!
* If multiple layers are added, they are painted in the added order.
* @param layer the layer which should be added
*/
void addLayer(Layer* layer);
 
//! returns the current zoom level
/*!
* @return returns the current zoom level
*/
int currentZoom() const;
 
void drawGeoms(QPainter* painter);
void drawImage(QPainter* painter);
 
private:
LayerManager& operator=(const LayerManager& rhs);
LayerManager(const LayerManager& old);
//! This method have to be invoked to draw a new offscreen image
/*!
* @param clearImage if the current offscreeen image should be cleared
* @param showZoomImage if a zoom image should be painted
*/
void newOffscreenImage(bool clearImage=true, bool showZoomImage=true);
inline bool checkOffscreen() const;
inline bool containsAll(QList<QPointF> coordinates) const;
inline void moveWidgets();
inline void setMiddle(QList<QPointF> coordinates);
 
MapControl* mapcontrol;
QPoint screenmiddle; // middle of the screen
QPoint scroll; // scrollvalue of the offscreen image
QPoint zoomImageScroll; // scrollvalue of the zoom image
 
QSize size; // widget size
QSize offSize; // size of the offscreen image
 
QPixmap composedOffscreenImage;
QPixmap composedOffscreenImage2;
QPixmap zoomImage;
 
QList<Layer*> mylayers;
 
QPoint mapmiddle_px; // projection-display coordinates
QPointF mapmiddle; // world coordinate
 
QPoint whilenewscroll;
 
public slots:
void updateRequest(QRectF rect);
void updateRequest();
void resize(QSize newSize);
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/linestring.cpp
0,0 → 1,170
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "linestring.h"
namespace qmapcontrol
{
LineString::LineString()
: Curve()
{
GeometryType = "LineString";
}
 
LineString::LineString(QList<Point*> const points, QString name, QPen* pen)
:Curve(name)
{
mypen = pen;
LineString();
setPoints(points);
}
 
LineString::~LineString()
{
}
 
// Geometry LineString::Clone(){}
 
// Point LineString::EndPoint(){}
// Point LineString::StartPoint(){}
// Point LineString::Value(){}
 
 
void LineString::addPoint(Point* point)
{
vertices.append(point);
}
 
QList<Point*> LineString::points()
{
return vertices;
}
 
void LineString::setPoints(QList<Point*> points)
{
for (int i=0; i<points.size(); i++)
{
points.at(i)->setParentGeometry(this);
}
vertices = points;
}
 
void LineString::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset)
{
if (!visible)
return;
 
QPolygon p = QPolygon();
 
QPointF c;
for (int i=0; i<vertices.size(); i++)
{
c = vertices[i]->coordinate();
p.append(mapadapter->coordinateToDisplay(c));
}
if (mypen != 0)
{
painter->save();
painter->setPen(*mypen);
}
painter->drawPolyline(p);
if (mypen != 0)
{
painter->restore();
}
for (int i=0; i<vertices.size(); i++)
{
vertices[i]->draw(painter, mapadapter, screensize, offset);
}
}
 
int LineString::numberOfPoints() const
{
return vertices.count();
}
bool LineString::Touches(Point* geom, const MapAdapter* mapadapter)
{
// qDebug() << "LineString::Touches Point";
touchedPoints.clear();
bool touches = false;
for (int i=0; i<vertices.count(); i++)
{
// use implementation from Point
if (vertices.at(i)->Touches(geom, mapadapter))
{
touchedPoints.append(vertices.at(i));
 
touches = true;
}
}
if (touches)
{
emit(geometryClicked(this, QPoint(0,0)));
}
return touches;
}
bool LineString::Touches(Geometry* /*geom*/, const MapAdapter* /*mapadapter*/)
{
// qDebug() << "LineString::Touches Geom";
touchedPoints.clear();
 
return false;
}
 
QList<Geometry*> LineString::clickedPoints()
{
return touchedPoints;
}
bool LineString::hasPoints() const
{
return vertices.size() > 0 ? true : false;
}
bool LineString::hasClickedPoints() const
{
return touchedPoints.size() > 0 ? true : false;
}
 
QRectF LineString::boundingBox()
{
qreal minlon=180;
qreal maxlon=-180;
qreal minlat=90;
qreal maxlat=-90;
for (int i=0; i<vertices.size(); i++)
{
Point* tmp = vertices.at(i);
if (tmp->longitude() < minlon) minlon = tmp->longitude();
if (tmp->longitude() > maxlon) maxlon = tmp->longitude();
if (tmp->latitude() < minlat) minlat = tmp->latitude();
if (tmp->latitude() > maxlat) maxlat = tmp->latitude();
}
QPointF min = QPointF(minlon, minlat);
QPointF max = QPointF(maxlon, maxlat);
QPointF dist = max - min;
QSizeF si = QSizeF(dist.x(), dist.y());
 
return QRectF(min, si);
 
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/linestring.h
0,0 → 1,120
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef LINESTRING_H
#define LINESTRING_H
 
#include "curve.h"
 
namespace qmapcontrol
{
//! A collection of Point objects to describe a line
/*!
* A LineString is a Curve with linear interpolation between Points. Each consecutive pair of Points defines a Line segment.
* @author Kai Winter <kaiwinter@gmx.de>
*/
class LineString : public Curve
{
Q_OBJECT
 
public:
LineString();
//! constructor
/*!
* The constructor of a LineString takes a list of Points to form a line.
* @param points a list of points
* @param name the name of the LineString
* @param pen a QPen can be used to modify the look of the line.
* @see http://doc.trolltech.com/4.3/qpen.html
*/
LineString ( QList<Point*> const points, QString name = QString(), QPen* pen = 0 );
virtual ~LineString();
 
//! returns the points of the LineString
/*!
* @return a list with the points of the LineString
*/
QList<Point*> points();
 
//! adds a point at the end of the LineString
/*!
* @param point the point which should be added to the LineString
*/
void addPoint ( Point* point );
 
//! sets the given list as points of the LineString
/*!
* @param points the points which should be set for the LineString
*/
void setPoints ( QList<Point*> points );
 
//! returns the number of Points the LineString consists of
/*!
* @return the number of the LineString´s Points
*/
int numberOfPoints() const;
 
// virtual Geometry Clone();
virtual QRectF boundingBox();
// virtual Point EndPoint();
// virtual Point StartPoint();
// virtual Point Value();
 
//! returns true if the LineString has Childs
/*!
* This is equal to: numberOfPoints() > 0
* @return true it the LineString has Childs (=Points)
* @see clickedPoints()
*/
virtual bool hasPoints() const;
 
//! returns true if the LineString has clicked Points
/*!
* @return true if childs of a LineString were clicked
* @see clickedPoints()
*/
virtual bool hasClickedPoints() const;
 
//! returns the clicked Points
/*!
* If a LineString was clicked it could be neccessary to figure out which of its points where clicked.
* Do do so the methods hasPoints() and clickedPoints() can be used.
* When a point is added to a LineString the Point becomes its child.
* It is possible (depending on the zoomfactor) to click more than one Point of a LineString, so this method returns a list.
* @return the clicked Points of the LineString
*/
virtual QList<Geometry*> clickedPoints();
 
protected:
virtual bool Touches ( Geometry* geom, const MapAdapter* mapadapter );
virtual bool Touches ( Point* geom, const MapAdapter* mapadapter );
virtual void draw ( QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset );
 
private:
QList<Point*> vertices;
QList<Geometry*> touchedPoints;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapadapter.cpp
0,0 → 1,69
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "mapadapter.h"
namespace qmapcontrol
{
MapAdapter::MapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom, int maxZoom)
:myhost(host), serverPath(serverPath), mytilesize(tilesize), min_zoom(minZoom), max_zoom(maxZoom)
{
current_zoom = min_zoom;
loc = QLocale(QLocale::English);
}
 
MapAdapter::~MapAdapter()
{
}
 
QString MapAdapter::host() const
{
return myhost;
}
 
int MapAdapter::tilesize() const
{
return mytilesize;
}
 
int MapAdapter::minZoom() const
{
return min_zoom;
}
 
int MapAdapter::maxZoom() const
{
return max_zoom;
}
 
int MapAdapter::currentZoom() const
{
return current_zoom;
}
 
int MapAdapter::adaptedZoom() const
{
return max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapadapter.h
0,0 → 1,151
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef MAPADAPTER_H
#define MAPADAPTER_H
 
#include <QObject>
#include <QSize>
#include <QPoint>
#include <QPointF>
#include <QLocale>
#include <QDebug>
#include <cmath>
 
namespace qmapcontrol
{
//! Used to fit map servers into QMapControl
/*!
* MapAdapters are needed to convert between world- and display coordinates.
* This calculations depend on the used map projection.
* There are two ready-made MapAdapters:
* - TileMapAdapter, which is ready to use for OpenStreetMap or Google (Mercator projection)
* - WMSMapAdapter, which could be used for the most WMS-Server (some servers show errors, because of image ratio)
*
* MapAdapters are also needed to form the HTTP-Queries to load the map tiles.
* The maps from WMS Servers are also divided into tiles, because those can be better cached.
*
* @see TileMapAdapter, @see WMSMapAdapter
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class MapAdapter : public QObject
{
friend class Layer;
 
Q_OBJECT
 
public:
virtual ~MapAdapter();
 
//! returns the host of this MapAdapter
/*!
* @return the host of this MapAdapter
*/
QString host() const;
 
//! returns the size of the tiles
/*!
* @return the size of the tiles
*/
int tilesize() const;
 
//! returns the min zoom value
/*!
* @return the min zoom value
*/
int minZoom() const;
 
//! returns the max zoom value
/*!
* @return the max zoom value
*/
int maxZoom() const;
 
//! returns the current zoom
/*!
* @return the current zoom
*/
int currentZoom() const;
 
virtual int adaptedZoom()const;
 
//! translates a world coordinate to display coordinate
/*!
* The calculations also needs the current zoom. The current zoom is managed by the MapAdapter, so this is no problem.
* To divide model from view the current zoom should be moved to the layers.
* @param coordinate the world coordinate
* @return the display coordinate (in widget coordinates)
*/
virtual QPoint coordinateToDisplay(const QPointF& coordinate) const = 0;
 
//! translates display coordinate to world coordinate
/*!
* The calculations also needs the current zoom. The current zoom is managed by the MapAdapter, so this is no problem.
* To divide model from view the current zoom should be moved to the layers.
* @param point the display coordinate
* @return the world coordinate
*/
virtual QPointF displayToCoordinate(const QPoint& point) const = 0;
 
protected:
MapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom = 0, int maxZoom = 0);
virtual void zoom_in() = 0;
virtual void zoom_out() = 0;
virtual bool isValid(int x, int y, int z) const = 0;
virtual QString query(int x, int y, int z) const = 0;
 
QSize size;
QString myhost;
QString serverPath;
int mytilesize;
int min_zoom;
int max_zoom;
int current_zoom;
 
int param1;
int param2;
int param3;
int param4;
int param5;
int param6;
 
QString sub1;
QString sub2;
QString sub3;
QString sub4;
QString sub5;
QString sub6;
 
int order[3][2];
 
int middle_x;
int middle_y;
 
qreal numberOfTiles;
QLocale loc;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapcontrol.cpp
0,0 → 1,414
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "mapcontrol.h"
namespace qmapcontrol
{
MapControl::MapControl(QSize size, MouseMode mousemode)
: size(size), mymousemode(mousemode), scaleVisible(false)
{
layermanager = new LayerManager(this, size);
screen_middle = QPoint(size.width()/2, size.height()/2);
 
mousepressed = false;
 
connect(ImageManager::instance(), SIGNAL(imageReceived()),
this, SLOT(updateRequestNew()));
 
connect(ImageManager::instance(), SIGNAL(loadingFinished()),
this, SLOT(loadingFinished()));
 
this->setMaximumSize(size.width()+1, size.height()+1);
}
 
MapControl::~MapControl()
{
delete layermanager;
}
 
QPointF MapControl::currentCoordinate() const
{
return layermanager->currentCoordinate();
}
 
Layer* MapControl::layer(const QString& layername) const
{
return layermanager->layer(layername);
}
 
QList<QString> MapControl::layers() const
{
return layermanager->layers();
}
 
int MapControl::numberOfLayers() const
{
return layermanager->layers().size();
}
 
void MapControl::followGeometry(const Geometry* geom) const
{
connect(geom, SIGNAL(positionChanged(Geometry*)),
this, SLOT(positionChanged(Geometry*)));
}
 
void MapControl::positionChanged(Geometry* geom)
{
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(((Point*)geom)->coordinate());
 
QPoint step = (dest-start);
 
layermanager->scrollView(step);
 
// setView(geom);
update();
}
 
void MapControl::moveTo(QPointF coordinate)
{
target = coordinate;
steps = 25;
if (moveMutex.tryLock())
{
QTimer::singleShot(40, this, SLOT(tick()));
}
else
{
// stopMove(coordinate);
}
}
void MapControl::tick()
{
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(target);
 
QPoint step = (dest-start)/steps;
QPointF next = currentCoordinate()- step;
 
// setView(Coordinate(next.x(), next.y()));
layermanager->scrollView(step);
 
update();
steps--;
if (steps>0)
{
QTimer::singleShot(40, this, SLOT(tick()));
}
else
{
moveMutex.unlock();
}
}
 
void MapControl::paintEvent(QPaintEvent* evnt)
{
QWidget::paintEvent(evnt);
QPainter painter(this);
 
// painter.translate(150,190);
// painter.scale(0.5,0.5);
 
// painter.setClipRect(0,0, size.width(), size.height());
 
// painter.setViewport(10000000000,0,size.width(),size.height());
 
/*
// rotating
rotation = 45;
painter.translate(256,256);
painter.rotate(rotation);
painter.translate(-256,-256);
*/
 
layermanager->drawImage(&painter);
layermanager->drawGeoms(&painter);
 
// added by wolf
// draw scale
if (scaleVisible)
{
QList<double> distanceList;
distanceList<<5000000<<2000000<<1000000<<1000000<<1000000<<100000<<100000<<50000<<50000<<10000<<10000<<10000<<1000<<1000<<500<<200<<100<<50<<25;
if (currentZoom() >= 0 && distanceList.size() > currentZoom())
{
double line;
line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
 
// draw the scale
painter.setPen(Qt::black);
QPoint p1(10,size.height()-20);
QPoint p2((int)line,size.height()-20);
painter.drawLine(p1,p2);
 
painter.drawLine(10,size.height()-15, 10,size.height()-25);
painter.drawLine((int)line,size.height()-15, (int)line,size.height()-25);
 
QString distance;
if (distanceList.at(currentZoom()) >= 1000)
{
distance = QVariant( distanceList.at(currentZoom())/1000 ) .toString()+ " km";
}
else
{
distance = QVariant( distanceList.at(currentZoom()) ).toString() + " m";
}
 
painter.drawText(QPoint((int)line+10,size.height()-15), distance);
}
}
 
painter.drawLine(screen_middle.x(), screen_middle.y()-10,
screen_middle.x(), screen_middle.y()+10); // |
painter.drawLine(screen_middle.x()-10, screen_middle.y(),
screen_middle.x()+10, screen_middle.y()); // -
 
// int cross_x = int(layermanager->getMapmiddle_px().x())%256;
// int cross_y = int(layermanager->getMapmiddle_px().y())%256;
// painter.drawLine(screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+0,
// screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+256); // |
// painter.drawLine(screen_middle.x()-cross_x+0, screen_middle.y()-cross_y+cross_y,
// screen_middle.x()-cross_x+256, screen_middle.y()-cross_y+cross_y); // -
 
painter.drawRect(0,0, size.width(), size.height());
/*
// rotating
painter.setMatrix(painter.matrix().inverted());
//qt = painter.transform();
qm = painter.combinedMatrix();
*/
 
if (mousepressed && mymousemode == Dragging)
{
QRect rect = QRect(pre_click_px, current_mouse_pos);
painter.drawRect(rect);
}
emit viewChanged(currentCoordinate(), currentZoom());
}
 
// mouse events
void MapControl::mousePressEvent(QMouseEvent* evnt)
{
//rotating (experimental)
// QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
// evnt = me;
// qDebug() << "evnt: " << evnt->x() << ", " << evnt->y() << ", " << evnt->pos();
 
layermanager->mouseEvent(evnt);
 
if (layermanager->layers().size()>0)
{
if (evnt->button() == 1)
{
mousepressed = true;
pre_click_px = QPoint(evnt->x(), evnt->y());
}
else if (evnt->button() == 2 && mymousemode != None) // zoom in
{
zoomIn();
} else if (evnt->button() == 4 && mymousemode != None) // zoom out
{
zoomOut();
}
}
 
// emit(mouseEvent(evnt));
emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
}
 
void MapControl::mouseReleaseEvent(QMouseEvent* evnt)
{
mousepressed = false;
if (mymousemode == Dragging)
{
QPointF ulCoord = clickToWorldCoordinate(pre_click_px);
QPointF lrCoord = clickToWorldCoordinate(current_mouse_pos);
 
QRectF coordinateBB = QRectF(ulCoord, QSizeF( (lrCoord-ulCoord).x(), (lrCoord-ulCoord).y()));
 
emit(boxDragged(coordinateBB));
}
 
emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
}
 
void MapControl::mouseMoveEvent(QMouseEvent* evnt)
{
// emit(mouseEvent(evnt));
 
/*
// rotating
QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
evnt = me;
*/
if (mousepressed && mymousemode == Panning)
{
QPoint offset = pre_click_px - QPoint(evnt->x(), evnt->y());
layermanager->scrollView(offset);
pre_click_px = QPoint(evnt->x(), evnt->y());
}
else if (mousepressed && mymousemode == Dragging)
{
current_mouse_pos = QPoint(evnt->x(), evnt->y());
}
// emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
 
update();
// emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
}
 
QPointF MapControl::clickToWorldCoordinate(QPoint click)
{
// click coordinate to image coordinate
QPoint displayToImage= QPoint(click.x()-screen_middle.x()+layermanager->getMapmiddle_px().x(),
click.y()-screen_middle.y()+layermanager->getMapmiddle_px().y());
// image coordinate to world coordinate
return layermanager->layer()->mapadapter()->displayToCoordinate(displayToImage);
}
 
void MapControl::updateRequest(QRect rect)
{
update(rect);
}
void MapControl::updateRequestNew()
{
// qDebug() << "MapControl::updateRequestNew()";
layermanager->forceRedraw();
update();
}
// slots
void MapControl::zoomIn()
{
layermanager->zoomIn();
update();
}
void MapControl::zoomOut()
{
layermanager->zoomOut();
update();
}
void MapControl::setZoom(int zoomlevel)
{
layermanager->setZoom(zoomlevel);
update();
}
int MapControl::currentZoom() const
{
return layermanager->currentZoom();
}
void MapControl::scrollLeft(int pixel)
{
layermanager->scrollView(QPoint(-pixel,0));
update();
}
void MapControl::scrollRight(int pixel)
{
layermanager->scrollView(QPoint(pixel,0));
update();
}
void MapControl::scrollUp(int pixel)
{
layermanager->scrollView(QPoint(0,-pixel));
update();
}
void MapControl::scrollDown(int pixel)
{
layermanager->scrollView(QPoint(0,pixel));
update();
}
void MapControl::scroll(const QPoint scroll)
{
layermanager->scrollView(scroll);
update();
}
 
void MapControl::setView(const QPointF& coordinate) const
{
layermanager->setView(coordinate);
}
 
void MapControl::setView(const QList<QPointF> coordinates) const
{
layermanager->setView(coordinates);
}
 
void MapControl::setViewAndZoomIn(const QList<QPointF> coordinates) const
{
layermanager->setViewAndZoomIn(coordinates);
}
 
void MapControl::setView(const Point* point) const
{
layermanager->setView(point->coordinate());
}
 
void MapControl::loadingFinished()
{
// qDebug() << "MapControl::loadingFinished()";
layermanager->removeZoomImage();
}
void MapControl::addLayer(Layer* layer)
{
layermanager->addLayer(layer);
}
 
void MapControl::setMouseMode(MouseMode mousemode)
{
mymousemode = mousemode;
}
MapControl::MouseMode MapControl::mouseMode()
{
return mymousemode;
}
 
void MapControl::stopFollowing(Geometry* geom)
{
geom->disconnect(SIGNAL(positionChanged(Geometry*)));
}
 
void MapControl::enablePersistentCache(const QDir& path)
{
ImageManager::instance()->setCacheDir(path);
}
 
void MapControl::setProxy(QString host, int port)
{
ImageManager::instance()->setProxy(host, port);
}
 
void MapControl::showScale(bool show)
{
scaleVisible = show;
}
 
void MapControl::resize(const QSize newSize)
{
this->size = newSize;
screen_middle = QPoint(newSize.width()/2, newSize.height()/2);
 
this->setMaximumSize(newSize.width()+1, newSize.height()+1);
layermanager->resize(newSize);
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapcontrol.h
0,0 → 1,333
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef MAPCONTROL_H
#define MAPCONTROL_H
 
#include <QtGui>
 
#include "layermanager.h"
#include "layer.h"
#include "mapadapter.h"
#include "geometry.h"
#include "imagemanager.h"
 
//! QMapControl namespace
namespace qmapcontrol
{
class LayerManager;
class MapAdapter;
class Layer;
 
//! The control element of the widget and also the widget itself
/*!
* This is the main widget.
* To this control layers can be added.
* A MapControl have to be instantiated with a QSize which sets the size the widget takes in a layout.
* The given size is also the size, which is asured to be filled with map images.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class MapControl : public QWidget
{
Q_OBJECT
 
public:
//! Declares what actions the mouse move has on the map
enum MouseMode
{
Panning, /*!< The map is moved */
Dragging, /*!< A rectangular can be drawn */
None, /*!< Mouse move events have no efect to the map */
};
 
//! The constructor of MapControl
/*!
* The MapControl is the widget which displays the maps.
* The size describes the area, which gets filled with map data
* When you give no MouseMode, the mouse is moving the map.
* You can change the MouseMode on runtime, to e.g. Dragging, which lets the user drag a rectangular box.
* After the dragging a signal with the size of the box is emitted.
* The mousemode ´None´ can be used, to completely define the control of the map yourself.
* @param size the size which the widget should fill with map data
* @param mousemode the way mouseevents are handled
*/
MapControl ( QSize size, MouseMode mousemode = Panning );
 
~MapControl();
 
//! adds a layer
/*!
* If multiple layers are added, they are painted in the added order.
* @param layer the layer which should be added
*/
void addLayer ( Layer* layer );
 
//! returns the layer with the given name
/*!
* @param layername name of the wanted layer
* @return the layer with the given name
*/
Layer* layer ( const QString& layername ) const;
 
//! returns the names of all layers
/*!
* @return returns a QList with the names of all layers
*/
QList<QString> layers() const;
 
//! returns the number of existing layers
/*!
* @return returns the number of existing layers
*/
int numberOfLayers() const;
 
//! returns the coordinate of the center of the map
/*!
* @return returns the coordinate of the middle of the screen
*/
QPointF currentCoordinate() const;
 
//! returns the current zoom level
/*!
* @return returns the current zoom level
*/
int currentZoom() const;
 
//! sets the middle of the map to the given coordinate
/*!
* @param coordinate the coordinate which the view´s middle should be set to
*/
void setView ( const QPointF& coordinate ) const;
 
//! sets the view, so all coordinates are visible
/*!
* @param coordinates the Coorinates which should be visible
*/
void setView ( const QList<QPointF> coordinates ) const;
 
//! sets the view and zooms in, so all coordinates are visible
/*!
* The code of setting the view to multiple coordinates is "brute force" and pretty slow.
* Have to be reworked.
* @param coordinates the Coorinates which should be visible
*/
void setViewAndZoomIn ( const QList<QPointF> coordinates ) const;
 
//! sets the view to the given Point
/*!
*
* @param point the geometric point the view should be set to
*/
void setView ( const Point* point ) const;
 
//! Keeps the center of the map on the Geometry, even when it moves
/*!
* To stop the following the method stopFollowing() have to be called
* @param geometry the Geometry which should stay centered.
*/
void followGeometry ( const Geometry* geometry ) const;
 
//TODO:
// void followGeometry(const QList<Geometry*>) const;
 
//! Stops the following of a Geometry
/*!
* if the view is set to follow a Geometry this method stops the trace.
* See followGeometry().
* @param geometry the Geometry which should not followed anymore
*/
void stopFollowing ( Geometry* geometry );
 
//! Smoothly moves the center of the view to the given Coordinate
/*!
* @param coordinate the Coordinate which the center of the view should moved to
*/
void moveTo ( QPointF coordinate );
 
//! sets the Mouse Mode of the MapControl
/*!
* There are three MouseModes declard by an enum.
* The MouesMode Dragging draws an rectangular in the map while the MouseButton is pressed.
* When the Button is released a boxDragged() signal is emitted.
*
* The second MouseMode (the default) is Panning, which allows to drag the map around.
* @param mousemode the MouseMode
*/
void setMouseMode ( MouseMode mousemode );
 
//! returns the current MouseMode
/*!
* For a explanation for the MouseModes see setMouseMode()
* @return the current MouseMode
*/
MapControl::MouseMode mouseMode();
 
//int rotation;
 
//! Enable persistent caching of map tiles
/*!
* Call this method to allow the QMapControl widget to save map tiles
* persistent (also over application restarts).
* Tiles are stored in the subdirectory "QMapControl.cache" within the
* user's home directory. This can be changed by giving a path.
* @param path the path to the cache directory
*/
void enablePersistentCache ( const QDir& path=QDir::homePath() + "/QMapControl.cache" );
 
 
//! Sets the proxy for HTTP connections
/*!
* This method sets the proxy for HTTP connections.
* This is not provided by the current Qtopia version!
* @param host the proxy´s hostname or ip
* @param port the proxy´s port
*/
void setProxy ( QString host, int port );
 
//! Displays the scale within the widget
/*!
*
* @param show true if the scale should be displayed
*/
void showScale ( bool show );
 
private:
LayerManager* layermanager;
QPoint screen_middle; // middle of the widget (half size)
 
QPoint pre_click_px; // used for scrolling (MouseMode Panning)
QPoint current_mouse_pos; // used for scrolling and dragging (MouseMode Panning/Dragging)
 
QSize size; // size of the widget
 
bool mousepressed;
MouseMode mymousemode;
bool scaleVisible;
 
bool m_loadingFlag;
 
QMutex moveMutex; // used for method moveTo()
QPointF target; // used for method moveTo()
int steps; // used for method moveTo()
 
QPointF clickToWorldCoordinate ( QPoint click );
MapControl& operator= ( const MapControl& rhs );
MapControl ( const MapControl& old );
 
protected:
void paintEvent ( QPaintEvent* evnt );
void mousePressEvent ( QMouseEvent* evnt );
void mouseReleaseEvent ( QMouseEvent* evnt );
void mouseMoveEvent ( QMouseEvent* evnt );
 
signals:
// void mouseEvent(const QMouseEvent* evnt);
 
//! Emitted AFTER a MouseEvent occured
/*!
* This signals allows to receive click events within the MapWidget together with the world coordinate.
* It is emitted on MousePressEvents and MouseReleaseEvents.
* The kind of the event can be obtained by checking the events type.
* @param evnt the QMouseEvent that occured
* @param coordinate the corresponding world coordinate
*/
void mouseEventCoordinate ( const QMouseEvent* evnt, const QPointF coordinate );
 
//! Emitted, after a Rectangular is dragged.
/*!
* It is possible to select a rectangular area in the map, if the MouseMode is set to Dragging.
* The coordinates are in world coordinates
* @param QRectF the dragged Rect
*/
void boxDragged ( const QRectF );
 
//! This signal is emitted, when a Geometry is clicked
/*!
* @param geometry The clicked Geometry object
* @param coord_px The coordinate in pixel coordinates
*/
void geometryClicked ( Geometry* geometry, QPoint coord_px );
 
//! This signal is emitted, after the view have changed
/*!
* @param coordinate The current coordinate
* @param zoom The current zoom
*/
void viewChanged ( const QPointF &coordinate, int zoom );
 
public slots:
//! zooms in one step
void zoomIn();
 
//! zooms out one step
void zoomOut();
 
//! sets the given zoomlevel
/*!
* @param zoomlevel the zoomlevel
*/
void setZoom ( int zoomlevel );
 
//! scrolls the view to the left
void scrollLeft ( int pixel=10 );
 
//! scrolls the view to the right
void scrollRight ( int pixel=10 );
 
//! scrolls the view up
void scrollUp ( int pixel=10 );
 
//! scrolls the view down
void scrollDown ( int pixel=10 );
 
//! scrolls the view by the given point
void scroll ( const QPoint scroll );
 
//! updates the map for the given rect
/*!
* @param rect the area which should be repainted
*/
void updateRequest ( QRect rect );
 
//! updates the hole map by creating a new offscreen image
/*!
*
*/
void updateRequestNew();
 
//! Resizes the map to the given size
/*!
* @param newSize The new size
*/
void resize(const QSize newSize);
 
private slots:
void tick();
void loadingFinished();
void positionChanged ( Geometry* geom );
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/maplayer.cpp
0,0 → 1,38
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "maplayer.h"
namespace qmapcontrol
{
MapLayer::MapLayer(QString layername, MapAdapter* mapadapter, bool takeevents)
: Layer(layername, mapadapter, Layer::MapLayer, takeevents)
{
}
 
 
MapLayer::~MapLayer()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/maplayer.h
0,0 → 1,65
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef MAPLAYER_H
#define MAPLAYER_H
 
#include "layer.h"
 
namespace qmapcontrol
{
//! MapLayer class
/*!
* There are two different layer types:
* - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
* - GeometryLayer: Only displays Geometry objects.
*
* MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
* added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
* not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
* position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
* are repainted immediately on changes.
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class MapLayer : public Layer
{
Q_OBJECT
 
public:
//! MapLayer constructor
/*!
* This is used to construct a map layer.
*
* @param layername The name of the Layer
* @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
* @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
* be something like a "speed up hint"
*/
MapLayer(QString layername, MapAdapter* mapadapter, bool takeevents=true);
virtual ~MapLayer();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapnetwork.cpp
0,0 → 1,136
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "mapnetwork.h"
#include <QWaitCondition>
namespace qmapcontrol
{
MapNetwork::MapNetwork(ImageManager* parent)
:parent(parent), http(new QHttp(this)), loaded(0)
{
connect(http, SIGNAL(requestFinished(int, bool)),
this, SLOT(requestFinished(int, bool)));
}
 
MapNetwork::~MapNetwork()
{
http->clearPendingRequests();
delete http;
}
 
 
void MapNetwork::loadImage(const QString& host, const QString& url)
{
// qDebug() << "getting: " << QString(host).append(url);
// http->setHost(host);
// int getId = http->get(url);
 
http->setHost(host);
QHttpRequestHeader header("GET", url);
header.setValue("User-Agent", "Mozilla");
header.setValue("Host", host);
int getId = http->request(header);
 
if (vectorMutex.tryLock())
{
loadingMap[getId] = url;
vectorMutex.unlock();
}
}
 
void MapNetwork::requestFinished(int id, bool error)
{
// sleep(1);
// qDebug() << "MapNetwork::requestFinished" << http->state() << ", id: " << id;
if (error)
{
qDebug() << "network error: " << http->errorString();
//restart query
 
}
else if (vectorMutex.tryLock())
{
// check if id is in map?
if (loadingMap.contains(id))
{
 
QString url = loadingMap[id];
loadingMap.remove(id);
vectorMutex.unlock();
// qDebug() << "request finished for id: " << id << ", belongs to: " << notifier.url << endl;
QByteArray ax;
 
if (http->bytesAvailable()>0)
{
QPixmap pm;
ax = http->readAll();
 
if (pm.loadFromData(ax))
{
loaded += pm.size().width()*pm.size().height()*pm.depth()/8/1024;
// qDebug() << "Network loaded: " << (loaded);
parent->receivedImage(pm, url);
}
else
{
qDebug() << "NETWORK_PIXMAP_ERROR: " << ax;
}
}
 
}
else
vectorMutex.unlock();
 
}
if (loadingMap.size() == 0)
{
// qDebug () << "all loaded";
parent->loadingQueueEmpty();
}
}
 
void MapNetwork::abortLoading()
{
http->clearPendingRequests();
if (vectorMutex.tryLock())
{
loadingMap.clear();
vectorMutex.unlock();
}
}
 
bool MapNetwork::imageIsLoading(QString url)
{
return loadingMap.values().contains(url);
}
 
void MapNetwork::setProxy(QString host, int port)
{
#ifndef Q_WS_QWS
// do not set proxy on qt/extended
http->setProxy(host, port);
#endif
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/mapnetwork.h
0,0 → 1,78
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef MAPNETWORK_H
#define MAPNETWORK_H
 
#include <QObject>
#include <QDebug>
#include <QHttp>
#include <QVector>
#include <QPixmap>
#include "imagemanager.h"
/**
@author Kai Winter <kaiwinter@gmx.de>
*/
namespace qmapcontrol
{
class ImageManager;
class MapNetwork : QObject
{
Q_OBJECT
 
public:
MapNetwork(ImageManager* parent);
~MapNetwork();
 
void loadImage(const QString& host, const QString& url);
 
/*!
* checks if the given url is already loading
* @param url the url of the image
* @return boolean, if the image is already loading
*/
bool imageIsLoading(QString url);
 
/*!
* Aborts all current loading threads.
* This is useful when changing the zoom-factor, though newly needed images loads faster
*/
void abortLoading();
void setProxy(QString host, int port);
 
private:
ImageManager* parent;
QHttp* http;
QMap<int, QString> loadingMap;
qreal loaded;
QMutex vectorMutex;
MapNetwork& operator=(const MapNetwork& rhs);
MapNetwork(const MapNetwork& old);
 
private slots:
void requestFinished(int id, bool error);
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/openaerialmapadapter.cpp
0,0 → 1,37
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2009 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "openaerialmapadapter.h"
namespace qmapcontrol
{
OpenAerialMapAdapter::OpenAerialMapAdapter()
: TileMapAdapter("tile.openaerialmap.org", "/tiles/1.0.0/openaerialmap-900913/%1/%2/%3.png", 256, 0, 17)
{
}
 
OpenAerialMapAdapter::~OpenAerialMapAdapter()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/openaerialmapadapter.h
0,0 → 1,49
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2009 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef OPENAERIALMAPADAPTER_H
#define OPENAERIALMAPADAPTER_H
 
#include "tilemapadapter.h"
namespace qmapcontrol
{
//! MapAdapter for OpenStreetMap
/*!
* This is a conveniece class, which extends and configures a TileMapAdapter. Source of maps is http://www.openaerialmap.org/
* @author Kai Winter <kaiwinter@gmx.de>
*/
class OpenAerialMapAdapter : public TileMapAdapter
{
Q_OBJECT
public:
//! constructor
/*!
* This construct a OpenAerialMap Adapter
*/
OpenAerialMapAdapter();
virtual ~OpenAerialMapAdapter();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/osmmapadapter.cpp
0,0 → 1,37
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "osmmapadapter.h"
namespace qmapcontrol
{
OSMMapAdapter::OSMMapAdapter()
: TileMapAdapter("tile.openstreetmap.org", "/%1/%2/%3.png", 256, 0, 17)
{
}
 
OSMMapAdapter::~OSMMapAdapter()
{
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/osmmapadapter.h
0,0 → 1,49
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef OSMMAPADAPTER_H
#define OSMMAPADAPTER_H
 
#include "tilemapadapter.h"
namespace qmapcontrol
{
//! MapAdapter for OpenStreetMap
/*!
* This is a conveniece class, which extends and configures a TileMapAdapter
* @author Kai Winter <kaiwinter@gmx.de>
*/
class OSMMapAdapter : public TileMapAdapter
{
Q_OBJECT
public:
//! constructor
/*!
* This construct a OpenStreetmap Adapter
*/
OSMMapAdapter();
virtual ~OSMMapAdapter();
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/point.cpp
0,0 → 1,330
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "point.h"
namespace qmapcontrol
{
Point::Point()
{}
Point::Point(const Point& point)
:Geometry(point.name()), X(point.longitude()), Y(point.latitude())
{
visible = point.isVisible();
mywidget = 0;
mypixmap = 0;
mypen = point.mypen;
homelevel = -1;
minsize = QSize(-1,-1);
maxsize = QSize(-1,-1);
}
 
Point::Point(qreal x, qreal y, QString name, enum Alignment alignment)
: Geometry(name), X(x), Y(y), myalignment(alignment)
{
GeometryType = "Point";
mywidget = 0;
mypixmap = 0;
visible = true;
homelevel = -1;
minsize = QSize(-1,-1);
maxsize = QSize(-1,-1);
}
 
Point::Point(qreal x, qreal y, QWidget* widget, QString name, enum Alignment alignment)
: Geometry(name), X(x), Y(y), mywidget(widget), myalignment(alignment)
{
// Point(x, y, name, alignment);
GeometryType = "Point";
mypixmap = 0;
visible = true;
size = widget->size();
homelevel = -1;
minsize = QSize(-1,-1);
maxsize = QSize(-1,-1);
mywidget->show();
}
Point::Point(qreal x, qreal y, QPixmap* pixmap, QString name, enum Alignment alignment)
: Geometry(name), X(x), Y(y), mypixmap(pixmap), myalignment(alignment)
{
GeometryType = "Point";
mywidget = 0;
visible = true;
size = pixmap->size();
homelevel = -1;
minsize = QSize(-1,-1);
maxsize = QSize(-1,-1);
}
/*
Point& Point::operator=(const Point& rhs)
{
if (this == &rhs)
return *this;
else
{
X = rhs.X;
Y = rhs.Y;
size = rhs.size;
 
mywidget = rhs.mywidget;
mypixmap = rhs.mypixmap;
alignment = rhs.alignment;
homelevel = rhs.homelevel;
minsize = rhs.minsize;
maxsize = rhs.maxsize;
}
}
*/
Point::~Point()
{
delete mywidget;
delete mypixmap;
}
 
void Point::setVisible(bool visible)
{
this->visible = visible;
if (mywidget !=0)
{
mywidget->setVisible(visible);
}
}
 
QRectF Point::boundingBox()
{
//TODO: have to be calculated in relation to alignment...
return QRectF(QPointF(X, Y), displaysize);
}
 
qreal Point::longitude() const
{
return X;
}
qreal Point::latitude() const
{
return Y;
}
QPointF Point::coordinate() const
{
return QPointF(X, Y);
}
 
void Point::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)
{
if (!visible)
return;
 
if (homelevel > 0)
{
 
int currentzoom = mapadapter->maxZoom() < mapadapter->minZoom() ? mapadapter->minZoom() - mapadapter->currentZoom() : mapadapter->currentZoom();
 
// int currentzoom = mapadapter->getZoom();
int diffzoom = homelevel-currentzoom;
int viewheight = size.height();
int viewwidth = size.width();
viewheight = int(viewheight / pow(2, diffzoom));
viewwidth = int(viewwidth / pow(2, diffzoom));
 
if (minsize.height()!= -1 && viewheight < minsize.height())
viewheight = minsize.height();
else if (maxsize.height() != -1 && viewheight > maxsize.height())
viewheight = maxsize.height();
 
 
if (minsize.width()!= -1 && viewwidth < minsize.width())
viewwidth = minsize.width();
else if (maxsize.width() != -1 && viewwidth > maxsize.width())
viewwidth = maxsize.width();
 
 
displaysize = QSize(viewwidth, viewheight);
}
else
{
displaysize = size;
}
 
 
if (mypixmap !=0)
{
const QPointF c = QPointF(X, Y);
QPoint point = mapadapter->coordinateToDisplay(c);
 
if (viewport.contains(point))
{
QPoint alignedtopleft = alignedPoint(point);
painter->drawPixmap(alignedtopleft.x(), alignedtopleft.y(), displaysize.width(), displaysize.height(), *mypixmap);
}
 
}
else if (mywidget!=0)
{
drawWidget(mapadapter, offset);
}
 
}
 
void Point::drawWidget(const MapAdapter* mapadapter, const QPoint offset)
{
const QPointF c = QPointF(X, Y);
QPoint point = mapadapter->coordinateToDisplay(c);
point -= offset;
 
QPoint alignedtopleft = alignedPoint(point);
mywidget->setGeometry(alignedtopleft.x(), alignedtopleft.y(), displaysize.width(), displaysize.height());
}
 
QPoint Point::alignedPoint(const QPoint point) const
{
QPoint alignedtopleft;
if (myalignment == Middle)
{
alignedtopleft.setX(point.x()-displaysize.width()/2);
alignedtopleft.setY(point.y()-displaysize.height()/2);
}
else if (myalignment == TopLeft)
{
alignedtopleft.setX(point.x());
alignedtopleft.setY(point.y());
}
else if (myalignment == TopRight)
{
alignedtopleft.setX(point.x()-displaysize.width());
alignedtopleft.setY(point.y());
}
else if (myalignment == BottomLeft)
{
alignedtopleft.setX(point.x());
alignedtopleft.setY(point.y()-displaysize.height());
}
else if (myalignment == BottomRight)
{
alignedtopleft.setX(point.x()-displaysize.width());
alignedtopleft.setY(point.y()-displaysize.height());
}
return alignedtopleft;
}
 
 
bool Point::Touches(Point* p, const MapAdapter* mapadapter)
{
if (this->isVisible() == false)
return false;
if (mypixmap == 0)
return false;
 
QPointF c = p->coordinate();
// coordinate to pixel
QPoint pxOfPoint = mapadapter->coordinateToDisplay(c);
// size/2 Pixel toleranz aufaddieren
QPoint p1;
QPoint p2;
 
switch (myalignment)
{
case Middle:
p1 = pxOfPoint - QPoint(displaysize.width()/2,displaysize.height()/2);
p2 = pxOfPoint + QPoint(displaysize.width()/2,displaysize.height()/2);
break;
case TopLeft:
p1 = pxOfPoint - QPoint(displaysize.width(),displaysize.height());
p2 = pxOfPoint;
break;
case TopRight:
p1 = pxOfPoint - QPoint(0, displaysize.height());
p2 = pxOfPoint + QPoint(displaysize.width(),0);
break;
case BottomLeft:
p1 = pxOfPoint - QPoint(displaysize.width(), 0);
p2 = pxOfPoint + QPoint(0, displaysize.height());
break;
case BottomRight:
p1 = pxOfPoint;
p2 = pxOfPoint + QPoint(displaysize.width(), displaysize.height());
break;
}
 
// calculate "Bounding Box" in coordinates
QPointF c1 = mapadapter->displayToCoordinate(p1);
QPointF c2 = mapadapter->displayToCoordinate(p2);
 
 
if(this->longitude()>=c1.x() && this->longitude()<=c2.x())
{
if (this->latitude()<=c1.y() && this->latitude()>=c2.y())
{
emit(geometryClicked(this, QPoint(0,0)));
return true;
}
}
return false;
}
 
void Point::setCoordinate(QPointF point)
{
// emit(updateRequest(this));
// emit(updateRequest(QRectF(X, Y, size.width(), size.height())));
X = point.x();
Y = point.y();
// emit(updateRequest(this));
emit(updateRequest(QRectF(X, Y, size.width(), size.height())));
 
emit(positionChanged(this));
}
QList<Point*> Point::points()
{
//TODO: assigning temp?!
QList<Point*> points;
points.append(this);
return points;
}
 
QWidget* Point::widget()
{
return mywidget;
}
 
QPixmap* Point::pixmap()
{
return mypixmap;
}
 
void Point::setBaselevel(int zoomlevel)
{
homelevel = zoomlevel;
}
void Point::setMinsize(QSize minsize)
{
this->minsize = minsize;
}
void Point::setMaxsize(QSize maxsize)
{
this->maxsize = maxsize;
}
Point::Alignment Point::alignment() const
{
return myalignment;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/point.h
0,0 → 1,215
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef POINT_H
#define POINT_H
#include <QWidget>
 
#include "geometry.h"
 
namespace qmapcontrol
{
//! A geometric point to draw objects into maps
/*!
* This class can be used to draw your custom QPixmap or other QWidgets into maps.
* You can instantiate a Point with any Pixmap you want. The objects cares about collision detection (for clickable objects)
*
* When drawing a pixmap, take care you are adding the point to a GeometryLayer.
* You can also add a point to a MapLayer, but this should only be done, if the point is not changing its position or color etc.
* (GeometryLayers are assured to be repainted on any changes at the point. MapLayers only gets repainted, if a new
* offscreenImage is painter. This is a performance issue.)
*
* Points emit click events, if the containing layer receives clickevents (the default)
*
* You can also add a widget into maps. But keep in mind, that widgets always are drawn on top of all layers.
* You also have to handle click events yourself.
*
* To create "zoomable objects" (objects that increases size on zooming), a base level have to be set.
* The base level is the zoom level on which the point´s pixmap gets displayed on full size.
* On lower zoom levels it gets displayed smaller and on higher zoom levels larger.
* A minimal size can be set as well as a maximum size.
* @see setBaselevel, setMinsize, setMaxsize
*
* @author Kai Winter <kaiwinter@gmx.de>
*/
class Point : public Geometry
{
Q_OBJECT
 
public:
friend class Layer;
friend class LineString;
 
//! sets where the point should be aligned
enum Alignment
{
TopLeft, /*!< Align on TopLeft*/
TopRight, /*!< Align on TopRight*/
BottomLeft, /*!< Align on BottomLeft*/
BottomRight,/*!< Align on BottomRight*/
Middle /*!< Align on Middle*/
};
 
Point();
explicit Point(const Point&);
//! Copy Constructor
/*!
* This constructor creates a Point with no image or widget.
* @param x longitude
* @param y latitude
* @param name name of the point
* @param alignment allignment of the point (Middle or TopLeft)
*/
Point(qreal x, qreal y, QString name = QString(), enum Alignment alignment=Middle);
 
//! Constructor
/*!
* This constructor creates a point which will display the given widget.
* You can set an alignment on which corner the widget should be aligned to the coordinate.
* You have to set the size of the widget, before adding it to
* IMPORTANT: You have to set the QMapControl as parent for the widget!
* @param x longitude
* @param y latitude
* @param widget the widget which should be displayed by this point
* @param name name of the point
* @param alignment allignment of the point (Middle or TopLeft)
*/
Point(qreal x, qreal y, QWidget* widget, QString name = QString(), enum Alignment alignment = Middle);
 
//! Constructor
/*!
* This constructor creates a point which will display the give pixmap.
* You can set an alignment on which corner the pixmap should be aligned to the coordinate.
* @param x longitude
* @param y latitude
* @param pixmap the pixmap which should be displayed by this point
* @param name name of the point
* @param alignment allignment of the point (Middle or TopLeft)
*/
Point(qreal x, qreal y, QPixmap* pixmap, QString name = QString(), enum Alignment alignment = Middle);
virtual ~Point();
 
//! returns the bounding box of the point
/*!
* The Bounding contains the coordinate of the point and its size.
* The size is set, if the point contains a pixmap or a widget
* @return the bounding box of the point
*/
virtual QRectF boundingBox();
 
//! returns the longitude of the point
/*!
* @return the longitude of the point
*/
qreal longitude() const;
 
//! returns the latitude of the point
/*!
* @return the latitude of the point
*/
qreal latitude() const;
 
//! returns the coordinate of the point
/*!
* The x component of the returned QPointF is the longitude value,
* the y component the latitude
* @return the coordinate of a point
*/
QPointF coordinate() const;
 
virtual QList<Point*> points();
 
/*! \brief returns the widget of the point
@return the widget of the point
*/
QWidget* widget();
 
//! returns the pixmap of the point
/*!
* @return the pixmap of the point
*/
QPixmap* pixmap();
 
//! Sets the zoom level on which the point�s pixmap gets displayed on full size
/*!
* Use this method to set a zoom level on which the pixmap gets displayed with its real size.
* On zoomlevels below it will be displayed smaller, and on zoom levels thereover it will be displayed larger
* @see setMinsize, setMaxsize
* @param zoomlevel the zoomlevel on which the point will be displayed on full size
*/
void setBaselevel(int zoomlevel);
 
//! sets a minimal size for the pixmap
/*!
* When the point's pixmap should change its size on zooming, this method sets the minimal size.
* @see setBaselevel
* @param minsize the minimal size which the pixmap should have
*/
void setMinsize(QSize minsize);
 
//! sets a maximal size for the pixmap
/*!
* When the point´s pixmap should change its size on zooming, this method sets the maximal size.
* @see setBaselevel
* @param maxsize the maximal size which the pixmap should have
*/
void setMaxsize(QSize maxsize);
 
Point::Alignment alignment() const;
 
protected:
qreal X;
qreal Y;
QSize size;
 
QWidget* mywidget;
QPixmap* mypixmap;
Alignment myalignment;
int homelevel;
QSize displaysize;
QSize minsize;
QSize maxsize;
 
 
void drawWidget(const MapAdapter* mapadapter, const QPoint offset);
// void drawPixmap(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint versch);
virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset);
QPoint alignedPoint(const QPoint point) const;
 
//! returns true if the given Point touches this Point
/*!
* The collision detection checks for the bounding rectangulars.
* @param geom the other point which should be tested on collision
* @param mapadapter the mapadapter which is used for calculations
* @return
*/
virtual bool Touches(Point* geom, const MapAdapter* mapadapter);
 
public slots:
void setCoordinate(QPointF point);
virtual void setVisible(bool visible);
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/tilemapadapter.cpp
0,0 → 1,185
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "tilemapadapter.h"
namespace qmapcontrol
{
TileMapAdapter::TileMapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom, int maxZoom)
:MapAdapter(host, serverPath, tilesize, minZoom, maxZoom)
{
PI = acos(-1.0);
 
/*
Initialize the "substring replace engine". First the string replacement
in getQuery was made by QString().arg() but this was very slow. So this
splits the servers path into substrings and when calling getQuery the
substrings get merged with the parameters of the URL.
Pretty complicated, but fast.
*/
param1 = serverPath.indexOf("%1");
param2 = serverPath.indexOf("%2");
param3 = serverPath.indexOf("%3");
 
int min = param1 < param2 ? param1 : param2;
min = param3 < min ? param3 : min;
 
int max = param1 > param2 ? param1 : param2;
max = param3 > max ? param3 : max;
 
int middle = param1+param2+param3-min-max;
 
order[0][0] = min;
if (min == param1)
order[0][1] = 0;
else if (min == param2)
order[0][1] = 1;
else
order[0][1] = 2;
 
order[1][0] = middle;
if (middle == param1)
order[1][1] = 0;
else if (middle == param2)
order[1][1] = 1;
else
order[1][1] = 2;
 
order[2][0] = max;
if (max == param1)
order[2][1] = 0;
else if(max == param2)
order[2][1] = 1;
else
order[2][1] = 2;
 
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
numberOfTiles = tilesonzoomlevel(zoom);
loc.setNumberOptions(QLocale::OmitGroupSeparator);
}
 
TileMapAdapter::~TileMapAdapter()
{
}
//TODO: pull out
void TileMapAdapter::zoom_in()
{
if (min_zoom > max_zoom)
{
//current_zoom = current_zoom-1;
current_zoom = current_zoom > max_zoom ? current_zoom-1 : max_zoom;
}
else if (min_zoom < max_zoom)
{
//current_zoom = current_zoom+1;
current_zoom = current_zoom < max_zoom ? current_zoom+1 : max_zoom;
}
 
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
numberOfTiles = tilesonzoomlevel(zoom);
 
}
void TileMapAdapter::zoom_out()
{
if (min_zoom > max_zoom)
{
//current_zoom = current_zoom+1;
current_zoom = current_zoom < min_zoom ? current_zoom+1 : min_zoom;
}
else if (min_zoom < max_zoom)
{
//current_zoom = current_zoom-1;
current_zoom = current_zoom > min_zoom ? current_zoom-1 : min_zoom;
}
 
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
numberOfTiles = tilesonzoomlevel(zoom);
}
 
qreal TileMapAdapter::deg_rad(qreal x) const
{
return x * (PI/180.0);
}
qreal TileMapAdapter::rad_deg(qreal x) const
{
return x * (180/PI);
}
 
QString TileMapAdapter::query(int x, int y, int z) const
{
x = xoffset(x);
y = yoffset(y);
 
int a[3] = {z, x, y};
return QString(serverPath).replace(order[2][0],2, loc.toString(a[order[2][1]]))
.replace(order[1][0],2, loc.toString(a[order[1][1]]))
.replace(order[0][0],2, loc.toString(a[order[0][1]]));
 
}
 
QPoint TileMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
{
qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
qreal y = (1-(log(tan(PI/4+deg_rad(coordinate.y())/2)) /PI)) /2 * (numberOfTiles*mytilesize);
 
return QPoint(int(x), int(y));
}
 
QPointF TileMapAdapter::displayToCoordinate(const QPoint& point) const
{
qreal longitude = (point.x()*(360/(numberOfTiles*mytilesize)))-180;
qreal latitude = rad_deg(atan(sinh((1-point.y()*(2/(numberOfTiles*mytilesize)))*PI)));
 
return QPointF(longitude, latitude);
 
}
 
bool TileMapAdapter::isValid(int x, int y, int z) const
{
if (max_zoom < min_zoom)
{
z= min_zoom - z;
}
 
if (x<0 || x>pow(2,z)-1 ||
y<0 || y>pow(2,z)-1)
{
return false;
}
return true;
 
}
int TileMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
return int(pow(2, zoomlevel));
}
int TileMapAdapter::xoffset(int x) const
{
return x;
}
int TileMapAdapter::yoffset(int y) const
{
return y;
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/tilemapadapter.h
0,0 → 1,76
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef TILEMAPADAPTER_H
#define TILEMAPADAPTER_H
 
#include "mapadapter.h"
 
namespace qmapcontrol
{
//! MapAdapter for servers with image tiles
/*!
* Use this derived MapAdapter to display maps from OpenStreetMap
* @author Kai Winter <kaiwinter@gmx.de>
*/
class TileMapAdapter : public MapAdapter
{
Q_OBJECT
public:
//! constructor
/*!
* Sample of a correct initialization of a MapAdapter:<br/>
* TileMapAdapter* ta = new TileMapAdapter("192.168.8.1", "/img/img_cache.php/%1/%2/%3.png", 256, 0,17);<br/>
* The placeholders %1, %2, %3 stands for x, y, z<br/>
* The minZoom is 0 (means the whole world is visible). The maxZoom is 17 (means it is zoomed in to the max)
* @param host The servers URL
* @param serverPath The path to the tiles with placeholders
* @param tilesize the size of the tiles
* @param minZoom the minimum zoom level
* @param maxZoom the maximum zoom level
*/
TileMapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom = 0, int maxZoom = 17);
 
virtual ~TileMapAdapter();
 
virtual QPoint coordinateToDisplay(const QPointF&) const;
virtual QPointF displayToCoordinate(const QPoint&) const;
 
qreal PI;
 
protected:
qreal rad_deg(qreal) const;
qreal deg_rad(qreal) const;
 
virtual bool isValid(int x, int y, int z) const;
virtual void zoom_in();
virtual void zoom_out();
virtual QString query(int x, int y, int z) const;
virtual int tilesonzoomlevel(int zoomlevel) const;
virtual int xoffset(int x) const;
virtual int yoffset(int y) const;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/wmsmapadapter.cpp
0,0 → 1,110
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "wmsmapadapter.h"
namespace qmapcontrol
{
WMSMapAdapter::WMSMapAdapter(QString host, QString serverPath, int tilesize)
: MapAdapter(host, serverPath, tilesize, 0, 17)
{
// param1 = serverPath.indexOf("%1");
// param2 = serverPath.indexOf("%2");
// param3 = serverPath.indexOf("%3");
// param4 = serverPath.indexOf("%4");
// param5 = serverPath.indexOf("%5");
// param6 = serverPath.lastIndexOf("%5");
 
// this->serverPath = serverPath.replace(param6, 2, QString().setNum(tilesize)).replace(param5, 2, QString().setNum(tilesize));
 
// sub1 = serverPath.mid(0, param1);
// sub2 = serverPath.mid(param1+2, param2-param1-2);
// sub3 = serverPath.mid(param2+2, param3-param2-2);
// sub4 = serverPath.mid(param3+2, param4-param3-2);
// sub5 = serverPath.mid(param4+2);
 
this->serverPath.append("&WIDTH=").append(loc.toString(tilesize))
.append("&HEIGHT=").append(loc.toString(tilesize))
.append("&BBOX=");
numberOfTiles = pow(2, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
 
 
WMSMapAdapter::~WMSMapAdapter()
{
}
 
QPoint WMSMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
{
qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
qreal y = -1*(coordinate.y()-90) * (numberOfTiles*mytilesize)/180.; // coord to pixel!
return QPoint(int(x), int(y));
}
QPointF WMSMapAdapter::displayToCoordinate(const QPoint& point) const
{
qreal lon = (point.x()*(360./(numberOfTiles*mytilesize)))-180;
qreal lat = -(point.y()*(180./(numberOfTiles*mytilesize)))+90;
return QPointF(lon, lat);
}
void WMSMapAdapter::zoom_in()
{
current_zoom+=1;
numberOfTiles = pow(2, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
void WMSMapAdapter::zoom_out()
{
current_zoom-=1;
numberOfTiles = pow(2, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
 
bool WMSMapAdapter::isValid(int /*x*/, int /*y*/, int /*z*/) const
{
// if (x>0 && y>0 && z>0)
{
return true;
}
// return false;
}
QString WMSMapAdapter::query(int i, int j, int /*z*/) const
{
return getQ(-180+i*coord_per_x_tile,
90-(j+1)*coord_per_y_tile,
-180+i*coord_per_x_tile+coord_per_x_tile,
90-(j+1)*coord_per_y_tile+coord_per_y_tile);
}
QString WMSMapAdapter::getQ(qreal ux, qreal uy, qreal ox, qreal oy) const
{
return QString().append(serverPath)
.append(loc.toString(ux)).append(",")
.append(loc.toString(uy)).append(",")
.append(loc.toString(ox)).append(",")
.append(loc.toString(oy));
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/wmsmapadapter.h
0,0 → 1,70
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef WMSMAPADAPTER_H
#define WMSMAPADAPTER_H
 
#include "mapadapter.h"
 
namespace qmapcontrol
{
//! MapAdapter for WMS servers
/*!
* Use this derived MapAdapter to display maps from WMS servers
* @author Kai Winter <kaiwinter@gmx.de>
*/
class WMSMapAdapter : public MapAdapter
{
public:
//! constructor
/*!
* Sample of a correct initialization of a MapAdapter:<br/>
* MapAdapter* mapadapter = new WMSMapAdapter("www2.demis.nl", "/wms/wms.asp?wms=WorldMap[...]&BBOX=%1,%2,%3,%4&WIDTH=%5&HEIGHT=%5&TRANSPARENT=TRUE", 256);<br/>
* The placeholders %1, %2, %3, %4 creates the bounding box, %5 is for the tilesize
* The minZoom is 0 (means the whole world is visible). The maxZoom is 17 (means it is zoomed in to the max)
* @param host The servers URL
* @param serverPath The path to the tiles with placeholders
* @param tilesize the size of the tiles
*/
WMSMapAdapter(QString host, QString serverPath, int tilesize = 256);
virtual ~WMSMapAdapter();
 
virtual QPoint coordinateToDisplay(const QPointF&) const;
virtual QPointF displayToCoordinate(const QPoint&) const;
 
protected:
virtual void zoom_in();
virtual void zoom_out();
virtual QString query(int x, int y, int z) const;
virtual bool isValid(int x, int y, int z) const;
 
private:
virtual QString getQ(qreal ux, qreal uy, qreal ox, qreal oy) const;
 
qreal coord_per_x_tile;
qreal coord_per_y_tile;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/yahoomapadapter.cpp
0,0 → 1,63
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#include "yahoomapadapter.h"
namespace qmapcontrol
{
YahooMapAdapter::YahooMapAdapter()
: TileMapAdapter("png.maps.yimg.com", "/png?v=3.1.0&x=%2&y=%3&z=%1", 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
numberOfTiles = pow(2, zoom+1);
}
YahooMapAdapter::YahooMapAdapter(QString host, QString url)
: TileMapAdapter(host, url, 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
numberOfTiles = pow(2, zoom+1);
}
YahooMapAdapter::~YahooMapAdapter()
{
}
 
bool YahooMapAdapter::isValid(int /*x*/, int /*y*/, int /*z*/) const
{
return true;
}
 
int YahooMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
return int(pow(2, zoomlevel+1));
}
 
int YahooMapAdapter::yoffset(int y) const
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
 
int tiles = int(pow(2, zoom));
y = y*(-1)+tiles-1;
return int(y);
}
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl/yahoomapadapter.h
0,0 → 1,56
/*
*
* This file is part of QMapControl,
* an open-source cross-platform map widget
*
* Copyright (C) 2007 - 2008 Kai Winter
*
* This program 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 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: kaiwinter@gmx.de
* Program URL : http://qmapcontrol.sourceforge.net/
*
*/
 
#ifndef YAHOOMAPADAPTER_H
#define YAHOOMAPADAPTER_H
 
#include "tilemapadapter.h"
 
namespace qmapcontrol
{
//! MapAdapter for Yahoo Maps
/*!
* @author Kai Winter <kaiwinter@gmx.de>
*/
class YahooMapAdapter : public TileMapAdapter
{
Q_OBJECT
 
public:
//! constructor
/*!
* This construct a Yahoo Adapter
*/
YahooMapAdapter();
YahooMapAdapter(QString host, QString url);
virtual ~YahooMapAdapter();
bool isValid(int x, int y, int z) const;
 
protected:
virtual int tilesonzoomlevel(int zoomlevel) const;
virtual int yoffset(int y) const;
};
}
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/ManageSerialPort.cpp
0,0 → 1,577
/********************************************************************************************************
* PROGRAM : QSerialPortTerminal
* DATE - TIME : vendredi 03 octobre 2008 - 11h15
* AUTHOR : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
* FILENAME : ManageSerialPort.cpp
* LICENSE : GPL
* COMMENTARY :
********************************************************************************************************/
#include <QtDebug>
#include "ManageSerialPort.h"
 
/********************************************************************************************************
* Classe ManageSerialPort
*****************************************************************************************************/
 
//Constructeur
ManageSerialPort::ManageSerialPort()
{
//Init pointeur a NULL
threadSend = NULL;
threadReceive = NULL;
//Init des bool
sendingEnabled = false;
receivingEnabled = false;
closeCalled = false;
saveStateSendEnabled = false;
saveStateReceivedEnabled = false;
saveStateReceiveData = false;
}
 
ManageSerialPort::ManageSerialPort(const QString &name, const BaudRateType baudRate, \
const DataBitsType dataBits, const ParityType parity, \
const StopBitsType stopBits, const FlowType flowControl, \
ulong seconds, ulong milliseconds)
{
//Init pointeur a NULL
threadSend = NULL;
threadReceive = NULL;
//Init des bool
sendingEnabled = false;
receivingEnabled = false;
closeCalled = false;
saveStateSendEnabled = false;
saveStateReceivedEnabled = false;
saveStateReceiveData = false;
setPort(name);
setBaudRate(baudRate);
setDataBits(dataBits);
setParity(parity);
setStopBits(stopBits);
setFlowControl(flowControl);
setTimeout(seconds, milliseconds);
}
 
//Destructeur
ManageSerialPort::~ManageSerialPort()
{
if (threadSend != NULL)
{
delete threadSend;
threadSend = NULL;
}
if (threadReceive != NULL)
{
delete threadReceive;
threadReceive = NULL;
}
if (isOpen())
extSerialPort.close();
}
 
bool ManageSerialPort::open()
{
bool res = extSerialPort.open(QIODevice::ReadWrite);
if (closeCalled)
{
if (saveStateSendEnabled)
enableSending();
if (saveStateReceivedEnabled)
enableReceiving();
if (saveStateReceiveData)
receiveData();
closeCalled = false;
}
return res;
}
 
bool ManageSerialPort::open(const QString &name, const BaudRateType baudRate, \
const DataBitsType dataBits,const ParityType parity, \
const StopBitsType stopBits, const FlowType flowControl, \
ulong seconds, ulong milliseconds)
{
setPort(name);
setBaudRate(baudRate);
setDataBits(dataBits);
setParity(parity);
setStopBits(stopBits);
setFlowControl(flowControl);
setTimeout(seconds, milliseconds);
bool res = extSerialPort.open(QIODevice::ReadWrite);
return res;
}
 
bool ManageSerialPort::isOpen()
{
return extSerialPort.isOpen();
}
 
void ManageSerialPort::close()
{
closeCalled = true;
saveStateSendEnabled = isSendingEnabled();
saveStateReceivedEnabled = isReceivingEnabled();
disableSending();
disableReceiving();
extSerialPort.close();
}
 
void ManageSerialPort::setPort(const QString &name)
{
extSerialPort.setPortName(name);
}
 
QString ManageSerialPort::getPort()
{
return extSerialPort.portName();
}
 
 
void ManageSerialPort::setBaudRate(const BaudRateType baudRate)
{
extSerialPort.setBaudRate(baudRate);
}
 
QString ManageSerialPort::getBaudRate()
{
switch (extSerialPort.baudRate())
{
case BAUD50:
return QString("50");
case BAUD75:
return QString("75");
case BAUD110:
return QString("110");
case BAUD134:
return QString("134");
case BAUD150:
return QString("150");
case BAUD200:
return QString("200");
case BAUD300:
return QString("300");
case BAUD600:
return QString("600");
case BAUD1200:
return QString("1200");
case BAUD1800:
return QString("1800");
case BAUD2400:
return QString("2400");
case BAUD4800:
return QString("4800");
case BAUD9600:
return QString("9600");
case BAUD14400:
return QString("14400");
case BAUD19200:
return QString("19200");
case BAUD38400:
return QString("38400");
case BAUD56000:
return QString("56000");
case BAUD57600:
return QString("57600");
case BAUD76800:
return QString("76800");
case BAUD115200:
return QString("115200");
case BAUD128000:
return QString("128000");
case BAUD256000:
return QString("256000");
}
return 0;
}
 
 
void ManageSerialPort::setDataBits(const DataBitsType dataBits)
{
extSerialPort.setDataBits(dataBits);
}
 
QChar ManageSerialPort::getDataBits()
{
switch (extSerialPort.dataBits())
{
case DATA_5:
return QChar('5');
case DATA_6:
return QChar('6');
case DATA_7:
return QChar('7');
case DATA_8:
return QChar('8');
}
return 0;
}
 
 
void ManageSerialPort::setParity(const ParityType parity)
{
extSerialPort.setParity(parity);
}
 
QString ManageSerialPort::getParity()
{
switch (extSerialPort.parity())
{
case PAR_NONE:
return QString(tr("None"));
case PAR_ODD:
return QString(tr("Odd"));
case PAR_EVEN:
return QString(tr("Even"));
case PAR_MARK:
return QString(tr("Mark"));
case PAR_SPACE:
return QString(tr("Space"));
}
return 0;
}
 
 
void ManageSerialPort::setStopBits(const StopBitsType stopBits)
{
extSerialPort.setStopBits(stopBits);
}
 
QString ManageSerialPort::getStopBit()
{
switch (extSerialPort.stopBits())
{
case STOP_1:
return QString("1");
case STOP_1_5:
return QString("1.5");
case STOP_2:
return QString("2");
}
return 0;
}
 
 
void ManageSerialPort::setFlowControl(const FlowType flowControl)
{
extSerialPort.setFlowControl(flowControl);
}
 
QString ManageSerialPort::getFlowControl()
{
switch (extSerialPort.flowControl())
{
case FLOW_OFF:
return QString(tr("None"));
case FLOW_HARDWARE :
return QString(tr("Hardware"));
case FLOW_XONXOFF :
return QString(tr("Xon/Xoff"));
}
return 0;
}
 
 
void ManageSerialPort::setTimeout(ulong seconds, ulong milliseconds)
{
extSerialPort.setTimeout(seconds,milliseconds);
}
 
/*
QString ManageSerialPort::getLastErrorToString()
{
ulong res = extSerialPort.lastError();
switch (res)
{
case E_NO_ERROR:
return QString(tr("No Error has occured"));
case E_INVALID_FD:
return QString(tr("Invalid file descriptor (port was not opened correctly)"));
case E_NO_MEMORY:
return QString(tr("Unable to allocate memory tables (POSIX)"));
case E_CAUGHT_NON_BLOCKED_SIGNAL:
return QString(tr("Caught a non-blocked signal (POSIX)"));
case E_PORT_TIMEOUT:
return QString(tr("Operation timed out (POSIX)"));
case E_INVALID_DEVICE:
return QString(tr("The file opened by the port is not a character device (POSIX)"));
case E_BREAK_CONDITION:
return QString(tr("The port detected a break condition"));
case E_FRAMING_ERROR:
return QString(tr("The port detected a framing error (usually caused by incorrect baud rate settings)"));
case E_IO_ERROR:
return QString(tr("There was an I/O error while communicating with the port"));
case E_BUFFER_OVERRUN:
return QString(tr("Character buffer overrun"));
case E_RECEIVE_OVERFLOW:
return QString(tr("Receive buffer overflow"));
case E_RECEIVE_PARITY_ERROR:
return QString(tr("The port detected a parity error in the received data"));
case E_TRANSMIT_OVERFLOW:
return QString(tr("Transmit buffer overflow"));
case E_READ_FAILED:
return QString(tr("General read operation failure"));
case E_WRITE_FAILED:
return QString(tr("General write operation failure"));
}
return 0;
}*/
 
/*
ulong ManageSerialPort::getLastError()
{
return extSerialPort.lastError();
}
*/
 
 
void ManageSerialPort::enableSending()
{
if (!sendingEnabled && threadSend == NULL) //Si l'envoi n'est pas active && si threadSend n'est pas alloue
{
threadSend = new ThreadSend(extSerialPort);
sendingEnabled = true;
}
}
 
void ManageSerialPort::disableSending()
{
if (sendingEnabled && threadSend != NULL) //Si l'envoi est active && si threadSend est alloue
{
delete (threadSend);
threadSend = NULL;
sendingEnabled = false;
}
}
 
bool ManageSerialPort::isSendingEnabled()
{
return sendingEnabled;
}
 
uchar ManageSerialPort::sendData(QByteArray &dataToSend)
{
if (!isOpen()) //Si le port n'est pas ouvert
return 2;
if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas alloue
return 3;
threadSend->addDataToSend(dataToSend); //Ajout des donnees a envoyer
return 1;
}
 
void ManageSerialPort::stopSending()
{
if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas été alloue
return;
if (threadSend->isRunning()) //si un envoi est en cour
{
threadSend->stopSending(); //on donne l'ordre d'arreter l'envoi
 
long tmp = ULONG_MAX;
threadSend->wait(tmp); //on attend l'arret
}
}
 
 
 
void ManageSerialPort::enableReceiving()
{
if (!receivingEnabled && threadReceive == NULL) //Si la reception n'est pas active && si threadReceive n'est pas alloue
{
threadReceive = new ThreadReceive(extSerialPort);
connect(threadReceive, SIGNAL(newDataReceived(const QByteArray &)), this, SIGNAL(newDataReceived(const QByteArray &)));
receivingEnabled = true;
}
}
 
void ManageSerialPort::disableReceiving()
{
if (receivingEnabled && threadReceive != NULL) //Si la reception est pas active && si threadReceive est alloue
{
delete (threadReceive);
threadReceive = NULL;
receivingEnabled = false;
}
}
 
bool ManageSerialPort::isReceivingEnabled()
{
return receivingEnabled;
}
 
uchar ManageSerialPort::receiveData()
{
if (!isOpen()) //Si le port n'est pas ouvert
return 2;
if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas été alloue
return 3;
if (!threadReceive->isRunning())
{
saveStateReceiveData = true;
threadReceive->start(); //Demarrage du thread de reception
}
return 1;
}
 
void ManageSerialPort::stopReceiving()
{
if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas alloue
return;
if (threadReceive->isRunning()) //Si le thread de reception est en fonctionnement
{
saveStateReceiveData = false;
threadReceive->stopReceiving(); //on donne l'ordre d'arreter la reception
 
long tmp = ULONG_MAX;
threadReceive->wait(tmp); //on attend l'arret
}
}
 
 
 
 
 
 
 
 
 
 
 
/********************************************************************************************************
* Classe ThreadSend
*****************************************************************************************************/
 
ThreadSend::ThreadSend(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
{
dataToSend.clear();
stopped=false;
}
 
ThreadSend::~ThreadSend()
{
if (isRunning())
{
stopSending();
wait();
}
}
 
 
void ThreadSend::addDataToSend(QByteArray &dataToAdd)
{
QMutexLocker locker(&mutexSend);
for (int i=0; i<dataToAdd.size(); i++)
dataToSend.enqueue(QByteArray(1,dataToAdd.at(i)));
if (!isRunning())
start();
}
 
void ThreadSend::stopSending()
{
stopped=true;
}
 
void ThreadSend::run()
{
QByteArray byteArray;
forever
{
if (dataToSend.isEmpty() || stopped)
{
stopped = false;
break;
}
mutexSend.lock();
byteArray = dataToSend.dequeue();
mutexSend.unlock();
extSerialPort.write(byteArray, 1);
}
}
 
 
 
 
 
/********************************************************************************************************
* Classe ThreadReceive - A TERMINER
*****************************************************************************************************/
 
ThreadReceive::ThreadReceive(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
{
stopped=false;
}
 
ThreadReceive::~ThreadReceive()
{
if (isRunning())
{
stopReceiving();
wait();
}
}
 
void ThreadReceive::stopReceiving()
{
stopped = true;
}
 
void ThreadReceive::run()
{
int numBytes=0;
char data[1024];
QByteArray dataReceived;
forever
{
if (stopped)
{
stopped = false;
break;
}
 
mutexReceive.lock();
 
numBytes = extSerialPort.bytesAvailable();
if (numBytes > 0)
{
extSerialPort.read(data, numBytes);
 
for (int xy=1; xy < numBytes; xy++)
{
if (data[xy] == 0)
{
data[xy] = 'a';
}
}
 
data[numBytes]='\0';
dataReceived = data;
emit newDataReceived(dataReceived);
}
mutexReceive.unlock();
}
}
 
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/ManageSerialPort.h
0,0 → 1,324
/********************************************************************************************************
* PROGRAM : QSerialPortTerminal
* DATE - TIME : vendredi 03 octobre 2008 - 11h15
* AUTHOR : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
* FILENAME : ManageSerialPort.h
* LICENSE : GPL
* COMMENTARY : Manage qExtSerialPort
********************************************************************************************************/
#ifndef MANAGESERIALPORT_H
#define MANAGESERIALPORT_H
 
#include <QThread>
#include <QQueue>
#include <QMetaType>
#include <QMutex>
#include "qextserialport.h"
 
Q_DECLARE_METATYPE(BaudRateType);
Q_DECLARE_METATYPE(DataBitsType);
Q_DECLARE_METATYPE(ParityType);
Q_DECLARE_METATYPE(StopBitsType);
Q_DECLARE_METATYPE(FlowType);
 
class ThreadSend;
class ThreadReceive;
 
 
class ManageSerialPort : public QObject
{
Q_OBJECT
 
public:
//Constructeurs + destructeur
ManageSerialPort();
ManageSerialPort(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
const ParityType parity, const StopBitsType stopBits, \
const FlowType flowControl, ulong seconds, ulong milliseconds);
~ManageSerialPort();
 
//General
bool open();
bool open(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
const ParityType parity, const StopBitsType stopBits, \
const FlowType flowControl, ulong seconds, ulong milliseconds);
bool isOpen();
void close();
 
//Sets the name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0"
void setPort(const QString &name);
QString getPort();
 
/*Most used : '*' (POSTX & Windows)
RATE Windows Speed POSIX Speed
----------- ------------- -----------
enum BaudRateType{
BAUD50 110 50 //POSIX ONLY
BAUD75 110 75 //POSIX ONLY
*BAUD110 110 110
BAUD134 110 134.5 //POSIX ONLY
BAUD150 110 150 //POSIX ONLY
BAUD200 110 200 //POSIX ONLY
*BAUD300 300 300
*BAUD600 600 600
*BAUD1200 1200 1200
BAUD1800 1200 1800 //POSIX ONLY
*BAUD2400 2400 2400
*BAUD4800 4800 4800
*BAUD9600 9600 9600
BAUD14400 14400 9600 //WINDOWS ONLY
*BAUD19200 19200 19200
*BAUD38400 38400 38400
BAUD56000 56000 38400 //WINDOWS ONLY
*BAUD57600 57600 57600
BAUD76800 57600 76800 //POSIX ONLY
*BAUD115200 115200 115200
BAUD128000 128000 115200 //WINDOWS ONLY
BAUD256000 256000 115200 //WINDOWS ONLY
}*/
void setBaudRate(const BaudRateType baudRate);
 
/*getBaudRate
return "50";
return "75";
return "110";
return "134";
return "150";
return "200";
return "300";
return "600";
return "1200";
return "1800";
return "2400";
return "4800";
return "9600";
return "14400";
return "19200";
return "38400";
return "56000";
return "57600";
return "76800";
return "115200";
return "128000";
return "256000";*/
QString getBaudRate();
 
 
/*enum DataBitsType {
DATA_5
DATA_6
DATA_7
DATA_8
};*/
void setDataBits(const DataBitsType dataBits);
 
/*getDataBits
return '5';
return '6';
return '7';
return '8';*/
QChar getDataBits();
 
 
/*enum ParityType {
PAR_NONE //None means that no parity bit is sent at all
PAR_ODD //Odd
PAR_EVEN //Even
PAR_MARK //Windows only : Mark parity means that the parity bit is always set to the mark signal condition (logical 1)
PAR_SPACE //Space parity always sends the parity bit in the space signal condition
};*/
void setParity(const ParityType parity);
 
/*getParity
return "None";
return "Odd";
return "Even";
return "Mark"; Windows only
return "Space";*/
QString getParity();
 
 
/*enum StopBitsType {
STOP_1
STOP_1_5 //WINDOWS ONLY
STOP_2
};*/
void setStopBits(const StopBitsType stopBits);
 
/*getStopBit
return "1"
return "1.5"
return "2"*/
QString getStopBit();
 
 
/*enum FlowType {
FLOW_OFF
FLOW_HARDWARE
FLOW_XONXOFF
};*/
void setFlowControl(const FlowType flowControl);
 
/*getFlowControl
return "None"
return "Hardware"
return "Xon/Xoff"*/
QString getFlowControl();
 
 
void setTimeout(ulong seconds, ulong milliseconds);
 
/*getLastErrorToString
return "No Error has occured"
return "Invalid file descriptor (port was not opened correctly)"
return "Unable to allocate memory tables (POSIX)"
return "Caught a non-blocked signal (POSIX)"
return "Operation timed out (POSIX)"
return "The file opened by the port is not a character device (POSIX)"
return "The port detected a break condition"
return "The port detected a framing error (usually caused by incorrect baud rate settings)"
 
return "There was an I/O error while communicating with the port"
return "Character buffer overrun"
return "Receive buffer overflow"
return "The port detected a parity error in the received data"
return "Transmit buffer overflow"
return "General read operation failure"
return "General write operation failure"*/
/*QString getLastErrorToString();*/
 
/*getLastError
return 0 : No Error has occured
return 1 : Invalid file descriptor (port was not opened correctly)
return 2 : Unable to allocate memory tables (POSIX)
return 3 : Caught a non-blocked signal (POSIX)
return 4 : Operation timed out (POSIX)
return 5 : The file opened by the port is not a character device (POSIX)
return 6 : The port detected a break condition"
return 7 : The port detected a framing error (usually caused by incorrect baud rate settings)
 
return 8 : There was an I/O error while communicating with the port
return 9 : Character buffer overrun
return 10 : Receive buffer overflow
return 11 : The port detected a parity error in the received data
return 12 : Transmit buffer overflow
return 13 : General read operation failure
return 14 : General write operation failure*/
/*ulong getLastError();*/
 
 
 
//Emission
void enableSending();
void disableSending();
 
/*isSendingEnabled
return 0 : sending is not enable
return 1 : sending is enable*/
bool isSendingEnabled();
 
/*sendData
return 1 : add OK
return 2 : port is not open
return 3 : sending is not enable*/
uchar sendData(QByteArray &dataToSend);
 
void stopSending();
 
//Reception
void enableReceiving();
void disableReceiving();
 
/*isReceivingEnabled
return 0 : receiving is not enable
return 1 : receiving is enable*/
bool isReceivingEnabled();
 
/*receiveData
return 1 : start thread OK
return 2 : port is not open
return 3 : receiving is not enable*/
uchar receiveData();
 
void stopReceiving();
 
signals:
void newDataReceived(const QByteArray &dataReceived);
 
private:
//Variables privees
QextSerialPort extSerialPort;
ThreadSend *threadSend;
ThreadReceive *threadReceive;
 
bool sendingEnabled;
bool receivingEnabled;
 
bool closeCalled;
bool saveStateSendEnabled;
bool saveStateReceivedEnabled;
bool saveStateReceiveData;
 
};
 
//#endif // MANAGESERIALPORT_H
 
 
 
 
 
 
 
 
 
class ThreadSend : public QThread
{
Q_OBJECT
 
public:
ThreadSend(QextSerialPort &addressSerialPort);
~ThreadSend();
void addDataToSend(QByteArray &dataToAdd);
void stopSending();
 
protected:
void run();
 
private:
QMutex mutexSend;
QextSerialPort &extSerialPort;
QQueue<QByteArray> dataToSend;
bool stopped;
};
 
 
 
 
 
 
 
 
 
 
class ThreadReceive : public QThread
{
Q_OBJECT
 
public:
ThreadReceive(QextSerialPort &addressSerialPort);
~ThreadReceive();
void stopReceiving();
 
protected:
void run();
 
private :
QMutex mutexReceive;
QextSerialPort &extSerialPort;
bool stopped;
 
signals:
void newDataReceived(const QByteArray &dataReceived);
};
 
#endif // MANAGESERIALPORT_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/posix_qextserialport.cpp
0,0 → 1,1114
 
/*!
\class Posix_QextSerialPort
\version 1.0.0
\author Stefan Sander
 
A cross-platform serial port class.
This class encapsulates the POSIX portion of QextSerialPort. The user will be notified of errors
and possible portability conflicts at run-time by default - this behavior can be turned off by
defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off portability
warnings) in the project. Note that _TTY_NOWARN_ will also turn off portability warnings.
*/
 
#include <stdio.h>
#include "posix_qextserialport.h"
 
/*!
\fn Posix_QextSerialPort::Posix_QextSerialPort()
Default constructor. Note that the name of the device used by a QextSerialPort constructed with
this constructor will be determined by #defined constants, or lack thereof - the default behavior
is the same as _TTY_LINUX_. Possible naming conventions and their associated constants are:
 
\verbatim
 
Constant Used By Naming Convention
---------- ------------- ------------------------
_TTY_WIN_ Windows COM1, COM2
_TTY_IRIX_ SGI/IRIX /dev/ttyf1, /dev/ttyf2
_TTY_HPUX_ HP-UX /dev/tty1p0, /dev/tty2p0
_TTY_SUN_ SunOS/Solaris /dev/ttya, /dev/ttyb
_TTY_DIGITAL_ Digital UNIX /dev/tty01, /dev/tty02
_TTY_FREEBSD_ FreeBSD /dev/ttyd0, /dev/ttyd1
_TTY_LINUX_ Linux /dev/ttyS0, /dev/ttyS1
<none> Linux /dev/ttyS0, /dev/ttyS1
\endverbatim
 
This constructor assigns the device name to the name of the first port on the specified system.
See the other constructors if you need to open a different port.
*/
Posix_QextSerialPort::Posix_QextSerialPort()
: QextSerialBase()
{
Posix_File=new QFile();
}
 
/*!
\fn Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort&)
Copy constructor.
*/
Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort& s)
: QextSerialBase(s.port)
{
setOpenMode(s.openMode());
port = s.port;
Settings.BaudRate=s.Settings.BaudRate;
Settings.DataBits=s.Settings.DataBits;
Settings.Parity=s.Settings.Parity;
Settings.StopBits=s.Settings.StopBits;
Settings.FlowControl=s.Settings.FlowControl;
lastErr=s.lastErr;
Posix_File=new QFile();
Posix_File=s.Posix_File;
memcpy(&Posix_Timeout, &s.Posix_Timeout, sizeof(struct timeval));
memcpy(&Posix_Copy_Timeout, &s.Posix_Copy_Timeout, sizeof(struct timeval));
memcpy(&Posix_CommConfig, &s.Posix_CommConfig, sizeof(struct termios));
}
 
/*!
\fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
Constructs a serial port attached to the port specified by name.
name is the name of the device, which is windowsystem-specific,
e.g."COM1" or "/dev/ttyS0".
*/
Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
: QextSerialBase(name)
{
Posix_File=new QFile();
}
 
/*!
\fn Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
Constructs a port with default name and specified settings.
*/
Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
: QextSerialBase()
{
setBaudRate(settings.BaudRate);
setDataBits(settings.DataBits);
setParity(settings.Parity);
setStopBits(settings.StopBits);
setFlowControl(settings.FlowControl);
Posix_File=new QFile();
setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}
 
/*!
\fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
Constructs a port with specified name and settings.
*/
Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
: QextSerialBase(name)
{
setBaudRate(settings.BaudRate);
setDataBits(settings.DataBits);
setParity(settings.Parity);
setStopBits(settings.StopBits);
setFlowControl(settings.FlowControl);
Posix_File=new QFile();
setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}
 
/*!
\fn Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
Override the = operator.
*/
Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
{
setOpenMode(s.openMode());
port = s.port;
Settings.BaudRate=s.Settings.BaudRate;
Settings.DataBits=s.Settings.DataBits;
Settings.Parity=s.Settings.Parity;
Settings.StopBits=s.Settings.StopBits;
Settings.FlowControl=s.Settings.FlowControl;
lastErr=s.lastErr;
Posix_File=s.Posix_File;
memcpy(&Posix_Timeout, &(s.Posix_Timeout), sizeof(struct timeval));
memcpy(&Posix_Copy_Timeout, &(s.Posix_Copy_Timeout), sizeof(struct timeval));
memcpy(&Posix_CommConfig, &(s.Posix_CommConfig), sizeof(struct termios));
return *this;
}
 
/*!
\fn Posix_QextSerialPort::~Posix_QextSerialPort()
Standard destructor.
*/
Posix_QextSerialPort::~Posix_QextSerialPort()
{
if (isOpen()) {
close();
}
Posix_File->close();
delete Posix_File;
}
 
/*!
\fn void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
Sets the baud rate of the serial port. Note that not all rates are applicable on
all platforms. The following table shows translations of the various baud rate
constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an *
are speeds that are usable on both Windows and POSIX.
 
\note
BAUD76800 may not be supported on all POSIX systems. SGI/IRIX systems do not support
BAUD1800.
 
\verbatim
 
RATE Windows Speed POSIX Speed
----------- ------------- -----------
BAUD50 110 50
BAUD75 110 75
*BAUD110 110 110
BAUD134 110 134.5
BAUD150 110 150
BAUD200 110 200
*BAUD300 300 300
*BAUD600 600 600
*BAUD1200 1200 1200
BAUD1800 1200 1800
*BAUD2400 2400 2400
*BAUD4800 4800 4800
*BAUD9600 9600 9600
BAUD14400 14400 9600
*BAUD19200 19200 19200
*BAUD38400 38400 38400
BAUD56000 56000 38400
*BAUD57600 57600 57600
BAUD76800 57600 76800
*BAUD115200 115200 115200
BAUD128000 128000 115200
BAUD256000 256000 115200
\endverbatim
*/
void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
{
LOCK_MUTEX();
if (Settings.BaudRate!=baudRate) {
switch (baudRate) {
case BAUD14400:
Settings.BaudRate=BAUD9600;
break;
case BAUD56000:
Settings.BaudRate=BAUD38400;
break;
case BAUD76800:
#ifndef B76800
Settings.BaudRate=BAUD57600;
#else
Settings.BaudRate=baudRate;
#endif
break;
case BAUD128000:
case BAUD256000:
Settings.BaudRate=BAUD115200;
break;
default:
Settings.BaudRate=baudRate;
break;
}
}
if (isOpen()) {
switch (baudRate) {
/*50 baud*/
case BAUD50:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 50 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B50;
#else
cfsetispeed(&Posix_CommConfig, B50);
cfsetospeed(&Posix_CommConfig, B50);
#endif
break;
/*75 baud*/
case BAUD75:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 75 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B75;
#else
cfsetispeed(&Posix_CommConfig, B75);
cfsetospeed(&Posix_CommConfig, B75);
#endif
break;
/*110 baud*/
case BAUD110:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B110;
#else
cfsetispeed(&Posix_CommConfig, B110);
cfsetospeed(&Posix_CommConfig, B110);
#endif
break;
/*134.5 baud*/
case BAUD134:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 134.5 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B134;
#else
cfsetispeed(&Posix_CommConfig, B134);
cfsetospeed(&Posix_CommConfig, B134);
#endif
break;
/*150 baud*/
case BAUD150:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 150 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B150;
#else
cfsetispeed(&Posix_CommConfig, B150);
cfsetospeed(&Posix_CommConfig, B150);
#endif
break;
/*200 baud*/
case BAUD200:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 200 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B200;
#else
cfsetispeed(&Posix_CommConfig, B200);
cfsetospeed(&Posix_CommConfig, B200);
#endif
break;
/*300 baud*/
case BAUD300:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B300;
#else
cfsetispeed(&Posix_CommConfig, B300);
cfsetospeed(&Posix_CommConfig, B300);
#endif
break;
/*600 baud*/
case BAUD600:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B600;
#else
cfsetispeed(&Posix_CommConfig, B600);
cfsetospeed(&Posix_CommConfig, B600);
#endif
break;
/*1200 baud*/
case BAUD1200:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B1200;
#else
cfsetispeed(&Posix_CommConfig, B1200);
cfsetospeed(&Posix_CommConfig, B1200);
#endif
break;
/*1800 baud*/
case BAUD1800:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and IRIX do not support 1800 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B1800;
#else
cfsetispeed(&Posix_CommConfig, B1800);
cfsetospeed(&Posix_CommConfig, B1800);
#endif
break;
/*2400 baud*/
case BAUD2400:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B2400;
#else
cfsetispeed(&Posix_CommConfig, B2400);
cfsetospeed(&Posix_CommConfig, B2400);
#endif
break;
/*4800 baud*/
case BAUD4800:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B4800;
#else
cfsetispeed(&Posix_CommConfig, B4800);
cfsetospeed(&Posix_CommConfig, B4800);
#endif
break;
/*9600 baud*/
case BAUD9600:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B9600;
#else
cfsetispeed(&Posix_CommConfig, B9600);
cfsetospeed(&Posix_CommConfig, B9600);
#endif
break;
/*14400 baud*/
case BAUD14400:
TTY_WARNING("Posix_QextSerialPort: POSIX does not support 14400 baud operation. Switching to 9600 baud.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B9600;
#else
cfsetispeed(&Posix_CommConfig, B9600);
cfsetospeed(&Posix_CommConfig, B9600);
#endif
break;
/*19200 baud*/
case BAUD19200:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B19200;
#else
cfsetispeed(&Posix_CommConfig, B19200);
cfsetospeed(&Posix_CommConfig, B19200);
#endif
break;
/*38400 baud*/
case BAUD38400:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B38400;
#else
cfsetispeed(&Posix_CommConfig, B38400);
cfsetospeed(&Posix_CommConfig, B38400);
#endif
break;
/*56000 baud*/
case BAUD56000:
TTY_WARNING("Posix_QextSerialPort: POSIX does not support 56000 baud operation. Switching to 38400 baud.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B38400;
#else
cfsetispeed(&Posix_CommConfig, B38400);
cfsetospeed(&Posix_CommConfig, B38400);
#endif
break;
/*57600 baud*/
case BAUD57600:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B57600;
#else
cfsetispeed(&Posix_CommConfig, B57600);
cfsetospeed(&Posix_CommConfig, B57600);
#endif
break;
/*76800 baud*/
case BAUD76800:
TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and some POSIX systems do not support 76800 baud operation.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
#ifdef B76800
Posix_CommConfig.c_cflag|=B76800;
#else
TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud.");
Posix_CommConfig.c_cflag|=B57600;
#endif //B76800
#else //CBAUD
#ifdef B76800
cfsetispeed(&Posix_CommConfig, B76800);
cfsetospeed(&Posix_CommConfig, B76800);
#else
TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud.");
cfsetispeed(&Posix_CommConfig, B57600);
cfsetospeed(&Posix_CommConfig, B57600);
#endif //B76800
#endif //CBAUD
break;
/*115200 baud*/
case BAUD115200:
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B115200;
#else
cfsetispeed(&Posix_CommConfig, B115200);
cfsetospeed(&Posix_CommConfig, B115200);
#endif
break;
/*128000 baud*/
case BAUD128000:
TTY_WARNING("Posix_QextSerialPort: POSIX does not support 128000 baud operation. Switching to 115200 baud.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B115200;
#else
cfsetispeed(&Posix_CommConfig, B115200);
cfsetospeed(&Posix_CommConfig, B115200);
#endif
break;
/*256000 baud*/
case BAUD256000:
TTY_WARNING("Posix_QextSerialPort: POSIX does not support 256000 baud operation. Switching to 115200 baud.");
#ifdef CBAUD
Posix_CommConfig.c_cflag&=(~CBAUD);
Posix_CommConfig.c_cflag|=B115200;
#else
cfsetispeed(&Posix_CommConfig, B115200);
cfsetospeed(&Posix_CommConfig, B115200);
#endif
break;
}
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
Sets the number of data bits used by the serial port. Possible values of dataBits are:
\verbatim
DATA_5 5 data bits
DATA_6 6 data bits
DATA_7 7 data bits
DATA_8 8 data bits
\endverbatim
 
\note
This function is subject to the following restrictions:
\par
5 data bits cannot be used with 2 stop bits.
\par
8 data bits cannot be used with space parity on POSIX systems.
 
*/
void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
{
LOCK_MUTEX();
if (Settings.DataBits!=dataBits) {
if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) ||
(Settings.StopBits==STOP_1_5 && dataBits!=DATA_5) ||
(Settings.Parity==PAR_SPACE && dataBits==DATA_8)) {
}
else {
Settings.DataBits=dataBits;
}
}
if (isOpen()) {
switch(dataBits) {
/*5 data bits*/
case DATA_5:
if (Settings.StopBits==STOP_2) {
TTY_WARNING("Posix_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
}
else {
Settings.DataBits=dataBits;
Posix_CommConfig.c_cflag&=(~CSIZE);
Posix_CommConfig.c_cflag|=CS5;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
/*6 data bits*/
case DATA_6:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Posix_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
}
else {
Settings.DataBits=dataBits;
Posix_CommConfig.c_cflag&=(~CSIZE);
Posix_CommConfig.c_cflag|=CS6;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
/*7 data bits*/
case DATA_7:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Posix_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
}
else {
Settings.DataBits=dataBits;
Posix_CommConfig.c_cflag&=(~CSIZE);
Posix_CommConfig.c_cflag|=CS7;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
/*8 data bits*/
case DATA_8:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Posix_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
}
else {
Settings.DataBits=dataBits;
Posix_CommConfig.c_cflag&=(~CSIZE);
Posix_CommConfig.c_cflag|=CS8;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setParity(ParityType parity)
Sets the parity associated with the serial port. The possible values of parity are:
\verbatim
PAR_SPACE Space Parity
PAR_MARK Mark Parity
PAR_NONE No Parity
PAR_EVEN Even Parity
PAR_ODD Odd Parity
\endverbatim
 
\note
This function is subject to the following limitations:
\par
POSIX systems do not support mark parity.
\par
POSIX systems support space parity only if tricked into doing so, and only with
fewer than 8 data bits. Use space parity very carefully with POSIX systems.
 
*/
void Posix_QextSerialPort::setParity(ParityType parity)
{
LOCK_MUTEX();
if (Settings.Parity!=parity) {
if (parity==PAR_MARK || (parity==PAR_SPACE && Settings.DataBits==DATA_8)) {
}
else {
Settings.Parity=parity;
}
}
if (isOpen()) {
switch (parity) {
/*space parity*/
case PAR_SPACE:
if (Settings.DataBits==DATA_8) {
TTY_PORTABILITY_WARNING("Posix_QextSerialPort: Space parity is only supported in POSIX with 7 or fewer data bits");
}
else {
/*space parity not directly supported - add an extra data bit to simulate it*/
Posix_CommConfig.c_cflag&=~(PARENB|CSIZE);
switch(Settings.DataBits) {
case DATA_5:
Settings.DataBits=DATA_6;
Posix_CommConfig.c_cflag|=CS6;
break;
case DATA_6:
Settings.DataBits=DATA_7;
Posix_CommConfig.c_cflag|=CS7;
break;
case DATA_7:
Settings.DataBits=DATA_8;
Posix_CommConfig.c_cflag|=CS8;
break;
case DATA_8:
break;
}
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
/*mark parity - WINDOWS ONLY*/
case PAR_MARK:
TTY_WARNING("Posix_QextSerialPort: Mark parity is not supported by POSIX.");
break;
/*no parity*/
case PAR_NONE:
Posix_CommConfig.c_cflag&=(~PARENB);
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
/*even parity*/
case PAR_EVEN:
Posix_CommConfig.c_cflag&=(~PARODD);
Posix_CommConfig.c_cflag|=PARENB;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
/*odd parity*/
case PAR_ODD:
Posix_CommConfig.c_cflag|=(PARENB|PARODD);
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
Sets the number of stop bits used by the serial port. Possible values of stopBits are:
\verbatim
STOP_1 1 stop bit
STOP_1_5 1.5 stop bits
STOP_2 2 stop bits
\endverbatim
\note
This function is subject to the following restrictions:
\par
2 stop bits cannot be used with 5 data bits.
\par
POSIX does not support 1.5 stop bits.
 
*/
void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
{
LOCK_MUTEX();
if (Settings.StopBits!=stopBits) {
if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) || stopBits==STOP_1_5) {}
else {
Settings.StopBits=stopBits;
}
}
if (isOpen()) {
switch (stopBits) {
/*one stop bit*/
case STOP_1:
Settings.StopBits=stopBits;
Posix_CommConfig.c_cflag&=(~CSTOPB);
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
/*1.5 stop bits*/
case STOP_1_5:
TTY_WARNING("Posix_QextSerialPort: 1.5 stop bit operation is not supported by POSIX.");
break;
/*two stop bits*/
case STOP_2:
if (Settings.DataBits==DATA_5) {
TTY_WARNING("Posix_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
}
else {
Settings.StopBits=stopBits;
Posix_CommConfig.c_cflag|=CSTOPB;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setFlowControl(FlowType flow)
Sets the flow control used by the port. Possible values of flow are:
\verbatim
FLOW_OFF No flow control
FLOW_HARDWARE Hardware (RTS/CTS) flow control
FLOW_XONXOFF Software (XON/XOFF) flow control
\endverbatim
\note
FLOW_HARDWARE may not be supported on all versions of UNIX. In cases where it is
unsupported, FLOW_HARDWARE is the same as FLOW_OFF.
 
*/
void Posix_QextSerialPort::setFlowControl(FlowType flow)
{
LOCK_MUTEX();
if (Settings.FlowControl!=flow) {
Settings.FlowControl=flow;
}
if (isOpen()) {
switch(flow) {
/*no flow control*/
case FLOW_OFF:
Posix_CommConfig.c_cflag&=(~CRTSCTS);
Posix_CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
/*software (XON/XOFF) flow control*/
case FLOW_XONXOFF:
Posix_CommConfig.c_cflag&=(~CRTSCTS);
Posix_CommConfig.c_iflag|=(IXON|IXOFF|IXANY);
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
case FLOW_HARDWARE:
Posix_CommConfig.c_cflag|=CRTSCTS;
Posix_CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec);
Sets the read and write timeouts for the port to sec seconds and millisec milliseconds.
Note that this is a per-character timeout, i.e. the port will wait this long for each
individual character, not for the whole read operation. This timeout also applies to the
bytesWaiting() function.
 
\note
POSIX does not support millisecond-level control for I/O timeout values. Any
timeout set using this function will be set to the next lowest tenth of a second for
the purposes of detecting read or write timeouts. For example a timeout of 550 milliseconds
will be seen by the class as a timeout of 500 milliseconds for the purposes of reading and
writing the port. However millisecond-level control is allowed by the select() system call,
so for example a 550-millisecond timeout will be seen as 550 milliseconds on POSIX systems for
the purpose of detecting available bytes in the read buffer.
 
*/
void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec)
{
LOCK_MUTEX();
Settings.Timeout_Sec=sec;
Settings.Timeout_Millisec=millisec;
Posix_Copy_Timeout.tv_sec=sec;
Posix_Copy_Timeout.tv_usec=millisec;
if (isOpen()) {
tcgetattr(Posix_File->handle(), &Posix_CommConfig);
Posix_CommConfig.c_cc[VTIME]=sec*10+millisec/100;
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
}
UNLOCK_MUTEX();
}
 
/*!
\fn bool Posix_QextSerialPort::open(OpenMode mode)
Opens the serial port associated to this class.
This function has no effect if the port associated with the class is already open.
The port is also configured to the current settings, as stored in the Settings structure.
*/
bool Posix_QextSerialPort::open(OpenMode mode)
{
LOCK_MUTEX();
if (mode == QIODevice::NotOpen)
return isOpen();
if (!isOpen()) {
/*open the port*/
Posix_File->setFileName(port);
if (Posix_File->open(QIODevice::ReadWrite|QIODevice::Unbuffered)) {
/*set open mode*/
QIODevice::open(mode);
/*configure port settings*/
tcgetattr(Posix_File->handle(), &Posix_CommConfig);
/*set up other port settings*/
Posix_CommConfig.c_cflag|=CREAD|CLOCAL;
Posix_CommConfig.c_lflag&=(~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG));
Posix_CommConfig.c_iflag&=(~(INPCK|IGNPAR|PARMRK|ISTRIP|ICRNL|IXANY));
Posix_CommConfig.c_oflag&=(~OPOST);
Posix_CommConfig.c_cc[VMIN]=0;
Posix_CommConfig.c_cc[VINTR] = _POSIX_VDISABLE;
Posix_CommConfig.c_cc[VQUIT] = _POSIX_VDISABLE;
Posix_CommConfig.c_cc[VSTART] = _POSIX_VDISABLE;
Posix_CommConfig.c_cc[VSTOP] = _POSIX_VDISABLE;
Posix_CommConfig.c_cc[VSUSP] = _POSIX_VDISABLE;
setBaudRate(Settings.BaudRate);
setDataBits(Settings.DataBits);
setParity(Settings.Parity);
setStopBits(Settings.StopBits);
setFlowControl(Settings.FlowControl);
setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
} else {
}
}
UNLOCK_MUTEX();
return isOpen();
}
 
/*!
\fn void Posix_QextSerialPort::close()
Closes a serial port. This function has no effect if the serial port associated with the class
is not currently open.
*/
void Posix_QextSerialPort::close()
{
LOCK_MUTEX();
Posix_File->close();
QIODevice::close();
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::flush()
Flushes all pending I/O to the serial port. This function has no effect if the serial port
associated with the class is not currently open.
*/
void Posix_QextSerialPort::flush()
{
LOCK_MUTEX();
if (isOpen()) {
Posix_File->flush();
}
UNLOCK_MUTEX();
}
 
/*!
\fn qint64 Posix_QextSerialPort::size() const
This function will return the number of bytes waiting in the receive queue of the serial port.
It is included primarily to provide a complete QIODevice interface, and will not record errors
in the lastErr member (because it is const). This function is also not thread-safe - in
multithreading situations, use Posix_QextSerialPort::bytesWaiting() instead.
*/
qint64 Posix_QextSerialPort::size() const
{
int numBytes;
if (ioctl(Posix_File->handle(), FIONREAD, &numBytes)<0) {
numBytes=0;
}
return (qint64)numBytes;
}
 
/*!
\fn qint64 Posix_QextSerialPort::bytesAvailable()
Returns the number of bytes waiting in the port's receive queue. This function will return 0 if
the port is not currently open, or -1 on error. Error information can be retrieved by calling
Posix_QextSerialPort::getLastError().
*/
qint64 Posix_QextSerialPort::bytesAvailable()
{
LOCK_MUTEX();
if (isOpen()) {
int bytesQueued;
fd_set fileSet;
FD_ZERO(&fileSet);
FD_SET(Posix_File->handle(), &fileSet);
/*on Linux systems the Posix_Timeout structure will be altered by the select() call.
Make sure we use the right timeout values*/
//memcpy(&Posix_Timeout, &Posix_Copy_Timeout, sizeof(struct timeval));
Posix_Timeout = Posix_Copy_Timeout;
int n=select(Posix_File->handle()+1, &fileSet, NULL, &fileSet, &Posix_Timeout);
if (!n) {
lastErr=E_PORT_TIMEOUT;
UNLOCK_MUTEX();
return -1;
}
if (n==-1 || ioctl(Posix_File->handle(), FIONREAD, &bytesQueued)==-1) {
translateError(errno);
UNLOCK_MUTEX();
return -1;
}
lastErr=E_NO_ERROR;
UNLOCK_MUTEX();
return bytesQueued + QIODevice::bytesAvailable();
}
UNLOCK_MUTEX();
return 0;
}
 
/*!
\fn void Posix_QextSerialPort::ungetChar(char)
This function is included to implement the full QIODevice interface, and currently has no
purpose within this class. This function is meaningless on an unbuffered device and currently
only prints a warning message to that effect.
*/
void Posix_QextSerialPort::ungetChar(char)
{
/*meaningless on unbuffered sequential device - return error and print a warning*/
TTY_WARNING("Posix_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
}
 
/*!
\fn void Posix_QextSerialPort::translateError(ulong error)
Translates a system-specific error code to a QextSerialPort error code. Used internally.
*/
void Posix_QextSerialPort::translateError(ulong error)
{
switch (error) {
case EBADF:
case ENOTTY:
lastErr=E_INVALID_FD;
break;
case EINTR:
lastErr=E_CAUGHT_NON_BLOCKED_SIGNAL;
break;
case ENOMEM:
lastErr=E_NO_MEMORY;
break;
}
}
 
/*!
\fn void Posix_QextSerialPort::setDtr(bool set)
Sets DTR line to the requested state (high by default). This function will have no effect if
the port associated with the class is not currently open.
*/
void Posix_QextSerialPort::setDtr(bool set)
{
LOCK_MUTEX();
if (isOpen()) {
int status;
ioctl(Posix_File->handle(), TIOCMGET, &status);
if (set) {
status|=TIOCM_DTR;
}
else {
status&=~TIOCM_DTR;
}
ioctl(Posix_File->handle(), TIOCMSET, &status);
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Posix_QextSerialPort::setRts(bool set)
Sets RTS line to the requested state (high by default). This function will have no effect if
the port associated with the class is not currently open.
*/
void Posix_QextSerialPort::setRts(bool set)
{
LOCK_MUTEX();
if (isOpen()) {
int status;
ioctl(Posix_File->handle(), TIOCMGET, &status);
if (set) {
status|=TIOCM_RTS;
}
else {
status&=~TIOCM_RTS;
}
ioctl(Posix_File->handle(), TIOCMSET, &status);
}
UNLOCK_MUTEX();
}
 
/*!
\fn unsigned long Posix_QextSerialPort::lineStatus()
returns the line status as stored by the port function. This function will retrieve the states
of the following lines: DCD, CTS, DSR, and RI. On POSIX systems, the following additional lines
can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD. The value returned is an unsigned
long with specific bits indicating which lines are high. The following constants should be used
to examine the states of individual lines:
 
\verbatim
Mask Line
------ ----
LS_CTS CTS
LS_DSR DSR
LS_DCD DCD
LS_RI RI
LS_RTS RTS (POSIX only)
LS_DTR DTR (POSIX only)
LS_ST Secondary TXD (POSIX only)
LS_SR Secondary RXD (POSIX only)
\endverbatim
 
This function will return 0 if the port associated with the class is not currently open.
*/
unsigned long Posix_QextSerialPort::lineStatus()
{
unsigned long Status=0, Temp=0;
LOCK_MUTEX();
if (isOpen()) {
ioctl(Posix_File->handle(), TIOCMGET, &Temp);
if (Temp&TIOCM_CTS) {
Status|=LS_CTS;
}
if (Temp&TIOCM_DSR) {
Status|=LS_DSR;
}
if (Temp&TIOCM_RI) {
Status|=LS_RI;
}
if (Temp&TIOCM_CD) {
Status|=LS_DCD;
}
if (Temp&TIOCM_DTR) {
Status|=LS_DTR;
}
if (Temp&TIOCM_RTS) {
Status|=LS_RTS;
}
if (Temp&TIOCM_ST) {
Status|=LS_ST;
}
if (Temp&TIOCM_SR) {
Status|=LS_SR;
}
}
UNLOCK_MUTEX();
return Status;
}
 
/*!
\fn qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
Reads a block of data from the serial port. This function will read at most maxSize bytes from
the serial port and place them in the buffer pointed to by data. Return value is the number of
bytes actually read, or -1 on error.
 
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
{
LOCK_MUTEX();
int retVal=0;
retVal=Posix_File->read(data, maxSize);
if (retVal==-1)
lastErr=E_READ_FAILED;
UNLOCK_MUTEX();
return retVal;
}
 
/*!
\fn qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
Writes a block of data to the serial port. This function will write maxSize bytes
from the buffer pointed to by data to the serial port. Return value is the number
of bytes actually written, or -1 on error.
 
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
{
LOCK_MUTEX();
int retVal=0;
retVal=Posix_File->write(data, maxSize);
if (retVal==-1)
lastErr=E_WRITE_FAILED;
UNLOCK_MUTEX();
flush();
return retVal;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/posix_qextserialport.h
0,0 → 1,56
 
#ifndef _POSIX_QEXTSERIALPORT_H_
#define _POSIX_QEXTSERIALPORT_H_
 
#include <stdio.h>
#include <termios.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include "qextserialbase.h"
 
class Posix_QextSerialPort:public QextSerialBase {
public:
Posix_QextSerialPort();
Posix_QextSerialPort(const Posix_QextSerialPort& s);
Posix_QextSerialPort(const QString & name);
Posix_QextSerialPort(const PortSettings& settings);
Posix_QextSerialPort(const QString & name, const PortSettings& settings);
Posix_QextSerialPort& operator=(const Posix_QextSerialPort& s);
virtual ~Posix_QextSerialPort();
virtual void setBaudRate(BaudRateType);
virtual void setDataBits(DataBitsType);
virtual void setParity(ParityType);
virtual void setStopBits(StopBitsType);
virtual void setFlowControl(FlowType);
virtual void setTimeout(ulong, ulong);
virtual bool open(OpenMode mode=0);
virtual void close();
virtual void flush();
virtual qint64 size() const;
virtual qint64 bytesAvailable();
virtual void ungetChar(char c);
virtual void translateError(ulong error);
virtual void setDtr(bool set=true);
virtual void setRts(bool set=true);
virtual ulong lineStatus();
protected:
QFile* Posix_File;
struct termios Posix_CommConfig;
struct timeval Posix_Timeout;
struct timeval Posix_Copy_Timeout;
virtual qint64 readData(char * data, qint64 maxSize);
virtual qint64 writeData(const char * data, qint64 maxSize);
};
 
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/qextserialbase.cpp
0,0 → 1,250
 
#include "qextserialbase.h"
 
/*!
\class QextSerialBase
\version 1.0.0
\author Stefan Sander
 
A common base class for Win_QextSerialBase, Posix_QextSerialBase and QextSerialPort.
*/
#ifdef QT_THREAD_SUPPORT
QMutex* QextSerialBase::mutex=NULL;
unsigned long QextSerialBase::refCount=0;
#endif
 
/*!
\fn QextSerialBase::QextSerialBase()
Default constructor.
*/
QextSerialBase::QextSerialBase()
: QIODevice()
{
 
#ifdef _TTY_WIN_
setPortName("COM1");
 
#elif defined(_TTY_IRIX_)
setPortName("/dev/ttyf1");
 
#elif defined(_TTY_HPUX_)
setPortName("/dev/tty1p0");
 
#elif defined(_TTY_SUN_)
setPortName("/dev/ttya");
 
#elif defined(_TTY_DIGITAL_)
setPortName("/dev/tty01");
 
#elif defined(_TTY_FREEBSD_)
setPortName("/dev/ttyd1");
 
#else
setPortName("/dev/ttyS0");
#endif
 
construct();
}
 
/*!
\fn QextSerialBase::QextSerialBase(const QString & name)
Construct a port and assign it to the device specified by the name parameter.
*/
QextSerialBase::QextSerialBase(const QString & name)
: QIODevice()
{
setPortName(name);
construct();
}
 
/*!
\fn QextSerialBase::~QextSerialBase()
Standard destructor.
*/
QextSerialBase::~QextSerialBase()
{
 
#ifdef QT_THREAD_SUPPORT
refCount--;
if (mutex && refCount==0) {
delete mutex;
mutex=NULL;
}
#endif
 
}
 
/*!
\fn void QextSerialBase::construct()
Common constructor function for setting up default port settings.
(9600 Baud, 8N1, no flow control where supported, otherwise no flow control, and 20 ms timeout).
*/
void QextSerialBase::construct()
{
Settings.BaudRate=BAUD9600;
Settings.DataBits=DATA_8;
Settings.Parity=PAR_NONE;
Settings.StopBits=STOP_1;
Settings.FlowControl=FLOW_OFF;
Settings.Timeout_Sec=0;
Settings.Timeout_Millisec=20;
 
#ifdef QT_THREAD_SUPPORT
if (!mutex) {
mutex=new QMutex( QMutex::Recursive );
}
refCount++;
#endif
 
setOpenMode(QIODevice::NotOpen);
}
 
/*!
\fn void QextSerialBase::setPortName(const QString & name)
Sets the name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0".
*/
void QextSerialBase::setPortName(const QString & name)
{
port = name;
}
 
/*!
\fn QString QextSerialBase::portName() const
Returns the name set by setPortName().
*/
QString QextSerialBase::portName() const
{
return port;
}
 
/*!
\fn BaudRateType QextSerialBase::baudRate(void) const
Returns the baud rate of the serial port. For a list of possible return values see
the definition of the enum BaudRateType.
*/
BaudRateType QextSerialBase::baudRate(void) const
{
return Settings.BaudRate;
}
 
/*!
\fn DataBitsType QextSerialBase::dataBits() const
Returns the number of data bits used by the port. For a list of possible values returned by
this function, see the definition of the enum DataBitsType.
*/
DataBitsType QextSerialBase::dataBits() const
{
return Settings.DataBits;
}
 
/*!
\fn ParityType QextSerialBase::parity() const
Returns the type of parity used by the port. For a list of possible values returned by
this function, see the definition of the enum ParityType.
*/
ParityType QextSerialBase::parity() const
{
return Settings.Parity;
}
 
/*!
\fn StopBitsType QextSerialBase::stopBits() const
Returns the number of stop bits used by the port. For a list of possible return values, see
the definition of the enum StopBitsType.
*/
StopBitsType QextSerialBase::stopBits() const
{
return Settings.StopBits;
}
 
/*!
\fn FlowType QextSerialBase::flowControl() const
Returns the type of flow control used by the port. For a list of possible values returned
by this function, see the definition of the enum FlowType.
*/
FlowType QextSerialBase::flowControl() const
{
return Settings.FlowControl;
}
 
/*!
\fn bool QextSerialBase::isSequential() const
Returns true if device is sequential, otherwise returns false. Serial port is sequential device
so this function always returns true. Check QIODevice::isSequential() documentation for more
information.
*/
bool QextSerialBase::isSequential() const
{
return true;
}
 
/*!
\fn bool QextSerialBase::atEnd() const
This function will return true if the input buffer is empty (or on error), and false otherwise.
Call QextSerialBase::lastError() for error information.
*/
bool QextSerialBase::atEnd() const
{
if (size()) {
return true;
}
return false;
}
 
/*!
\fn qint64 QextSerialBase::readLine(char * data, qint64 maxSize)
This function will read a line of buffered input from the port, stopping when either maxSize bytes
have been read, the port has no more data available, or a newline is encountered.
The value returned is the length of the string that was read.
*/
qint64 QextSerialBase::readLine(char * data, qint64 maxSize)
{
qint64 numBytes = bytesAvailable();
char* pData = data;
 
if (maxSize < 2) //maxSize must be larger than 1
return -1;
 
/*read a byte at a time for MIN(bytesAvail, maxSize - 1) iterations, or until a newline*/
while (pData<(data+numBytes) && --maxSize) {
readData(pData, 1);
if (*pData++ == '\n') {
break;
}
}
*pData='\0';
 
/*return size of data read*/
return (pData-data);
}
 
/*!
\fn ulong QextSerialBase::lastError() const
Returns the code for the last error encountered by the port, or E_NO_ERROR if the last port
operation was successful. Possible error codes are:
 
\verbatim
Error Explanation
--------------------------- -------------------------------------------------------------
E_NO_ERROR No Error has occured
E_INVALID_FD Invalid file descriptor (port was not opened correctly)
E_NO_MEMORY Unable to allocate memory tables (POSIX)
E_CAUGHT_NON_BLOCKED_SIGNAL Caught a non-blocked signal (POSIX)
E_PORT_TIMEOUT Operation timed out (POSIX)
E_INVALID_DEVICE The file opened by the port is not a character device (POSIX)
E_BREAK_CONDITION The port detected a break condition
E_FRAMING_ERROR The port detected a framing error
(usually caused by incorrect baud rate settings)
E_IO_ERROR There was an I/O error while communicating with the port
E_BUFFER_OVERRUN Character buffer overrun
E_RECEIVE_OVERFLOW Receive buffer overflow
E_RECEIVE_PARITY_ERROR The port detected a parity error in the received data
E_TRANSMIT_OVERFLOW Transmit buffer overflow
E_READ_FAILED General read operation failure
E_WRITE_FAILED General write operation failure
\endverbatim
*/
ulong QextSerialBase::lastError() const
{
return lastErr;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/qextserialbase.h
0,0 → 1,196
 
#ifndef _QEXTSERIALBASE_H_
#define _QEXTSERIALBASE_H_
 
#include <QIODevice>
#include <QFile>
 
#ifdef QT_THREAD_SUPPORT
#include <QThread>
#include <QMutex>
#endif
 
/*if all warning messages are turned off, flag portability warnings to be turned off as well*/
#ifdef _TTY_NOWARN_
#define _TTY_NOWARN_PORT_
#endif
 
/*macros for thread support*/
#ifdef QT_THREAD_SUPPORT
#define LOCK_MUTEX() mutex->lock()
#define UNLOCK_MUTEX() mutex->unlock()
#else
#define LOCK_MUTEX()
#define UNLOCK_MUTEX()
#endif
 
/*macros for warning messages*/
#ifdef _TTY_NOWARN_PORT_
#define TTY_PORTABILITY_WARNING(s)
#else
#define TTY_PORTABILITY_WARNING(s) qWarning(s)
#endif
#ifdef _TTY_NOWARN_
#define TTY_WARNING(s)
#else
#define TTY_WARNING(s) qWarning(s)
#endif
 
 
/*line status constants*/
#define LS_CTS 0x01
#define LS_DSR 0x02
#define LS_DCD 0x04
#define LS_RI 0x08
#define LS_RTS 0x10
#define LS_DTR 0x20
#define LS_ST 0x40
#define LS_SR 0x80
 
/*error constants*/
#define E_NO_ERROR 0
#define E_INVALID_FD 1
#define E_NO_MEMORY 2
#define E_CAUGHT_NON_BLOCKED_SIGNAL 3
#define E_PORT_TIMEOUT 4
#define E_INVALID_DEVICE 5
#define E_BREAK_CONDITION 6
#define E_FRAMING_ERROR 7
#define E_IO_ERROR 8
#define E_BUFFER_OVERRUN 9
#define E_RECEIVE_OVERFLOW 10
#define E_RECEIVE_PARITY_ERROR 11
#define E_TRANSMIT_OVERFLOW 12
#define E_READ_FAILED 13
#define E_WRITE_FAILED 14
 
/*enums for port settings*/
enum NamingConvention {
WIN_NAMES,
IRIX_NAMES,
HPUX_NAMES,
SUN_NAMES,
DIGITAL_NAMES,
FREEBSD_NAMES,
LINUX_NAMES
};
 
enum BaudRateType {
BAUD50, //POSIX ONLY
BAUD75, //POSIX ONLY
BAUD110,
BAUD134, //POSIX ONLY
BAUD150, //POSIX ONLY
BAUD200, //POSIX ONLY
BAUD300,
BAUD600,
BAUD1200,
BAUD1800, //POSIX ONLY
BAUD2400,
BAUD4800,
BAUD9600,
BAUD14400, //WINDOWS ONLY
BAUD19200,
BAUD38400,
BAUD56000, //WINDOWS ONLY
BAUD57600,
BAUD76800, //POSIX ONLY
BAUD115200,
BAUD128000, //WINDOWS ONLY
BAUD256000 //WINDOWS ONLY
};
 
enum DataBitsType {
DATA_5,
DATA_6,
DATA_7,
DATA_8
};
 
enum ParityType {
PAR_NONE,
PAR_ODD,
PAR_EVEN,
PAR_MARK, //WINDOWS ONLY
PAR_SPACE
};
 
enum StopBitsType {
STOP_1,
STOP_1_5, //WINDOWS ONLY
STOP_2
};
 
enum FlowType {
FLOW_OFF,
FLOW_HARDWARE,
FLOW_XONXOFF
};
 
/*structure to contain port settings*/
struct PortSettings {
BaudRateType BaudRate;
DataBitsType DataBits;
ParityType Parity;
StopBitsType StopBits;
FlowType FlowControl;
ulong Timeout_Sec;
ulong Timeout_Millisec;
};
 
class QextSerialBase : public QIODevice {
public:
QextSerialBase();
QextSerialBase(const QString & name);
virtual ~QextSerialBase();
virtual void construct();
virtual void setPortName(const QString & name);
virtual QString portName() const;
 
virtual void setBaudRate(BaudRateType)=0;
virtual BaudRateType baudRate() const;
virtual void setDataBits(DataBitsType)=0;
virtual DataBitsType dataBits() const;
virtual void setParity(ParityType)=0;
virtual ParityType parity() const;
virtual void setStopBits(StopBitsType)=0;
virtual StopBitsType stopBits() const;
virtual void setFlowControl(FlowType)=0;
virtual FlowType flowControl() const;
virtual void setTimeout(ulong, ulong)=0;
 
virtual bool open(OpenMode mode=0)=0;
virtual bool isSequential() const;
virtual void close()=0;
virtual void flush()=0;
 
virtual qint64 size() const=0;
virtual qint64 bytesAvailable()=0;
virtual bool atEnd() const;
 
virtual void ungetChar(char c)=0;
virtual qint64 readLine(char * data, qint64 maxSize);
 
virtual ulong lastError() const;
virtual void translateError(ulong error)=0;
 
virtual void setDtr(bool set=true)=0;
virtual void setRts(bool set=true)=0;
virtual ulong lineStatus()=0;
 
protected:
QString port;
PortSettings Settings;
ulong lastErr;
 
#ifdef QT_THREAD_SUPPORT
static QMutex* mutex;
static ulong refCount;
#endif
 
virtual qint64 readData(char * data, qint64 maxSize)=0;
virtual qint64 writeData(const char * data, qint64 maxSize)=0;
 
};
 
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/qextserialport.cpp
0,0 → 1,98
 
/*!
\class QextSerialPort
\version 1.0.0
\author Stefan Sander
 
A cross-platform serial port class.
This class encapsulates a serial port on both POSIX and Windows systems. The user will be
notified of errors and possible portability conflicts at run-time by default - this behavior can
be turned off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn
off portability warnings) in the project.
 
\note
On Windows NT/2000/XP this class uses Win32 serial port functions by default. The user may
select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can
make no guarantees as to the quality of POSIX support under NT/2000 however.
 
*/
 
#include <stdio.h>
#include "qextserialport.h"
 
/*!
\fn QextSerialPort::QextSerialPort()
Default constructor. Note that the naming convention used by a QextSerialPort constructed with
this constructor will be determined by #defined constants, or lack thereof - the default behavior
is the same as _TTY_LINUX_. Possible naming conventions and their associated constants are:
 
\verbatim
 
Constant Used By Naming Convention
---------- ------------- ------------------------
_TTY_WIN_ Windows COM1, COM2
_TTY_IRIX_ SGI/IRIX /dev/ttyf1, /dev/ttyf2
_TTY_HPUX_ HP-UX /dev/tty1p0, /dev/tty2p0
_TTY_SUN_ SunOS/Solaris /dev/ttya, /dev/ttyb
_TTY_DIGITAL_ Digital UNIX /dev/tty01, /dev/tty02
_TTY_FREEBSD_ FreeBSD /dev/ttyd0, /dev/ttyd1
_TTY_LINUX_ Linux /dev/ttyS0, /dev/ttyS1
<none> Linux /dev/ttyS0, /dev/ttyS1
\endverbatim
 
The object will be associated with the first port in the system, e.g. COM1 on Windows systems.
See the other constructors if you need to use a port other than the first.
*/
QextSerialPort::QextSerialPort()
: QextBaseType()
{}
 
/*!
\fn QextSerialPort::QextSerialPort(const QString & name)
Constructs a serial port attached to the port specified by name.
name is the name of the device, which is windowsystem-specific,
e.g."COM1" or "/dev/ttyS0".
*/
QextSerialPort::QextSerialPort(const QString & name)
: QextBaseType(name)
{}
 
/*!
\fn QextSerialPort::QextSerialPort(PortSettings const& settings)
Constructs a port with default name and settings specified by the settings parameter.
*/
QextSerialPort::QextSerialPort(PortSettings const& settings)
: QextBaseType(settings)
{}
 
/*!
\fn QextSerialPort::QextSerialPort(const QString & name, PortSettings const& settings)
Constructs a port with the name and settings specified.
*/
QextSerialPort::QextSerialPort(const QString & name, PortSettings const& settings)
: QextBaseType(name, settings)
{}
 
/*!
\fn QextSerialPort::QextSerialPort(const QextSerialPort& s)
Copy constructor.
*/
QextSerialPort::QextSerialPort(const QextSerialPort& s)
: QextBaseType(s)
{}
 
/*!
\fn QextSerialPort& QextSerialPort::operator=(const QextSerialPort& s)
Overrides the = operator.
*/
QextSerialPort& QextSerialPort::operator=(const QextSerialPort& s)
{
return (QextSerialPort&)QextBaseType::operator=(s);
}
 
/*!
\fn QextSerialPort::~QextSerialPort()
Standard destructor.
*/
QextSerialPort::~QextSerialPort()
{}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/qextserialport.h
0,0 → 1,27
 
#ifndef _QEXTSERIALPORT_H_
#define _QEXTSERIALPORT_H_
 
/*POSIX CODE*/
#ifdef _TTY_POSIX_
#include "posix_qextserialport.h"
#define QextBaseType Posix_QextSerialPort
 
/*MS WINDOWS CODE*/
#else
#include "win_qextserialport.h"
#define QextBaseType Win_QextSerialPort
#endif
 
class QextSerialPort: public QextBaseType {
public:
QextSerialPort();
QextSerialPort(const QString & name);
QextSerialPort(PortSettings const& s);
QextSerialPort(const QString & name, PortSettings const& s);
QextSerialPort(const QextSerialPort& s);
QextSerialPort& operator=(const QextSerialPort&);
virtual ~QextSerialPort();
};
 
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/win_qextserialport.cpp
0,0 → 1,877
/*!
\class Win_QextSerialPort
\version 1.0.0
\author Stefan Sander
 
A cross-platform serial port class.
This class encapsulates the Windows portion of QextSerialPort. The user will be notified of
errors and possible portability conflicts at run-time by default - this behavior can be turned
off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off
portability warnings) in the project. Note that defining _TTY_NOWARN_ also defines
_TTY_NOWARN_PORT_.
 
\note
On Windows NT/2000/XP this class uses Win32 serial port functions by default. The user may
select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can
make no guarantees as to the quality of POSIX support under NT/2000 however.
 
*/
 
#include <stdio.h>
#include "win_qextserialport.h"
 
/*!
\fn Win_QextSerialPort::Win_QextSerialPort()
Default constructor. Note that the name of the device used by a Win_QextSerialPort constructed
with this constructor will be determined by #defined constants, or lack thereof - the default
behavior is the same as _TTY_LINUX_. Possible naming conventions and their associated constants
are:
 
\verbatim
 
Constant Used By Naming Convention
---------- ------------- ------------------------
_TTY_WIN_ Windows COM1, COM2
_TTY_IRIX_ SGI/IRIX /dev/ttyf1, /dev/ttyf2
_TTY_HPUX_ HP-UX /dev/tty1p0, /dev/tty2p0
_TTY_SUN_ SunOS/Solaris /dev/ttya, /dev/ttyb
_TTY_DIGITAL_ Digital UNIX /dev/tty01, /dev/tty02
_TTY_FREEBSD_ FreeBSD /dev/ttyd0, /dev/ttyd1
_TTY_LINUX_ Linux /dev/ttyS0, /dev/ttyS1
<none> Linux /dev/ttyS0, /dev/ttyS1
\endverbatim
 
This constructor associates the object with the first port on the system, e.g. COM1 for Windows
platforms. See the other constructor if you need a port other than the first.
*/
Win_QextSerialPort::Win_QextSerialPort():QextSerialBase() {
Win_Handle=INVALID_HANDLE_VALUE;
}
 
/*!Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort&)
Copy constructor.
*/
Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort& s):QextSerialBase(s.port) {
Win_Handle=INVALID_HANDLE_VALUE;
setOpenMode(s.openMode());
lastErr=s.lastErr;
port = s.port;
Settings.FlowControl=s.Settings.FlowControl;
Settings.Parity=s.Settings.Parity;
Settings.DataBits=s.Settings.DataBits;
Settings.StopBits=s.Settings.StopBits;
Settings.BaudRate=s.Settings.BaudRate;
Win_Handle=s.Win_Handle;
memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
}
 
/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const QString & name)
Constructs a serial port attached to the port specified by devName.
devName is the name of the device, which is windowsystem-specific,
e.g."COM2" or "/dev/ttyS0".
*/
Win_QextSerialPort::Win_QextSerialPort(const QString & name):QextSerialBase(name) {
Win_Handle=INVALID_HANDLE_VALUE;
}
 
/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings)
Constructs a port with default name and specified settings.
*/
Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) {
Win_Handle=INVALID_HANDLE_VALUE;
setBaudRate(settings.BaudRate);
setDataBits(settings.DataBits);
setStopBits(settings.StopBits);
setParity(settings.Parity);
setFlowControl(settings.FlowControl);
setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}
 
/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings)
Constructs a port with specified name and settings.
*/
Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings) {
Win_Handle=INVALID_HANDLE_VALUE;
setPortName(name);
setBaudRate(settings.BaudRate);
setDataBits(settings.DataBits);
setStopBits(settings.StopBits);
setParity(settings.Parity);
setFlowControl(settings.FlowControl);
setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}
 
/*!
\fn Win_QextSerialPort::~Win_QextSerialPort()
Standard destructor.
*/
Win_QextSerialPort::~Win_QextSerialPort() {
if (isOpen()) {
close();
}
}
 
/*!
\fn Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s)
overrides the = operator
*/
Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) {
setOpenMode(s.openMode());
lastErr=s.lastErr;
port = s.port;
Settings.FlowControl=s.Settings.FlowControl;
Settings.Parity=s.Settings.Parity;
Settings.DataBits=s.Settings.DataBits;
Settings.StopBits=s.Settings.StopBits;
Settings.BaudRate=s.Settings.BaudRate;
Win_Handle=s.Win_Handle;
memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
return *this;
}
 
/*!
\fn bool Win_QextSerialPort::open(OpenMode mode)
Opens a serial port. Note that this function does not specify which device to open. If you need
to open a device by name, see Win_QextSerialPort::open(const char*). This function has no effect
if the port associated with the class is already open. The port is also configured to the current
settings, as stored in the Settings structure.
*/
bool Win_QextSerialPort::open(OpenMode mode) {
unsigned long confSize = sizeof(COMMCONFIG);
Win_CommConfig.dwSize = confSize;
LOCK_MUTEX();
if (mode == QIODevice::NotOpen)
return isOpen();
if (!isOpen()) {
/*open the port*/
Win_Handle=CreateFileA(port.toAscii(), GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (Win_Handle!=INVALID_HANDLE_VALUE) {
/*set open mode*/
QIODevice::open(mode);
/*configure port settings*/
GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
GetCommState(Win_Handle, &(Win_CommConfig.dcb));
/*set up parameters*/
Win_CommConfig.dcb.fBinary=TRUE;
Win_CommConfig.dcb.fInX=FALSE;
Win_CommConfig.dcb.fOutX=FALSE;
Win_CommConfig.dcb.fAbortOnError=FALSE;
Win_CommConfig.dcb.fNull=FALSE;
setBaudRate(Settings.BaudRate);
setDataBits(Settings.DataBits);
setStopBits(Settings.StopBits);
setParity(Settings.Parity);
setFlowControl(Settings.FlowControl);
setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
}
UNLOCK_MUTEX();
return isOpen();
}
 
/*!
\fn void Win_QextSerialPort::close()
Closes a serial port. This function has no effect if the serial port associated with the class
is not currently open.
*/
void Win_QextSerialPort::close() {
LOCK_MUTEX();
CloseHandle(Win_Handle);
QIODevice::close();
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::flush()
Flushes all pending I/O to the serial port. This function has no effect if the serial port
associated with the class is not currently open.
*/
void Win_QextSerialPort::flush() {
LOCK_MUTEX();
if (isOpen()) {
FlushFileBuffers(Win_Handle);
}
UNLOCK_MUTEX();
}
 
/*!
\fn qint64 Win_QextSerialPort::size() const
This function will return the number of bytes waiting in the receive queue of the serial port.
It is included primarily to provide a complete QIODevice interface, and will not record errors
in the lastErr member (because it is const). This function is also not thread-safe - in
multithreading situations, use Win_QextSerialPort::bytesAvailable() instead.
*/
qint64 Win_QextSerialPort::size() const {
int availBytes;
COMSTAT Win_ComStat;
DWORD Win_ErrorMask=0;
ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
availBytes = Win_ComStat.cbInQue;
return (qint64)availBytes;
}
 
/*!
\fn qint64 Win_QextSerialPort::bytesAvailable()
Returns the number of bytes waiting in the port's receive queue. This function will return 0 if
the port is not currently open, or -1 on error. Error information can be retrieved by calling
Win_QextSerialPort::getLastError().
*/
qint64 Win_QextSerialPort::bytesAvailable() {
LOCK_MUTEX();
if (isOpen()) {
DWORD Errors;
COMSTAT Status;
bool success=ClearCommError(Win_Handle, &Errors, &Status);
translateError(Errors);
if (success) {
lastErr=E_NO_ERROR;
UNLOCK_MUTEX();
return Status.cbInQue + QIODevice::bytesAvailable();
}
UNLOCK_MUTEX();
return (unsigned int)-1;
}
UNLOCK_MUTEX();
return 0;
}
 
/*!
\fn void Win_QextSerialPort::translateError(ulong error)
Translates a system-specific error code to a QextSerialPort error code. Used internally.
*/
void Win_QextSerialPort::translateError(ulong error) {
if (error&CE_BREAK) {
lastErr=E_BREAK_CONDITION;
}
else if (error&CE_FRAME) {
lastErr=E_FRAMING_ERROR;
}
else if (error&CE_IOE) {
lastErr=E_IO_ERROR;
}
else if (error&CE_MODE) {
lastErr=E_INVALID_FD;
}
else if (error&CE_OVERRUN) {
lastErr=E_BUFFER_OVERRUN;
}
else if (error&CE_RXPARITY) {
lastErr=E_RECEIVE_PARITY_ERROR;
}
else if (error&CE_RXOVER) {
lastErr=E_RECEIVE_OVERFLOW;
}
else if (error&CE_TXFULL) {
lastErr=E_TRANSMIT_OVERFLOW;
}
}
 
/*!
\fn qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize)
Reads a block of data from the serial port. This function will read at most maxlen bytes from
the serial port and place them in the buffer pointed to by data. Return value is the number of
bytes actually read, or -1 on error.
 
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize)
{
LOCK_MUTEX();
int retVal=0;
COMSTAT Win_ComStat;
DWORD Win_BytesRead=0;
DWORD Win_ErrorMask=0;
ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
if (Win_ComStat.cbInQue &&
(!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesRead, NULL)
|| Win_BytesRead==0)) {
lastErr=E_READ_FAILED;
retVal=-1;
}
else {
retVal=((int)Win_BytesRead);
}
UNLOCK_MUTEX();
return retVal;
}
 
/*!
\fn qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize)
Writes a block of data to the serial port. This function will write len bytes
from the buffer pointed to by data to the serial port. Return value is the number
of bytes actually written, or -1 on error.
 
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize)
{
LOCK_MUTEX();
int retVal=0;
DWORD Win_BytesWritten;
if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesWritten, NULL)) {
lastErr=E_WRITE_FAILED;
retVal=-1;
}
else {
retVal=((int)Win_BytesWritten);
}
UNLOCK_MUTEX();
flush();
return retVal;
}
 
/*!
\fn void Win_QextSerialPort::ungetChar(char c)
This function is included to implement the full QIODevice interface, and currently has no
purpose within this class. This function is meaningless on an unbuffered device and currently
only prints a warning message to that effect.
*/
void Win_QextSerialPort::ungetChar(char c) {
/*meaningless on unbuffered sequential device - return error and print a warning*/
TTY_WARNING("Win_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
}
 
/*!
\fn void Win_QextSerialPort::setFlowControl(FlowType flow)
Sets the flow control used by the port. Possible values of flow are:
\verbatim
FLOW_OFF No flow control
FLOW_HARDWARE Hardware (RTS/CTS) flow control
FLOW_XONXOFF Software (XON/XOFF) flow control
\endverbatim
*/
void Win_QextSerialPort::setFlowControl(FlowType flow) {
LOCK_MUTEX();
if (Settings.FlowControl!=flow) {
Settings.FlowControl=flow;
}
if (isOpen()) {
switch(flow) {
/*no flow control*/
case FLOW_OFF:
Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
Win_CommConfig.dcb.fInX=FALSE;
Win_CommConfig.dcb.fOutX=FALSE;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
break;
/*software (XON/XOFF) flow control*/
case FLOW_XONXOFF:
Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
Win_CommConfig.dcb.fInX=TRUE;
Win_CommConfig.dcb.fOutX=TRUE;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
break;
case FLOW_HARDWARE:
Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
Win_CommConfig.dcb.fInX=FALSE;
Win_CommConfig.dcb.fOutX=FALSE;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setParity(ParityType parity)
Sets the parity associated with the serial port. The possible values of parity are:
\verbatim
PAR_SPACE Space Parity
PAR_MARK Mark Parity
PAR_NONE No Parity
PAR_EVEN Even Parity
PAR_ODD Odd Parity
\endverbatim
*/
void Win_QextSerialPort::setParity(ParityType parity) {
LOCK_MUTEX();
if (Settings.Parity!=parity) {
Settings.Parity=parity;
}
if (isOpen()) {
Win_CommConfig.dcb.Parity=(unsigned char)parity;
switch (parity) {
/*space parity*/
case PAR_SPACE:
if (Settings.DataBits==DATA_8) {
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems.");
}
Win_CommConfig.dcb.fParity=TRUE;
break;
/*mark parity - WINDOWS ONLY*/
case PAR_MARK:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Mark parity is not supported by POSIX systems");
Win_CommConfig.dcb.fParity=TRUE;
break;
/*no parity*/
case PAR_NONE:
Win_CommConfig.dcb.fParity=FALSE;
break;
/*even parity*/
case PAR_EVEN:
Win_CommConfig.dcb.fParity=TRUE;
break;
/*odd parity*/
case PAR_ODD:
Win_CommConfig.dcb.fParity=TRUE;
break;
}
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setDataBits(DataBitsType dataBits)
Sets the number of data bits used by the serial port. Possible values of dataBits are:
\verbatim
DATA_5 5 data bits
DATA_6 6 data bits
DATA_7 7 data bits
DATA_8 8 data bits
\endverbatim
 
\note
This function is subject to the following restrictions:
\par
5 data bits cannot be used with 2 stop bits.
\par
1.5 stop bits can only be used with 5 data bits.
\par
8 data bits cannot be used with space parity on POSIX systems.
 
*/
void Win_QextSerialPort::setDataBits(DataBitsType dataBits) {
LOCK_MUTEX();
if (Settings.DataBits!=dataBits) {
if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) ||
(Settings.StopBits==STOP_1_5 && dataBits!=DATA_5)) {
}
else {
Settings.DataBits=dataBits;
}
}
if (isOpen()) {
switch(dataBits) {
/*5 data bits*/
case DATA_5:
if (Settings.StopBits==STOP_2) {
TTY_WARNING("Win_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
}
else {
Win_CommConfig.dcb.ByteSize=5;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
/*6 data bits*/
case DATA_6:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Win_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
}
else {
Win_CommConfig.dcb.ByteSize=6;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
/*7 data bits*/
case DATA_7:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Win_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
}
else {
Win_CommConfig.dcb.ByteSize=7;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
/*8 data bits*/
case DATA_8:
if (Settings.StopBits==STOP_1_5) {
TTY_WARNING("Win_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
}
else {
Win_CommConfig.dcb.ByteSize=8;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setStopBits(StopBitsType stopBits)
Sets the number of stop bits used by the serial port. Possible values of stopBits are:
\verbatim
STOP_1 1 stop bit
STOP_1_5 1.5 stop bits
STOP_2 2 stop bits
\endverbatim
 
\note
This function is subject to the following restrictions:
\par
2 stop bits cannot be used with 5 data bits.
\par
1.5 stop bits cannot be used with 6 or more data bits.
\par
POSIX does not support 1.5 stop bits.
*/
void Win_QextSerialPort::setStopBits(StopBitsType stopBits) {
LOCK_MUTEX();
if (Settings.StopBits!=stopBits) {
if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) ||
(stopBits==STOP_1_5 && Settings.DataBits!=DATA_5)) {
}
else {
Settings.StopBits=stopBits;
}
}
if (isOpen()) {
switch (stopBits) {
/*one stop bit*/
case STOP_1:
Win_CommConfig.dcb.StopBits=ONESTOPBIT;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
break;
/*1.5 stop bits*/
case STOP_1_5:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX.");
if (Settings.DataBits!=DATA_5) {
TTY_WARNING("Win_QextSerialPort: 1.5 stop bits can only be used with 5 data bits");
}
else {
Win_CommConfig.dcb.StopBits=ONE5STOPBITS;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
/*two stop bits*/
case STOP_2:
if (Settings.DataBits==DATA_5) {
TTY_WARNING("Win_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
}
else {
Win_CommConfig.dcb.StopBits=TWOSTOPBITS;
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
break;
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setBaudRate(BaudRateType baudRate)
Sets the baud rate of the serial port. Note that not all rates are applicable on
all platforms. The following table shows translations of the various baud rate
constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an *
are speeds that are usable on both Windows and POSIX.
\verbatim
 
RATE Windows Speed POSIX Speed
----------- ------------- -----------
BAUD50 110 50
BAUD75 110 75
*BAUD110 110 110
BAUD134 110 134.5
BAUD150 110 150
BAUD200 110 200
*BAUD300 300 300
*BAUD600 600 600
*BAUD1200 1200 1200
BAUD1800 1200 1800
*BAUD2400 2400 2400
*BAUD4800 4800 4800
*BAUD9600 9600 9600
BAUD14400 14400 9600
*BAUD19200 19200 19200
*BAUD38400 38400 38400
BAUD56000 56000 38400
*BAUD57600 57600 57600
BAUD76800 57600 76800
*BAUD115200 115200 115200
BAUD128000 128000 115200
BAUD256000 256000 115200
\endverbatim
*/
void Win_QextSerialPort::setBaudRate(BaudRateType baudRate) {
LOCK_MUTEX();
if (Settings.BaudRate!=baudRate) {
switch (baudRate) {
case BAUD50:
case BAUD75:
case BAUD134:
case BAUD150:
case BAUD200:
Settings.BaudRate=BAUD110;
break;
case BAUD1800:
Settings.BaudRate=BAUD1200;
break;
case BAUD76800:
Settings.BaudRate=BAUD57600;
break;
default:
Settings.BaudRate=baudRate;
break;
}
}
if (isOpen()) {
switch (baudRate) {
/*50 baud*/
case BAUD50:
TTY_WARNING("Win_QextSerialPort: Windows does not support 50 baud operation. Switching to 110 baud.");
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*75 baud*/
case BAUD75:
TTY_WARNING("Win_QextSerialPort: Windows does not support 75 baud operation. Switching to 110 baud.");
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*110 baud*/
case BAUD110:
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*134.5 baud*/
case BAUD134:
TTY_WARNING("Win_QextSerialPort: Windows does not support 134.5 baud operation. Switching to 110 baud.");
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*150 baud*/
case BAUD150:
TTY_WARNING("Win_QextSerialPort: Windows does not support 150 baud operation. Switching to 110 baud.");
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*200 baud*/
case BAUD200:
TTY_WARNING("Win_QextSerialPort: Windows does not support 200 baud operation. Switching to 110 baud.");
Win_CommConfig.dcb.BaudRate=CBR_110;
break;
/*300 baud*/
case BAUD300:
Win_CommConfig.dcb.BaudRate=CBR_300;
break;
/*600 baud*/
case BAUD600:
Win_CommConfig.dcb.BaudRate=CBR_600;
break;
/*1200 baud*/
case BAUD1200:
Win_CommConfig.dcb.BaudRate=CBR_1200;
break;
/*1800 baud*/
case BAUD1800:
TTY_WARNING("Win_QextSerialPort: Windows does not support 1800 baud operation. Switching to 1200 baud.");
Win_CommConfig.dcb.BaudRate=CBR_1200;
break;
/*2400 baud*/
case BAUD2400:
Win_CommConfig.dcb.BaudRate=CBR_2400;
break;
/*4800 baud*/
case BAUD4800:
Win_CommConfig.dcb.BaudRate=CBR_4800;
break;
/*9600 baud*/
case BAUD9600:
Win_CommConfig.dcb.BaudRate=CBR_9600;
break;
/*14400 baud*/
case BAUD14400:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 14400 baud operation.");
Win_CommConfig.dcb.BaudRate=CBR_14400;
break;
/*19200 baud*/
case BAUD19200:
Win_CommConfig.dcb.BaudRate=CBR_19200;
break;
/*38400 baud*/
case BAUD38400:
Win_CommConfig.dcb.BaudRate=CBR_38400;
break;
/*56000 baud*/
case BAUD56000:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 56000 baud operation.");
Win_CommConfig.dcb.BaudRate=CBR_56000;
break;
/*57600 baud*/
case BAUD57600:
Win_CommConfig.dcb.BaudRate=CBR_57600;
break;
/*76800 baud*/
case BAUD76800:
TTY_WARNING("Win_QextSerialPort: Windows does not support 76800 baud operation. Switching to 57600 baud.");
Win_CommConfig.dcb.BaudRate=CBR_57600;
break;
/*115200 baud*/
case BAUD115200:
Win_CommConfig.dcb.BaudRate=CBR_115200;
break;
/*128000 baud*/
case BAUD128000:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 128000 baud operation.");
Win_CommConfig.dcb.BaudRate=CBR_128000;
break;
/*256000 baud*/
case BAUD256000:
TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 256000 baud operation.");
Win_CommConfig.dcb.BaudRate=CBR_256000;
break;
}
SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setDtr(bool set)
Sets DTR line to the requested state (high by default). This function will have no effect if
the port associated with the class is not currently open.
*/
void Win_QextSerialPort::setDtr(bool set) {
LOCK_MUTEX();
if (isOpen()) {
if (set) {
EscapeCommFunction(Win_Handle, SETDTR);
}
else {
EscapeCommFunction(Win_Handle, CLRDTR);
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn void Win_QextSerialPort::setRts(bool set)
Sets RTS line to the requested state (high by default). This function will have no effect if
the port associated with the class is not currently open.
*/
void Win_QextSerialPort::setRts(bool set) {
LOCK_MUTEX();
if (isOpen()) {
if (set) {
EscapeCommFunction(Win_Handle, SETRTS);
}
else {
EscapeCommFunction(Win_Handle, CLRRTS);
}
}
UNLOCK_MUTEX();
}
 
/*!
\fn ulong Win_QextSerialPort::lineStatus(void)
returns the line status as stored by the port function. This function will retrieve the states
of the following lines: DCD, CTS, DSR, and RI. On POSIX systems, the following additional lines
can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD. The value returned is an unsigned
long with specific bits indicating which lines are high. The following constants should be used
to examine the states of individual lines:
 
\verbatim
Mask Line
------ ----
LS_CTS CTS
LS_DSR DSR
LS_DCD DCD
LS_RI RI
\endverbatim
 
This function will return 0 if the port associated with the class is not currently open.
*/
ulong Win_QextSerialPort::lineStatus(void) {
unsigned long Status=0, Temp=0;
LOCK_MUTEX();
if (isOpen()) {
GetCommModemStatus(Win_Handle, &Temp);
if (Temp&MS_CTS_ON) {
Status|=LS_CTS;
}
if (Temp&MS_DSR_ON) {
Status|=LS_DSR;
}
if (Temp&MS_RING_ON) {
Status|=LS_RI;
}
if (Temp&MS_RLSD_ON) {
Status|=LS_DCD;
}
}
UNLOCK_MUTEX();
return Status;
}
 
/*!
\fn void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec);
Sets the read and write timeouts for the port to sec seconds and millisec milliseconds.
*/
void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec) {
LOCK_MUTEX();
Settings.Timeout_Sec=sec;
Settings.Timeout_Millisec=millisec;
if(isOpen()) {
Win_CommTimeouts.ReadIntervalTimeout = sec*1000+millisec;
Win_CommTimeouts.ReadTotalTimeoutMultiplier = sec*1000+millisec;
Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
Win_CommTimeouts.WriteTotalTimeoutMultiplier = sec*1000+millisec;
Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
}
UNLOCK_MUTEX();
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort/win_qextserialport.h
0,0 → 1,48
#ifndef _WIN_QEXTSERIALPORT_H_
#define _WIN_QEXTSERIALPORT_H_
 
#include "qextserialbase.h"
 
/*if all warning messages are turned off, flag portability warnings to be turned off as well*/
#ifdef _TTY_NOWARN_
#define _TTY_NOWARN_PORT_
#endif
 
#include <windows.h>
 
class Win_QextSerialPort:public QextSerialBase {
public:
Win_QextSerialPort();
Win_QextSerialPort(Win_QextSerialPort const& s);
Win_QextSerialPort(const QString & name);
Win_QextSerialPort(const PortSettings& settings);
Win_QextSerialPort(const QString & name, const PortSettings& settings);
Win_QextSerialPort& operator=(const Win_QextSerialPort& s);
virtual ~Win_QextSerialPort();
virtual bool open(OpenMode mode=0);
virtual void close();
virtual void flush();
virtual qint64 size() const;
virtual void ungetChar(char c);
virtual void setFlowControl(FlowType);
virtual void setParity(ParityType);
virtual void setDataBits(DataBitsType);
virtual void setStopBits(StopBitsType);
virtual void setBaudRate(BaudRateType);
virtual void setDtr(bool set=true);
virtual void setRts(bool set=true);
virtual ulong lineStatus(void);
virtual qint64 bytesAvailable();
virtual void translateError(ulong);
virtual void setTimeout(ulong, ulong);
protected:
HANDLE Win_Handle;
COMMCONFIG Win_CommConfig;
COMMTIMEOUTS Win_CommTimeouts;
virtual qint64 readData(char *data, qint64 maxSize);
virtual qint64 writeData(const char *data, qint64 maxSize);
};
 
#endif
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Connection-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Connection-NO.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Connection-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Connection-OK.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Debug.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Debug.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Exit.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Exit.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Green.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Green.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Off.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Off.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Red.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Red.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Yellow.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/LED_Yellow.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Load-Map.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Load-Map.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Load.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Load.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Log-Record.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Log-Record.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Log-Stop.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Log-Stop.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Plotter-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Plotter-NO.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Plotter-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Plotter-OK.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Preferences-Data.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Preferences-Data.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Read.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Read.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Save.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Save.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Terminal.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Terminal.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Write.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Actions/Write.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Down-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Down-1.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Down-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Down-2.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Left-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Left-1.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Left-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Left-2.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Right-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Right-1.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Right-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Right-2.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Up-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Up-1.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Up-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Arrows/Up-2.png
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/Target.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/Target.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-black.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-black.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-blue.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-blue.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-green.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-green.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-red.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-red.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-yellow.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Flags/flag-yellow.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Communicator.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Communicator.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Logger.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Logger.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Maps.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Maps.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Scope.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Scope.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Settings.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Settings.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Voice.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Images/Icons/QMK-Voice.png
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl.h
0,0 → 1,18
#include "../../Global/Class_QMapControl/mapcontrol.h"
#include "../../Global/Class_QMapControl/gps_position.h"
#include "../../Global/Class_QMapControl/wmsmapadapter.h"
#include "../../Global/Class_QMapControl/geometry.h"
#include "../../Global/Class_QMapControl/point.h"
#include "../../Global/Class_QMapControl/imagepoint.h"
#include "../../Global/Class_QMapControl/circlepoint.h"
#include "../../Global/Class_QMapControl/linestring.h"
#include "../../Global/Class_QMapControl/gps_position.h"
#include "../../Global/Class_QMapControl/osmmapadapter.h"
#include "../../Global/Class_QMapControl/maplayer.h"
#include "../../Global/Class_QMapControl/geometrylayer.h"
#include "../../Global/Class_QMapControl/yahoomapadapter.h"
#include "../../Global/Class_QMapControl/googlemapadapter.h"
#include "../../Global/Class_QMapControl/googlesatmapadapter.h"
#include "../../Global/Class_QMapControl/openaerialmapadapter.h"
#include "../../Global/Class_QMapControl/fixedimageoverlay.h"
#include "../../Global/Class_QMapControl/emptymapadapter.h"
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_QMapControl.pri
0,0 → 1,54
DEPENDPATH += ../Global/Class_QMapControl
INCLUDEPATH += ../Global/Class_QMapControl
 
# Input
HEADERS += curve.h \
geometry.h \
imagemanager.h \
layer.h \
layermanager.h \
linestring.h \
mapadapter.h \
mapcontrol.h \
mapnetwork.h \
point.h \
tilemapadapter.h \
wmsmapadapter.h \
circlepoint.h \
imagepoint.h \
gps_position.h \
osmmapadapter.h \
maplayer.h \
geometrylayer.h \
yahoomapadapter.h \
googlemapadapter.h \
googlesatmapadapter.h \
openaerialmapadapter.h \
fixedimageoverlay.h \
emptymapadapter.h
SOURCES += curve.cpp \
geometry.cpp \
imagemanager.cpp \
layer.cpp \
layermanager.cpp \
linestring.cpp \
mapadapter.cpp \
mapcontrol.cpp \
mapnetwork.cpp \
point.cpp \
tilemapadapter.cpp \
wmsmapadapter.cpp \
circlepoint.cpp \
imagepoint.cpp \
gps_position.cpp \
osmmapadapter.cpp \
maplayer.cpp \
geometrylayer.cpp \
yahoomapadapter.cpp \
googlemapadapter.cpp \
googlesatmapadapter.cpp \
openaerialmapadapter.cpp \
fixedimageoverlay.cpp \
emptymapadapter.cpp
 
QT += network
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Class_SerialPort.pri
0,0 → 1,18
DEPENDPATH += ../Global/Class_SerialPort
INCLUDEPATH += ../Global/Class_SerialPort
 
SOURCES += qextserialbase.cpp \
qextserialport.cpp \
ManageSerialPort.cpp
 
win32:SOURCES += win_qextserialport.cpp
 
unix:SOURCES += posix_qextserialport.cpp
 
HEADERS += qextserialbase.h \
qextserialport.h \
ManageSerialPort.h
 
win32:HEADERS += win_qextserialport.h
 
unix:HEADERS += posix_qextserialport.h
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Global.h
0,0 → 1,51
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef GLOBAL_H
#define GLOBAL_H
 
#include <QString>
 
#ifdef Q_OS_LINUX
static const QString QA_OS = "Linux";
#else
#ifdef Q_OS_DARWIN
static const QString QA_OS = "OSX";
#else
#ifdef Q_OS_WIN32
static const QString QA_OS = "Windows";
#else
static const QString QA_OS = "n/a";
#endif
#endif
#endif
 
static const QString QA_AUTHOR = "Manuel Schrape";
static const QString QA_EMAIL = "manuel.schrape@gmx.de";
 
struct s_Directorys
{
QString MainData;
QString MapCache;
QString WPRoutes;
QString Flights;
QString MapPics;
QString Settings;
QString Logs;
};
#endif // GLOBAL_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/Kopter.h
0,0 → 1,52
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef KOPTER_H
#define KOPTER_H
 
#include <QString>
#include <QRgb>
 
#include <stdint.h>
 
#ifdef _BETA_
static const QString QA_HWVERSION = "FlightCtrl v0.76e & NaviCtrl v0.17e";
#else
static const QString QA_HWVERSION = "FlightCtrl v0.76e & NaviCtrl v0.17e";
#endif
 
// Datenfeld-ID's
static const int DATA_VERSION = 1;
static const int DATA_READ_SETTINGS = 2;
static const int DATA_WRITE_SETTINGS = 3;
static const int DATA_READ_MIXER = 4;
static const int DATA_WRITE_MIXER = 5;
static const int DATA_READ_LABEL = 6;
static const int DATA_WRITE_WAYPOINT = 7;
 
//static const
 
static const QString HardwareType[] = {"Default", "FlightCtrl", "NaviCtrl", "MK3Mag"};
 
static const int MAX_DebugData = 32;
 
static const QString DEF_DebugNames[] = {"Integral Nick", "Integral Roll", "ACC Nick", "ACC Roll", "Gyro Gier", "Hoehen-Wert", "ACC Z", "GAS", "Kompass-Value", "Spannung", "Empfang", "Ersatzkompass", "Motor Vorne", "Motor Hinten", "Motor Links", "Motor Rechts", "Analog 16", "Distance", "OSD-Bar", "MK3Mag", "Servo", "Nick", "Roll", "Analog 23", "Analog 24", "Analog 25", "Analog 26", "Kalman Max", "Analog 28", "Kalman K", "GPS Nick", "GPS Roll"};
 
static const QRgb DEF_DebugColors[] = {0x00FF0000, 0x0000FF00, 0x00FFFF00, 0x000000FF, 0x00FF00FF, 0x0000FFFF, 0x00FFFFFF, 0x00660000, 0x00006600, 0x00666600, 0x00000066, 0x00660066, 0x000066, 0x00666666, 0x00990000, 0x00009900, 0x00999900, 0x00000099, 0x00990099, 0x00009999, 0x00999999, 0x00CC0000, 0x0000CC00, 0x00CCCC00, 0x000000CC, 0x00CC00CC, 0x0000CCCC, 0x00CCCCCC, 0x0066FF99, 0x009966FF, 0x00FF9966, 0x0099FF66};
 
#endif // KOPTER_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/License.head
0,0 → 1,18
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/Global/MK_Datatypes.h
0,0 → 1,252
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef MK_DATATYPES_H
#define MK_DATATYPES_H
 
#include <stdint.h>
 
#ifdef _BETA_
static const int MK_VERSION_SETTINGS = 80; // wird angepasst, wenn sich die EEPROM-Daten ge�ndert haben
#else
static const int MK_VERSION_SETTINGS = 80; // wird angepasst, wenn sich die EEPROM-Daten ge�ndert haben
#endif
 
static const int MK_VERSION_NAVI = 2; // wird angepasst, wenn sich die Mixer-Daten ge�ndert haben
 
static const int MK_VERSION_MIXER = 1; // wird angepasst, wenn sich die Mixer-Daten ge�ndert haben
static const int MK_MAX_MOTOR = 16; // Maximale Anzahl der Motoren im Mixer
 
// Version des Seriellen Protokoll
static const int VERSION_SERIAL_MAJOR = 10;
static const int VERSION_SERIAL_MINOR = 0;
 
// Basis-Addressen der verschiedenen Hardware
static const int ADDRESS_ALL = 0;
static const int ADDRESS_FC = 1;
static const int ADDRESS_NC = 2;
static const int ADDRESS_MK3MAG = 3;
 
#define FLAG_MOTOR_RUN 1
#define FLAG_FLY 2
#define FLAG_CALIBRATE 4
#define FLAG_START 8
#define FLAG_NOTLANDUNG 16
#define FLAG_LOWBAT 32
 
#define CFG_HOEHENREGELUNG 0x01
#define CFG_HOEHEN_SCHALTER 0x02
#define CFG_HEADING_HOLD 0x04
#define CFG_KOMPASS_AKTIV 0x08
#define CFG_KOMPASS_FIX 0x10
#define CFG_GPS_AKTIV 0x20
#define CFG_ACHSENKOPPLUNG_AKTIV 0x40
#define CFG_DREHRATEN_BEGRENZER 0x80
 
#define CFG_LOOP_OBEN 0x01
#define CFG_LOOP_UNTEN 0x02
#define CFG_LOOP_LINKS 0x04
#define CFG_LOOP_RECHTS 0x08
#define CFG_MOTOR_BLINK 0x10
#define CFG_MOTOR_OFF_LED1 0x20
#define CFG_MOTOR_OFF_LED2 0x40
#define CFG_RES4 0x80
 
#define CFG2_HEIGHT_LIMIT 0x01
#define CFG2_VARIO_BEEP 0x02
#define CFG_SENSITIVE_RC 0x04
 
struct s_MK_Settings
{
// Die ersten beiden Bytes nicht an den MK senden.
unsigned char Index;
unsigned char Version;
 
unsigned char Kanalbelegung[8]; // GAS[0], GIER[1],NICK[2], ROLL[3], POTI1, POTI2, POTI3
unsigned char GlobalConfig; // 0x01=H�henregler aktiv,0x02=Kompass aktiv, 0x04=GPS aktiv, 0x08=Heading Hold aktiv
unsigned char Hoehe_MinGas; // Wert : 0-100
unsigned char Luftdruck_D; // Wert : 0-250
unsigned char MaxHoehe; // Wert : 0-32
unsigned char Hoehe_P; // Wert : 0-32
unsigned char Hoehe_Verstaerkung; // Wert : 0-50
unsigned char Hoehe_ACC_Wirkung; // Wert : 0-250
unsigned char Hoehe_HoverBand; // Wert : 0-250
unsigned char Hoehe_GPS_Z; // Wert : 0-250
unsigned char Hoehe_StickNeutralPoint;// Wert : 0-250
unsigned char Stick_P; // Wert : 1-6
unsigned char Stick_D; // Wert : 0-64
unsigned char Gier_P; // Wert : 1-20
unsigned char Gas_Min; // Wert : 0-32
unsigned char Gas_Max; // Wert : 33-250
unsigned char GyroAccFaktor; // Wert : 1-64
unsigned char KompassWirkung; // Wert : 0-32
unsigned char Gyro_P; // Wert : 10-250
unsigned char Gyro_I; // Wert : 0-250
unsigned char Gyro_D; // Wert : 0-250
unsigned char Gyro_Gier_P; // Wert : 10-250
unsigned char Gyro_Gier_I; // Wert : 0-250
unsigned char UnterspannungsWarnung; // Wert : 0-250
unsigned char NotGas; // Wert : 0-250 //Gaswert bei Emp�ngsverlust
unsigned char NotGasZeit; // Wert : 0-250 // Zeitbis auf NotGas geschaltet wird, wg. Rx-Problemen
unsigned char UfoAusrichtung; // X oder + Formation
unsigned char I_Faktor; // Wert : 0-250
unsigned char UserParam1; // Wert : 0-250
unsigned char UserParam2; // Wert : 0-250
unsigned char UserParam3; // Wert : 0-250
unsigned char UserParam4; // Wert : 0-250
unsigned char ServoNickControl; // Wert : 0-250 // Stellung des Servos
unsigned char ServoNickComp; // Wert : 0-250 // Einfluss Gyro/Servo
unsigned char ServoNickMin; // Wert : 0-250 // Anschlag
unsigned char ServoNickMax; // Wert : 0-250 // Anschlag
//--- Seit V0.75
unsigned char ServoRollControl; // Wert : 0-250 // Stellung des Servos
unsigned char ServoRollComp; // Wert : 0-250
unsigned char ServoRollMin; // Wert : 0-250
unsigned char ServoRollMax; // Wert : 0-250
//---
unsigned char ServoNickRefresh; //
unsigned char LoopGasLimit; // Wert: 0-250 max. Gas w�hrend Looping
unsigned char LoopThreshold; // Wert: 0-250 Schwelle f�r Stickausschlag
unsigned char LoopHysterese; // Wert: 0-250 Hysterese f�r Stickausschlag
unsigned char AchsKopplung1; // Wert: 0-250 Faktor, mit dem Gier die Achsen Roll und Nick koppelt (NickRollMitkopplung)
unsigned char AchsKopplung2; // Wert: 0-250 Faktor, mit dem Nick und Roll verkoppelt werden
unsigned char CouplingYawCorrection; // Wert: 0-250 Faktor, mit dem Nick und Roll verkoppelt werden
unsigned char WinkelUmschlagNick; // Wert: 0-250 180�-Punkt
unsigned char WinkelUmschlagRoll; // Wert: 0-250 180�-Punkt
unsigned char GyroAccAbgleich; // 1/k (Koppel_ACC_Wirkung)
unsigned char Driftkomp;
unsigned char DynamicStability;
unsigned char UserParam5; // Wert : 0-250
unsigned char UserParam6; // Wert : 0-250
unsigned char UserParam7; // Wert : 0-250
unsigned char UserParam8; // Wert : 0-250
//---Output ---------------------------------------------
unsigned char J16Bitmask; // for the J16 Output
unsigned char J16Timing; // for the J16 Output
unsigned char J17Bitmask; // for the J17 Output
unsigned char J17Timing; // for the J17 Output
// seit version V0.75c
unsigned char WARN_J16_Bitmask; // for the J16 Output
unsigned char WARN_J17_Bitmask; // for the J17 Output
//---NaviCtrl---------------------------------------------
unsigned char NaviGpsModeControl; // Parameters for the Naviboard
unsigned char NaviGpsGain;
unsigned char NaviGpsP;
unsigned char NaviGpsI;
unsigned char NaviGpsD;
unsigned char NaviGpsPLimit;
unsigned char NaviGpsILimit;
unsigned char NaviGpsDLimit;
unsigned char NaviGpsACC;
unsigned char NaviGpsMinSat;
unsigned char NaviStickThreshold;
unsigned char NaviWindCorrection;
unsigned char NaviSpeedCompensation;
unsigned char NaviOperatingRadius;
unsigned char NaviAngleLimitation;
unsigned char NaviPH_LoginTime;
//---Ext.Ctrl---------------------------------------------
unsigned char ExternalControl; // for serial Control
//------------------------------------------------
unsigned char BitConfig; // (war Loop-Cfg) Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt
unsigned char ServoCompInvert; // // 0x01 = Nick, 0x02 = Roll 0 oder 1 // WICHTIG!!! am Ende lassen
unsigned char ExtraConfig; // bitcodiert
char Name[12];
};
 
struct s_MK_Mixer
{
char Revision;
char Name[12];
signed char Motor[16][4];
};
 
///////////////
// Navi-Ctrl //
///////////////
 
#define INVALID 0x00
#define NEWDATA 0x01
#define PROCESSED 0x02
 
#define NC_FLAG_FREE 0x01
#define NC_FLAG_PH 0x02
#define NC_FLAG_CH 0x04
#define NC_FLAG_RANGE_LIMIT 0x08
#define NC_FLAG_NOSERIALLINK 0x10
#define NC_FLAG_TARGET_REACHED 0x20
#define NC_FLAG_MANUAL_CONTROL 0x40
#define NC_FLAG_8 0x80
 
typedef struct
{
int32_t Longitude; // in 1E-7 deg
int32_t Latitude; // in 1E-7 deg
int32_t Altitude; // in mm
uint8_t Status; // validity of data
} __attribute__((packed)) GPS_Pos_t;
 
typedef struct
{
uint16_t Distance; // distance to target in dm
int16_t Bearing; // course to target in deg
} __attribute__((packed)) GPS_PosDev_t;
 
typedef struct
{
uint8_t Version; // version of the data structure
GPS_Pos_t CurrentPosition; // see ubx.h for details
GPS_Pos_t TargetPosition;
GPS_PosDev_t TargetPositionDeviation;
GPS_Pos_t HomePosition;
GPS_PosDev_t HomePositionDeviation;
uint8_t WaypointIndex; // index of current waypoints running from 0 to WaypointNumber-1
uint8_t WaypointNumber; // number of stored waypoints
uint8_t SatsInUse; // number of satellites used for position solution
int16_t Altimeter; // hight according to air pressure
int16_t Variometer; // climb(+) and sink(-) rate
uint16_t FlyingTime; // in seconds
uint8_t UBat; // Battery Voltage in 0.1 Volts
uint16_t GroundSpeed; // speed over ground in cm/s (2D)
int16_t Heading; // current flight direction in ° as angle to north
int16_t CompassHeading; // current compass value in °
int8_t AngleNick; // current Nick angle in 1°
int8_t AngleRoll; // current Rick angle in 1°
uint8_t RC_Quality; // RC_Quality
uint8_t MKFlags; // Flags from FC
uint8_t NCFlags; // Flags from NC
uint8_t Errorcode; // 0 --> okay
uint8_t OperatingRadius; // current operation radius around the Home Position in m
int16_t TopSpeed; // velocity in vertical direction in cm/s
uint8_t TargetHoldTime; // time in s to stay at the given target, counts down to 0 if target has been reached
uint8_t RC_RSSI; // Receiver signal strength (since version 2 added)
int16_t SetpointAltitude; // setpoint for altitude
uint8_t Gas; // for future use
} __attribute__((packed)) s_MK_NaviData;
 
typedef struct
{
GPS_Pos_t Position; // the gps position of the waypoint, see ubx.h for details
int16_t Heading; // orientation, future implementation
uint8_t ToleranceRadius; // in meters, if the MK is within that range around the target, then the next target is triggered
uint8_t HoldTime; // in seconds, if the was once in the tolerance area around a WP, this time defies the delay before the next WP is triggered
uint8_t Event_Flag; // future emplementation
uint8_t reserve[12]; // reserve
} __attribute__((packed)) s_MK_WayPoint;
 
#endif // MK_DATATYPES_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Classes/cSettings.cpp
0,0 → 1,92
/***************************************************************************
* Copyright (C) 2008 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QSettings>
#include <QDir>
 
#include "cSettings.h"
 
cSettings::cSettings()
{
Settings_ID = 1;
 
read_Settings();
}
 
void cSettings::read_Settings()
{
QSettings Setting("QMK", QA_NAME);
 
Setting.beginGroup("Global");
Settings_ID = Setting.value("Settings ID", Settings_ID).toInt();
Setting.endGroup();
 
Setting.beginGroup("SERVER");
SERVER.TCP_PORT = Setting.value("TCP-PORT", DEV_IP_PORT).toInt();
SERVER.UDP_PORT = Setting.value("UDP-PORT", DEV_IP_PORT).toInt();
SERVER.Password = Setting.value("Password", QString("")).toString();
Setting.endGroup();
 
Setting.beginGroup("CLIENT");
CLIENT.TTY_MAX = Setting.value("TTY_MAX", 1).toInt();
CLIENT.TTY_ID = Setting.value("TTY_ID", 0).toInt();
 
for (int z = 0; z < CLIENT.TTY_MAX; z++)
{
CLIENT.TTY_DEVICES[z] = Setting.value("TTY_DEVICE_" + QString("%1").arg(z), QString("/dev/ttyS3")).toString();
}
Setting.endGroup();
 
Setting.beginGroup("GUI");
GUI.isMax = Setting.value("IsMax",false).toBool();
GUI.Size = Setting.value("Size", QSize(500, 350)).toSize();
GUI.Point = Setting.value("Point",QPoint(1,1)).toPoint();
Setting.endGroup();
}
 
void cSettings::write_Settings()
{
QSettings Setting("QMK", QA_NAME);
 
Setting.beginGroup("Global");
Setting.setValue("Settings ID", Settings_ID);
Setting.endGroup();
 
Setting.beginGroup("SERVER");
Setting.setValue("TCP-PORT", SERVER.TCP_PORT);
Setting.setValue("UDP-PORT", SERVER.UDP_PORT);
Setting.setValue("Password", SERVER.Password);
Setting.endGroup();
 
Setting.beginGroup("CLIENT");
Setting.setValue("TTY_MAX", CLIENT.TTY_MAX);
Setting.setValue("TTY_ID", CLIENT.TTY_ID);
 
for (int z = 0; z < CLIENT.TTY_MAX; z++)
{
Setting.setValue("TTY_DEVICE_" + QString("%1").arg(z), CLIENT.TTY_DEVICES[z]);
}
Setting.endGroup();
 
Setting.beginGroup("GUI");
Setting.setValue("IsMax", GUI.isMax);
Setting.setValue("Size", GUI.Size);
Setting.setValue("Point", GUI.Point);
Setting.endGroup();
 
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Classes/cSettings.h
0,0 → 1,63
/***************************************************************************
* Copyright (C) 2008 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CSETTINGS_H
#define CSETTINGS_H
 
#include <QSize>
#include <QPoint>
#include <QString>
 
#include "../Defines.h"
 
struct set_SERVER
{
int TCP_PORT;
int UDP_PORT;
QString Password;
};
 
struct set_CLIENT
{
QString TTY_DEVICES[10];
int TTY_MAX;
int TTY_ID;
};
 
struct set_GUI
{
bool isMax;
QSize Size;
QPoint Point;
};
 
class cSettings
{
public:
cSettings();
void read_Settings();
void write_Settings();
 
int Settings_ID;
 
set_GUI GUI;
set_SERVER SERVER;
set_CLIENT CLIENT;
};
 
#endif // CSETTINGS_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Dialogs/dlg_Main.cpp
0,0 → 1,522
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
 
#include <QMessageBox>
 
#include "dlg_Main.h"
 
// Konstruktor Main-Form
////////////////////////
dlg_Main::dlg_Main()
{
setupUi(this);
 
o_Settings = new cSettings();
 
o_Input = new Input();
 
f_Terminal = new dlg_Terminal(this);
 
init_GUI();
init_Connections();
 
init_TCP();
}
 
void dlg_Main::set_ARGV(char *Programm)
{
QString tmp = QString(Programm);
QMK_Dir = tmp.left(tmp.lastIndexOf("/"));
}
 
// Grafische Oberfläche initialisieren
//////////////////////////////////////
void dlg_Main::init_GUI()
{
setWindowTitle(QA_NAME + " " + QA_VERSION);
 
resize(o_Settings->GUI.Size);
move(o_Settings->GUI.Point);
 
if (o_Settings->GUI.isMax)
{
showMaximized();
}
 
// todo: In abhängigkeit von Settings
wg_IP->setVisible(false);
rb_Device->setChecked(true);
 
for (int z = 0; z < DEV_IP_MAX; z++)
{
Item[z][0] = new QListWidgetItem();
Item[z][1] = new QListWidgetItem();
}
 
for(int z = 0; z < o_Settings->CLIENT.TTY_MAX; z++)
{
if (cb_Device->findText(o_Settings->CLIENT.TTY_DEVICES[z]) == -1)
{
cb_Device->addItem(o_Settings->CLIENT.TTY_DEVICES[z]);
}
}
 
cb_Device->setCurrentIndex(o_Settings->CLIENT.TTY_ID);
}
 
// Signale mit Slots verbinden
//////////////////////////////
void dlg_Main::init_Connections()
{
// Connect-Button
connect(btn_Connect, SIGNAL(clicked()), this, SLOT(slot_btn_Connect()));
 
connect(btn_cScope, SIGNAL(clicked()), this, SLOT(slot_btn_cScope()));
connect(btn_cSettings, SIGNAL(clicked()), this, SLOT(slot_btn_cSettings()));
connect(btn_cMaps, SIGNAL(clicked()), this, SLOT(slot_btn_cMaps()));
connect(btn_cVoice, SIGNAL(clicked()), this, SLOT(slot_btn_cVoice()));
connect(btn_cLogger, SIGNAL(clicked()), this, SLOT(slot_btn_cLogger()));
 
connect(btn_Terminal, SIGNAL(clicked()), this, SLOT(slot_btn_Terminal()));
 
// About QMK-Kernel & About-QT Dialog einfügen
connect(ac_About, SIGNAL(triggered()), this, SLOT(slot_ac_About()));
connect(ac_Server, SIGNAL(triggered()), this, SLOT(slot_ac_Server()));
menu_Help->addAction(trUtf8("Über &Qt"), qApp, SLOT(aboutQt()));
}
 
// IP-Ports initialisiern
/////////////////////////
// todo: Port und Anzahl aus Settings
bool dlg_Main::init_TCP()
{
Connect_Count = 0;
Connection[0].TCP = false;
Connection[0].UDP = false;
 
for (int a = 0; a < DEV_IP_MAX; a++)
{
Connection[a].Open = false;
}
 
TCP_Server = new QTcpServer(this);
 
if (TCP_Server->listen(QHostAddress::Any, qint16(o_Settings->SERVER.TCP_PORT)))
{
connect(TCP_Server, SIGNAL(newConnection()), this, SLOT(slot_TCP_NewConnection()));
}
 
return true;
}
 
// Eingangsdaten verarbeiten
////////////////////////////
void dlg_Main::parse_Input_Data(QString t_Data)
{
unsigned char OutData[150];
char *InData = t_Data.toLatin1().data();
 
if (HandlerMK::Decode_64(InData, t_Data.length(), OutData) != 0)
{
switch(InData[2])
{
case 'V' : // Versions-Info
{
o_Input->stop_Resend(DATA_VERSION);
VersionInfo = HandlerMK::parse_Version(OutData, InData[1] - 'a');
lb_Info->setText(tr("Verbunden mit ") + VersionInfo.Hardware + " " + VersionInfo.Version + trUtf8(" über ") + s_Input.Main + ".");
 
if (VersionInfo.ID == ADDRESS_FC)
{
rb_FC->setChecked(true);
}
if (VersionInfo.ID == ADDRESS_NC)
{
rb_NC->setChecked(true);
}
if (VersionInfo.ID == ADDRESS_MK3MAG)
{
rb_MK3MAG->setChecked(true);
}
}
break;
}
}
}
 
void dlg_Main::route_Input_Data(QString t_Data)
{
// An alle offenen TCP-Sockets senden.
for (int a = 1; a < DEV_IP_MAX; a++)
{
if (Connection[a].Open == true)
{
if (Connection[a].TCP == true)
{
send_TCP(o_TCP[a], t_Data + "\r");
}
}
}
}
 
void dlg_Main::parse_TCP_Data(QString t_Data, int t_ID)
{
QStringList Data;
Data = t_Data.split(":");
 
if (Data.count() > 1)
{
int CMD = Data[2].toInt();
 
switch(CMD)
{
case 101 :
{
Item[t_ID][1]->setText(Data[3]);
if (Connection[t_ID].Auth == true)
Item[t_ID][1]->setText("* " + Data[3]);
}
break;
case 105 :
{
if (Connection[t_ID].Auth == false)
{
if ((o_Settings->SERVER.Password != "") && (Data[3] == o_Settings->SERVER.Password))
{
send_TCP(o_TCP[t_ID],HandlerIP::make_Frame(ID_COMMUNICATOR, 505, "OK"));
 
Connection[t_ID].Auth = true;
Item[t_ID][1]->setText("* " + Item[t_ID][1]->text());
}
else
{
send_TCP(o_TCP[t_ID],HandlerIP::make_Frame(ID_COMMUNICATOR, 505, "NO"));
}
}
}
break;
}
}
}
 
// Freies IP-Socket ermitteln
int dlg_Main::get_FreeSocket()
{
for (int a = 1; a < DEV_IP_MAX; a++)
{
if (Connection[a].Open == false)
return a;
}
return 0;
}
 
// Daten auf TCP Senden
void dlg_Main::send_TCP(QTcpSocket *Socket, QString Data)
{
QByteArray SendText = Data.toAscii();
 
Socket->write(SendText + "\n");
}
 
///////////ettings
// Slots //
///////////
 
void dlg_Main::slot_btn_cScope()
{
QString Programm = QMK_Dir + "/QMK-Scope";
 
QStringList Argumente;
 
o_cScope = new QProcess();
 
Argumente << "";
 
o_cScope->start(Programm, Argumente); // Programmaufruf
}
 
void dlg_Main::slot_btn_cSettings()
{
QString Programm = QMK_Dir + "/QMK-Settings";
 
QStringList Argumente;
 
o_cSettings = new QProcess();
 
Argumente << "";
 
o_cSettings->start(Programm, Argumente); // Programmaufruf
}
 
void dlg_Main::slot_btn_cMaps()
{
QString Programm = QMK_Dir + "/QMK-Maps";
 
QStringList Argumente;
 
o_cMaps = new QProcess();
 
Argumente << "";
 
o_cMaps->start(Programm, Argumente); // Programmaufruf
}
 
void dlg_Main::slot_btn_cVoice()
{
QString Programm = QMK_Dir + "/QMK-Voice";
 
QStringList Argumente;
 
o_cVoice = new QProcess();
 
Argumente << "";
 
o_cVoice->start(Programm, Argumente); // Programmaufruf
}
 
void dlg_Main::slot_btn_cLogger()
{
QString Programm = QMK_Dir + "/QMK-Logger";
 
QStringList Argumente;
 
o_cLogger = new QProcess();
 
Argumente << "";
 
o_cLogger->start(Programm, Argumente); // Programmaufruf
}
 
void dlg_Main::slot_btn_Terminal()
{
if (!f_Terminal->isVisible())
{
f_Terminal->show();
}
}
 
// Verbindung herstellen
void dlg_Main::slot_btn_Connect()
{
if (!o_Input->IsOpen())
{
if (rb_Device->isChecked())
{
if (cb_Device->findText(cb_Device->currentText()) == -1)
{
cb_Device->addItem(cb_Device->currentText());
cb_Device->setCurrentIndex(cb_Device->findText(cb_Device->currentText()));
}
 
s_Input.Main = cb_Device->currentText();
 
o_Input = new Input_TTY();
o_Input->Init();
 
if (o_Input->Open(s_Input) == true)
{
connect(o_Input, SIGNAL(sig_NewData(QString)), this, SLOT(slot_Input_Data(QString)));
 
o_Input->send_Data(HandlerMK::make_Frame('v', 0, c_Data, 0).toLatin1().data(), DATA_VERSION);
 
btn_Connect->setText(tr("Trennen"));
cb_Device->setEnabled(false);
}
}
}
else
{
if (rb_Device->isChecked())
{
o_Input->Close();
btn_Connect->setText(tr("Verbinden"));
cb_Device->setEnabled(true);
}
}
}
 
// About-Dialog
void dlg_Main::slot_ac_About()
{
QMessageBox::about(this, trUtf8(("Über ")) + QA_NAME, QA_ABOUT);
}
 
void dlg_Main::slot_ac_Server()
{
dlg_Preferences *f_Preferences = new dlg_Preferences(this);
 
f_Preferences->set_Settings(o_Settings);
 
if (f_Preferences->exec()==QDialog::Accepted)
{
o_Settings = f_Preferences->get_Settings();
o_Settings->write_Settings();
}
}
 
// Neue Daten empfangen.
void dlg_Main::show_Terminal(int t_Typ, QString t_Data)
{
if (f_Terminal->isVisible())
{
f_Terminal->show_Data(t_Typ, t_Data);
}
}
 
void dlg_Main::slot_Input_Data(QString t_Data)
{
if (HandlerMK::Check_CRC(t_Data.toLatin1().data(), t_Data.length()))
{
show_Terminal(1, t_Data);
parse_Input_Data(t_Data);
route_Input_Data(t_Data);
}
else
{
show_Terminal(2, t_Data);
}
}
 
//////////////
// IP-Slots //
//////////////
 
void dlg_Main::slot_TCP_NewConnection()
{
if (!o_Input->IsOpen())
slot_btn_Connect();
 
int ID = get_FreeSocket();
 
if (ID != 0)
{
Connect_Count++;
// Leeres Connection erzeugen
Connection[ID] = Connection[0];
Connection[ID].Open = true;
Connection[ID].TCP = true;
Connection[ID].Auth = false;
 
o_TCP[ID] = TCP_Server->nextPendingConnection();
o_TCP[ID]->setProperty("ID", ID);
 
send_TCP(o_TCP[ID],HandlerIP::make_Frame(ID_COMMUNICATOR, 501, QA_NAME + " " + QA_VERSION));
 
connect(o_TCP[ID], SIGNAL(disconnected()),o_TCP[ID], SLOT(deleteLater()));
connect(o_TCP[ID], SIGNAL(disconnected()),this, SLOT(slot_TCP_Disconnect()));
connect(o_TCP[ID], SIGNAL(readyRead()),this, SLOT(slot_TCP_Read()));
 
Item[ID][0]->setText(o_TCP[ID]->peerAddress().toString());
lw_ClientsIP->addItem(Item[ID][0]);
Item[ID][1]->setText("n/a");
lw_Clients->addItem(Item[ID][1]);
 
if (Item[ID][0]->text() == "127.0.0.1")
Connection[ID].Auth = true;
 
if (Connection[ID].Auth)
Item[ID][1]->setText("* n/a");
 
}
else
{ // Server voll
o_TCP[ID] = TCP_Server->nextPendingConnection();
o_TCP[ID]->setProperty("ID", ID);
 
// send_TCP(o_TCP[ID], QString("SERVER FULL\n"));
o_TCP[ID]->disconnectFromHost();
}
}
 
void dlg_Main::slot_TCP_Read()
{
QTcpSocket *Socket = (QTcpSocket*)sender();
 
// if (Socket->canReadLine())
{
int ID = Socket->property("ID").toUInt();
ID = ID;
 
QString t_Data = QString(Socket->readLine((Socket->bytesAvailable())));
 
QStringList s_Data = t_Data.split('\r');
 
for (int z = 0; z < s_Data.length() - 1; z++)
{
if (s_Data[z][0] == '$')
{
// qDebug(QString("TCP: " + s_Data[z]).toLatin1().data());
parse_TCP_Data(s_Data[z], ID);
}
else
{ // Daten vom Client an den MK. todo: Nur erlauben wenn autemtifiziert oder Localhost
if ((Connection[ID].Auth == true))
{
show_Terminal(3, s_Data[z]);
o_Input->send_Data(s_Data[z]);
}
}
}
}
}
 
void dlg_Main::slot_TCP_Disconnect()
{
QTcpSocket *Socket = (QTcpSocket*)sender();
 
int ID = Socket->property("ID").toUInt();
 
Item[ID][1]->setText("Disconected");
 
Connection[ID] = Connection[0];
Connection[ID].Open = false;
 
Connect_Count--;
 
Socket->setProperty("ID", 0);
 
if (Connect_Count == 0)
slot_btn_Connect();
}
 
 
// Programm Ende
////////////////
dlg_Main::~dlg_Main()
{
o_Settings->GUI.isMax = isMaximized();
o_Settings->GUI.Size = size();
o_Settings->GUI.Point = pos();
 
o_Settings->CLIENT.TTY_MAX = cb_Device->count();
o_Settings->CLIENT.TTY_ID = cb_Device->currentIndex();
 
for (int z = 0; z < cb_Device->count(); z++)
{
if (z < 10)
{
o_Settings->CLIENT.TTY_DEVICES[z] = cb_Device->itemText(z);
}
}
 
 
o_Settings->write_Settings();
 
// qDebug("Ende.");
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Dialogs/dlg_Main.h
0,0 → 1,132
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef DLG_MAIN_H
#define DLG_MAIN_H
 
#include <QtGui/QMainWindow>
#include <QTcpServer>
#include <QTcpSocket>
#include <QProcess>
#include <QDir>
 
#include "ui_dlg_Main.h"
 
#include "dlg_Preferences.h"
#include "dlg_Terminal.h"
 
#include "../Defines.h"
#include "../TypeDefs.h"
 
#include "../Classes/cSettings.h"
 
#include "../../Global/Kopter.h"
#include "../../Global/Class_Input/Input.h"
#include "../../Global/Class_Input/Input_TTY.h"
#include "../../Global/Class_HandlerMK/HandlerMK.h"
#include "../../Global/Class_HandlerIP/HandlerIP.h"
#include "../../Global/Class_SerialPort/ManageSerialPort.h"
 
class dlg_Main : public QMainWindow, public Ui::dlg_Main_UI
{
Q_OBJECT
 
public:
dlg_Main();
~dlg_Main();
void set_ARGV(char *Programm);
 
private:
QString QMK_Dir;
 
// Input Device.
Input *o_Input;
set_Input s_Input;
 
// Settings-Object
cSettings *o_Settings;
 
dlg_Terminal *f_Terminal;
 
QProcess *o_cScope;
QProcess *o_cSettings;
QProcess *o_cMaps;
QProcess *o_cVoice;
QProcess *o_cLogger;
 
// TCP Server und Socket.
QTcpServer *TCP_Server;
QTcpSocket *o_TCP[DEV_IP_MAX];
 
//Liste alle IP-Verbindungen und deren Parameter.
int Connect_Count;
sConnection Connection[DEV_IP_MAX];
 
QListWidgetItem *Item[DEV_IP_MAX][2];
 
s_Hardware VersionInfo;
 
char c_Data[150];
 
// Programm-Initialisirungen
void init_GUI();
void init_Connections();
 
// IP-Ports initialisieren
bool init_TCP();
 
// Einkommende Datenpackete zerlegen.
void parse_Input_Data(QString t_Data);
 
// Einkommende Datenpackete weiterleiten
void route_Input_Data(QString t_Data);
 
void parse_TCP_Data(QString t_Data, int t_ID);
 
// Freies IP-Socket ermitteln
int get_FreeSocket();
 
// Daten aufs IP-Interface senden.
void send_TCP(QTcpSocket *Socket, QString Data);
 
void show_Terminal(int t_Typ, QString t_Data);
 
private slots:
void slot_ac_About();
void slot_ac_Server();
 
// Connect-Button
void slot_btn_Connect();
 
void slot_btn_cScope();
void slot_btn_cSettings();
void slot_btn_cMaps();
void slot_btn_cVoice();
void slot_btn_cLogger();
 
void slot_btn_Terminal();
 
// Einkommende Datenpackete.
void slot_Input_Data(QString t_Data);
 
void slot_TCP_NewConnection();
void slot_TCP_Disconnect();
void slot_TCP_Read();
};
 
#endif // DLG_MAIN_H
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Dialogs/dlg_Main.ui
0,0 → 1,503
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>dlg_Main_UI</class>
<widget class="QMainWindow" name="dlg_Main_UI">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>446</width>
<height>350</height>
</rect>
</property>
<property name="windowTitle">
<string>QMK-Communicator</string>
</property>
<property name="windowIcon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</iconset>
</property>
<widget class="QWidget" name="centralWidget">
<layout class="QGridLayout" name="gridLayout_9">
<property name="margin">
<number>2</number>
</property>
<item row="0" column="0">
<widget class="QGroupBox" name="groupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Verbindung zum Mikrokopter</string>
</property>
<layout class="QGridLayout" name="gridLayout_8">
<item row="0" column="0" colspan="2">
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_7">
<property name="margin">
<number>2</number>
</property>
<item row="0" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QRadioButton" name="rb_Device">
<property name="text">
<string>Device</string>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="rb_TCP">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>T CP</string>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="rb_UDP">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>UDP</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
<zorder></zorder>
</widget>
</item>
<item row="1" column="0">
<widget class="QWidget" name="wg_Device" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QGridLayout" name="gridLayout_5">
<property name="margin">
<number>2</number>
</property>
<item row="1" column="2">
<widget class="QComboBox" name="cb_Device">
<property name="editable">
<bool>true</bool>
</property>
<property name="insertPolicy">
<enum>QComboBox::InsertAtTop</enum>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="lb_Device">
<property name="text">
<string>Device:</string>
</property>
</widget>
</item>
<item row="0" column="2">
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>1</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
<item row="1" column="1">
<widget class="QWidget" name="wg_IP" native="true">
<property name="enabled">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_6">
<property name="margin">
<number>2</number>
</property>
<item row="0" column="1">
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>60</width>
<height>1</height>
</size>
</property>
</spacer>
</item>
<item row="1" column="1">
<widget class="QComboBox" name="cb_IP">
<property name="editable">
<bool>true</bool>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QComboBox" name="cb_Port">
<property name="editable">
<bool>true</bool>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QLabel" name="label_6">
<property name="text">
<string>Port:</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>IP:</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0" colspan="2">
<widget class="QFrame" name="frame_2">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<property name="margin">
<number>2</number>
</property>
<item row="1" column="0">
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QRadioButton" name="rb_FC">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>FlightCtrl</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QRadioButton" name="rb_NC">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>NaviCtrl</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QRadioButton" name="rb_MK3MAG">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>MK3MAG</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item row="2" column="0" colspan="2">
<widget class="QPushButton" name="btn_Connect">
<property name="text">
<string>Verbinden</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Client-Verbindungen</string>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<property name="horizontalSpacing">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QListWidget" name="lw_ClientsIP">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
</font>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QListWidget" name="lw_Clients">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
</font>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0" colspan="2">
<widget class="QLabel" name="lb_Info">
<property name="frameShape">
<enum>QFrame::Box</enum>
</property>
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="0" column="1" rowspan="2">
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Clients</string>
</property>
<layout class="QGridLayout" name="gridLayout_4">
<item row="0" column="0">
<widget class="QPushButton" name="btn_Terminal">
<property name="text">
<string>Terminal</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Actions/Global/Images/Actions/Terminal.png</normaloff>:/Actions/Global/Images/Actions/Terminal.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QPushButton" name="btn_cScope">
<property name="text">
<string>Scope</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Scope.png</normaloff>:/Icon/Global/Images/Icons/QMK-Scope.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QPushButton" name="btn_cSettings">
<property name="text">
<string>Settings</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Settings.png</normaloff>:/Icon/Global/Images/Icons/QMK-Settings.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QPushButton" name="btn_cMaps">
<property name="text">
<string>Maps</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Maps.png</normaloff>:/Icon/Global/Images/Icons/QMK-Maps.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
<item row="7" column="0">
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>229</height>
</size>
</property>
</spacer>
</item>
<item row="6" column="0">
<widget class="QPushButton" name="btn_cVoice">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Voice</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Voice.png</normaloff>:/Icon/Global/Images/Icons/QMK-Voice.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QPushButton" name="btn_cLogger">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Logger</string>
</property>
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Logger.png</normaloff>:/Icon/Global/Images/Icons/QMK-Logger.png</iconset>
</property>
<property name="iconSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<widget class="QMenuBar" name="menuBar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>446</width>
<height>21</height>
</rect>
</property>
<widget class="QMenu" name="menu_Program">
<property name="title">
<string>Programm</string>
</property>
<addaction name="ac_Quit"/>
</widget>
<widget class="QMenu" name="menu_Preferences">
<property name="title">
<string>Einstellungen</string>
</property>
<addaction name="ac_Server"/>
</widget>
<widget class="QMenu" name="menu_Help">
<property name="title">
<string>Hilfe</string>
</property>
<addaction name="ac_About"/>
</widget>
<addaction name="menu_Program"/>
<addaction name="menu_Preferences"/>
<addaction name="menu_Help"/>
</widget>
<action name="ac_Quit">
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Actions/Global/Images/Actions/Exit.png</normaloff>:/Actions/Global/Images/Actions/Exit.png</iconset>
</property>
<property name="text">
<string>Beenden</string>
</property>
</action>
<action name="ac_About">
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</iconset>
</property>
<property name="text">
<string>Über QMK-Communicator</string>
</property>
</action>
<action name="ac_Server">
<property name="icon">
<iconset resource="../QMK-Communicator.qrc">
<normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</normaloff>:/Icon/Global/Images/Icons/QMK-Communicator.png</iconset>
</property>
<property name="text">
<string>Server</string>
</property>
</action>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources>
<include location="../QMK-Communicator.qrc"/>
</resources>
<connections>
<connection>
<sender>ac_Quit</sender>
<signal>triggered()</signal>
<receiver>dlg_Main_UI</receiver>
<slot>close()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>182</x>
<y>88</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Dialogs/dlg_Preferences.cpp
0,0 → 1,42
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "dlg_Preferences.h"
 
dlg_Preferences::dlg_Preferences(QWidget *parent) : QDialog(parent)
{
setupUi(this);
}
 
void dlg_Preferences::set_Settings(cSettings *t_Settings)
{
o_Settings = t_Settings;
 
le_TCP_Port->setText(QString("%1").arg(o_Settings->SERVER.TCP_PORT));
le_UDP_Port->setText(QString("%1").arg(o_Settings->SERVER.UDP_PORT));
le_Password->setText(o_Settings->SERVER.Password);
}
 
cSettings *dlg_Preferences::get_Settings()
{
o_Settings->SERVER.Password = le_Password->text();
o_Settings->SERVER.TCP_PORT = le_TCP_Port->text().toInt();
o_Settings->SERVER.UDP_PORT = le_UDP_Port->text().toInt();
 
return o_Settings;
}
/QMK-Groundstation/tags/QMK-Tools v1.1.0a/QMK-Communicator/Dialogs/dlg_Preferences.h
0,0 → 1,41
/***************************************************************************
* Copyright (C) 2009 by Manuel Schrape *
* manuel.schrape@gmx.de *
* *
* 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. *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef DLG_PREFERENCES_H