基于Qt的数字化教学辅助平台的设计与实现（完成版）

本文链接：https://blog.csdn.net/weixin_53815819/article/details/145347370

首先给大家梳理一下有哪些功能模块：

(1)课程内容管理模块：该模块为教师提供一个管理和编辑教学内容的平台，支持多种教学资源的上传和分类管理。方案方面，教师可以通过系统上传课件、视频、音频等教学资源，并将其按照学科、章节进行分类存储。Qt界面的文件管理器可以方便教师操作和检索资源。
(2)互动教学模块：该模块支持教师与学生之间的实时互动，包括在线问答、实时投票、课堂讨论等功能。方案上，利用Qt的网络通信功能，实现实时的问答与投票功能，通过多线程和信号槽机制确保互动的流畅性。学生可以通过客户端提问或参与投票，教师可以实时查看并作出回应。
(3)学习进度追踪模块：该模块为学生提供学习进度的跟踪和管理功能，帮助学生了解自己的学习情况，督促其按时完成任务。方案方面，Qt平台通过数据存储与分析功能记录学生的每次学习进度，生成学习报告，并通过图表等可视化方式呈现给学生。教师也可以查看班级整体学习进度，以便及时调整教学策略。
(4)实时评价与反馈模块：该模块能够对学生的学习情况进行实时评价，支持教师根据学生的学习表现进行定期评分或评价。方案方面，系统提供多种评价标准（如作业完成情况、课堂互动表现等），通过Qt界面显示学生的实时成绩和反馈信息，帮助学生及时改进学习方法。
(5)多媒体展示模块：该模块支持教学内容的多媒体展示，包括PPT演示、视频播放、图像展示等功能。方案方面，Qt通过集成多种多媒体支持库，能够实现教学内容的多种呈现方式，支持高质量的视频和音频播放，提升课堂的互动性和可视化效果。
(6)在线考试与作业模块：该模块提供在线考试和作业提交功能，学生可以在平台上进行自测、作业提交以及参与在线考试。方案上，Qt通过嵌入式数据库保存考试题目和作业内容，学生可以在线答题并实时提交，系统自动批改并给出反馈。教师也可以通过后台查看考试成绩和作业完成情况。
(7)数据统计与分析模块：该模块对教学过程中的各种数据进行收集和分析，为教师提供课堂数据支持。方案方面，Qt系统通过数据存储模块记录学生的学习行为、考试成绩、互动频次等数据，并通过图表等方式进行可视化展示，帮助教师优化教学策略。
(8)用户管理模块：该模块为教师和学生提供账号管理功能，支持用户的注册、登录、角色权限分配等操作。方案上，Qt界面提供简洁的用户登录界面，后台采用数据库存储用户信息，根据不同角色（教师或学生）分配不同的功能权限。
下面是全部代码，里面的许多功能实现的并不完美，大家有好的想法可以在评论区或私信我一起交流改进。
演示视频
演示视频

#ifndef CONTENT_H
#define CONTENT_H

#include <QWidget>
#include <QFileDialog>
#include <QFileInfo>
#include <QDir>
#include <QFile>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
namespace Ui {
class Content;
}

class Content : public QWidget
{
    Q_OBJECT

public:
    explicit Content(QWidget *parent = nullptr);
    ~Content();
private slots:
    void onSelectButtonClicked();
    void onUploadButtonClicked();
    void onSearchButtonClicked();
    void returncontorlsClicked();
    void onUploadPaperButtonClicked();
private:
    Ui::Content *ui;
    QString currentFile;  // 用于保存当前选择的文件路径
};

#endif // CONTENT_H
#ifndef CONTROLS_H
#define CONTROLS_H

#include <QWidget>
#include <QGraphicsDropShadowEffect> //创建图形阴影效果的类
#include <QMessageBox>
#include <QtCharts>
#include "content.h"
#include "interactiveteachingdialog.h"
#include "multimedia.h"
#include "onlineexamandhomework.h"
#include "progresstracking.h"
#include "evaluationmodule.h"
#include "datastatistics.h"
namespace Ui {
class Controls;
}

class Controls : public QWidget
{
    Q_OBJECT

public:
    explicit Controls(QWidget *parent = nullptr);
    ~Controls();
private slots:
    //点击内容管理执行的槽函数
    void on_btn_Content_management();
    //点击互动教学执行的槽函数
    void on_btn_Interactive_teaching();
    //点击进度追踪执行的槽函数
    void on_btn_Progress_tracking();
    //点击评价与反馈执行的槽函数
    void on_btn_Evaluation_and_feedback();
    //点击多媒体展示执行的槽函数
    void on_btn_Multimedia_display();
    //点击考试与作业展示执行的槽函数
    void on_btn_Tests_and_assignments();
    //点击数据统计展示执行的槽函数
    void on_btn_Data_statistics();
private:
    Ui::Controls *ui;
};

#endif // CONTROLS_H
#ifndef DATASTATISTICS_H
#define DATASTATISTICS_H

#include <QWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QChartView>
#include <QBarSet>
#include <QBarSeries>
#include <QBarCategoryAxis>
#include <QValueAxis>
#include <QLabel>
#include <QMessageBox>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QStringList>
#include <QDebug>
#include <QDateTime>
#include <QTime>
#include <QtCharts>  // 包含 QtCharts 头文件
#include "controls.h"


class DataStatistics : public QWidget
{
    Q_OBJECT

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

private:
    QVBoxLayout *mainLayout;  // 主布局
    QPushButton *backButton;  // 返回按钮
    QTime loginTime;
    QMap<QString, int> moduleUsageMap; // 存储模块使用次数
    QList<int> examScoresList; // 存储考试成绩
    void initializeData();
    void generateCombinedChart();
    void centerWindow(); // 新增函数：将窗口置于桌面居中
    void close();
};

#endif // DATASTATISTICS_H

#ifndef EVALUATIONMODULE_H
#define EVALUATIONMODULE_H

#include <QWidget>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QLineEdit>
#include <QTextEdit>
#include <QListWidget>
#include <QMessageBox>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QDebug>
#include "controls.h"

namespace Ui {
class EvaluationModule;
}

class EvaluationModule : public QWidget
{
    Q_OBJECT

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

private slots:
    // 点击评价按钮的槽函数
    void on_evaluateButton_clicked();
    // 从列表中选择学生的槽函数
    void on_studentListWidget_itemClicked(QListWidgetItem *item);

private:
    Ui::EvaluationModule *ui;
    QSqlDatabase db;
    QListWidget *studentListWidget; // 存储学生列表的部件
    QTextEdit *evaluationTextEdit; // 用于输入评价的部件
    QLineEdit *scoreLineEdit; // 用于输入分数的部件
    void loadStudents(); // 加载学生列表的函数
    QSet<QString> evaluatedStudents; // 存储已评价的学生
};

#endif // EVALUATIONMODULE_H


