I hava a question for developing QT Application. I want to change GUI using SINGAL and SLOT. sendValue() from mythread.cpp to showValue() from myserver.cpp is good working. That connected very well and I can check the value.

But sendApp() from myserver.cpp to showApp() from application.cpp is not working. I'm confusing that not connection or no emit or other problem. There is two question. One is how to connect from sendApp() to showApp() using SIGNAL and SLOT. emit is not work? or connection is not work? I can't find cause. The other is is that possible if showApp() function work? Please Answer me. I am so sorry this is my first time to develop QT application.

application.h

#ifndef APPLICATION_H
#define APPLICATION_H

#include <QWidget>
#include <QObject>
#include <menu.h>
#include <QTcpServer>
#include "myserver.h"
#include "mythread.h"

QT_BEGIN_NAMESPACE
namespace Ui { class application; }
QT_END_NAMESPACE

class application : public QWidget
{
    Q_OBJECT

public:
    application(QWidget *parent = nullptr);
    ~application();

private slots:
    void on_menuBt_clicked();
    void menuBackBtClicked();
    void showApp(QString strValue);

private:
    Ui::application *ui;
    menu menuPage;

};

#endif // APPLICATION_H

application.cpp

#include "application.h"
#include "ui_application.h"
#include "myserver.h"
#include "mythread.h"

application::application(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::application)
{
    ui->setupUi(this);

    Myserver *myserver = new Myserver(this);


    ui->firstToggle->setVisible(false);
    ui->secondToggle->setVisible(false);
    ui->thirdToggle->setVisible(false);
    ui->forthToggle->setVisible(false);
    ui->stackedWidget->addWidget(&menuPage);

    ui->stackedWidget->insertWidget(1, &menuPage);

    connect(&menuPage, SIGNAL(menuBackClick()), this, SLOT(menuBackBtClicked()));
    connect(myserver, SIGNAL(sendApp(QString)), this, SLOT(showApp(QString)));

    setWindowFlags(Qt::FramelessWindowHint);

}

application::~application()
{
    delete ui;
}


void application::on_menuBt_clicked()
{
    ui->stackedWidget->setCurrentIndex(1); //menuLayout
}

void application::menuBackBtClicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}

void application::showApp(QString strValue) {
    QString compare = "13";
    int x = QString::compare(strValue,compare, Qt::CaseInsensitive);
    if(x == 0) {
        ui->firstToggle->setVisible(true);
    }
}

myserver.h

#ifndef MYSERVER_H
#define MYSERVER_H

#include <QObject>
#include <QTcpServer>
#include "mythread.h"
#include "application.h"

class Myserver : public QTcpServer
{
    Q_OBJECT

public:
    explicit Myserver(QObject *parent = 0);
    void startServer();
signals:
    void sendApp(QString strValue);

private slots:
    void showValue(QString strValue);

protected:
    void incomingConnection(qintptr socketDescriptor);

private:
    MyThread *mythread;


};

#endif // MYSERVER_H

myserver.cpp

#include "myserver.h"
#include "mythread.h"
#include "application.h"

Myserver::Myserver(QObject *parent) :
    QTcpServer(parent)
{
}

void Myserver::startServer()
{
    int port = 3333;

    if(!this->listen(QHostAddress::Any,port))
    {
        qDebug() << "Could not start server";
    }
    else
    {
        qDebug() << "Listening to port " << port << "...";
    }
}

void Myserver::incomingConnection(qintptr socketDescriptor)
{
    // We have a new connection
    qDebug() << socketDescriptor << " Connecting...";

    MyThread *thread = new MyThread(socketDescriptor, this);

    // connect signal/slot
    // once a thread is not needed, it will be beleted later
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    connect(thread, SIGNAL(sendValue(QString)), this, SLOT(showValue(QString)));

    thread->start();
}
void Myserver::showValue(QString strValue){
    emit sendApp(strValue);
}

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QTcpSocket>
#include <QThread>
#include <QDebug>

class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(qintptr ID, QObject *parent = 0);
    void run();

signals:
    void error(QTcpSocket::SocketError socketerror);
    void sendValue(QString strValue);

private slots:
    void readyRead();
    void disconnected();

private:
    QTcpSocket *socket;
    qintptr socketDescriptor;

};

#endif // MYTHREAD_H

mythread.cpp

#include "mythread.h"

#include <QThread>

MyThread::MyThread(qintptr ID, QObject *parent) :
    QThread(parent)
{
    this->socketDescriptor = ID;
}

int count = 0;

void MyThread::run()
{
    // thread starts here
    qDebug() << " Thread started";

    socket = new QTcpSocket();

    // set the ID
    if(!socket->setSocketDescriptor(this->socketDescriptor))
    {
        // something's wrong, we just emit a signal
        emit error(socket->error());
        return;
    }

    // connect socket and signal
    // note - Qt::DirectConnection is used because it's multithreaded
    //        This makes the slot to be invoked immediately, when the signal is emitted.

    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));

    // We'll have multiple clients, we want to know which is which
    qDebug() << socketDescriptor << "Client connected";

    QString strValue = QString::number(socketDescriptor);

    emit sendValue(strValue);

    // make this thread a loop,
    // thread will stay alive so that signal/slot to function properly
    // not dropped out in the middle when thread dies

    exec();
}

void MyThread::readyRead()
{
    // get the information
    QByteArray Data = socket->readAll();

    // will write on server side window
    qDebug() << socketDescriptor << " Data in: " << Data;

    socket->write(Data);
}

void MyThread::disconnected()
{
    qDebug() << socketDescriptor << " Disconnected";

    socket->deleteLater();
    exit(0);
}

CodePudding user response：

You just forgot to start your server!

It might work just by adding startServer() function call after your connections in application class constructor.

connect(&menuPage, SIGNAL(menuBackClick()), this, SLOT(menuBackBtClicked()));
connect(myserver, SIGNAL(sendApp(QString)), this, SLOT(showApp(QString)));

myserver->startServer();