// 头文件 mywidget.h（类声明必须放在头文件，MOC仅解析头文件）
#ifndef MYWIDGET_H
#define MYWIDGET_H

#include <QWidget>

// 必须继承QObject或其子类（QWidget是QObject的子类）
class MyWidget : public QWidget
{
    // 必须添加此宏，启用元对象系统
    Q_OBJECT

public:
    explicit MyWidget(QWidget *parent = nullptr);
    ~MyWidget();

// 信号声明区
signals:
    void mySignal(int value);

// 槽函数声明区
public slots:
    void mySlot(int value);
};

#endif // MYWIDGET_H

MyWidget *w = new MyWidget;
QPushButton *btn = new QPushButton("点击", w);

// 基础连接：按钮点击信号 连接到 窗口槽函数
QObject::connect(btn, &QPushButton::clicked, w, &MyWidget::mySlot);

// 连接Lambda表达式（Qt5核心优势）
QObject::connect(btn, &QPushButton::clicked, w, [=](){
    qDebug() << "按钮被点击";
});

// 信号连接信号（信号转发）
QObject::connect(btn, &QPushButton::clicked, w, &MyWidget::mySignal);

// 1. 断开发送者所有信号的所有连接
disconnect(sender, nullptr, nullptr, nullptr);

// 2. 断开发送者特定信号的所有连接
disconnect(sender, &Sender::signal, nullptr, nullptr);

// 3. 断开发送者和接收者的所有连接
disconnect(sender, nullptr, receiver, nullptr);

// 4. 断开特定的信号槽连接
disconnect(sender, &Sender::signal, receiver, &Receiver::slot);

# 1. 模块引入（Qt5默认包含core、gui模块，widgets需手动添加）
QT += core gui widgets  # 基础桌面项目必选
QT += network           # 新增网络模块
QT += sql               # 新增数据库模块
QT -= gui               # 移除默认模块（控制台程序）

# 2. 源文件与资源声明
SOURCES += main.cpp \
           mywidget.cpp
HEADERS += mywidget.h
FORMS += mywidget.ui    # Qt Designer UI文件
RESOURCES += res.qrc    # 资源文件

# 3. 目标配置
TARGET = MyQtApp        # 生成的可执行文件名
TEMPLATE = app          # 项目模板：app=应用程序，lib=库，subdirs=子项目

# 4. 编译配置
CONFIG += c++17         # 指定C++标准
CONFIG += debug         # debug模式，release为发布模式

# 5. 平台专属配置
win32 {
    DEFINES += WIN32_PLATFORM  # Windows平台宏定义
}
unix {
    DEFINES += UNIX_PLATFORM   # Linux/macOS平台宏定义
}

#include "mywidget.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    // QApplication是GUI应用的核心，管理事件循环、UI资源
    QApplication a(argc, argv);

    // 创建主窗口
    MyWidget w;
    // 显示窗口
    w.show();

    // 启动应用事件循环，阻塞直到程序退出
    return a.exec();
}

// 1. 初始化
QString str1 = "Hello Qt5";
QString str2("Hello World");
QString str3 = QString::number(100);  // 数字转字符串
// 格式化字符串（Qt5推荐，安全无溢出）
QString str4 = QString("姓名：%1，年龄：%2").arg("张三").arg(20);
// C风格格式化（兼容，不推荐）
QString str5 = QString::asprintf("年龄：%d", 20);

// 2. 常用操作
str1.append("!");               // 追加字符串
str1.prepend("Hi ");            // 前置字符串
str1.contains("Qt5");           // 判断是否包含子串，返回bool
str1.isEmpty();                 // 判断是否为空字符串（长度为0）
str1.isNull();                  // 判断是否为null（未初始化）
str1.trimmed();                 // 去除首尾空白字符
str1.replace("Qt5", "Qt 5.15");// 替换子串
str1.split(" ");                // 按分隔符拆分，返回QStringList
str1.toInt();                   // 转int，配套toDouble()/toLongLong()
str1.toUpper();                 // 转大写，toLower()转小写

