Qt: INTERNAL ERROR: failed to install GetMessage hook: 1158

#include "mainwindow.h"
#include "myserver.h"
#include <QApplication>
#include <QDir>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MyServer server;
    server.startServer();
    MainWindow w;
    QObject::connect(&server, SIGNAL(signal1(qreal)), &w, SLOT(onAppendData(qreal)));
    w.show();
    return a.exec();
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtCharts>
#include <QChartView>
#include <QChart>
#include <QDateTime>
#include <QDebug>

using namespace QtCharts;

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

    QLineSeries *series = new QLineSeries();
    QDateTimeAxis *axisX = new QDateTimeAxis;
    QValueAxis *axisY = new QValueAxis();
    int i = 0;
    QDateTime minX;
    QDateTime maxX;
    qreal minY;
    qreal maxY;

public slots:
    void onAppendData(qreal);
};
#endif // MAINWINDOW_H

#include "mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QWidget *widget = new QWidget;
    setCentralWidget(widget);
    QVBoxLayout *layout = new QVBoxLayout;
    layout->setMargin(5);
    widget->setLayout(layout);
    QChartView *chartView = new QChartView(this);
    layout->addWidget(chartView);

    QChart *chart = new QChart();
    chart->addSeries(series);
    chart->setTitle("График температуры во времени");

    axisX->setFormat("hh:mm:ss");
    axisX->setTitleText("Время");
    axisX->setTickCount(10);
    chart->addAxis(axisX, Qt::AlignBottom);
    series->attachAxis(axisX);

    axisY->setTitleText("Температура, °С");
    axisY->setLabelFormat("%g");
    axisY->setTickCount(10);
    chart->addAxis(axisY, Qt::AlignLeft);
    series->attachAxis(axisY);
    chartView->setChart(chart);
}

MainWindow::~MainWindow()
{
}

void MainWindow::onAppendData(qreal data)
{
    QDateTime x = QDateTime::currentDateTime();
    qreal y = data;
    if(i == 0){
        minX = x;
        maxX = x;
        minY = y;
        maxY = y;
        axisX->setRange(minX, maxX);
        axisY->setRange(minY, maxY);
        series->append(x.toMSecsSinceEpoch(), y);
    } else {
    minX = axisX->min();
    maxX = axisX->max();
    minY = axisY->min();
    maxY = axisY->max();
    axisX->setRange(x < minX ? x : minX, x > maxX ? x : maxX);
    axisY->setRange(y < minY ? y : minY, y > maxY ? y : maxY);
    if(i>99999){
        series->remove(0);
        minX = QDateTime::fromMSecsSinceEpoch(series->at(0).x());
        axisX->setRange(minX, x > maxX ? x : maxX);
    }
    series->append(x.toMSecsSinceEpoch(), y);
    }
    i++;
}

#ifndef MYSERVER_H
#define MYSERVER_H

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

class MyServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = 0);
    void startServer();
signals:
    void signal1(qreal);


public slots:
void onSignalData(qreal);
protected:
    void incomingConnection(qintptr socketDescriptor);

};

#endif // MYSERVER_H

#include "myserver.h"

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

void MyServer::startServer()
{
    int port = 5555;
    if(!this->listen(QHostAddress("192.168.1.201"),port))
    {
        qDebug() << "Could not start server";
    }
    else
    {
        qDebug() << "Listening to port " << port << "...";
    }

}

void MyServer::incomingConnection(qintptr socketDescriptor)
{
    qDebug() << socketDescriptor << " Connecting...";
    MyThread *thread = new MyThread(socketDescriptor, this);
    connect(thread, SIGNAL(signalData(qreal)), this, SLOT(onSignalData(qreal)), Qt::DirectConnection);
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

void MyServer::onSignalData(qreal data){
    qDebug()<<"слот сработал"<<data;
    emit signal1(data);
}

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTcpSocket>
#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 signalData(qreal);

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

private:
    QTcpSocket *socket;
    qintptr socketDescriptor;
};

#endif // MYTHREAD_H

#include "mythread.h"

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

void MyThread::run()
{
    qDebug() << " Thread started";
    socket = new QTcpSocket();
    if(!socket->setSocketDescriptor(this->socketDescriptor))
    {
        emit error(socket->error());
        return;
    }
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
    qDebug() << socketDescriptor << " Client connected";
    exec();
}

void MyThread::readyRead()
{
    QByteArray Data = socket->readAll();
    qDebug() << socketDescriptor << " Data in: " << Data;
    emit signalData(Data.toFloat());
}

void MyThread::disconnected()
{
    qDebug() << socketDescriptor << " Disconnected";
    socket->deleteLater();
    exit(0);
}