// main.cpp - Qt 对象模型基础
// Qt Object Model Basics
#include <QCoreApplication>
#include <QDebug>
#include <QObject>
#include <QTimer>

class Animal : public QObject {
    Q_OBJECT

public:
    explicit Animal(const QString &name, QObject *parent = nullptr)
        : QObject(parent), m_name(name) {
        qDebug() << "Animal created:" << m_name;
    }

    ~Animal() override {
        qDebug() << "Animal destroyed:" << m_name;
    }

    QString name() const { return m_name; }

private:
    QString m_name;
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    // 对象树演示：parent 拥有 child 的所有权
    // Object tree: parent owns child
    QObject root;

    auto *cat = new Animal("Cat", &root);    // root 拥有 cat
    auto *dog = new Animal("Dog", &root);    // root 拥有 dog
    auto *bird = new Animal("Bird", cat);    // cat 拥有 bird

    qDebug() << "Children of root:" << root.children().size();
    qDebug() << "Children of cat:" << cat->children().size();

    // 当 root 被销毁时，cat、dog、bird 都会被自动销毁
    // When root is destroyed, cat, dog, bird are auto-destroyed

    // 遍历对象树
    // Traverse object tree
    for (QObject *child : root.children()) {
        auto *animal = qobject_cast<Animal *>(child);
        if (animal) {
            qDebug() << "Found animal:" << animal->name();
        }
    }

    // 使用 QTimer 在 0ms 后退出（演示事件循环）
    QTimer::singleShot(0, &app, &QCoreApplication::quit);

    return app.exec();
}

#include "main.moc"

#!/usr/bin/env python3
"""Qt 对象模型基础 - PySide6"""
"""Qt Object Model Basics - PySide6"""

import sys
from PySide6.QtCore import QObject, QTimer


class Animal(QObject):
    """动物类，演示对象树"""
    """Animal class demonstrating object tree"""

    def __init__(self, name: str, parent: QObject | None = None):
        super().__init__(parent)
        self._name = name
        print(f"Animal created: {name}")

    def __del__(self):
        print(f"Animal destroyed: {self._name}")

    @property
    def name(self) -> str:
        return self._name


def main():
    root = QObject()

    cat = Animal("Cat", root)      # root 拥有 cat
    dog = Animal("Dog", root)      # root 拥有 dog
    bird = Animal("Bird", cat)     # cat 拥有 bird

    print(f"Children of root: {len(root.children())}")
    print(f"Children of cat: {len(cat.children())}")

    # 遍历对象树
    for child in root.children():
        if isinstance(child, Animal):
            print(f"Found animal: {child.name}")

    # root 销毁时，所有子对象自动销毁
    print("--- Destroying root ---")
    root.deleteLater()


if __name__ == "__main__":
    from PySide6.QtCore import QCoreApplication

    app = QCoreApplication(sys.argv)
    QTimer.singleShot(0, main)
    QTimer.singleShot(100, app.quit)
    app.exec()

// signals_slots.cpp - 信号与槽完整示例
// Signals & Slots Complete Example
#include <QCoreApplication>
#include <QDebug>
#include <QTimer>

class Thermometer : public QObject {
    Q_OBJECT

public:
    explicit Thermometer(QObject *parent = nullptr) : QObject(parent) {}

    void setTemperature(double temp) {
        if (!qFuzzyCompare(m_temperature, temp)) {
            m_temperature = temp;
            emit temperatureChanged(temp);
            if (temp > 100.0) {
                emit overheating(temp);
            }
        }
    }

signals:
    void temperatureChanged(double newTemp);
    void overheating(double temp);

private:
    double m_temperature = 0.0;
};

class Alarm : public QObject {
    Q_OBJECT

public slots:
    void onOverheating(double temp) {
        qDebug() << "⚠️ ALARM: Temperature too high:" << temp << "°C!";
    }
};