// 1. QList<T>：Qt5最常用顺序容器，动态数组，Qt5.15后与QVector合并
QList<int> list;
list << 1 << 2 << 3;               // 流式添加元素
list.append(4);                     // 尾部追加
list.prepend(0);                    // 头部插入
list.insert(2, 10);                 // 索引2位置插入10

// 元素访问
int val = list[0];
int first = list.first();
int last = list.last();

// 遍历
for(int i : list) { qDebug() << i; }
for(int i=0; i<list.size(); i++) { qDebug() << list[i]; }

// 其他操作
list.removeAt(0);                   // 移除指定索引元素
list.contains(2);                   // 判断是否包含元素
list.clear();                       // 清空容器

// 2. QStringList：QList<QString>别名，字符串专用容器
QStringList strList;
strList << "a" << "b" << "c";
strList.join(",");                  // 拼接为"a,b,c"
strList.filter("a");                // 筛选包含指定子串的元素

// 1. QMap<Key, T>：有序键值对，红黑树实现，Key需重载<运算符
QMap<QString, int> map;
map["张三"] = 20;
map.insert("李四", 25);

// 元素访问
int age = map["张三"];
int age2 = map.value("李四", 0);    // 不存在则返回默认值0

// 遍历
QMap<QString, int>::iterator it;
for(it = map.begin(); it != map.end(); it++){
    qDebug() << it.key() << it.value();
}

// 2. QHash<Key, T>：无序哈希表，查找速度优于QMap，Key需重载==和qHash()
QHash<QString, int> hash;
hash["王五"] = 30;
// 操作API与QMap基本一致

#include <QDebug>

// 基础输出
qDebug() << "Hello Qt5" << 123 << QString("测试");

// 容器输出
QList<int> list << 1 << 2 << 3;
qDebug() << "列表内容：" << list;

// C风格格式化输出
qDebug("姓名：%s，年龄：%d", "张三", 20);

// 创建独立窗口
QWidget *window = new QWidget;
window->setWindowTitle("Qt5 窗口");  // 设置窗口标题
window->resize(800, 600);            // 设置窗口大小
window->setFixedSize(800, 600);      // 固定窗口大小，禁止缩放
window->move(100, 100);               // 移动窗口到屏幕坐标(100,100)
window->show();                        // 显示窗口
// window->showMaximized();           // 最大化显示
// window->showFullScreen();          // 全屏显示
// window->hide();                    // 隐藏窗口

// 创建子控件，指定父窗口（父窗口销毁时自动释放子控件）
QPushButton *btn = new QPushButton("按钮", window);
btn->setGeometry(100, 100, 200, 50); // 设置控件位置和大小(x,y,宽,高)

QWidget *window = new QWidget;
window->setWindowTitle("布局示例");
window->resize(400, 300);

// 1. 创建主垂直布局，绑定到窗口
QVBoxLayout *mainLayout = new QVBoxLayout(window);
// 设置布局边距和控件间距
mainLayout->setContentsMargins(20, 20, 20, 20);
mainLayout->setSpacing(10);

// 2. 创建水平布局，存放标签和输入框
QHBoxLayout *hLayout = new QHBoxLayout;
QLabel *label = new QLabel("用户名：");
QLineEdit *edit = new QLineEdit;
hLayout->addWidget(label);
hLayout->addWidget(edit);

// 3. 添加控件和子布局到主布局
QPushButton *btn = new QPushButton("登录");
mainLayout->addLayout(hLayout);
mainLayout->addWidget(btn);
mainLayout->addStretch();  // 添加伸缩项，将控件顶到上方

window->show();