#ifndef INTERACTIVETEACHINGDIALOG_H
#define INTERACTIVETEACHINGDIALOG_H

#include <QWidget>
#include <QTcpSocket>
#include <QTcpServer>
#include <QMessageBox>
#include <QGraphicsDropShadowEffect> //创建图形阴影效果的类
namespace Ui {
class InteractiveTeachingDialog;
}

class InteractiveTeachingDialog : public QWidget
{
    Q_OBJECT

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

private slots:
    // 发送消息按钮点击的槽函数
    void on_pushButton_send_clicked();
    // 处理接收消息的槽函数
    void readMessage();
    // 有新连接进来后的初始化操作槽函数（用于处理客户端连接成功后的相关逻辑）
    void onNewConnection();
    //返回之间的界面
    void return1();
    // 新用户连接按钮点击的槽函数
    void onNewUserConnectionClicked();


private:
    Ui::InteractiveTeachingDialog *ui;
    // TCP服务器对象，用于监听客户端连接
    QTcpServer *tcpServer;
    // 存储所有已连接的客户端套接字，方便群发消息等操作（这里简单用列表存储）
    QList<QTcpSocket *> clientSockets;
    int nextUserId; // 用于分配下一个用户ID
    QMap<QTcpSocket *, int> socketToUserId; // 存储套接字与用户ID的对应关系
    bool isNewUserConnectionClicked; // 新增标志变量，用于记录新用户连接按钮是否已被点击过
};

#endif // INTERACTIVETEACHINGDIALOG_H
/*
 * 实现登录模块
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QSqlDatabase> //数据驱动
#include <QSqlQuery> //数据库执行语句
#include <QMessageBox>//消息盒子
#include <QDebug>
void sqlite_Init();

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

private slots:
    //执行点击登录按钮的槽函数
    void on_btn_signin_clicked();
    //执行点击注册按钮的槽函数
    void on_btn_signup_clicked();

private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
#ifndef MULTIMEDIADIALOG_H
#define MULTIMEDIADIALOG_H

#include <QWidget>
#include <QFileDialog>
#include <QListWidget>
#include <QPushButton>
#include <QMessageBox>
#include <QGraphicsDropShadowEffect>
#include <QImage>
#include <QPainter>
#include <QSize>
#include <QTimer>
#include <QMediaPlayer>
#include <QVideoWidget>
#include <QResizeEvent>
#include <QAxWidget>
#include <QAxObject>
#include "controls.h"
namespace Ui {
class MultimediaDialog;
}

class MultimediaDialog : public QWidget
{
    Q_OBJECT
signals:
    void resized(const QSize &size);

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

protected:
    virtual void resizeEvent(QResizeEvent *event) override;

private slots:
    // PPT演示相关槽函数
    void on_pushButton_selectPPT_clicked();
    void on_pushButton_startPPT_clicked();
    void on_pushButton_stopPPT_clicked();
    // 视频播放相关槽函数
    void on_pushButton_selectVideo_clicked();
    void on_pushButton_playVideo_clicked();
    void on_pushButton_pauseVideo_clicked();
    // 图像展示相关槽函数
    void on_pushButton_selectImage_clicked();
    void on_pushButton_enlargeImage_clicked();
    void on_pushButton_shrinkImage_clicked();
    void showSelectedImage();

    void return1();

private:
    Ui::MultimediaDialog *ui;

    QMediaPlayer *mediaPlayer;
    QVideoWidget *videoWidget;

    QImage currentImage;
    double imageScaleFactor;

    QAxWidget *pptWidget;
    QString currentPPTFilePath;
};

#endif // MULTIMEDIADIALOG_H
#ifndef ONLINEEXAMANDHOMEWORK_H
#define ONLINEEXAMANDHOMEWORK_H

#include <QWidget>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QMessageBox>
#include <QDebug>
#include <QDateTime>
namespace Ui {
class OnlineExamAndHomework;
}

class OnlineExamAndHomework : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_pushButton_submit_clicked();
    void on_pushButton_selectExam_clicked();
private:
    Ui::OnlineExamAndHomework *ui;
    QSqlDatabase db;
    int currentQuestionId;
    bool hasSelectedPaper;  // 新增 hasSelectedPaper 变量声明
};

#endif // ONLINEEXAMANDHOMEWORK_H
#ifndef PROGRESSTRACKING_H
#define PROGRESSTRACKING_H

#include <QWidget>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QTextEdit>
#include <QChartView>
#include <QBarSet>
#include <QBarSeries>
#include <QBarCategoryAxis>
#include <QValueAxis>
#include <QLabel>
#include <QMessageBox>
#include "content.h"
#include "multimedia.h"
#include "onlineexamandhomework.h"

namespace Ui {
    class ProgressTracking;
}

class ProgressTracking : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_closeButton_clicked();

private:
    Ui::ProgressTracking *ui;
    QTextEdit *summaryTextEdit;
    QChartView *chartView;
    void generateSummaryAndChart();
};

#endif // PROGRESSTRACKING_H
/*
 * 实现注册模块
*/
#ifndef SIGNUP_H
#define SIGNUP_H

#include <QWidget>

namespace Ui {
class Signup;
}

class Signup : public QWidget
{
    Q_OBJECT

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

private slots:
    //点击确认注册的槽函数
    void on_pushButton_2_clicked();
    //点击返回登录按钮的槽函数
    void on_btn_return_clicked();

private:
    Ui::Signup *ui;
};

#endif // SIGNUP_H

#include "content.h"
#include "ui_content.h"
#include "controls.h"
#include <QMessageBox>
#include <QGraphicsDropShadowEffect>

// 辅助函数，用于转义特殊字符
QString escapeString(const QString& input) {
    QString result = input;
    result.replace("'", "''");
    return result;
}

Content::Content(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Content)
{
    ui->setupUi(this);
    // 创建一个QPixmap对象，用于加载指定路径（这里使用资源文件路径":/blue.png"）的图片
    QPixmap *pix = new QPixmap(":/1736525693588.png");
    // 获取界面上名为label_image的标签的尺寸大小
    QSize sz = ui->label->size();
    // 将加载的图片按照标签的尺寸进行缩放，并设置为该标签显示的图片内容
    ui->label->setPixmap(pix->scaled(sz));

    //设置阴影
    QGraphicsDropShadowEffect *shadow = new QGraphicsDropShadowEffect(this);
    shadow->setOffset(-3, 0);
    shadow->setColor(QColor("#888888"));
            shadow->setBlurRadius(30);
    ui->label->setGraphicsEffect(shadow);
    // 连接按钮的点击信号到对应的槽函数
    connect(ui->pushButton, &QPushButton::clicked, this, &Content::onSelectButtonClicked);
    connect(ui->pushButton_2, &QPushButton::clicked, this, &Content::onUploadButtonClicked);
    connect(ui->pushButton_3, &QPushButton::clicked, this, &Content::onSearchButtonClicked);
    connect(ui->pushButton_4, &QPushButton::clicked, this, &Content::returncontorlsClicked);
    connect(ui->pushButton_uploadPaper, &QPushButton::clicked, this, &Content::onUploadPaperButtonClicked);
}