class Display : public QObject {
    Q_OBJECT

public slots:
    void updateDisplay(double temp) {
        qDebug() << "🌡️ Display:" << temp << "°C";
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    auto *thermo = new Thermometer;
    auto *display = new Display;
    auto *alarm = new Alarm;

    // 1:1 连接 / 1:1 connection
    QObject::connect(thermo, &Thermometer::temperatureChanged,
                     display, &Display::updateDisplay);

    // 1:N 连接：同一个信号连接多个槽 / 1:N: one signal, multiple slots
    QObject::connect(thermo, &Thermometer::overheating,
                     display, &Display::updateDisplay);
    QObject::connect(thermo, &Thermometer::overheating,
                     alarm, &Alarm::onOverheating);

    // Lambda 连接 / Lambda connection
    QObject::connect(thermo, &Thermometer::temperatureChanged,
                     [](double temp) {
                         if (temp < 0) {
                             qDebug() << "❄️ Freezing!";
                         }
                     });

    // 模拟温度变化
    QTimer::singleShot(0, [thermo]() {
        thermo->setTemperature(25.0);   // 正常
        thermo->setTemperature(-5.0);   // 低温
        thermo->setTemperature(105.0);  // 过热
    });

    QTimer::singleShot(100, &app, &QCoreApplication::quit);
    return app.exec();
}

#include "main.moc"

#!/usr/bin/env python3
"""信号与槽完整示例 - PySide6"""
"""Signals & Slots Complete Example - PySide6"""

import sys
from PySide6.QtCore import QObject, Signal, Slot, QCoreApplication, QTimer


class Thermometer(QObject):
    """温度计：发射信号"""
    """Thermometer: emits signals"""

    temperature_changed = Signal(float)
    overheating = Signal(float)

    def __init__(self, parent: QObject | None = None):
        super().__init__(parent)
        self._temperature = 0.0

    @property
    def temperature(self) -> float:
        return self._temperature

    @temperature.setter
    def temperature(self, value: float):
        if self._temperature != value:
            self._temperature = value
            self.temperature_changed.emit(value)
            if value > 100.0:
                self.overheating.emit(value)


class Alarm(QObject):
    """警报器：接收信号"""
    """Alarm: receives signals"""

    @Slot(float)
    def on_overheating(self, temp: float):
        print(f"⚠️ ALARM: Temperature too high: {temp}°C!")


class Display(QObject):
    """显示器"""
    """Display"""

    @Slot(float)
    def update_display(self, temp: float):
        print(f"🌡️ Display: {temp}°C")


def main():
    thermo = Thermometer()
    display = Display()
    alarm = Alarm()

    # 1:1 连接
    thermo.temperature_changed.connect(display.update_display)

    # 1:N 连接
    thermo.overheating.connect(display.update_display)
    thermo.overheating.connect(alarm.on_overheating)

    # Lambda 连接
    thermo.temperature_changed.connect(
        lambda temp: print("❄️ Freezing!") if temp < 0 else None
    )

    # 触发信号
    thermo.temperature = 25.0
    thermo.temperature = -5.0
    thermo.temperature = 105.0


if __name__ == "__main__":
    app = QCoreApplication(sys.argv)
    QTimer.singleShot(0, main)
    QTimer.singleShot(100, app.quit)
    app.exec()

// 跨线程连接示例
// Cross-thread connection
QObject::connect(worker, &Worker::resultReady,
                 gui, &GUI::updateResult,
                 Qt::QueuedConnection);

// 防止重复连接
// Prevent duplicate connections
QObject::connect(button, &QPushButton::clicked,
                 this, &MyWidget::onClicked,
                 Qt::UniqueConnection);

// ❌ 旧语法（字符串-based，编译期不检查类型）
// Old syntax (string-based, no compile-time check)
connect(button, SIGNAL(clicked()), this, SLOT(onClicked()));

// ✅ 新语法（类型安全，编译期检查）
// New syntax (type-safe, compile-time check)
connect(button, &QPushButton::clicked, this, &MyWidget::onClicked);

// ✅ 新语法 + Lambda
connect(button, &QPushButton::clicked, [this]() {
    qDebug() << "Button clicked!";
});

#include <QObject>
#include <QColor>
#include <QDebug>

class Person : public QObject {
    Q_OBJECT

    // 声明属性 / Declare properties
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
    Q_PROPERTY(int age READ age WRITE setAge NOTIFY ageChanged)
    Q_PROPERTY(QColor favoriteColor READ favoriteColor
               WRITE setFavoriteColor NOTIFY favoriteColorChanged)

public:
    explicit Person(QObject *parent = nullptr) : QObject(parent) {}

    // getter 函数 / Getters
    QString name() const { return m_name; }
    int age() const { return m_age; }
    QColor favoriteColor() const { return m_color; }

    // setter 函数 / Setters
    void setName(const QString &name) {
        if (m_name != name) {
            m_name = name;
            emit nameChanged(name);
        }
    }

    void setAge(int age) {
        if (m_age != age) {
            m_age = age;
            emit ageChanged(age);
        }
    }