// 1. 消息对话框 QMessageBox
QMessageBox::information(window, "提示", "操作成功");  // 信息提示
QMessageBox::warning(window, "警告", "操作有误");      // 警告提示
QMessageBox::critical(window, "错误", "致命错误");     // 错误提示
// 询问确认框
int ret = QMessageBox::question(window, "确认", "是否退出？",
                                 QMessageBox::Yes | QMessageBox::No,
                                 QMessageBox::No);
if(ret == QMessageBox::Yes) { window->close(); }

// 2. 文件对话框 QFileDialog
// 打开单个文件
QString filePath = QFileDialog::getOpenFileName(window,
    "打开文件", "./", "文本文件(*.txt);;所有文件(*.*)");
// 保存文件
QString savePath = QFileDialog::getSaveFileName(window,
    "保存文件", "./", "文本文件(*.txt)");
// 选择文件夹
QString dirPath = QFileDialog::getExistingDirectory(window, "选择文件夹", "./");

// 3. 输入对话框 QInputDialog
bool ok;
// 文本输入
QString text = QInputDialog::getText(window, "输入", "请输入用户名：",
                                      QLineEdit::Normal, "默认值", &ok);
// 数字输入
int num = QInputDialog::getInt(window, "输入数字", "请输入年龄：",
                                20, 0, 100, 1, &ok);

// 鼠标事件
void mousePressEvent(QMouseEvent *event) override;    // 鼠标按下
void mouseReleaseEvent(QMouseEvent *event) override;  // 鼠标释放
void mouseMoveEvent(QMouseEvent *event) override;     // 鼠标移动
void wheelEvent(QWheelEvent *event) override;         // 鼠标滚轮

// 键盘事件
void keyPressEvent(QKeyEvent *event) override;        // 按键按下
void keyReleaseEvent(QKeyEvent *event) override;      // 按键释放

// 绘制事件（必须在此函数内执行绘制操作）
void paintEvent(QPaintEvent *event) override;

// 窗口事件
void resizeEvent(QResizeEvent *event) override;       // 窗口大小变化
void closeEvent(QCloseEvent *event) override;         // 窗口关闭

// 焦点事件
void focusInEvent(QFocusEvent *event) override;       // 获得焦点
void focusOutEvent(QFocusEvent *event) override;     // 失去焦点

// 1. 鼠标按下事件处理
void MyWidget::mousePressEvent(QMouseEvent *event)
{
    if(event->button() == Qt::LeftButton) {
        qDebug() << "左键按下，窗口坐标：" << event->pos();
        qDebug() << "屏幕全局坐标：" << event->globalPos();
    } else if(event->button() == Qt::RightButton) {
        qDebug() << "右键按下";
    }
    // 调用父类实现，保证事件继续传递
    QWidget::mousePressEvent(event);
}

// 2. 键盘按下事件处理
void MyWidget::keyPressEvent(QKeyEvent *event)
{
    // 单按键判断
    if(event->key() == Qt::Key_Escape) {
        this->close();
    }
    // 组合键判断
    if(event->modifiers() == Qt::ControlModifier && event->key() == Qt::Key_S) {
        qDebug() << "按下Ctrl+S，执行保存";
    }
    QWidget::keyPressEvent(event);
}

// 3. 绘制事件处理（QPainter必须在paintEvent内创建）
void MyWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    // 设置画笔
    QPen pen(Qt::red, 2, Qt::SolidLine);
    painter.setPen(pen);

    // 基础绘制
    painter.drawLine(0, 0, 100, 100);          // 绘制直线
    painter.drawRect(100, 100, 200, 150);     // 绘制矩形
    painter.drawEllipse(200, 200, 100, 100);  // 绘制圆形
    painter.drawText(300, 300, "Hello Qt5");   // 绘制文本
}

// 头文件声明
class MyWidget : public QWidget
{
    Q_OBJECT
protected:
    bool eventFilter(QObject *watched, QEvent *event) override;
private:
    QPushButton *m_btn;
};

