| 0,0 → 1,1153 |
|---|
| /*************************************************************************** |
| * 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 <QDomDocument> |
| #include <QFile> |
| |
| #include "dlg_Main.h" |
| #include "dlg_MapPos.h" |
| |
| // Konstruktor Main-Form |
| dlg_Main::dlg_Main() |
| { |
| setupUi(this); |
| |
| o_Settings = new cSettings(); |
| |
| o_Input = new Input(); |
| |
| o_Map = new MapControl(QSize(25,25)); |
| l_RouteWP = new LineString(); |
| init_Directorys(); |
| init_GUI(); |
| init_Connections(); |
| } |
| |
| // 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(); |
| } |
| |
| for(int z = 0; z < o_Settings->SERVER.IP_MAX; z++) |
| { |
| if (cb_Server->findText(o_Settings->SERVER.IP[z]) == -1) |
| { |
| cb_Server->addItem(o_Settings->SERVER.IP[z]); |
| } |
| } |
| |
| cb_Server->setCurrentIndex(o_Settings->SERVER.IP_ID); |
| |
| le_Password->setText(o_Settings->SERVER.Password); |
| |
| sb_Intervall->setValue(o_Settings->DATA.Intervall); |
| |
| cb_CenterPos->setChecked(o_Settings->CONFIG.cb_CenterPos); |
| cb_ShowRoute->setChecked(o_Settings->CONFIG.cb_ShowRoute); |
| cb_ShowWPs->setChecked(o_Settings->CONFIG.cb_ShowWPs); |
| cb_Goto->setChecked(o_Settings->CONFIG.cb_Goto); |
| |
| // tb_More->addWidget(cb_Maps); |
| cb_Maps->setVisible(false); |
| |
| ac_Toolbar->setChecked(o_Settings->GUI.Toolbar); |
| |
| if (ac_Toolbar->isChecked()) |
| { |
| btn_Connect->setVisible(false); |
| } |
| else |
| { |
| ToolBar->setVisible(false); |
| tb_More->setVisible(false); |
| } |
| } |
| |
| // Signale mit Slots verbinden |
| void dlg_Main::init_Connections() |
| { |
| connect(ac_Connect, SIGNAL(triggered()), this, SLOT(slot_ac_Connect())); |
| connect(ac_Toolbar, SIGNAL(triggered()), this, SLOT(slot_ac_Toolbar())); |
| |
| // About QMK-Kernel & About-QT Dialog einfügen |
| connect(ac_About, SIGNAL(triggered()), this, SLOT(slot_ac_About())); |
| menu_Help->addAction(trUtf8("Über &Qt"), qApp, SLOT(aboutQt())); |
| |
| connect(sb_Intervall, SIGNAL(valueChanged(int)), this, SLOT(slot_sb_Intervall(int))); |
| |
| connect(sl_Zoom, SIGNAL(valueChanged(int)), this, SLOT(slot_Zoom(int))); |
| connect(cb_Maps, SIGNAL(currentIndexChanged(int)), this, SLOT(slot_ChangeMap(int))); |
| |
| connect(cb_ShowWPs, SIGNAL(toggled(bool)), this, SLOT(slot_ShowWayPoints(bool))); |
| |
| connect(btn_WPAdd, SIGNAL(clicked()), this, SLOT(slot_btn_WPAdd())); |
| connect(btn_WPFly, SIGNAL(clicked()), this, SLOT(slot_btn_WPFly())); |
| connect(btn_WPDelete, SIGNAL(clicked()), this, SLOT(slot_btn_WPDelete())); |
| |
| connect(ac_LoadRoute, SIGNAL(triggered()), this, SLOT(slot_ac_LoadWayPoints())); |
| connect(ac_SaveRoute, SIGNAL(triggered()), this, SLOT(slot_ac_SaveRoute())); |
| |
| connect(ac_LoadMap, SIGNAL(triggered()), this, SLOT(slot_ac_LoadMapPic())); |
| connect(ac_Record, SIGNAL(triggered()), this, SLOT(slot_ac_Record())); |
| connect(ac_RouteDelete, SIGNAL(triggered()), this, SLOT(slot_ac_RouteDelete())); |
| } |
| |
| void dlg_Main::init_Directorys() |
| { |
| QDir *t_Dir = new QDir(); |
| |
| s_Dir.MainData = QDir::homePath() + "/QMK-Data"; |
| if (!t_Dir->exists(s_Dir.MainData)) |
| { |
| t_Dir->mkdir(s_Dir.MainData); |
| } |
| |
| s_Dir.MapCache = s_Dir.MainData + "/Map-Cache"; |
| if (!t_Dir->exists(s_Dir.MapCache)) |
| { |
| t_Dir->mkdir(s_Dir.MapCache); |
| } |
| |
| s_Dir.WPRoutes = s_Dir.MainData + "/WP-Routes"; |
| if (!t_Dir->exists(s_Dir.WPRoutes)) |
| { |
| t_Dir->mkdir(s_Dir.WPRoutes); |
| } |
| |
| s_Dir.MapPics = s_Dir.MainData + "/Map-Pics"; |
| if (!t_Dir->exists(s_Dir.MapPics)) |
| { |
| t_Dir->mkdir(s_Dir.MapPics); |
| } |
| |
| s_Dir.Flights = s_Dir.MainData + "/Flights"; |
| if (!t_Dir->exists(s_Dir.Flights)) |
| { |
| t_Dir->mkdir(s_Dir.Flights); |
| } |
| } |
| |
| void dlg_Main::parse_IP_Data(QString t_Data) |
| { |
| QStringList Data; |
| Data = t_Data.split(":"); |
| |
| if (Data.count() > 1) |
| { |
| int CMD = Data[2].toInt(); |
| |
| switch(CMD) |
| { |
| case 501 : |
| { |
| o_Input->send_Data(HandlerIP::make_Frame(0, 105, le_Password->text())); |
| } |
| break; |
| case 505 : |
| { |
| if (Data[3] == "OK") |
| { |
| } |
| else |
| { |
| QMessageBox::warning(this, QA_NAME, trUtf8("Authentifizierung fehlgeschlagen. <br />Daten senden zum Mikrokopter nicht möglich."), QMessageBox::Ok); |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| // Eingangsdaten verarbeiten |
| void dlg_Main::parse_MK_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'); |
| setWindowTitle(QA_NAME + " " + QA_VERSION + " - " + VersionInfo.Hardware + " " + VersionInfo.Version); |
| |
| if (VersionInfo.ID == ADDRESS_NC) |
| { |
| c_Data[0] = sb_Intervall->value() / 10; |
| o_Input->send_Data(HandlerMK::make_Frame('o', ADDRESS_ALL, c_Data, 1).toLatin1().data()); |
| } |
| else // TODO: Befehl wenden zum Wechseln auf Navi. |
| { |
| } |
| } |
| break; |
| case 'O' : // Navi-OSD-Data |
| { |
| if (InData[1] - 'a' == ADDRESS_NC) |
| { |
| s_MK_NaviData MK_NaviData; |
| |
| memcpy((unsigned char *)&MK_NaviData, (unsigned char *)&OutData, sizeof(MK_NaviData)); |
| if (MK_NaviData.Version == MK_VERSION_NAVI) |
| { |
| show_Data(MK_NaviData); |
| add_Position(MK_NaviData); |
| } |
| } |
| } |
| break; |
| case 'W' : // WayPoints |
| { |
| o_Input->stop_Resend(DATA_WRITE_WAYPOINT); |
| |
| if (OutData[0] < l_WayPoints.count()) |
| { |
| send_WayPoints(l_WayPoints, OutData[0] + 1); |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////// |
| // QMK-Maps // |
| /////////////////////////////////////////////////////////////////// |
| |
| void dlg_Main::create_Map() |
| { |
| o_Map->resize(w_Map->size() - QSize(25,50)); |
| o_Map->enablePersistentCache(s_Dir.MapCache); |
| o_Map->showScale(true); |
| |
| o_Adapter = new OSMMapAdapter(); |
| |
| o_Layer = new MapLayer("MapLayer", o_Adapter); |
| o_Click = new GeometryLayer("Click", o_Adapter); |
| o_Info = new GeometryLayer("Poute", o_Adapter); |
| o_RouteWP = new GeometryLayer("Route-WayPoint", o_Adapter); |
| o_RouteFL = new GeometryLayer("Route-Flight", o_Adapter); |
| |
| o_Map->addLayer(o_Layer); |
| o_Map->addLayer(o_Click); |
| o_Map->addLayer(o_Info); |
| o_Map->addLayer(o_RouteWP); |
| o_Map->addLayer(o_RouteFL); |
| |
| o_Map->setZoom(17); |
| // o_Map->setView(QPointF(o_Settings->NAVI.Longitude,o_Settings->NAVI.Latitude)); |
| // o_Map->setView(QPointF(13.5,52.5)); |
| o_Map->setView(QPointF(13.419805,52.431787)); |
| connect(o_Map, SIGNAL(mouseEventCoordinate(const QMouseEvent*, const QPointF)), this, SLOT(slot_Click(const QMouseEvent*, const QPointF))); |
| |
| l_Map->addWidget(o_Map); |
| |
| sl_Zoom->setValue(17); |
| |
| // Flight |
| Pen[0] = new QPen(QColor(0,0,255,255)); |
| Pen[0]->setWidth(2); |
| Pen[1] = new QPen(QColor(0,0,255,255)); |
| Pen[1]->setWidth(1); |
| // WayPoint |
| Pen[2] = new QPen(QColor(255,0,0,255)); |
| Pen[2]->setWidth(2); |
| Pen[3] = new QPen(QColor(255,0,0,255)); |
| Pen[3]->setWidth(1); |
| // Info |
| Pen[4] = new QPen(QColor(0,128,128,255)); |
| Pen[4]->setWidth(2); |
| Pen[5] = new QPen(QColor(0,128,128,255)); |
| Pen[5]->setWidth(1); |
| } |
| |
| // auf Veränderung der Fenstergröße reagieren |
| void dlg_Main::resizeEvent ( QResizeEvent * event ) |
| { |
| event = event; |
| o_Map->resize(w_Map->size() - QSize(25,25)); |
| } |
| |
| void dlg_Main::wheelEvent(QWheelEvent *event) |
| { |
| int zoomValue = sl_Zoom->value(); |
| int numDegrees = event->delta() / 8; |
| int numSteps = numDegrees / 15; |
| zoomValue += numSteps; |
| if (zoomValue < 0) { zoomValue = 0;} |
| if (zoomValue > 17) { zoomValue = 17;} |
| sl_Zoom->setValue(zoomValue); |
| } |
| |
| QList<sWayPoint> dlg_Main::parse_WayPointKML(QString s_File) |
| { |
| QList<sWayPoint> tmp_WayPoints; |
| sWayPoint tmp_WayPoint; |
| |
| QFile f_KML(s_File); |
| f_KML.open(QIODevice::ReadOnly | QIODevice::Text); |
| |
| QByteArray s_KML; |
| |
| while (!f_KML.atEnd()) |
| { |
| s_KML.append(f_KML.readLine()); |
| } |
| |
| f_KML.close(); |
| |
| QDomDocument *UserXML; |
| UserXML = new QDomDocument; |
| |
| UserXML->setContent(s_KML); |
| |
| QDomElement Root = UserXML->firstChildElement("kml"); |
| QDomElement Document = Root.firstChildElement("Document"); |
| QDomElement Placemark = Document.firstChildElement("Placemark"); |
| QDomElement Linestring = Placemark.firstChildElement("LineString"); |
| |
| QString Name = Placemark.firstChildElement("name").toElement().text(); |
| |
| QString Route = Linestring.firstChildElement("coordinates").toElement().text(); |
| |
| QStringList s_Points = Route.split(" "); |
| |
| QStringList Position; |
| |
| for (int z = 0; z < s_Points.count() - 1; z++) |
| { |
| if (z != 20) |
| { |
| Position = s_Points[z].split(","); |
| tmp_WayPoint.Longitude = Position[0].toDouble(); |
| tmp_WayPoint.Latitude = Position[1].toDouble(); |
| tmp_WayPoint.Altitude = Position[2].toDouble(); |
| tmp_WayPoint.Time = sb_Time->value(); |
| |
| tmp_WayPoints.append(tmp_WayPoint); |
| } |
| else |
| { |
| QMessageBox::warning(this, QA_NAME,trUtf8("Die Wegpunkt-Liste umfasst mehr als 20 Einträge. Es werden nur die ersten 20 Einträge übernommen."), QMessageBox::Ok); |
| |
| btn_WPAdd->setEnabled(false); |
| |
| z = s_Points.count(); |
| } |
| } |
| return tmp_WayPoints; |
| } |
| |
| QList<sWayPoint> dlg_Main::parse_WayPointMKW(QString s_File) |
| { |
| QList<sWayPoint> tmp_WayPoints; |
| sWayPoint tmp_WayPoint; |
| |
| QFile f_MKW(s_File); |
| f_MKW.open(QIODevice::ReadOnly | QIODevice::Text); |
| |
| QString s_MKW; |
| |
| while (!f_MKW.atEnd()) |
| { |
| s_MKW.append(f_MKW.readLine()); |
| } |
| |
| f_MKW.close(); |
| |
| QStringList s_Points = s_MKW.split(" "); |
| |
| QStringList Position; |
| |
| for (int z = 0; z < s_Points.count() - 1; z++) |
| { |
| if (z != 20) |
| { |
| Position = s_Points[z].split(","); |
| tmp_WayPoint.Longitude = Position[0].toDouble(); |
| tmp_WayPoint.Latitude = Position[1].toDouble(); |
| tmp_WayPoint.Altitude = Position[2].toDouble(); |
| tmp_WayPoint.Time = Position[3].toInt(); |
| |
| tmp_WayPoints.append(tmp_WayPoint); |
| } |
| else |
| { |
| QMessageBox::warning(this, QA_NAME,trUtf8("Die Wegpunkt-Liste umfasst mehr als 20 Einträge. Es werden nur die ersten 20 Einträge übernommen."), QMessageBox::Ok); |
| |
| btn_WPAdd->setEnabled(false); |
| |
| z = s_Points.count(); |
| } |
| } |
| return tmp_WayPoints; |
| } |
| |
| // Waypoint-Route anzeigen in Karte |
| void dlg_Main::show_WayPoints(QList<sWayPoint> WayPoints) |
| { |
| Point* p_Point; |
| |
| o_RouteWP->removeGeometry(l_RouteWP); |
| p_RouteWP.clear(); |
| l_WayPoints.clear(); |
| |
| l_WayPoints = WayPoints; |
| |
| for (int z = 0; z < WayPoints.count(); z++) |
| { |
| p_Point = new Point(WayPoints[z].Longitude, WayPoints[z].Latitude); |
| |
| p_RouteWP.append(p_Point); |
| } |
| |
| l_RouteWP = new LineString(p_RouteWP, "", Pen[3]); |
| o_RouteWP->addGeometry(l_RouteWP); |
| |
| o_Map->setView(p_Point); |
| |
| o_Map->updateRequestNew(); |
| } |
| |
| // Waypoint-Liste speichern |
| void dlg_Main::save_WayPointsMKW(QString s_File) |
| { |
| QFile *f_MKW = new QFile(s_File); |
| |
| f_MKW->open(QIODevice::ReadWrite | QIODevice::Text); |
| |
| QTextStream out(f_MKW); |
| |
| out.setRealNumberPrecision(9); |
| |
| for (int z = 0; z < l_WayPoints.count(); z++) |
| { |
| out << l_WayPoints[z].Longitude << "," << l_WayPoints[z].Latitude << "," << l_WayPoints[z].Altitude << "," << l_WayPoints[z].Time << " \n"; |
| } |
| |
| f_MKW->close(); |
| } |
| |
| void dlg_Main::show_Data(s_MK_NaviData t_NaviData) |
| { |
| QString Mode = "NC-Flags : "; |
| if (t_NaviData.NCFlags & 0x08) {le_Mode->setText(tr("Range Limit")); Mode += "R";} |
| if (t_NaviData.NCFlags & 0x10) {le_Mode->setText(tr("Serial Error")); Mode += "S";} |
| if (t_NaviData.NCFlags & 0x20) {le_Mode->setText(tr("Target reached")); Mode += "T";} |
| if (t_NaviData.NCFlags & 0x40) {le_Mode->setText(tr("Manual Control")); Mode += "M";} |
| if (t_NaviData.NCFlags & 0x01) {le_Mode->setText(tr("Free")); Mode += "F";} |
| if (t_NaviData.NCFlags & 0x02) {le_Mode->setText(tr("Position Hold")); Mode += "P";} |
| if (t_NaviData.NCFlags & 0x04) {le_Mode->setText(tr("Coming Home")); Mode += "C";} |
| |
| //qDebug(Mode.toLatin1().data()); |
| |
| le_WP->setText(QString("%1/").arg(t_NaviData.WaypointIndex) + QString("%1").arg(t_NaviData.WaypointNumber)); |
| le_WPTime->setText(QString("%1:").arg(t_NaviData.TargetHoldTime / 60) + (QString("%1").arg(t_NaviData.TargetHoldTime % 60)).rightJustified(2, '0')); |
| le_WPDist->setText(QString("%1m").arg(t_NaviData.TargetPositionDeviation.Distance / 10)); |
| le_HomeDist->setText(QString("%1m").arg(t_NaviData.HomePositionDeviation.Distance / 10)); |
| } |
| |
| // Aktuelle MK-Position hinzufügen |
| void dlg_Main::add_Position(s_MK_NaviData t_NaviData) |
| { |
| sWayPoint WayPoint; |
| |
| WayPoint.Longitude = HandlerMK::Int2Double(t_NaviData.CurrentPosition.Longitude, 7); |
| WayPoint.Latitude = HandlerMK::Int2Double(t_NaviData.CurrentPosition.Latitude, 7); |
| WayPoint.Altitude = HandlerMK::Int2Double(t_NaviData.CurrentPosition.Altitude, 3); |
| |
| o_Settings->NAVI.Latitude = WayPoint.Latitude; |
| o_Settings->NAVI.Longitude = WayPoint.Longitude; |
| |
| l_Track.append(WayPoint); |
| |
| o_RouteFL->removeGeometry(l_RouteFL); |
| p_RouteFL.append(new Point(WayPoint.Longitude, WayPoint.Latitude)); |
| |
| o_Click->removeGeometry(LastPos); |
| |
| Point* P = new CirclePoint(WayPoint.Longitude, WayPoint.Latitude, "P1", Point::Middle, Pen[0]); |
| LastPos = P; |
| // P->setBaselevel(17); |
| o_Click->addGeometry(P); |
| |
| // Target anzeigen |
| o_Click->removeGeometry(Target); |
| |
| Target = new ImagePoint( HandlerMK::Int2Double(t_NaviData.TargetPosition.Longitude, 7), HandlerMK::Int2Double(t_NaviData.TargetPosition.Latitude, 7), ":/Flags/Global/Images/Flags/Target.png", "Start"); |
| Target->setBaselevel(o_Adapter->adaptedZoom()); |
| o_Click->addGeometry(Target); |
| |
| if (cb_CenterPos->isChecked()) |
| { |
| o_Map->setView(QPointF(WayPoint.Longitude, WayPoint.Latitude)); |
| } |
| |
| if (cb_ShowRoute->isChecked()) |
| { |
| l_RouteFL = new LineString(p_RouteFL, "", Pen[1]); |
| |
| o_RouteFL->addGeometry(l_RouteFL); |
| } |
| o_Map->updateRequestNew(); |
| |
| if (ac_Record->isChecked()) |
| { |
| QTextStream Out(o_Record); |
| |
| Out.setRealNumberPrecision(9); |
| |
| Out << WayPoint.Longitude << ", " << WayPoint.Latitude << ", " << WayPoint.Altitude << "\n"; |
| } |
| } |
| |
| // Ein Ziel anfliegen. |
| // TODO: Check auf Entfernung zur IST-Position. |
| void dlg_Main::send_Target(Point *t_Target) |
| { |
| if (l_Track.length() > 0) |
| { |
| s_MK_WayPoint s_WayPoint; |
| |
| s_WayPoint.Position.Latitude = int32_t(t_Target->latitude() * 10000000+0.5); |
| s_WayPoint.Position.Longitude = int32_t(t_Target->longitude() * 10000000+0.5); |
| s_WayPoint.Position.Altitude = 0; |
| s_WayPoint.Position.Status = NEWDATA; |
| s_WayPoint.Heading = -1; |
| s_WayPoint.ToleranceRadius = 5; |
| s_WayPoint.HoldTime = sb_Time->value(); |
| s_WayPoint.Event_Flag = 0; |
| s_WayPoint.reserve[0] = 0; // reserve |
| s_WayPoint.reserve[1] = 0; // reserve |
| s_WayPoint.reserve[2] = 0; // reserve |
| s_WayPoint.reserve[3] = 0; |
| |
| memcpy((unsigned char *)&c_Data, (unsigned char *)&s_WayPoint, sizeof(s_WayPoint)); |
| o_Input->send_Data(HandlerMK::make_Frame('s', ADDRESS_NC, c_Data, sizeof(s_WayPoint)).toLatin1().data()); |
| } |
| else |
| { |
| QMessageBox::warning(this, QA_NAME,tr("Es wurden noch keine aktuellen Positionsdaten vom Mikrokopter empfangen."), QMessageBox::Ok); |
| } |
| } |
| |
| //Waypoint-Liste zum MK senden |
| void dlg_Main::send_WayPoints(QList<sWayPoint> t_WayPoints, int t_Pos) |
| { |
| s_MK_WayPoint s_WayPoint; |
| double Longitude, Latitude; |
| |
| if (t_Pos == 0) |
| { // Waypoint-Liste löschen |
| s_WayPoint.Position.Status = INVALID; |
| |
| memcpy((unsigned char *)&c_Data, (unsigned char *)&s_WayPoint, sizeof(s_WayPoint)); |
| o_Input->send_Data(HandlerMK::make_Frame('w', ADDRESS_NC, c_Data, sizeof(s_WayPoint)).toLatin1().data(), DATA_WRITE_WAYPOINT); |
| } |
| else |
| { |
| int z = t_Pos - 1; |
| Longitude = t_WayPoints[z].Longitude; |
| Latitude = t_WayPoints[z].Latitude; |
| |
| if (Longitude < 100) |
| Longitude *= 10000000+0.5; |
| |
| if (Latitude < 100) |
| Latitude *= 10000000+0.5; |
| |
| //fülle Wegpunkt-Daten |
| s_WayPoint.Position.Altitude = 0; |
| s_WayPoint.Position.Longitude = int32_t(Longitude); |
| s_WayPoint.Position.Latitude = int32_t(Latitude); |
| s_WayPoint.Position.Status = NEWDATA; |
| s_WayPoint.Heading = -1; |
| s_WayPoint.ToleranceRadius = 5; |
| s_WayPoint.HoldTime = t_WayPoints[z].Time; |
| s_WayPoint.Event_Flag = 0; |
| s_WayPoint.reserve[0] = 0; // reserve |
| s_WayPoint.reserve[1] = 0; // reserve |
| s_WayPoint.reserve[2] = 0; // reserve |
| s_WayPoint.reserve[3] = 0; // reserve |
| |
| memcpy((unsigned char *)&c_Data, (unsigned char *)&s_WayPoint, sizeof(s_WayPoint)); |
| o_Input->send_Data(HandlerMK::make_Frame('w', ADDRESS_NC, c_Data, sizeof(s_WayPoint)).toLatin1().data(), DATA_WRITE_WAYPOINT); |
| } |
| } |
| |
| /////////// |
| // Slots // |
| /////////// |
| |
| // About-Dialog |
| void dlg_Main::slot_ac_About() |
| { |
| QMessageBox::about(this, trUtf8(("Über ")) + QA_NAME, QA_ABOUT); |
| } |
| |
| void dlg_Main::slot_ac_Toolbar() |
| { |
| if (ac_Toolbar->isChecked()) |
| { |
| btn_Connect->setVisible(false); |
| ToolBar->setVisible(true); |
| tb_More->setVisible(true); |
| } |
| else |
| { |
| btn_Connect->setVisible(true); |
| ToolBar->setVisible(false); |
| tb_More->setVisible(false); |
| } |
| } |
| |
| |
| // Datenintervall geändert. |
| void dlg_Main::slot_sb_Intervall(int t_Intervall) |
| { |
| if (t_Intervall == 0) |
| { |
| c_Data[0] = 0; |
| } |
| else |
| { |
| c_Data[0] = t_Intervall / 10; |
| } |
| o_Input->send_Data(HandlerMK::make_Frame('o', ADDRESS_ALL, c_Data, 1).toLatin1().data()); |
| } |
| |
| // Verbindung zum Server auf f_Settings = new wdg_Settings( this );bauen |
| void dlg_Main::slot_ac_Connect() |
| { |
| if (!o_Input->IsOpen()) |
| { |
| if (cb_Server->findText(cb_Server->currentText()) == -1) |
| { |
| cb_Server->addItem(cb_Server->currentText()); |
| cb_Server->setCurrentIndex(cb_Server->findText(cb_Server->currentText())); |
| } |
| |
| cb_Server->setEnabled(false); |
| le_Password->setEnabled(false); |
| |
| if (cb_Server->currentText().startsWith('/')) |
| { |
| o_Input = new Input_TTY(); |
| o_Input->Init(); |
| |
| set_Input s_Input; |
| s_Input.Main = cb_Server->currentText(); |
| |
| if (o_Input->Open(s_Input) == true) |
| { |
| ac_Connect->setText(tr("Trennen")); |
| 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); |
| } |
| else |
| { |
| cb_Server->setEnabled(true); |
| le_Password->setEnabled(true); |
| } |
| |
| } |
| else |
| { |
| o_Input = new Input_TCP(); |
| o_Input->Init(); |
| |
| set_Input s_Input; |
| |
| QStringList Server = cb_Server->currentText().split(":"); |
| |
| s_Input.Main = Server[0]; |
| s_Input.Sub = Server[1]; |
| |
| if (o_Input->Open(s_Input) == true) |
| { |
| connect(o_Input, SIGNAL(sig_Disconnected(int)), this, SLOT(slot_Input_Disconnected(int))); |
| connect(o_Input, SIGNAL(sig_Connected()), this, SLOT(slot_Input_Connected())); |
| } |
| } |
| } |
| else |
| { |
| cb_Server->setEnabled(true); |
| le_Password->setEnabled(true); |
| |
| ac_Connect->setText(tr("Verbinden")); |
| o_Input->Close(); |
| disconnect(o_Input, SIGNAL(sig_NewData(QString)), 0, 0); |
| if (o_Input->Mode() == TCP) |
| { |
| disconnect(o_Input, SIGNAL(sig_Disconnected(int)), 0, 0); |
| disconnect(o_Input, SIGNAL(sig_Connected()), 0, 0); |
| } |
| } |
| } |
| |
| // Neue Daten empfangen. |
| void dlg_Main::slot_Input_Data(QString t_Data) |
| { |
| if ((t_Data[0] == '#')) |
| { |
| if ((HandlerMK::Check_CRC(t_Data.toLatin1().data(), t_Data.length() - 1)) || ((o_Input->Mode() == TTY) && (HandlerMK::Check_CRC(t_Data.toLatin1().data(), t_Data.length())))) |
| { |
| parse_MK_Data(t_Data); |
| } |
| else |
| { |
| // qDebug(QString("CRC-Error - " + t_Data).toLatin1().data()); |
| } |
| } |
| else if (o_Input->Mode() == TCP) |
| { |
| parse_IP_Data(t_Data); |
| } |
| } |
| |
| // Serververbindung beendet |
| void dlg_Main::slot_Input_Disconnected(int Error) |
| { |
| cb_Server->setEnabled(true); |
| le_Password->setEnabled(true); |
| |
| // qDebug("Close"); |
| disconnect(o_Input, SIGNAL(sig_NewData(QString)), 0, 0); |
| if (o_Input->Mode() == TCP) |
| { |
| disconnect(o_Input, SIGNAL(sig_Disconnected(int)), 0, 0); |
| disconnect(o_Input, SIGNAL(sig_Connected()), 0, 0); |
| } |
| ac_Connect->setChecked(false); |
| ac_Connect->setText(tr("Verbinden")); |
| btn_Connect->setChecked(false); |
| |
| switch (Error) |
| { |
| case REMOTECLOSED : |
| { |
| // lb_Status->setText(tr("Verbindung vom Server beendet.")); |
| QMessageBox::warning(this, QA_NAME,tr("QMK-Datenserver: Verbindung wurde vom Server beendet."), QMessageBox::Ok); |
| } |
| break; |
| case REFUSED : |
| { |
| // lb_Status->setText(tr("Server nicht gefunden.")); |
| QMessageBox::warning(this, QA_NAME,tr("QMK-Datenserver: Kann nicht zum Server verbinden."), QMessageBox::Ok); |
| } |
| break; |
| case 3 : |
| { |
| // lb_Status->setText(tr("Serververbindung getrennt. Logindaten falsch.")); |
| QMessageBox::warning(this, QA_NAME,tr("QMK-Datenserver: Loginname oder Password falsch."), QMessageBox::Ok); |
| } |
| break; |
| default : |
| { |
| // lb_Status->setText(tr("Getrennt vom QMK-Datenserver.")); |
| } |
| break; |
| } |
| |
| } |
| |
| // Serververbindung hergestellt |
| void dlg_Main::slot_Input_Connected() |
| { |
| connect(o_Input, SIGNAL(sig_NewData(QString)), this, SLOT(slot_Input_Data(QString))); |
| |
| o_Input->send_Data(HandlerIP::make_Frame(0, 101, QA_NAME + " " + QA_VERSION)); |
| o_Input->send_Data(HandlerMK::make_Frame('v', 0, c_Data, 0).toLatin1().data(), DATA_VERSION); |
| ac_Connect->setText(tr("Trennen")); |
| } |
| |
| /////////////////////////////////////////////////////////////////// |
| // QMK-Maps // |
| /////////////////////////////////////////////////////////////////// |
| |
| // Zoom der Karte ändern |
| void dlg_Main::slot_Zoom(int t_Zoom) |
| { |
| o_Map->setZoom(t_Zoom); |
| } |
| |
| // Karte wechseln |
| void dlg_Main::slot_ChangeMap(int t_Set) |
| { |
| int zoom = o_Adapter->adaptedZoom(); |
| QPointF a = o_Map->currentCoordinate(); |
| |
| o_Map->setZoom(0); |
| |
| switch(t_Set) |
| { |
| case 0 : // OpenStreetMap |
| { |
| o_Adapter = new OSMMapAdapter(); |
| } |
| break; |
| case 1 : // Yahoo Sat |
| { |
| o_Adapter = new TileMapAdapter("tile.openaerialmap.org", "/tiles/1.0.0/openaerialmap-900913/%1/%2/%3.png", 256, 0, 17); |
| } |
| break; |
| case 2 : // Google Maps |
| { |
| o_Adapter = new GoogleMapAdapter(); |
| } |
| break; |
| case 3 : // Google Sat |
| { |
| o_Adapter = new GoogleSatMapAdapter(); |
| } |
| break; |
| case 4 : // Yahoo Maps |
| { |
| o_Adapter = new YahooMapAdapter(); |
| } |
| break; |
| case 5 : // Yahoo Sat |
| { |
| o_Adapter = new YahooMapAdapter("us.maps3.yimg.com", "/aerial.maps.yimg.com/png?v=1.7&t=a&s=256&x=%2&y=%3&z=%1"); |
| } |
| break; |
| } |
| |
| o_Layer->setMapAdapter(o_Adapter); |
| o_Click->setMapAdapter(o_Adapter); |
| o_Info->setMapAdapter(o_Adapter); |
| o_RouteWP->setMapAdapter(o_Adapter); |
| o_RouteFL->setMapAdapter(o_Adapter); |
| |
| o_Map->updateRequestNew(); |
| o_Map->setZoom(zoom); |
| } |
| |
| // Click in die Karte |
| void dlg_Main::slot_Click(const QMouseEvent* Event, const QPointF Coord) |
| { |
| if ((Event->type() == QEvent::MouseButtonPress) && ((Event->button() == Qt::RightButton) || (Event->button() == Qt::MidButton))) |
| { |
| sl_Zoom->setValue(o_Adapter->adaptedZoom()); |
| } |
| |
| // Überwachen ob Karte verschoben wird |
| if ((Event->type() == QEvent::MouseButtonPress) && (Event->button() == Qt::LeftButton)) |
| { |
| MapCenter = o_Map->currentCoordinate(); |
| } |
| |
| // Nur wenn nicht Verschoben dann einen Punkt setzen |
| if ((Event->type() == QEvent::MouseButtonRelease) && (Event->button() == Qt::LeftButton)) |
| { |
| if (o_Map->currentCoordinate() == MapCenter) |
| { |
| if (l_WayPoints.count() < 20) |
| { |
| btn_WPAdd->setEnabled(true); |
| } |
| |
| o_Click->removeGeometry(ClickPoint); |
| |
| ClickPoint = new CirclePoint(Coord.x(), Coord.y(), 6, "P1", Point::Middle, Pen[2]); |
| |
| |
| LastClick = new Point(Coord.x(), Coord.y()); |
| |
| ClickPoint->setBaselevel(o_Adapter->adaptedZoom()); |
| o_Click->addGeometry(ClickPoint); |
| |
| // o_Click->removeGeometry(Flag); |
| // Flag = new ImagePoint(Coord.x(), Coord.y(), ":/Flags/Global/Images/Flags/Target.png", "Start"); |
| // Flag->setBaselevel(o_Adapter->adaptedZoom()); |
| // o_Click->addGeometry(Flag); |
| |
| |
| if (cb_Goto->isChecked()) |
| { |
| send_Target(LastClick); |
| } |
| } |
| } |
| |
| o_Map->updateRequestNew(); |
| // qDebug(QString("%1").arg(Coord.x()).toLatin1().data()); |
| // qDebug(QString("%1").arg(Coord.y()).toLatin1().data()); |
| } |
| |
| // WayPoint zur Liste hinzufügen |
| void dlg_Main::slot_btn_WPAdd() |
| { |
| cb_ShowWPs->setChecked(true); |
| |
| sWayPoint WayPoint; |
| |
| WayPoint.Longitude = LastClick->longitude(); |
| WayPoint.Latitude = LastClick->latitude(); |
| WayPoint.Time = sb_Time->value(); |
| |
| l_WayPoints.append(WayPoint); |
| |
| o_RouteWP->removeGeometry(l_RouteWP); |
| |
| p_RouteWP.append(LastClick); |
| l_RouteWP = new LineString(p_RouteWP, "", Pen[3]); |
| |
| o_RouteWP->addGeometry(l_RouteWP); |
| o_Map->updateRequestNew(); |
| |
| btn_WPFly->setEnabled(true); |
| |
| if (l_WayPoints.count() == 20) |
| { |
| QMessageBox::warning(this, QA_NAME,trUtf8("Wegpunkt-Liste ist voll. Es können maximal 20 Wegpunkte benutzt werden."), QMessageBox::Ok); |
| btn_WPAdd->setEnabled(false); |
| } |
| } |
| |
| // WayPoint-Liste übertragen |
| void dlg_Main::slot_btn_WPFly() |
| { |
| send_WayPoints(l_WayPoints, 0); |
| } |
| |
| // WayPpoint-Liste löschen |
| void dlg_Main::slot_btn_WPDelete() |
| { |
| p_RouteWP.clear(); |
| l_WayPoints.clear(); |
| o_RouteWP->clearGeometries(); |
| l_RouteWP = new LineString(p_RouteWP, "", Pen[0]); |
| // o_RouteWP->addGeometry(l_RouteWP); |
| // o_RouteWP->removeGeometry(l_RouteWP); |
| |
| o_Map->updateRequestNew(); |
| |
| btn_WPFly->setEnabled(false); |
| btn_WPAdd->setEnabled(true); |
| } |
| |
| // WayPoint-Liste laden |
| void dlg_Main::slot_ac_LoadWayPoints() |
| { |
| QString Filename = QFileDialog::getOpenFileName(this, "WayPoint-Route laden", s_Dir.WPRoutes, "Mikrokopter WayPoints(*.mkw);;KML-Datei(*.kml);;Alle Dateien (*)"); |
| |
| if (!Filename.isEmpty()) |
| { |
| if (Filename.endsWith(".kml", Qt::CaseInsensitive)) |
| { |
| cb_ShowWPs->setChecked(true); |
| btn_WPFly->setEnabled(true); |
| |
| show_WayPoints(parse_WayPointKML(Filename)); |
| } |
| if (Filename.endsWith(".mkw", Qt::CaseInsensitive)) |
| { |
| cb_ShowWPs->setChecked(true); |
| btn_WPFly->setEnabled(true); |
| |
| show_WayPoints(parse_WayPointMKW(Filename)); |
| } |
| } |
| } |
| |
| // WayPoint-Liste speichern |
| void dlg_Main::slot_ac_SaveRoute() |
| { |
| QString Filename = QFileDialog::getSaveFileName(this, "WayPoint-Route speichern", s_Dir.WPRoutes, "Mikrokopter WayPoints(*.mkw);;Alle Dateien (*)"); |
| |
| if (!Filename.isEmpty()) |
| { |
| if (!(Filename.endsWith(".mkw", Qt::CaseInsensitive))) |
| { |
| Filename = Filename + QString(".mkw"); |
| } |
| |
| save_WayPointsMKW(Filename); |
| } |
| } |
| |
| // Route anzeigen / ausblenden |
| void dlg_Main::slot_ShowWayPoints(bool Show) |
| { |
| if (Show == true) |
| { |
| // qDebug("Error 1"); |
| if (l_RouteWP->hasPoints()) |
| { |
| // qDebug("Error 2"); |
| o_RouteWP->addGeometry(l_RouteWP); |
| // qDebug("Error 3"); |
| o_Map->updateRequestNew(); |
| // qDebug("Error 4"); |
| } |
| } |
| else |
| { |
| o_RouteWP->removeGeometry(l_RouteWP); |
| o_Map->updateRequestNew(); |
| } |
| } |
| |
| // Bilddatei als Karteladen. |
| void dlg_Main::slot_ac_LoadMapPic() |
| { |
| QString Filename = QFileDialog::getOpenFileName(this, "Bild als Karte", s_Dir.MapPics, "Bilddatei(*.jpg *.png *.gif);;Alle Dateien (*)"); |
| |
| if (!Filename.isEmpty()) |
| { |
| QFile *f_Points = new QFile(Filename + ".pos"); |
| |
| if (f_Points->exists()) |
| { |
| f_Points->open(QIODevice::ReadOnly | QIODevice::Text); |
| |
| QString s_Points; |
| |
| while (!f_Points->atEnd()) |
| { |
| s_Points.append(f_Points->readLine()); |
| } |
| |
| f_Points->close(); |
| |
| QStringList s_Pos = s_Points.split(","); |
| |
| FixedImageOverlay* fip = new FixedImageOverlay(s_Pos[0].toDouble(), s_Pos[1].toDouble(), s_Pos[2].toDouble(), s_Pos[3].toDouble(), Filename); |
| |
| o_Layer->addGeometry(fip); |
| o_Map->setView(QPointF(((s_Pos[0].toDouble() + s_Pos[2].toDouble()) / 2),((s_Pos[1].toDouble() + s_Pos[3].toDouble()) / 2))); |
| |
| o_Map->updateRequestNew(); |
| } |
| else |
| { |
| dlg_MapPos *f_MapPos = new dlg_MapPos(this); |
| |
| if (f_MapPos->exec()==QDialog::Accepted) |
| { |
| QString Data = f_MapPos->get_Data(); |
| |
| f_Points->open(QIODevice::ReadWrite | QIODevice::Text); |
| |
| QTextStream out(f_Points); |
| |
| out.setRealNumberPrecision(9); |
| |
| out << Data << "\n"; |
| |
| f_Points->close(); |
| |
| QStringList s_Pos = Data.split(","); |
| |
| FixedImageOverlay* fip = new FixedImageOverlay(s_Pos[0].toDouble(), s_Pos[1].toDouble(), s_Pos[2].toDouble(), s_Pos[3].toDouble(), Filename); |
| |
| o_Layer->addGeometry(fip); |
| o_Map->updateRequestNew(); |
| } |
| |
| } |
| } |
| } |
| |
| // Flug als KML aufzeichnen |
| void dlg_Main::slot_ac_Record() |
| { |
| if (ac_Record->isChecked()) |
| { |
| QString f_Name = s_Dir.Flights + "/" + QDate::currentDate().toString(("yyyy-MM-dd")) + "_" + QTime::currentTime().toString("hh-mm"); |
| |
| ac_Record->setText(tr("Stoppen")); |
| |
| o_Record = new QFile(f_Name + ".kml"); |
| o_Record->open(QIODevice::Append | QIODevice::Text); |
| |
| QTextStream Out(o_Record); |
| Out << HandlerKML::get_Header(tr("Mikrokopter Flugaufzeichnung")) << "\n"; |
| |
| } |
| else |
| { |
| QTextStream Out(o_Record); |
| Out << HandlerKML::get_Footer() << "\n"; |
| o_Record->close(); |
| ac_Record->setText(tr("Aufzeichnen")); |
| } |
| } |
| |
| // WayPpoint-Liste löschen |
| void dlg_Main::slot_ac_RouteDelete() |
| { |
| p_RouteFL.clear(); |
| l_Track.clear(); |
| o_RouteFL->clearGeometries(); |
| l_RouteFL = new LineString(p_RouteFL, "", Pen[0]); |
| // o_RouteFL->removeGeometry(l_RouteFL); |
| |
| o_Map->updateRequestNew(); |
| } |
| |
| // Programm Ende |
| dlg_Main::~dlg_Main() |
| { |
| o_Settings->GUI.isMax = isMaximized(); |
| o_Settings->GUI.Size = size(); |
| o_Settings->GUI.Point = pos(); |
| o_Settings->GUI.Toolbar = ac_Toolbar->isChecked(); |
| |
| o_Settings->DATA.Intervall = sb_Intervall->value(); |
| |
| o_Settings->SERVER.Password = le_Password->text(); |
| o_Settings->SERVER.IP_MAX = cb_Server->count(); |
| o_Settings->SERVER.IP_ID = cb_Server->currentIndex(); |
| |
| for (int z = 0; z < cb_Server->count(); z++) |
| { |
| if (z < 10) |
| { |
| o_Settings->SERVER.IP[z] = cb_Server->itemText(z); |
| } |
| } |
| |
| o_Settings->CONFIG.cb_CenterPos = cb_CenterPos->isChecked(); |
| o_Settings->CONFIG.cb_ShowRoute = cb_ShowRoute->isChecked(); |
| o_Settings->CONFIG.cb_ShowWPs = cb_ShowWPs->isChecked(); |
| o_Settings->CONFIG.cb_Goto = cb_Goto->isChecked(); |
| |
| o_Settings->NAVI.StayTime = sb_Time->value(); |
| |
| o_Settings->write_Settings(); |
| |
| // qDebug("Ende."); |
| } |