Content::~Content()
{
    delete ui;
}
// “选择教学资源”按钮的槽函数，用于选择文件
void Content::onSelectButtonClicked()
{
    QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("选择教学资源"), "",
                                                          tr("视频文件 (*.mp4);;文档文件 (*.pdf *.docx);;所有文件 (*)"));
    if (!fileNames.isEmpty()) {
        currentFile = fileNames.first();
        ui->pushButton->setEnabled(true);
    }
}
// “上传”按钮的槽函数，实现文件上传到本地的逻辑，避免重复上传
void Content::onUploadButtonClicked()
{
    QString currentFileName = QFileInfo(currentFile).fileName();
    bool fileAlreadyExists = false;
    // 遍历已上传文件列表，检查当前要上传的文件是否已存在
    for (int i = 0; i < ui->listWidget->count(); ++i) {
        QListWidgetItem *item = ui->listWidget->item(i);
        if (item->text() == currentFileName) {
            fileAlreadyExists = true;
            break;
        }
    }
    if (fileAlreadyExists) {
        QMessageBox::warning(this, tr("上传提示"), tr("该文件已上传过，无需重复上传！"));
        return;
    }

    ui->progressBar->show();
    QString savePath = "D:/qt/project/Qt-logon-screen--main/assets";
    QDir dir(savePath);
    if (!dir.exists()) {
        dir.mkpath(savePath);
    }
    QFile file(currentFile);
    if (file.open(QIODevice::ReadOnly)) {
        QFileInfo fileInfo(file);
        QString destinationFile = savePath + fileInfo.fileName();
        QFile destFile(destinationFile);
        if (destFile.open(QIODevice::WriteOnly)) {
            destFile.write(file.readAll());
            destFile.close();
            // 上传成功后将文件名添加到列表显示
            QListWidgetItem *item = new QListWidgetItem(fileInfo.fileName());
            ui->listWidget->addItem(item);
        }
        file.close();
    }
    ui->progressBar->hide();
    ui->pushButton_2->setEnabled(true);
}
// “搜索”按钮的槽函数，实现搜索已上传文件的功能
void Content::onSearchButtonClicked()
{
    QString keyword = ui->lineEdit->text();
    bool fileFound = false; // 用于标记是否找到文件
    for (int i = 0; i < ui->listWidget->count(); ++i) {
        QListWidgetItem *item = ui->listWidget->item(i);
        if (item->text().contains(keyword)) {
            item->setHidden(false);
            fileFound = true; // 找到匹配文件，标记为true
        } else {
            item->setHidden(true);
        }
    }
    if (fileFound) {
        QMessageBox::information(this, tr("搜索结果"), tr("找到了匹配的文件！"));
    } else {
        QMessageBox::information(this, tr("搜索结果"), tr("未找到匹配的文件。"));
    }
}
void Content::returncontorlsClicked()
{
    this->close();
    Controls *c1 = new Controls;
    c1->show();
}
void Content::onUploadPaperButtonClicked()
{
    QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("选择试卷"), "",
                                                          tr("文本文件 (*.txt);;所有文件 (*)"));
    if (!fileNames.isEmpty()) {
        QString filePath = fileNames.first();
        QFile file(filePath);
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QString fileContent = file.readAll();
            file.close();
            fileContent = escapeString(fileContent); // 转义特殊字符

            QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
            db.setDatabaseName("your_database_name.db");
            if (!db.open()) {
                QMessageBox::critical(this, tr("数据库错误"), db.lastError().text());
                return;
            }
            // 检查表是否存在
            QSqlQuery checkTableQuery(db);
            if (!checkTableQuery.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='papers'")) {
                QMessageBox::critical(this, tr("表错误"), tr("papers 表不存在！"));
                // 创建表
                QSqlQuery createTableQuery(db);
                if (!createTableQuery.exec("CREATE TABLE papers (id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL)")) {
                    QMessageBox::critical(this, tr("表创建错误"), createTableQuery.lastError().text());
                    db.close();
                    return;
                }
            } else if (!checkTableQuery.next()) {
                QMessageBox::critical(this, tr("表错误"), tr("papers 表不存在！"));
                // 创建表
                QSqlQuery createTableQuery(db);
                if (!createTableQuery.exec("CREATE TABLE papers (id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL)")) {
                    QMessageBox::critical(this, tr("表创建错误"), createTableQuery.lastError().text());
                    db.close();
                    return;
                }
            }

            QSqlQuery query(db);
            query.prepare("INSERT INTO papers (content) VALUES (?)");
            query.addBindValue(fileContent);
            if (!query.exec()) {
                QMessageBox::critical(this, tr("插入错误"), query.lastError().text());
            } else {
                QMessageBox::information(this, tr("上传成功"), tr("试卷已成功上传至数据库！"));
            }
            db.close();
        } else {
            QMessageBox::critical(this, tr("文件错误"), tr("无法打开文件"));
        }
    }
}
#include "controls.h"
#include "ui_controls.h"

Controls::Controls(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Controls)
{
    ui->setupUi(this);
    // 创建一个QPixmap对象，用于加载指定路径（这里使用资源文件路径":/blue.png"）的图片
    QPixmap *pix = new QPixmap(":/1736434134274.png");
    QPixmap *pix_1 = new QPixmap(":/1736434158438.png");
    QPixmap *pix_2 = new QPixmap(":/1736434186195.png");
    QPixmap *pix_3 = new QPixmap(":/1736434205950.png");
    QPixmap *pix_4 = new QPixmap(":/1736434224008.png");
    QPixmap *pix_5 = new QPixmap(":/1736434242280.png");
    QPixmap *pix_6 = new QPixmap(":/1736434263894.png");
    QPixmap *pix_7 = new QPixmap(":/1736439968382.png");
    // 获取界面上名为label_image的标签的尺寸大小
    QSize sz = ui->label->size();
    QSize sz_1 = ui->label_2->size();
    QSize sz_2 = ui->label_3->size();
    QSize sz_3 = ui->label_4->size();
    QSize sz_4 = ui->label_5->size();
    QSize sz_5 = ui->label_6->size();
    QSize sz_6 = ui->label_7->size();
    QSize sz_7 = ui->label_8->size();
    // 将加载的图片按照标签的尺寸进行缩放，并设置为该标签显示的图片内容
    ui->label->setPixmap(pix->scaled(sz));
    ui->label_2->setPixmap(pix_1->scaled(sz_1));
    ui->label_3->setPixmap(pix_2->scaled(sz_2));
    ui->label_4->setPixmap(pix_3->scaled(sz_3));
    ui->label_5->setPixmap(pix_4->scaled(sz_4));
    ui->label_6->setPixmap(pix_5->scaled(sz_5));
    ui->label_7->setPixmap(pix_6->scaled(sz_6));
    ui->label_8->setPixmap(pix_7->scaled(sz_7));
    //设置阴影
    QGraphicsDropShadowEffect *shadow_1 = new QGraphicsDropShadowEffect(this);
    shadow_1->setOffset(-3, 0);
    shadow_1->setColor(QColor("#888888"));
    shadow_1->setBlurRadius(30);
    ui->label_8->setGraphicsEffect(shadow_1);
    // 连接按钮的点击信号到对应的槽函数
    connect(ui->pushButton, &QPushButton::clicked, this, &Controls::on_btn_Content_management);
    connect(ui->pushButton_2, &QPushButton::clicked, this, &Controls::on_btn_Interactive_teaching);
    connect(ui->pushButton_5, &QPushButton::clicked, this, &Controls::on_btn_Multimedia_display);
    connect(ui->pushButton_6, &QPushButton::clicked, this, &Controls::on_btn_Tests_and_assignments);
    connect(ui->pushButton_3, &QPushButton::clicked, this, &Controls::on_btn_Progress_tracking);
    connect(ui->pushButton_4, &QPushButton::clicked, this, &Controls::on_btn_Evaluation_and_feedback);
    connect(ui->pushButton_7, &QPushButton::clicked, this, &Controls::on_btn_Data_statistics);
}