// 实现
MyWidget::MyWidget(QWidget *parent) : QWidget(parent)
{
    m_btn = new QPushButton("测试按钮", this);
    // 给按钮安装事件过滤器，this作为过滤器对象
    m_btn->installEventFilter(this);
}

bool MyWidget::eventFilter(QObject *watched, QEvent *event)
{
    // 判断目标对象
    if(watched == m_btn) {
        // 拦截鼠标按下事件
        if(event->type() == QEvent::MouseButtonPress) {
            qDebug() << "事件过滤器拦截到按钮按下";
            // return true; // 拦截事件，按钮不会收到按下事件
        }
    }
    // 其他事件交给父类处理
    return QWidget::eventFilter(watched, event);
}

// 1. 创建数据模型
QStringListModel *model = new QStringListModel;
QStringList list;
list << "苹果" << "香蕉" << "橙子" << "葡萄";
model->setStringList(list);

// 2. 创建视图，绑定模型
QListView *view = new QListView;
view->setModel(model);
view->resize(300, 200);
view->show();

// 1. 创建表格模型，4行3列
QStandardItemModel *model = new QStandardItemModel(4, 3);
// 设置表头
model->setHeaderData(0, Qt::Horizontal, "姓名");
model->setHeaderData(1, Qt::Horizontal, "年龄");
model->setHeaderData(2, Qt::Horizontal, "性别");

// 2. 填充数据
model->setItem(0, 0, new QStandardItem("张三"));
model->setItem(0, 1, new QStandardItem("20"));
model->setItem(0, 2, new QStandardItem("男"));
model->setItem(1, 0, new QStandardItem("李四"));
model->setItem(1, 1, new QStandardItem("25"));
model->setItem(1, 2, new QStandardItem("女"));

// 3. 创建表格视图，绑定模型
QTableView *view = new QTableView;
view->setModel(model);
view->resize(500, 300);
// 表格属性设置
view->horizontalHeader()->setStretchLastSection(true);  // 最后一列拉伸
view->setEditTriggers(QAbstractItemView::DoubleClicked); // 双击编辑
view->setSelectionBehavior(QAbstractItemView::SelectRows); // 选中整行
view->show();

// 线程类头文件 mythread.h
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>

class MyThread : public QThread
{
    Q_OBJECT
protected:
    void run() override; // 重写线程入口函数

signals:
    void progressChanged(int value); // 进度更新信号
    void threadFinished();           // 线程完成信号
};

#endif // MYTHREAD_H

// 线程类实现 mythread.cpp
#include "mythread.h"

void MyThread::run()
{
    // 子线程执行的耗时操作
    for(int i=0; i<=100; i++) {
        msleep(10); // 模拟耗时
        emit progressChanged(i); // 发送信号到主线程
    }
    emit threadFinished();
}

// 主线程调用
MyThread *thread = new MyThread;
// 线程结束自动销毁
connect(thread, &MyThread::finished, thread, &MyThread::deleteLater);
// 进度信号更新UI
connect(thread, &MyThread::progressChanged, this, [=](int value){
    ui->progressBar->setValue(value); // 主线程更新UI
});
// 启动线程（自动调用run()）
thread->start();

// 业务类头文件 worker.h
#ifndef WORKER_H
#define WORKER_H

#include <QObject>

class Worker : public QObject
{
    Q_OBJECT
public slots:
    void doWork(); // 业务处理槽函数，在子线程执行

signals:
    void progressChanged(int value);
    void workFinished();
};

#endif // WORKER_H

// 业务类实现 worker.cpp
#include "worker.h"
#include <QThread>

void Worker::doWork()
{
    // 子线程执行的耗时操作
    for(int i=0; i<=100; i++) {
        QThread::msleep(10);
        emit progressChanged(i);
    }
    emit workFinished();
}

// 主线程调用
// 1. 创建子线程
QThread *thread = new QThread;
// 2. 创建业务对象，禁止指定父对象
Worker *worker = new Worker;
// 3. 将业务对象移动到子线程
worker->moveToThread(thread);

