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