Controls::~Controls()
{
    delete ui;
}
//点击内容管理执行的槽函数
void Controls::on_btn_Content_management()
{
    // 关闭当前的主窗口，可能意味着进入注册流程时先隐藏登录界面之类的操作
    this->hide();
    Content *c = new Content;
    c->show();
}
//点击互动教学执行的槽函数
void Controls::on_btn_Interactive_teaching()
{
    // 关闭当前的主窗口，可能意味着进入注册流程时先隐藏登录界面之类的操作
    this->hide();
    InteractiveTeachingDialog *i = new InteractiveTeachingDialog;
    i->show();
}

//点击进度追踪执行的槽函数
void Controls::on_btn_Progress_tracking()
{
    // 这里添加点击“进度追踪”按钮的具体功能实现
    this->hide();
    ProgressTracking *p = new ProgressTracking;
    p->show();
}
//点击评价与反馈执行的槽函数
void Controls::on_btn_Evaluation_and_feedback()
{
    // 这里添加点击“评价与反馈”按钮的具体功能实现
    this->hide();
    EvaluationModule *e = new EvaluationModule;
    e->show();
}

//点击多媒体展示执行的槽函数
void Controls::on_btn_Multimedia_display()
{
    MultimediaDialog *dialog = new MultimediaDialog;
    dialog->show();
}

//点击考试与作业展示执行的槽函数
void Controls::on_btn_Tests_and_assignments()
{
    OnlineExamAndHomework *o = new OnlineExamAndHomework;
    o->show();
}

//点击数据统计展示执行的槽函数
void Controls::on_btn_Data_statistics()
{
    // 这里添加点击“数据统计展示”按钮的具体功能实现
    this->hide();
    DataStatistics *d = new DataStatistics;
    d->show();
}
#include "datastatistics.h"


DataStatistics::DataStatistics(QWidget *parent) :
    QWidget(parent),
    mainLayout(new QVBoxLayout(this)),
    backButton(new QPushButton("返回", this)),
    moduleUsageMap(),
    examScoresList()
{
    setFixedSize(860, 640);
    // 假设用户登录时记录了登录时间，这里使用一个成员变量存储
    loginTime = QTime::currentTime();

    // 连接按钮点击信号到槽函数
    connect(backButton, &QPushButton::clicked, this, &DataStatistics::close);

    // 添加按钮到布局
    mainLayout->addWidget(backButton);

    // 初始化数据
    initializeData();

    // 生成组合图表
    generateCombinedChart();

    // 将窗口置于桌面居中
    centerWindow();
}

DataStatistics::~DataStatistics()
{
    // 不需要删除 ui 指针，因为没有使用 ui 文件
}


// 初始化数据
void DataStatistics::initializeData()
{
    // 假设在用户使用模块时，会调用以下函数更新 moduleUsageMap
    // 这里我们手动添加一些示例数据
    moduleUsageMap["Content Management"] = 5;
    moduleUsageMap["Interactive Teaching"] = 3;
    moduleUsageMap["Progress Tracking"] = 2;
    moduleUsageMap["Evaluation and Feedback"] = 4;
    moduleUsageMap["Multimedia Display"] = 1;
    moduleUsageMap["Online Exam and Homework"] = 3;

    // 假设在用户完成考试时，会调用以下函数更新 examScoresList
    // 这里我们手动添加一些示例数据
    examScoresList << 85 << 90 << 78 << 88;
}


// 生成组合图表展示数据
void DataStatistics::generateCombinedChart()
{
    QBarSeries *combinedSeries = new QBarSeries();

    // 学习时长数据
    QBarSet *studyTimeSet = new QBarSet("学习时长");
    int elapsedSeconds = loginTime.secsTo(QTime::currentTime());
    *studyTimeSet << elapsedSeconds;
    combinedSeries->append(studyTimeSet);

    // 模块使用次数数据
    QBarSet *moduleUsageSet = new QBarSet("模块使用次数");
    QStringList moduleNames;
    for (const QString &moduleName : moduleUsageMap.keys()) {
        moduleNames << moduleName;
        *moduleUsageSet << moduleUsageMap[moduleName];
    }
    combinedSeries->append(moduleUsageSet);

    // 考试成绩数据
    QBarSet *examScoresSet = new QBarSet("考试成绩");
    for (int score : examScoresList) {
        *examScoresSet << score;
    }
    combinedSeries->append(examScoresSet);

    QChart *combinedChart = new QChart();
    combinedChart->addSeries(combinedSeries);
    combinedChart->setTitle("综合统计信息");

    // 设置轴
    QBarCategoryAxis *axisX = new QBarCategoryAxis();
    axisX->append(moduleNames);
    combinedChart->addAxis(axisX, Qt::AlignBottom);
    combinedSeries->attachAxis(axisX);

    QValueAxis *axisY = new QValueAxis();
    combinedChart->addAxis(axisY, Qt::AlignLeft);
    combinedSeries->attachAxis(axisY);

    QChartView *combinedChartView = new QChartView(combinedChart);
    combinedChartView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    mainLayout->addWidget(combinedChartView);
}


// 返回到主界面的按钮点击槽函数
void DataStatistics::close()
{
    this->hide();
    Controls *c = new Controls;
    c->show();
}