// 4. 信号槽连接
// 线程启动后执行业务函数
connect(thread, &QThread::started, worker, &Worker::doWork);
// 工作完成，退出线程事件循环
connect(worker, &Worker::workFinished, thread, &QThread::quit);
// 线程退出，自动销毁对象
connect(thread, &QThread::finished, worker, &Worker::deleteLater);
connect(thread, &QThread::finished, thread, &QThread::deleteLater);
// 进度更新UI
connect(worker, &Worker::progressChanged, this, [=](int value){
    ui->progressBar->setValue(value);
});

// 5. 启动线程
thread->start();

#include <QTcpServer>
#include <QTcpSocket>

class TcpServer : public QObject
{
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = nullptr) {
        m_server = new QTcpServer(this);
        // 新客户端连接信号
        connect(m_server, &QTcpServer::newConnection, this, &TcpServer::onNewConnection);
    }

    // 启动服务，监听端口
    bool startServer(quint16 port) {
        return m_server->listen(QHostAddress::Any, port);
    }

private slots:
    // 处理新客户端连接
    void onNewConnection() {
        QTcpSocket *socket = m_server->nextPendingConnection();
        m_clientList.append(socket);

        // 连接信号槽
        connect(socket, &QTcpSocket::readyRead, this, &TcpServer::onReadyRead);
        connect(socket, &QTcpSocket::disconnected, socket, &QTcpSocket::deleteLater);
    }

    // 接收客户端数据
    void onReadyRead() {
        QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
        QByteArray data = socket->readAll();
        qDebug() << "收到客户端数据：" << data;
        // 回复客户端
        socket->write("服务器已收到：" + data);
    }

private:
    QTcpServer *m_server;
    QList<QTcpSocket*> m_clientList;
};

#include <QTcpSocket>

class TcpClient : public QObject
{
    Q_OBJECT
public:
    explicit TcpClient(QObject *parent = nullptr) {
        m_socket = new QTcpSocket(this);
        connect(m_socket, &QTcpSocket::connected, this, &TcpClient::onConnected);
        connect(m_socket, &QTcpSocket::readyRead, this, &TcpClient::onReadyRead);
        connect(m_socket, &QTcpSocket::errorOccurred, this, &TcpClient::onError);
    }

    // 连接服务器
    void connectToServer(const QString &ip, quint16 port) {
        m_socket->connectToHost(ip, port);
    }

    // 发送数据
    void sendData(const QByteArray &data) {
        if(m_socket->state() == QAbstractSocket::ConnectedState) {
            m_socket->write(data);
            m_socket->flush();
        }
    }

private slots:
    void onConnected() { qDebug() << "连接服务器成功"; }
    void onReadyRead() {
        QByteArray data = m_socket->readAll();
        qDebug() << "收到服务器数据：" << data;
    }
    void onError(QAbstractSocket::SocketError error) {
        qDebug() << "连接错误：" << m_socket->errorString();
    }

private:
    QTcpSocket *m_socket;
};

#include <QUdpSocket>

// 1. UDP接收端
QUdpSocket *udpReceiver = new QUdpSocket(this);
udpReceiver->bind(QHostAddress::Any, 8888); // 绑定端口
// 接收数据
connect(udpReceiver, &QUdpSocket::readyRead, this, [=](){
    while(udpReceiver->hasPendingDatagrams()) {
        QByteArray datagram;
        datagram.resize(udpReceiver->pendingDatagramSize());
        QHostAddress senderAddr;
        quint16 senderPort;
        // 读取数据
        udpReceiver->readDatagram(datagram.data(), datagram.size(), &senderAddr, &senderPort);
        qDebug() << "收到数据：" << datagram << "来自：" << senderAddr.toString() << ":" << senderPort;
    }
});

