Subversion Repositories Projects

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

 *   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.");

}