// 将窗口置于桌面居中
void DataStatistics::centerWindow()
{
    QDesktopWidget *desktop = QApplication::desktop();
    int screenWidth = desktop->width();
    int screenHeight = desktop->height();
    int x = (screenWidth - this->width()) / 2;
    int y = (screenHeight - this->height()) / 2;
    this->move(x, y);
}
    #include "evaluationmodule.h"
    #include "ui_evaluationmodule.h"


    EvaluationModule::EvaluationModule(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::EvaluationModule)
    {
        ui->setupUi(this);
        db = QSqlDatabase::addDatabase("QSQLITE");
        db.setDatabaseName("user.db"); // 使用注册代码中的数据库 "user.db"

        if (!db.open()) {
            QMessageBox::critical(this, "数据库错误", "无法打开数据库");
            return;
        }

        studentListWidget = ui->studentListWidget;
        evaluationTextEdit = ui->evaluationTextEdit;
        scoreLineEdit = ui->scoreLineEdit;

        loadStudents();

        connect(ui->evaluateButton, &QPushButton::clicked, this, &EvaluationModule::on_evaluateButton_clicked);
        connect(studentListWidget, &QListWidget::itemClicked, this, &EvaluationModule::on_studentListWidget_itemClicked);
    }

    EvaluationModule::~EvaluationModule()
    {
        db.close();
        delete ui;
    }

    // 加载学生列表
    void EvaluationModule::loadStudents()
    {
        studentListWidget->clear();
        QSqlQuery query(db);
        if (query.exec("SELECT username FROM user")) { // 从 "user" 表中获取用户名作为学生列表
            while (query.next()) {
                QString studentName = query.value(0).toString();
                studentListWidget->addItem(studentName);
            }
        } else {
            QMessageBox::warning(this, "加载错误", "无法加载学生列表：" + query.lastError().text());
        }
    }

    // 点击评价按钮的槽函数
    void EvaluationModule::on_evaluateButton_clicked()
    {
        QString selectedStudent = studentListWidget->currentItem()->text();
        QString score = scoreLineEdit->text();
        QString evaluation = evaluationTextEdit->toPlainText();

        // 这里可以根据评价结果给出相应的学习方案，以下为示例逻辑
        QString learningPlan;
        if (score.toInt() >= 80) {
            learningPlan = "继续保持，可尝试更具挑战性的学习任务。";
        } else if (score.toInt() >= 60) {
            learningPlan = "需要加强学习，可多做一些针对性的练习。";
        } else {
            learningPlan = "需要重点辅导，可安排额外的辅导课程。";
        }

        // 将评价结果显示在 evaluationTextEdit 中
        QString evaluationResult = "评价已生成：\n" + evaluation + "\n分数：" + score + "\n学习方案：" + learningPlan;

        // 检查该学生是否已经被评价过
        if (!evaluatedStudents.contains(selectedStudent)) {
            evaluationTextEdit->append(evaluationResult);
            evaluatedStudents.insert(selectedStudent);
        } else {
            QMessageBox::information(this, "评价提示", "该学生已经评价过，不能重复评价。");
        }
    }


    // 从列表中选择学生的槽函数
    void EvaluationModule::on_studentListWidget_itemClicked(QListWidgetItem *item)
    {
        // 当选择学生时，可以在这里添加逻辑，例如加载该学生之前的评价信息等
        // 这里仅清空评价输入框作为示例
        evaluationTextEdit->clear();
        scoreLineEdit->clear();
    }
#include "interactiveteachingdialog.h"
#include "ui_interactiveteachingdialog.h"
#include "controls.h"

// 构造函数，初始化界面及相关变量
InteractiveTeachingDialog::InteractiveTeachingDialog(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::InteractiveTeachingDialog),
    tcpServer(nullptr),
    nextUserId(1),
    isNewUserConnectionClicked(false) // 初始化标志变量为false，表示按钮还未被点击过
{
    ui->setupUi(this);
    // 创建一个QPixmap对象，用于加载指定路径（这里使用资源文件路径":/blue.png"）的图片
    QPixmap *pix = new QPixmap(":/111.png");
    QSize sz = ui->label_2->size();
    ui->label_2->setPixmap(pix->scaled(sz));
    QGraphicsDropShadowEffect *shadow_1 = new QGraphicsDropShadowEffect(this);
    shadow_1->setOffset(-3, 0);
    shadow_1->setColor(QColor("#888888"));
    shadow_1->setBlurRadius(30);
    ui->label_2->setGraphicsEffect(shadow_1);
    tcpServer = new QTcpServer(this);
    if (tcpServer->listen(QHostAddress::Any, 8888)) {  // 监听本地所有IP的8888端口，可自行修改端口号
        QMessageBox::information(this, "提示", "服务器已启动，可开始连接进行互动！");
        connect(tcpServer, &QTcpServer::newConnection, this, &InteractiveTeachingDialog::onNewConnection);
    } else {
        QMessageBox::warning(this, "错误", "启动服务器失败！");
        delete tcpServer;
        tcpServer = nullptr;
    }

    connect(ui->pushButton_2, &QPushButton::clicked, this, &InteractiveTeachingDialog::on_pushButton_send_clicked);
    connect(ui->pushButton, &QPushButton::clicked, this, &InteractiveTeachingDialog::return1);
    // 连接新用户连接按钮的信号到槽函数
    connect(ui->pushButton_3, &QPushButton::clicked, this, &InteractiveTeachingDialog::onNewUserConnectionClicked);
}

// 析构函数，释放相关资源
InteractiveTeachingDialog::~InteractiveTeachingDialog()
{
    delete ui;
    if (tcpServer) {
        tcpServer->close();
        delete tcpServer;
    }
    // 关闭所有已连接的客户端套接字并释放内存
    for (QTcpSocket *socket : clientSockets) {
        socket->close();
        delete socket;
    }
}

// 发送消息按钮点击的槽函数
void InteractiveTeachingDialog::on_pushButton_send_clicked()
{
    QString message = ui->lineEdit->text();
    if (!message.isEmpty()) {
        qDebug() << "当前已连接客户端套接字数量: " << clientSockets.size();  // 添加调试输出查看连接情况
        // 遍历所有已连接的客户端套接字，将消息发送给每个客户端
        for (QTcpSocket *socket : clientSockets) {
            if (socket && socket->isOpen()) {
                socket->write(message.toUtf8());
            }
        }
        ui->textEdit->append("发送: " + message);  // 在自己界面显示发送的消息
    }
}

// 读取接收到的消息并显示在界面文本框
void InteractiveTeachingDialog::readMessage()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket && socket->bytesAvailable() > 0) {
        QByteArray data = socket->readAll();
        QString message = QString::fromUtf8(data);
        int userId = socketToUserId[socket];
        ui->textEdit->append(QString("用户 %1: %2").arg(userId).arg(message));
    }
}

// 有新连接进来后的初始化操作槽函数
void InteractiveTeachingDialog::onNewConnection()
{
    QTcpSocket *newSocket = tcpServer->nextPendingConnection();
    if (newSocket) {
        clientSockets.append(newSocket);
        int userId = nextUserId++;
        socketToUserId[newSocket] = userId;
        connect(newSocket, &QTcpSocket::readyRead, this, &InteractiveTeachingDialog::readMessage);
        connect(newSocket, &QTcpSocket::disconnected, this, [this, newSocket]() {
            clientSockets.removeOne(newSocket);
            socketToUserId.remove(newSocket);
            newSocket->deleteLater();
        });
    }
}