// 2. UDP发送端
QUdpSocket *udpSender = new QUdpSocket(this);
QByteArray data = "Hello UDP";
// 发送数据到目标地址和端口，广播用QHostAddress::Broadcast
udpSender->writeDatagram(data, QHostAddress("127.0.0.1"), 8888);

#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>

// 1. 创建全局管理器
QNetworkAccessManager *manager = new QNetworkAccessManager(this);

// 2. GET 请求
QNetworkRequest getRequest;
getRequest.setUrl(QUrl("https://www.qt.io"));
getRequest.setRawHeader("User-Agent", "Qt5 App");

QNetworkReply *getReply = manager->get(getRequest);
connect(getReply, &QNetworkReply::finished, this, [=](){
    if(getReply->error() == QNetworkReply::NoError) {
        QByteArray data = getReply->readAll();
        qDebug() << "响应数据：" << data;
    } else {
        qDebug() << "请求错误：" << getReply->errorString();
    }
    getReply->deleteLater();
});

// 3. POST JSON 请求
QJsonObject jsonObj;
jsonObj["username"] = "test";
jsonObj["password"] = "123456";
QByteArray jsonData = QJsonDocument(jsonObj).toJson();

QNetworkRequest postRequest;
postRequest.setUrl(QUrl("https://example.com/api/login"));
postRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

QNetworkReply *postReply = manager->post(postRequest, jsonData);
connect(postReply, &QNetworkReply::finished, this, [=](){
    if(postReply->error() == QNetworkReply::NoError) {
        QByteArray data = postReply->readAll();
        qDebug() << "POST响应：" << data;
    }
    postReply->deleteLater();
});

class MyWidget : public QWidget
{
    Q_OBJECT
    // 定义属性
    Q_PROPERTY(int age READ age WRITE setAge NOTIFY ageChanged)
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)

public:
    // 读函数
    int age() const { return m_age; }
    QString name() const { return m_name; }

    // 写函数
    void setAge(int age) {
        if(m_age != age) {
            m_age = age;
            emit ageChanged(m_age);
        }
    }
    void setName(const QString &name) {
        if(m_name != name) {
            m_name = name;
            emit nameChanged(m_name);
        }
    }

signals:
    // 属性变化通知信号
    void ageChanged(int age);
    void nameChanged(const QString &name);

private:
    int m_age = 0;
    QString m_name;
};

// 属性使用
MyWidget *w = new MyWidget;
w->setProperty("age", 20);        // 写属性
int age = w->property("age").toInt(); // 读属性

// 自定义类型
struct MyData {
    int id;
    QString name;
};

// 1. 头文件中声明，必须在结构体定义之后
Q_DECLARE_METATYPE(MyData)

// 2. 使用前注册（main函数中），支持跨线程信号槽
qRegisterMetaType<MyData>("MyData");

// 使用
MyData data;
data.id = 1;
data.name = "test";
QVariant var = QVariant::fromValue(data); // 存入QVariant
MyData data2 = var.value<MyData>();       // 取出数据

class MyClass : public QObject
{
    Q_OBJECT
public:
    enum Color {
        Red,
        Green,
        Blue
    };
    // 注册枚举
    Q_ENUM(Color)
};

// 使用
MyClass::Color color = MyClass::Red;
// 枚举值转字符串
QString colorStr = QMetaEnum::fromType<MyClass::Color>().valueToKey(color);
// 字符串转枚举值
int colorVal = QMetaEnum::fromType<MyClass::Color>().keyToValue("Blue");

// 1. 单次定时器，1000ms后执行一次
QTimer::singleShot(1000, this, [=](){
    qDebug() << "单次定时器执行";
});

// 2. 循环定时器
QTimer *timer = new QTimer(this);
timer->setInterval(1000); // 间隔1000ms
connect(timer, &QTimer::timeout, this, [=](){
    qDebug() << "定时器超时";
});
timer->start(); // 启动定时器
// timer->stop(); // 停止定时器