    void setFavoriteColor(const QColor &color) {
        if (m_color != color) {
            m_color = color;
            emit favoriteColorChanged(color);
        }
    }

signals:
    void nameChanged(const QString &name);
    void ageChanged(int age);
    void favoriteColorChanged(const QColor &color);

private:
    QString m_name;
    int m_age = 0;
    QColor m_color = Qt::blue;
};

// 动态属性操作 / Dynamic property operations
void propertyDemo() {
    Person person;
    person.setName("Alice");
    person.setAge(30);
    person.setFavoriteColor(Qt::red);

    // 通过属性系统读写 / Read/write via property system
    qDebug() << "Name:" << person.property("name").toString();
    person.setProperty("age", 31);

    // 动态添加属性 / Add dynamic property
    person.setProperty("nickname", "Ali");
    qDebug() << "Nickname:" << person.property("nickname").toString();

    // 遍历所有属性 / Iterate all properties
    const QMetaObject *meta = person.metaObject();
    for (int i = 0; i < meta->propertyCount(); ++i) {
        QMetaProperty prop = meta->property(i);
        qDebug() << prop.name() << "=" << prop.read(&person);
    }
}

"""属性系统示例 - PySide6"""
"""Property System Example - PySide6"""

from PySide6.QtCore import QObject, Property, Signal


class Person(QObject):
    name_changed = Signal(str)
    age_changed = Signal(int)

    def __init__(self, parent=None):
        super().__init__(parent)
        self._name = ""
        self._age = 0

    def _get_name(self) -> str:
        return self._name

    def _set_name(self, name: str):
        if self._name != name:
            self._name = name
            self.name_changed.emit(name)

    # PySide6 属性声明
    name = Property(str, _get_name, _set_name, notify=name_changed)

    def _get_age(self) -> int:
        return self._age

    def _set_age(self, age: int):
        if self._age != age:
            self._age = age
            self.age_changed.emit(age)

    age = Property(int, _get_age, _set_age, notify=age_changed)


# 使用示例
person = Person()
person.name_changed.connect(lambda n: print(f"Name changed to: {n}"))
person.name = "Alice"  # 触发信号

# CMakeLists.txt
cmake_minimum_required(VERSION 3.16)
project(MyQtApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_AUTOMOC ON)     # 自动运行 MOC / Auto-run MOC
set(CMAKE_AUTORCC ON)     # 自动处理 .qrc / Auto-handle .qrc
set(CMAKE_AUTOUIC ON)     # 自动处理 .ui / Auto-handle .ui

find_package(Qt6 REQUIRED COMPONENTS Core Widgets)

add_executable(myapp
    main.cpp
    mainwindow.h      # 含 Q_OBJECT 的头文件
    mainwindow.cpp
)

target_link_libraries(myapp PRIVATE Qt6::Core Qt6::Widgets)

class MyClass : public QObject {
    Q_OBJECT   // ← 必须！如果类中需要以下功能：
               // Required! If class needs:
public:
    // ✅ 自定义信号
    signals:
        void mySignal();

    // ✅ 自定义槽函数
    public slots:
        void mySlot();

    // ✅ 使用 tr() 进行国际化
    QString text = tr("Hello");

    // ✅ 使用 qobject_cast<>()
    // ✅ 使用 Q_PROPERTY
    // ✅ 使用 dynamic properties
};

#include <QWidget>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QDebug>

class MyWidget : public QWidget {
    Q_OBJECT

public:
    explicit MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        setFocusPolicy(Qt::StrongFocus);
        setMouseTracking(true);
    }

protected:
    // 重写事件处理器 / Override event handlers
    void keyPressEvent(QKeyEvent *event) override {
        qDebug() << "Key pressed:" << event->text()
                 << "code:" << event->key();
        if (event->key() == Qt::Key_Escape) {
            close();
        }
        QWidget::keyPressEvent(event);
    }

    void mousePressEvent(QMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            qDebug() << "Left click at:" << event->pos();
        }
        QWidget::mousePressEvent(event);
    }

    void mouseMoveEvent(QMouseEvent *event) override {
        qDebug() << "Mouse at:" << event->pos();
        QWidget::mouseMoveEvent(event);
    }

    // 通用事件过滤 / Generic event filter
    bool event(QEvent *event) override {
        if (event->type() == QEvent::KeyPress) {
            qDebug() << "Event filter: KeyPress";
        }
        return QWidget::event(event);
    }
};