//返回之前的界面
void InteractiveTeachingDialog::return1()
{
    this->close();
    Controls *c1 = new Controls;
    c1->show();
}

// 新用户连接按钮点击的槽函数，修改此处逻辑
void InteractiveTeachingDialog::onNewUserConnectionClicked()
{
    if (!isNewUserConnectionClicked) {
        QTcpSocket *newSocket = new QTcpSocket(this);
        newSocket->connectToHost(QHostAddress::LocalHost, 8888);
        if (newSocket->waitForConnected(3000)) {
            clientSockets.append(newSocket);
            int userId = nextUserId++;
            socketToUserId[newSocket] = userId;
            connect(newSocket, &QTcpSocket::readyRead, this, &InteractiveTeachingDialog::readMessage);
            connect(newSocket, &QTcpSocket::disconnected, this, [this, newSocket]() {
                clientSockets.removeOne(newSocket);
                socketToUserId.remove(newSocket);
                newSocket->deleteLater();
            });
            isNewUserConnectionClicked = true; // 点击后设置标志变量为true，表示已点击过
        } else {
            QMessageBox::warning(this, "错误", "新用户连接失败，请检查服务器状态！");
            delete newSocket;
        }
    }
}
#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "signup.h"
#include "controls.h"
#include <QGraphicsDropShadowEffect> //创建图形阴影效果的类
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    // 创建一个QPixmap对象，用于加载指定路径（这里使用资源文件路径":/blue.png"）的图片
    QPixmap *pix = new QPixmap(":/blue.png");
    // 获取界面上名为label_image的标签的尺寸大小
    QSize sz = ui->label_image->size();
    // 将加载的图片按照标签的尺寸进行缩放，并设置为该标签显示的图片内容
    ui->label_image->setPixmap(pix->scaled(sz));

    //设置阴影
    QGraphicsDropShadowEffect *shadow = new QGraphicsDropShadowEffect(this);
    shadow->setOffset(-3, 0);
    shadow->setColor(QColor("#888888"));
    shadow->setBlurRadius(30);
    ui->label_image->setGraphicsEffect(shadow);
    //初始化数据库
    sqlite_Init();

}

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

void sqlite_Init()
{
    // 获取一个QSQLITE类型的数据库连接对象，使用QSqlDatabase的静态函数来添加数据库驱动并获取连接
    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
     // 设置数据库的名称为"user.db"，指定了要操作的数据库文件
    db.setDatabaseName("user.db");
    if(!db.open())
    {
        qDebug()<<"open error";
    }
    // 创建SQL语句，用于创建一个名为"user"的表，如果该表不存在则创建，表结构包含自增的整数型主键"id"、
    //唯一且不能为空的文本型用户名"username"以及不能为空的文本型密码"password"
    QString createsql=QString("create table if not exists user(id integer primary key autoincrement,"
                        "username ntext unique not NULL,"
                        "password ntext not NULL)");
    // 创建一个QSqlQuery对象，用于执行SQL语句
    QSqlQuery query;
    if(!query.exec(createsql)){
        qDebug()<<"table create error";
    }
    else{
        qDebug()<<"table create success";
    }
}

//用于处理用户登录相关逻辑
void MainWindow::on_btn_signin_clicked()
{
    // 再次初始化数据库
    sqlite_Init();
    // 获取界面上名为lineEdit_username的文本框中输入的用户名内容
    QString username = ui->lineEdit_username->text();
    // 获取界面上名为lineEdit_password的文本框中输入的密码内容
    QString password = ui->lineEdit_password->text();
    // 构建一个SQL查询语句，用于从名为"user"的表中查询用户名和密码与输入内容匹配的记录
    QString sql=QString("select * from user where username='%1' and password='%2'")
            .arg(username).arg(password);
    //创建执行语句对象
    QSqlQuery query(sql);
    //判断执行结果
    if(!query.next())
    {
        qDebug()<<"Login error";
        QMessageBox::information(this,"登录认证","登录失败,账户或者密码错误");

    }
    else
    {
        qDebug()<<"Login success";
        // 弹出一个信息提示框，告知用户登录成功
        QMessageBox::information(this,"登录认证","登录成功");
        // 创建一个新的QWidget对象，可能用于展示登录成功后的界面
        Controls *c = new Controls;
        c->show();
        // 关闭当前的主窗口，比如可能意味着完成登录流程后不需要再显示登录界面了
        this->close();
    }
}
//用于处理用户注册相关逻辑
void MainWindow::on_btn_signup_clicked()
{
    // 关闭当前的主窗口，可能意味着进入注册流程时先隐藏登录界面之类的操作
    this->close();
    // 创建一个Signup类的对象，该类应该是用于实现用户注册相关界面和功能的，然后显示该注册界面
    Signup *s = new Signup;
    s->show();

}
#include "multimedia.h"
#include "ui_multimediadialog.h"
#include <QAxObject>  // 添加这一行

// 构造函数，初始化界面及相关变量
MultimediaDialog::MultimediaDialog(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MultimediaDialog),
    imageScaleFactor(1),
    pptWidget(new QAxWidget(this))
{
    ui->setupUi(this);

    // 初始化QMediaPlayer和QVideoWidget
    mediaPlayer = new QMediaPlayer(this);
    videoWidget = qobject_cast<QVideoWidget*>(ui->videoWidget);
    if (videoWidget) {
        mediaPlayer->setVideoOutput(videoWidget);

        // 连接视频尺寸变化信号（使用resizeEvent来间接实现类似功能，因为QVideoWidget没有sizeChanged信号）
        connect(this, &MultimediaDialog::resized, this, [this](const QSize &size) {
            if (videoWidget) {
                qDebug() << "QVideoWidget所在窗口尺寸变化为: " << size;
            }
        });
    } else {
        qDebug() << "无法将videoWidget转换为QVideoWidget*类型，视频播放功能可能受影响";
    }

    // 设置PPT演示相关按钮的信号与槽连接
    connect(ui->pushButton_selectPPT, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_selectPPT_clicked);
    connect(ui->pushButton_startPPT, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_startPPT_clicked);
    connect(ui->pushButton_stopPPT, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_stopPPT_clicked);

    // 设置视频播放相关按钮的信号与槽连接
    connect(ui->pushButton_playPauseVideo, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_playVideo_clicked);
    connect(ui->pushButton_playPauseVideo_2, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_pauseVideo_clicked);

    // 设置图像展示相关按钮的信号与槽连接
    connect(ui->pushButton_selectImage, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_selectImage_clicked);
    connect(ui->pushButton_enlargeImage, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_enlargeImage_clicked);
    connect(ui->pushButton_shrinkImage, &QPushButton::clicked, this, &MultimediaDialog::on_pushButton_shrinkImage_clicked);
    connect(ui->listWidget_images, &QListWidget::itemClicked, this, &MultimediaDialog::showSelectedImage);

    connect(ui->pushButton,&QPushButton::clicked, this, &MultimediaDialog::return1);
}
// 析构函数，释放相关资源
MultimediaDialog::~MultimediaDialog()
{
    delete mediaPlayer;
    delete ui;
    delete pptWidget;
}

// PPT演示 - “选择PPT文件”按钮点击的槽函数
void MultimediaDialog::on_pushButton_selectPPT_clicked()
{
    QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("选择PPT文件"), "",
                                                          tr("PPT文件 (*.ppt *.pptx);;所有文件 (*)"));
    for (const QString &fileName : fileNames) {
        QListWidgetItem *item = new QListWidgetItem(fileName);
        ui->listWidget_ppt->addItem(item);
    }
    if (!fileNames.isEmpty()) {
        currentPPTFilePath = fileNames.first();
    }
}

// PPT演示 - “开始演示”按钮点击的槽函数
void MultimediaDialog::on_pushButton_startPPT_clicked()
{
    if (!currentPPTFilePath.isEmpty()) {
        pptWidget->setControl("PowerPoint.Application");
        QVariant vt = QVariant(currentPPTFilePath);
        QAxObject *presentation = pptWidget->querySubObject("Presentations")->querySubObject("Open(const QString&)", vt);
        if (presentation) {
            QAxObject *slideShowSettings = presentation->querySubObject("SlideShowSettings");
            if (slideShowSettings) {
                slideShowSettings->dynamicCall("Run()");
            }
        }
    } else {
        QMessageBox::warning(this, "提示", "请先选择要演示的PPT文件");
    }
}
// PPT演示 - “停止演示”按钮点击的槽函数
void MultimediaDialog::on_pushButton_stopPPT_clicked()
{
    if (!pptWidget->isNull())  // 修改此处，使用isNull函数判断
    {
        QAxObject *presentation = pptWidget->querySubObject("ActivePresentation");
        if (presentation) {
            presentation->dynamicCall("Close()");
        }
        pptWidget->clear();
    }
}

// 视频播放 - “选择视频文件”按钮点击的槽函数
void MultimediaDialog::on_pushButton_selectVideo_clicked()
{
    QString videoFilePath = QFileDialog::getOpenFileName(this, tr("选择视频文件"), "",
                                                         tr("视频文件 (*.mp4 *.avi *.mkv);;所有文件 (*)"));
    if (!videoFilePath.isEmpty()) {
        mediaPlayer->setMedia(QUrl::fromLocalFile(videoFilePath));

        // 连接缓冲进度相关信号（使用mediaStatusChanged信号结合状态判断来模拟缓冲进度相关处理）
        connect(mediaPlayer, &QMediaPlayer::mediaStatusChanged, this, [](QMediaPlayer::MediaStatus status) {
            if (status == QMediaPlayer::BufferingMedia) {
                // 这里可以尝试获取更具体的缓冲进度信息，例如通过其他方式（可能需要借助平台相关API等）
                // 目前简单打印提示信息
                qDebug() << "正在缓冲媒体...";
            } else if (status == QMediaPlayer::BufferedMedia) {
                qDebug() << "媒体已缓冲完成，可以播放。";
            }
        });

        // 连接播放结束相关信号（同样使用mediaStatusChanged信号来判断播放结束）
        connect(mediaPlayer, &QMediaPlayer::mediaStatusChanged, this, [](QMediaPlayer::MediaStatus status) {
            if (status == QMediaPlayer::EndOfMedia) {
                qDebug() << "媒体播放结束。";
            }
        });
    }
}

// 视频播放 - “播放”按钮点击的槽函数
void MultimediaDialog::on_pushButton_playVideo_clicked()
{
    if (mediaPlayer->state() == QMediaPlayer::StoppedState) {
        if (mediaPlayer->media().isNull()) {
            QMessageBox::information(this, "提示", "请先选择要播放的视频文件");
            return;
        }
        mediaPlayer->play();
    } else if (mediaPlayer->state() == QMediaPlayer::PausedState) {
        mediaPlayer->play();
    }
}

// 视频播放 - “暂停”按钮点击的槽函数
void MultimediaDialog::on_pushButton_pauseVideo_clicked()
{
    if (mediaPlayer->state() == QMediaPlayer::PlayingState) {
        mediaPlayer->pause();
    }
}

// 图像展示 - “选择图像文件”按钮点击的槽函数
void MultimediaDialog::on_pushButton_selectImage_clicked()
{
    QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("选择图像文件"), "",
                                                          tr("图像文件 (*.png *.jpg *.jpeg);;所有文件 (*)"));
    for (const QString &fileName : fileNames) {
        QListWidgetItem *item = new QListWidgetItem(fileName);
        ui->listWidget_images->addItem(item);
    }
}

// 图像展示 - “放大”按钮点击的槽函数
void MultimediaDialog::on_pushButton_enlargeImage_clicked()
{
    imageScaleFactor *= 1.2;
    showSelectedImage();
}

// 图像展示 - “缩小”按钮点击的槽函数
void MultimediaDialog::on_pushButton_shrinkImage_clicked()
{
    imageScaleFactor /= 1.2;
    showSelectedImage();
}

// 图像展示 - 显示选中图像的函数
void MultimediaDialog::showSelectedImage()
{
    QListWidgetItem *selectedItem = ui->listWidget_images->currentItem();
    if (selectedItem) {
        QString imageFilePath = selectedItem->text();
        currentImage = QImage(imageFilePath);
        if (!currentImage.isNull()) {
            QPixmap scaledPixmap = QPixmap::fromImage(currentImage).scaled(currentImage.width() * imageScaleFactor,
                                                                           currentImage.height() * imageScaleFactor,
                                                                           Qt::KeepAspectRatio);
            ui->label_image->setPixmap(scaledPixmap);
        }
    }
}

// 重写resizeEvent函数，使其与类声明中的函数声明匹配
void MultimediaDialog::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);
    emit resized(event->size());
}

void MultimediaDialog::return1()
{
    this->hide();
    Controls *c = new Controls;
    c->show();
}
#include "onlineexamandhomework.h"
#include "ui_onlineexamandhomework.h"
#include <QFileDialog>
#include <QDateTime>
#include <QSqlError>

OnlineExamAndHomework::OnlineExamAndHomework(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::OnlineExamAndHomework),
    currentQuestionId(1),
    hasSelectedPaper(false)  // 新增标志变量，初始化为 false
{
    ui->setupUi(this);

    // 初始化数据库连接，使用与 Content 模块相同的数据库
    db = QSqlDatabase::addDatabase("QSQLITE");
    db.setDatabaseName("your_database_name.db");
    if (!db.open()) {
        QMessageBox::warning(this, "数据库错误", "无法打开数据库");
        return;
    }

    // 连接提交按钮的点击信号到相应的槽函数
    connect(ui->pushButton, &QPushButton::clicked, this, &OnlineExamAndHomework::on_pushButton_submit_clicked);
    // 连接选择试卷按钮的点击信号到相应的槽函数
    connect(ui->pushButton_selectExam, &QPushButton::clicked, this, &OnlineExamAndHomework::on_pushButton_selectExam_clicked);
}

OnlineExamAndHomework::~OnlineExamAndHomework()
{
    db.close();
    delete ui;
}

// 新添加的槽函数，用于选择试卷
void OnlineExamAndHomework::on_pushButton_selectExam_clicked()
{
    // 从 papers 表中选择试卷
    QSqlQuery query(db);
    query.prepare("SELECT content FROM papers LIMIT 1"); // 这里仅取第一条试卷记录，可根据需求修改
    if (query.exec() && query.next()) {
        QString paperContent = query.value(0).toString();
        ui->textEdit->setText(paperContent);
        hasSelectedPaper = true;  // 成功选择试卷后设置标志为 true
    } else {
        QMessageBox::warning(this, "试卷选择错误", "无法选择试卷，错误信息: " + query.lastError().text());
    }
}

void OnlineExamAndHomework::on_pushButton_submit_clicked()
{
    if (!hasSelectedPaper) {
        QMessageBox::warning(this, "提交错误", "请先选择试卷！");  // 未选择试卷时给出提示
        return;
    }

    QString studentAnswer = ui->textEdit->toPlainText();
    QString paperContent = ui->textEdit->toPlainText(); // 获取试卷内容，可根据实际需求修改获取方式

    // 仅在 textEdit_2 中显示提交信息，不插入数据库
    QString successMessage = "某某某在： " + QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss") + " 成功提交了试卷。";
    ui->textEdit_2->setText(successMessage);
}
#include "progressTracking.h"
#include "controls.h"
#include "ui_progressTracking.h"

ProgressTracking::ProgressTracking(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ProgressTracking)
{
    ui->setupUi(this);
    // 创建部件
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QLabel *titleLabel = new QLabel("进度追踪", this);
    summaryTextEdit = new QTextEdit(this);
    chartView = new QChartView(this);
    QPushButton *closeButton = new QPushButton("返回", this);

    // 布局设置
    mainLayout->addWidget(titleLabel);
    mainLayout->addWidget(summaryTextEdit);
    mainLayout->addWidget(chartView);
    mainLayout->addWidget(closeButton);

    // 连接信号与槽
    connect(closeButton, &QPushButton::clicked, this, &ProgressTracking::on_closeButton_clicked);

    // 生成总结和图表
    generateSummaryAndChart();
}

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

void ProgressTracking::on_closeButton_clicked()
{
    this->close();
    Controls *c = new Controls;
    c->show();
}

void ProgressTracking::generateSummaryAndChart()
{
    QString summary;
    QBarSet *contentSet = new QBarSet("内容管理");
    QBarSet *multimediaSet = new QBarSet("多媒体展示");
    QBarSet *examSet = new QBarSet("考试与作业");

    // 假设从相关模块获取数据，以下为示例数据，实际需根据模块的使用情况获取
    *contentSet << 3 << 2 << 4; // 假设内容管理中分别在不同类别学习了3, 2, 4个资源
    *multimediaSet << 1 << 0 << 2; // 假设多媒体展示中使用了不同资源的次数
    *examSet << 2 << 1 << 0; // 假设考试与作业完成的数量

    QBarSeries *barSeries = new QBarSeries();
    barSeries->append(contentSet);
    barSeries->append(multimediaSet);
    barSeries->append(examSet);

    QChart *chart = new QChart();
    chart->addSeries(barSeries);
    chart->setTitle("学习进度统计");

    QStringList categories;
    categories << "类别1" << "类别2" << "类别3";
    QBarCategoryAxis *axisX = new QBarCategoryAxis();
    axisX->append(categories);
    chart->addAxis(axisX, Qt::AlignBottom);
    barSeries->attachAxis(axisX);

    QValueAxis *axisY = new QValueAxis();
    chart->addAxis(axisY, Qt::AlignLeft);
    barSeries->attachAxis(axisY);

    chartView->setChart(chart);
    chartView->setRenderHint(QPainter::Antialiasing);

    // 生成总结文本，根据具体情况从相关模块获取数据
    summary += "内容管理：学习了多个教学资源，包括视频和文档。\n";
    summary += "多媒体展示：进行了图像查看和视频播放操作。\n";
    summary += "考试与作业：完成了部分考试和作业。\n";
    summaryTextEdit->setText(summary);
}
#include "signup.h"
#include "ui_signup.h"
#include "mainwindow.h"

Signup::Signup(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Signup)
{
    ui->setupUi(this);
    QPixmap *pix = new QPixmap(":/girl1.png");
    QSize sz = ui->label_image->size();
    ui->label_image->setPixmap(pix->scaled(sz));
}

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

//返回登录按钮
void Signup::on_btn_return_clicked()
{
    // 创建一个MainWindow类的对象，MainWindow类应该是用于展示登录相关界面的类
    MainWindow *w = new MainWindow;
    // 显示登录界面，让用户可以切换回登录状态进行登录操作等
    w->show();
    // 关闭当前的注册界面，因为用户选择返回登录界面，所以隐藏注册界面
    this->close();
}
//注册按钮
void Signup::on_pushButton_2_clicked()
{
    // 调用sqlite_Init函数初始化数据库
    sqlite_Init();
    // 获取界面上名为lineEdit_username的文本框中输入的用户名内容
    QString username = ui->lineEdit_username->text();
    // 获取界面上名为lineEdit_passwd的文本框中输入的密码内容
    QString password = ui->lineEdit_passwd->text();
    // 获取界面上名为lineEdit_surepasswd的文本框中输入的用于确认密码的内容
    QString surepass = ui->lineEdit_surepasswd->text();
    //判断密码是否一致
    if(password == surepass)
    {
        // 构建一个SQL插入语句，用于向名为"user"的表中插入新用户的用户名和密码信息，将获取到的用户名和密码值填充到语句中
        QString sql=QString("insert into user(username,password) values('%1','%2');")
                .arg(username).arg(password);
        //创建执行语句对象
        QSqlQuery query;
        //判断执行结果
        if(!query.exec(sql))
        {
            qDebug()<<"insert into error";
            QMessageBox::information(this,"注册认证","插入失败！");
        }
        else
        {
            qDebug()<<"insert into success";
            QMessageBox::information(this,"注册认证","插入成功！");
            MainWindow *w = new MainWindow;
            w->show();
            this->close();
        }

    }else{
        QMessageBox::information(this,"注册认证","两次密码输入不一致");
    }
}