[QT]Rich Text Editor(2)

👉아래는 QT6버전 프로그램 소스 코드 입니다.
Below is the QT6 version program source code.

👉약간의 기능이 더 추가 되어 있습니다.
There are a few more features added.

1.main.cpp

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}
/*
 * fontAwesome : 폰트다운로드 / fontdownload
 * https://fontawesome.com/search?q=pdf&o=r
 *
 *
 *
*/

2.mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTextCharFormat> // QTextCharFormat 사용을 위해 포함 / Included for use with QTextCharFormat
#include <QFileInfo>       // QFileInfo 사용을 위해 포함 / Included for using QFileInfo
// 드래그 이미지 / drag image
#include <QPoint>          // 마우스 드래그 시작 위치 저장을 위해 추가 / Added to save the mouse drag start position

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

    // QObject의 이벤트 필터 함수를 오버라이드합니다. / Override QObject's event filter function.
    bool eventFilter(QObject *obj, QEvent *event) override;

private slots:

    // == 파일 관련 슬롯 / File-related slots ==
    bool saveFile(const QString &path);
    void save(); // Save
    void saveAs(); // Save As
    void actionNew();  // 새 파일 / new file
    void actionOpen(); // 파일 열기 / open
    void actionExit(); // 종료 / Exit

    // == 편집 / Edit ==
    void actionFind();     // 찾기 기능 / find
    void actionReplace();  // 바꾸기 기능 / replace

    // == 뷰 ==
    void actionZoomIn();  // 줌인 / zoom in
    void actionZoomOut(); // 줌아웃 / zoom out
    void actionZoomReset(); // 줌 초기화 / zoom reset

    // == 이미지 / Image ==
    void actionInsertImage(); // 이미지 삽입 / insert image

    // == Export ==
    void actionExportBase64(); // Export As Base64
    void actionExportBase64WithImages(); // Export As Base64 for image
    void actionExportPdf(); //Export As Pdf

    // == Import ==
    void actionImportBase64(); // Import As Base64

    // == 텍스트 기능 / Text function ==
    void actionBold(bool checked);
    void actionItalic(bool checked);
    void actionUnderline(bool checked);
    void actionStrike(bool checked);

    // -- 자동연결설정(이전에 사용하던 방식으로 경고 발생) --
    // -- Automatic connection setup (warning occurs in the previous method) --
    // void on_actionColor_triggered();
    // void on_actionFont_triggered();

    // -- 수동연결 --
    void actionColor(); // 색상 선택은 토글이 아니므로 bool 인자가 없음 / Color selection is not a toggle, so there is no bool argument.
    void actionFont();  // 폰트 선택은 토글이 아니므로 bool 인자가 없음 / Font selection is not a toggle, so there is no bool argument.

    // 현재 커서 위치의 서식 변경을 감지하는 슬롯
    // Slot to detect format changes at the current cursor position
    void updateFormat(const QTextCharFormat &format);


    // == 도움말 기능 / help ==
    void actionHelp();  // 도움말 / help
    void actionAbout(); // 정보 / about


private:
    Ui::MainWindow *ui;
    QString currentFilePath; // 현재 파일을 추적하는 변수 추가 / Add a variable to track the current file

    // == 이미지 리사이즈를 위한 멤버 변수 / Member variables for image resizing ==
    bool m_isResizing = false;
    QPoint m_dragStartPos;
    int m_originalImageWidth = 0;
    int m_originalImageHeight = 0;


    // == 줌인/줌아웃 설정을 위한 멤버 변수 / Member variables for zoom in/zoom out settings ==
    // 폰트 크기 초기화용 변수 추가(변화하는 현재상태 저장)
    // Add a variable to initialize the font size (save the current state as it changes)
    int m_currentFontSize = 10;

    // 기본 폰트 크기를 저장하는 멤버 변수(리셋할때의 값)
    // Member variable that stores the default font size (value when reset)
    int m_defaultPointSize = 10; // 초기 기본값 설정 / Set factory defaults

};

#endif // MAINWINDOW_H

3.mainwindow.cpp

#include "mainwindow.h"
#include "./ui_mainwindow.h"

// 코드 추가 / Add code
#include <QFileDialog>
#include <QFile>
#include <QTextStream>
#include <QMessageBox>
#include <QTextCharFormat>
#include <QColorDialog> // 색상 선택 다이얼로그 / Color selection dialog
#include <QFontDialog>  // 폰트 선택 다이얼로그 / Font selection dialog

#include <QDir>         // QDir 사용을 위해 추가 / Added for QDir use
#include <QFileInfo>    // QFileInfo 사용을 위해 추가 / Added for using QFileInfo
#include <QUrl>         // 이미지 파일 경로를 URL로 변환하기 위해 필요 / Needed to convert image file path to URL
#include <QImage>       // 이미지 로드를 위해 필요 / Required for image loading
#include <QTextDocument> // QTextDocument::addResource 사용을 위해 필요 / Required for using QTextDocument::addResource
#include <QTextImageFormat> // 이미지 삽입 포맷 지정을 위해 필요 / Required to specify image insertion format
#include <QTextCursor>
#include <QInputDialog> // 사용자 입력 다이얼로그를 위해 추가 / Added for user input dialog
#include <QMouseEvent>  // 마우스 이벤트 처리를 위해 추가 / Added for mouse event handling
#include <QtMath>       // qMax, qMin 등을 위해 필요 (여기서는 qMax 사용) / Required for qMax, qMin, etc. (qMax is used here)

// export as base64
#include <QByteArray>
#include <QClipboard>
#include <QApplication>

// export base64 with images
#include <QRegularExpression>
#include <QRegularExpressionMatchIterator>
#include <QBuffer>

// pdf
#include <QPrinter>
#include <QFileDialog>
#include <QMessageBox>
#include <QPdfWriter>

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

    // 메인 윈도우의 중앙 영역에 textEdit 위젯을 배치
    // Place the textEdit widget in the center area of ​​the main window
    setCentralWidget(ui->textEdit);

    // == 파일 기능 / File functon ==
    connect(ui->actionSave, &QAction::triggered, this, &MainWindow::save);  // save
    connect(ui->actionSave_As, &QAction::triggered, this, &MainWindow::saveAs); // saveas
    connect(ui->actionExit, &QAction::triggered, this, &MainWindow::actionExit); // exit
    connect(ui->actionNew, &QAction::triggered, this, &MainWindow::actionNew); // new
    connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::actionOpen);// open
    connect(ui->actionExport_As_Base64, &QAction::triggered, this, &MainWindow::actionExportBase64); //save as base64
    connect(ui->actionImport_Base64, &QAction::triggered, this, &MainWindow::actionImportBase64); //Import base64
    connect(ui->actionExport_Base64_With_Images, &QAction::triggered, this, &MainWindow::actionExportBase64WithImages); //Import base64
    connect(ui->actionExport_As_Pdf, &QAction::triggered, this, &MainWindow::actionExportPdf); //Export As Pdf


    // == 편집 기능 구현 / Implementing editing functions ==
    connect(ui->actionCopy, &QAction::triggered, ui->textEdit, &QTextEdit::copy); //copy
    connect(ui->actionCut, &QAction::triggered, ui->textEdit, &QTextEdit::cut); // cut
    connect(ui->actionPaste, &QAction::triggered, ui->textEdit, &QTextEdit::paste); // past
    connect(ui->actionSelect_All, &QAction::triggered, ui->textEdit, &QTextEdit::selectAll); // select all
    connect(ui->actionUndo, &QAction::triggered, ui->textEdit, &QTextEdit::undo); // undo
    connect(ui->actionRedo, &QAction::triggered, ui->textEdit, &QTextEdit::redo); // redo

    // == 뷰 / View ==
    connect(ui->actionZoom_in, &QAction::triggered, this, &MainWindow::actionZoomIn);
    connect(ui->actionZoom_out, &QAction::triggered, this, &MainWindow::actionZoomOut);
    connect(ui->actionZoom_reset, &QAction::triggered, this, &MainWindow::actionZoomReset);

    // 사용자 정의 슬롯 / custom slots
    connect(ui->actionFind, &QAction::triggered, this, &MainWindow::actionFind); // find
    connect(ui->actionReplace, &QAction::triggered, this, &MainWindow::actionReplace); // replace




    // == 텍스트 / Text ==

    // 볼드체 / Bold
    // -- actionBold를 굵게/얇게 상태를 유지하는 '토글' 버튼으로 설정
    // -- Set actionBold to a 'toggle' button that maintains the bold/thin state.
    ui->actionBold->setCheckable(true);

    // -- 툴바 액션 클릭 시 서식을 적용하도록 연결
    // -- Connect to apply formatting when clicking a toolbar action
    connect(ui->actionBold, &QAction::triggered, this, &MainWindow::actionBold);

    // 이탤릭체 / Italic
    ui->actionItalic->setCheckable(true);
    connect(ui->actionItalic, &QAction::triggered, this, &MainWindow::actionItalic);

    // 밑줄 / Underline
    ui->actionUnderline->setCheckable(true);
    connect(ui->actionUnderline, &QAction::triggered, this, &MainWindow::actionUnderline);

    // 취소선 / strikethrough
    ui->actionStrike->setCheckable(true);
    connect(ui->actionStrike, &QAction::triggered, this, &MainWindow::actionStrike);

    // 글꼴 색상 / font color
    connect(ui->actionColor, &QAction::triggered, this, &MainWindow::actionColor);

    // 글꼴 선택 / Select font
    connect(ui->actionFont, &QAction::triggered, this, &MainWindow::actionFont);

    // 이미지 이미지 드래그 리사이즈 /  Image Image Drag Resize
    ui->textEdit->viewport()->installEventFilter(this);




    // == 이미지 삽입 / Insert image ==
    connect(ui->actionInsert_image, &QAction::triggered, this, &MainWindow::actionInsertImage);

    // -- 텍스트 커서의 서식이 바뀔 때마다 툴바 상태를 업데이트하도록 연결
    // -- Connect to update the toolbar state whenever the text cursor's format changes.
    connect(ui->textEdit, &QTextEdit::currentCharFormatChanged,
            this, &MainWindow::updateFormat);


    // == 도움말 기능 / Help ==
    // Help
    connect(ui->actionHelp, &QAction::triggered, this, &MainWindow::actionHelp);

    // About
    connect(ui->actionAbout, &QAction::triggered, this, &MainWindow::actionAbout);
}


// == 슬롯 / Slot ==

// Export As PDF
void MainWindow::actionExportPdf()
{
    // 저장할 PDF 파일 경로 선택 / Select the path to save the PDF file
    QString filePath = QFileDialog::getSaveFileName(this,
                                                    tr("PDF로 내보내기/Export pdf"),
                                                    QDir::homePath() + "/export.pdf",
                                                    tr("PDF 파일/PDF file (*.pdf)"));

    if (filePath.isEmpty())
        return;

    // QPrinter 객체를 PDF 모드로 설정
    // Set the QPrinter object to PDF mode
    QPrinter printer(QPrinter::HighResolution);
    printer.setOutputFormat(QPrinter::PdfFormat);
    printer.setOutputFileName(filePath);

    // 페이지 여백 및 용지 설정
    // Page margins and paper settings
    printer.setPageMargins(QMarginsF(15, 15, 15, 15));
    printer.setPageSize(QPageSize(QPageSize::A4));

    // QTextEdit의 문서를 프린터로 출력
    ui->textEdit->document()->print(&printer);

    QMessageBox::information(this, tr("완료/comolete"), tr("PDF로 성공적으로 내보냈습니다:\n%1").arg(filePath));
}

// Export base64 with images
void MainWindow::actionExportBase64WithImages()
{
    QTextDocument *doc = ui->textEdit->document();
    QString html = doc->toHtml();

    // 이미지 경로를 Base64 데이터 URI로 변환
    // Convert image path to Base64 data URI
    static const QRegularExpression imgRegex(R"###(<img[^>]*src="([^"]+)"[^>]*>)###");
    QRegularExpressionMatchIterator it = imgRegex.globalMatch(html);

    while (it.hasNext()) {
        QRegularExpressionMatch match = it.next();
        QString imgTag = match.captured(0);
        QString imgPath = match.captured(1);

        if (imgPath.startsWith("data:image"))
            continue;

        QImage image(QUrl(imgPath).toLocalFile());
        if (image.isNull())
            continue;

        QByteArray ba;
        QBuffer buffer(&ba);
        buffer.open(QIODevice::WriteOnly);
        image.save(&buffer, "PNG");

        QString base64Data = QString("data:image/png;base64,%1")
                                 .arg(QString::fromLatin1(ba.toBase64()));

        QString newTag = imgTag;
        newTag.replace(imgPath, base64Data);
        html.replace(imgTag, newTag);
    }


    // 최종 HTML을 Base64로 인코딩
    // Encode the final HTML to Base64
    QByteArray finalBase64 = html.toUtf8().toBase64();

    // 파일 저장 대화 상자 / Save file dialog box
    QString filePath = QFileDialog::getSaveFileName(this, tr("Export as Base64 HTML"),
                                                    QDir::homePath() + "/export_with_images.txt",
                                                    tr("텍스트 파일/text file (*.txt);;모든 파일 (*)"));
    if (filePath.isEmpty())
        return;

    // 파일 저장 / Save file
    QFile file(filePath);
    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        QTextStream out(&file);
        out << finalBase64;
        file.close();
        QMessageBox::information(this, tr("완료/Complete"), tr("이미지를 포함한 Base64 HTML로 내보냈습니다."));
    }
}


// base64 Import
void MainWindow::actionImportBase64()
{
    // 파일 열기 대화 상자 / Open file dialog box
    QString filePath = QFileDialog::getOpenFileName(
        this, tr("Base64 파일 열기"),
        QDir::homePath(),
        tr("텍스트 파일 (*.txt);;모든 파일 (*)"));

    if (filePath.isEmpty())
        return;

    // 파일 읽기 / read file
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return;

    QByteArray base64Data = file.readAll();
    // Base64 디코딩 / Base64 Encoding
    QByteArray decoded = QByteArray::fromBase64(base64Data);
    QString html = QString::fromUtf8(decoded);


    // 문서를 완전히 새로 생성하여 기존 상태 리셋 / Reset the previous state by creating a completely new document
    QTextDocument *newDoc = new QTextDocument(this);
    ui->textEdit->setDocument(newDoc);

    // HTML 로드 / HTML Load
    ui->textEdit->setHtml(html);

    QMessageBox::information(this, tr("완료/Complete"), tr("Base64 문서를 불러왔습니다."));
}


// base 64로 저장하기 / Save as base 64
void MainWindow::actionExportBase64()
{
    // QTextEdit의 내용을 HTML로 가져옴 / Get the contents of QTextEdit as HTML
    QString htmlContent = ui->textEdit->toHtml();

    // HTML 문자열을 Base64로 인코딩 / Encode HTML string to Base64
    QByteArray base64Data = htmlContent.toUtf8().toBase64();

    // 사용자에게 저장 또는 클립보드 복사 선택지 제공 / Give users the option to save or copy to clipboard
    QStringList options = {tr("파일로 저장"), tr("클립보드에 복사"), tr("취소")};
    bool ok;
    QString choice = QInputDialog::getItem(this, tr("Base64 내보내기"),
                                           tr("작업 선택:"), options, 0, false, &ok);
    if (!ok || choice == tr("취소"))
        return;

    if (choice == tr("파일로 저장")) {
        QString filePath = QFileDialog::getSaveFileName(this,
                                                        tr("Base64 파일로 내보내기"),
                                                        QDir::homePath() + "/export_base64.txt",
                                                        tr("텍스트 파일 (*.txt);;모든 파일 (*)"));

        if (!filePath.isEmpty()) {
            QFile file(filePath);
            if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                QTextStream out(&file);
                out << base64Data;
                file.close();
                QMessageBox::information(this, tr("완료/Complete"), tr("Base64 데이터가 파일로 저장되었습니다."));
            } else {
                QMessageBox::critical(this, tr("오류/Error"), tr("파일을 저장할 수 없습니다:\n") + file.errorString());
            }
        }
    } else if (choice == tr("클립보드에 복사/Copy to clipboard")) {
        QClipboard *clipboard = QApplication::clipboard();
        clipboard->setText(QString::fromUtf8(base64Data));
        QMessageBox::information(this, tr("완료/Complete"), tr("Base64 데이터가 클립보드에 복사되었습니다."));
    }
}


// HTML저장 / Save html
bool MainWindow::saveFile(const QString &path)
{
    QFile file(path);
    // QTextEdit의 내용을 가져옵니다.
    //QString content = ui->textEdit->toPlainText(); // 일반 텍스트 저장 예시 / Plain text storage example
    // 만약 리치 텍스트(HTML)로 저장하려면:
     QString content = ui->textEdit->toHtml();

    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        QTextStream out(&file);
        out << content;
        file.close();
        currentFilePath = path; // 저장 성공 시 경로 업데이트 / Update path when save is successful
        setWindowTitle(QFileInfo(path).fileName() + " - Editor"); // 창 제목 변경 / Change window title
        return true;
    } else {
        QMessageBox::critical(this, tr("오류/Error"), tr("파일을 저장할 수 없습니다:\n") + file.errorString());
        return false;
    }
}


// 다른 이름으로 저장하기 / Save As
void MainWindow::saveAs()
{
    // QFileDialog를 사용하여 사용자에게 파일 경로를 묻습니다.
    // Use QFileDialog to ask the user for a file path.
    QString filePath = QFileDialog::getSaveFileName(this,
                                                    tr("문서 저장/Save Document"),
                                                    currentFilePath.isEmpty() ? QDir::homePath() : currentFilePath,
                                                    tr("텍스트 파일 (*.txt);;HTML 파일 (*.html);;모든 파일 (*)"));

    if (!filePath.isEmpty()) {
        saveFile(filePath);
    }
}

// 저장하기 / Save
void MainWindow::save()
{
    if (currentFilePath.isEmpty()) {
        // 경로가 없으면 'Save As'를 호출합니다. / If there is no path, call 'Save As'.
        saveAs();
    } else {
        // 경로가 있으면 기존 파일에 덮어씁니다. / If the path exists, it will overwrite the existing file.
        saveFile(currentFilePath);
    }
}

// 종료하기 슬롯 / Exit slot
void MainWindow::actionExit()
{
    close(); // 메인 윈도우를 닫고 애플리케이션을 종료합니다. / Close the main window and exit the application.
}

// 새 파일 생성 슬롯 / New file creation slot
void MainWindow::actionNew()
{
    ui->textEdit->clear();
    currentFilePath.clear();
    setWindowTitle(tr("Untitled - Editor"));
}

// 파일 열기 슬롯 / file open slot
void MainWindow::actionOpen()
{
    QString filePath = QFileDialog::getOpenFileName(this,
                                                    tr("문서 열기/Open"),
                                                    QDir::homePath(),
                                                    tr("리치 텍스트 파일 (*.html *.htm);;텍스트 파일 (*.txt);;이미지 파일 (*.png *.jpg *.jpeg *.gif);;모든 파일 (*)"));
    if (!filePath.isEmpty()) {
        QFile file(filePath);
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QString content = file.readAll();

            if (filePath.endsWith(".html", Qt::CaseInsensitive) || filePath.endsWith(".htm", Qt::CaseInsensitive)) {
                ui->textEdit->setHtml(content); // HTML 형식으로 로드 / Load in HTML format
            }
            // 이미지 파일을 바로 열면 텍스트 편집기에 삽입 / Open the image file directly and insert it into a text editor
            else if (filePath.endsWith(".png", Qt::CaseInsensitive) ||
                     filePath.endsWith(".jpg", Qt::CaseInsensitive) ||
                     filePath.endsWith(".jpeg", Qt::CaseInsensitive) ||
                     filePath.endsWith(".gif", Qt::CaseInsensitive)) {

                ui->textEdit->clear();
                QTextDocument *doc = ui->textEdit->document();
                QUrl imageUrl = QUrl::fromLocalFile(filePath);
                QImage image(filePath);

                doc->addResource(QTextDocument::ImageResource, imageUrl, image);

                QTextImageFormat imageFormat;
                imageFormat.setWidth(image.width());
                imageFormat.setHeight(image.height());
                imageFormat.setName(imageUrl.toString());

                QTextCursor cursor = ui->textEdit->textCursor();
                cursor.insertImage(imageFormat);

            } else {
                ui->textEdit->setText(content); // 일반 텍스트로 로드 / Load as plain text
            }

            file.close();
            currentFilePath = filePath;
            setWindowTitle(QFileInfo(filePath).fileName() + tr(" - Editor"));
        } else {
            QMessageBox::critical(this, tr("오류/Error"), tr("파일을 열 수 없습니다:\n") + file.errorString());
        }
    }
}


// == 편집 기능 슬롯 / Edit function slot ==

// '찾기' 기능 / 'Find' function
void MainWindow::actionFind()
{
    bool ok;
    // 사용자에게 찾을 텍스트를 입력받습니다. / Ask the user to enter the text they want to find.
    QString text = QInputDialog::getText(this, tr("텍스트 찾기"),
                                         tr("찾을 단어를 입력하세요:"), QLineEdit::Normal,
                                         "", &ok);
    if (ok && !text.isEmpty()) {
        QTextDocument::FindFlags flags = QTextDocument::FindFlags();

        // QTextEdit::find()를 사용하여 다음 일치 항목을 찾고 선택합니다.
        bool found = ui->textEdit->find(text, flags);

        if (!found) {
            QMessageBox::information(this, tr("찾기 결과"), tr("'%1'을(를) 찾을 수 없습니다.").arg(text));
        }
    }
}

// '바꾸기' 기능 / replace function
void MainWindow::actionReplace()
{
    //  찾을 텍스트 입력 / Enter text to find
    bool ok;
    QString findText = QInputDialog::getText(this, tr("텍스트 바꾸기"),
                                             tr("찾을 단어를 입력하세요:"), QLineEdit::Normal,
                                             "", &ok);
    if (!ok || findText.isEmpty()) return;

    // 바꿀 텍스트 입력 / Enter text to find
    QString replaceText = QInputDialog::getText(this, tr("텍스트 바꾸기"),
                                                tr("바꿀 단어를 입력하세요:"), QLineEdit::Normal,
                                                "", &ok);
    if (!ok) return;

    QTextCursor cursor = ui->textEdit->textCursor();
    QTextDocument::FindFlags flags = QTextDocument::FindFlags();
    int count = 0;

    // 텍스트를 문서 시작부터 다시 찾기 시작하도록 커서를 문서 시작으로 이동
    // Move the cursor to the beginning of the document to start searching text again from the beginning of the document
    cursor.movePosition(QTextCursor::Start);
    ui->textEdit->setTextCursor(cursor);

    // 문서 끝까지 반복하며 찾기 및 바꾸기
    // Find and replace until the end of the document
    while (ui->textEdit->find(findText, flags)) {
        // find()가 성공하면 텍스트는 이미 선택되어 있습니다.
        // If find() succeeds, the text is already selected.
        QTextCursor currentSelection = ui->textEdit->textCursor();

        // 선택된 텍스트를 replaceText로 대체
        // Replace the selected text with replaceText
        currentSelection.insertText(replaceText);
        count++;

        // 다음 검색을 위해 커서를 삽입된 텍스트 뒤로 이동 (find가 자동으로 처리함)
        // Move the cursor after the inserted text for the next search (find handles this automatically)
    }

    QMessageBox::information(this, tr("바꾸기 완료"), tr("총 %1개의 항목을 변경했습니다.").arg(count));
}

// ==  뷰 기능 슬롯 / View function slot ==

//----------------------------------------------------------------
// -- 내장함수 기능을 사용하면 저장이나 내보내기 한 파일을 적용되지 않음--
// -- Using built-in functions does not apply to files saved or exported--
//----------------------------------------------------------------
// 줌인(내장함수) / Zoom in (built-in function)
// void MainWindow::actionZoomIn()
// {
//     // ui->textEdit은 QMainWindow에 포함된 QTextEdit 위젯의 objectName이라고 가정합니다.
//     if (ui->textEdit) {
//         qDebug() << "Zoom In triggered";
//         // 기본 줌 단계를 사용하여 확대 / Zoom in using the default zoom level
//         ui->textEdit->zoomIn(1);
//     }
// }

// 줌아웃(내장함수) / Zoom out (built-in function)
// void MainWindow::actionZoomOut()
// {
//     if (ui->textEdit) {
//         qDebug() << "Zoom Out triggered";
//         // 기본 줌 단계를 사용하여 축소 / Zoom out using the default zoom level
//         ui->textEdit->zoomOut(1);
//     }
// }
//-----------------------------------------------------------------------


// 줌인 커스텀 / Zoom in custom
void MainWindow::actionZoomIn()
{
    // ui->textEdit이 유효한지 확인합니다. / Check if ui->textEdit is valid.
    if (!ui->textEdit) {
        return;
    }

    // 현재 문서의 기본 폰트(또는 커서 위치의 폰트) 정보를 가져옵니다.
    // Get information about the default font of the current document (or the font at the cursor position).

    // 문서 전체의 기본 폰트 크기를 사용할지, 현재 커서의 폰트 크기를 사용할지 결정합니다.
    // Determines whether to use the default font size for the entire document or the font size of the current cursor.

    // 줌 기능은 보통 문서 전체의 기본 폰트 크기를 변경합니다.
    // The zoom feature usually changes the default font size for the entire document.
    QFont font = ui->textEdit->document()->defaultFont();
    int currentSize = font.pointSize();

    // 폰트 크기가 포인트 단위로 설정되지 않았을 경우 (예: 픽셀) 또는 0일 경우,
    // 적절한 기본값(예: 12)을 사용합니다.
    // If the font size is not set in points (e.g., pixels) or is 0,
    // use an appropriate default value (e.g., 12).
    if (currentSize <= 0) {
        currentSize = 12;
    }

    // 줌 단계 설정 및 최대 크기 제한 (Max Zoom)
    // Set zoom level and limit maximum size (Max Zoom)
    const int ZOOM_STEP = 2; // 확대 단위를 2pt로 설정 / Set the zoom unit to 2pt
    const int MAX_FONT_SIZE = 48; // 최대 폰트 크기를 48pt로 제한 / Limit maximum font size to 48pt

    if (currentSize < MAX_FONT_SIZE) {
        int newSize = qMin(currentSize + ZOOM_STEP, MAX_FONT_SIZE);

        // 새 폰트 크기 적용 / Apply new font size
        font.setPointSize(newSize);
        ui->textEdit->document()->setDefaultFont(font);

        // 텍스트 전체에 새 폰트 크기 적용 (기존 HTML 로드 시 인라인 스타일이 적용되어 있다면 필요)
        // Apply new font size to all text (needed if inline styles were applied when loading existing HTML)
        QTextCursor cursor(ui->textEdit->document());
        cursor.select(QTextCursor::Document);
        QTextCharFormat fmt;
        fmt.setFontPointSize(newSize);

        // 포맷을 병합하여 폰트 크기만 변경하고 다른 스타일은 유지합니다.
        // Merge formats to change only the font size and keep other styles.
        cursor.mergeCharFormat(fmt);
        cursor.clearSelection();

        qDebug() << "Zoom In to size:" << newSize;

        // (옵션) 줌 상태 표시 업데이트
        // (Optional) Update the zoom status display
        // updateZoomStatus(newSize);
    } else {
        qDebug() << "Maximum zoom level reached.";
    }
}



// 줌아웃 커스텀 / Zoom out coustom
void MainWindow::actionZoomOut()
{
    // ui->textEdit이 유효한지 확인합니다.
    // Check if ui->textEdit is valid.
    if (!ui->textEdit) {
        return;
    }

    // 현재 문서의 기본 폰트 정보를 가져옵니다.
    // Get the default font information for the current document.
    QFont font = ui->textEdit->document()->defaultFont();
    int currentSize = font.pointSize();

    // 폰트 크기가 포인트 단위로 설정되지 않았거나 0일 경우, 적절한 기본값(예: 12)을 사용합니다.
    // If the font size is not set in points or is 0, a reasonable default (e.g. 12) is used.
    if (currentSize <= 0) {
        currentSize = 12;
    }

    // 줌 단계 설정 및 최소 크기 제한 (Min Zoom)
    // Set zoom level and minimum size limit (Min Zoom)
    const int ZOOM_STEP = 2; // 축소 단위를 2pt로 설정 (줌 인과 동일하게 유지) / Set the zoom unit to 2pt (keep it the same as zoom in)
    const int MIN_FONT_SIZE = 8; // 최소 폰트 크기를 8pt로 제한 / Limit minimum font size to 8pt

    if (currentSize > MIN_FONT_SIZE) {

        // 현재 크기에서 줌 단계만큼 빼고, 최소 크기(MIN_FONT_SIZE)보다 작아지지 않도록 제한합니다.
        // Subtract the zoom level from the current size, and limit it to no smaller than the minimum size (MIN_FONT_SIZE).
        int newSize = qMax(currentSize - ZOOM_STEP, MIN_FONT_SIZE);

        // 새 폰트 크기 적용 / Apply new font size
        font.setPointSize(newSize);
        ui->textEdit->document()->setDefaultFont(font);

        // 텍스트 전체에 새 폰트 크기 적용 (줌 아웃이 뷰포트뿐만 아니라 실제 폰트 크기에 반영되도록)
        // Apply the new font size to the entire text (so that zooming out reflects the actual font size, not just the viewport)
        QTextCursor cursor(ui->textEdit->document());
        cursor.select(QTextCursor::Document);
        QTextCharFormat fmt;
        fmt.setFontPointSize(newSize);

        // 포맷을 병합하여 폰트 크기만 변경하고 다른 스타일은 유지합니다. / Merge formats to change only the font size and keep other styles.
        cursor.mergeCharFormat(fmt);
        cursor.clearSelection();

        qDebug() << "Zoom Out to size:" << newSize;

        // 줌 상태 표시 업데이트 / Updated zoom status display
        // updateZoomStatus(newSize);
    } else {
        qDebug() << "Minimum zoom level reached.";
    }
}

// 줌 초기화 / Reset zoom
void MainWindow::actionZoomReset()
{
    // ui->textEdit이 유효한지 확인합니다.
    // Check if ui->textEdit is valid.
    if (!ui->textEdit) {
        return;
    }

    // 기본 폰트 크기를 가져옵니다. / Get the default font size.
    const int newSize = m_defaultPointSize;

    // 문서의 기본 폰트를 설정합니다. / Sets the default font for the document.
    QFont font = ui->textEdit->document()->defaultFont();
    font.setPointSize(newSize);
    ui->textEdit->document()->setDefaultFont(font);

    // 텍스트 전체에 서식 일괄 적용 (인라인 스타일을 덮어쓰기 위함)
    // Apply formatting to all text (to overwrite inline styles)
    QTextCursor cursor(ui->textEdit->document());
    cursor.select(QTextCursor::Document);
    QTextCharFormat fmt;
    fmt.setFontPointSize(newSize);

    // 포맷을 병합하여 폰트 크기만 기본값으로 변경합니다.
    // Merge formats to only change the font size to default.
    cursor.mergeCharFormat(fmt);
    cursor.clearSelection();

    qDebug() << "Zoom Reset to default size:" << newSize;

    // 줌 상태 표시 업데이트 / Updated zoom status display
    // updateZoomStatus(newSize);
}


// ==  텍스트 기능 구현 슬롯 / Text function implementation slot ==

// 굵게 버튼이 클릭될 때 호출되는 슬롯 / A slot called when the bold button is clicked
// 볼드체 적용 슬롯 구현 / Implementing a bold font slot
void MainWindow::actionBold(bool checked)
{
    // 새로운 문자 서식 객체를 생성 / Create a new character format object
    QTextCharFormat format;

    // QAction의 체크 상태(눌림 상태)에 따라 굵게/보통을 설정
    // Set bold/normal depending on the checked state (pressed state) of QAction

    // QAction::triggered(bool checked) 시그널의 'checked' 값을 사용합니다.
    // Use the 'checked' value of the QAction::triggered(bool checked) signal.
    format.setFontWeight(checked ? QFont::Bold : QFont::Normal);

    // 서식을 텍스트 편집기에 병합 (선택 영역 또는 커서 위치의 단어에 적용)
    // Merge formatting into text editor (applies to selection or word at cursor position)

    // 이 코드는 QTextEdit::mergeCurrentCharFormat()을 사용합니다.
    // This code uses QTextEdit::mergeCurrentCharFormat().
    ui->textEdit->mergeCurrentCharFormat(format);

    // QAction의 상태는 연결된 QToolButton에 의해 자동으로 토글됩니다.
    // The state of a QAction is automatically toggled by the connected QToolButton.
}



// 이탤릭 버튼이 클릭될 때 호출되는 슬롯 / A slot called when the italic button is clicked.
void MainWindow::actionItalic(bool checked)
{
    QTextCharFormat format;

    // checked 상태에 따라 이탤릭 속성 설정 / Set italic property based on checked state
    format.setFontItalic(checked);
    ui->textEdit->mergeCurrentCharFormat(format);
}

// 밑줄 버튼이 클릭될 때 호출되는 슬롯
// Slot called when the underline button is clicked
void MainWindow::actionUnderline(bool checked)
{
    QTextCharFormat format;

    // checked 상태에 따라 밑줄 속성 설정
    // Set the underline property according to the checked state
    format.setFontUnderline(checked);
    ui->textEdit->mergeCurrentCharFormat(format);
}

// 취소선 버튼이 클릭될 때 호출되는 슬롯
// Slot called when the cancel button is clicked
void MainWindow::actionStrike(bool checked)
{
    QTextCharFormat format;

    // checked 상태에 따라 취소선 속성 설정
    // Set strikethrough property based on checked status
    format.setFontStrikeOut(checked);
    ui->textEdit->mergeCurrentCharFormat(format);
}

// 글꼴 색상 버튼이 클릭될 때 호출되는 슬롯 (수동연결 사용시)
// Slot called when the font color button is clicked (when using manual linking)
void MainWindow::actionColor()
{
    // 현재 텍스트 색상을 기본값으로 사용 / Use current text color as default
    QColor initialColor = ui->textEdit->currentCharFormat().foreground().color();
    QColor color = QColorDialog::getColor(initialColor, this, tr("글꼴 색상 선택"));

    if (color.isValid()) {
        QTextCharFormat format;
        // 선택된 색상을 전경색(글꼴 색상)으로 설정 / Set the selected color as the foreground color (font color)
        format.setForeground(QBrush(color));
        ui->textEdit->mergeCurrentCharFormat(format);
    }
}

// 글꼴 선택 버튼이 클릭될 때 호출되는 슬롯 (수동연결 사용시)
// Slot called when the font selection button is clicked (when using manual linking)
void MainWindow::actionFont()
{
    // 현재 폰트를 기본값으로 사용 / Use the current font as default
    QFont initialFont = ui->textEdit->currentCharFormat().font();
    bool ok;
    QFont font = QFontDialog::getFont(&ok, initialFont, this, tr("글꼴 선택"));

    if (ok) {
        QTextCharFormat format;
        // 선택된 폰트를 적용 / Apply selected font
        format.setFont(font);
        ui->textEdit->mergeCurrentCharFormat(format);
    }
}

// == 자동연결은 경고 발생함 ==
// void MainWindow::on_actionColor_triggered()
// {
//     // 현재 텍스트 색상을 기본값으로 사용
//     QColor initialColor = ui->textEdit->currentCharFormat().foreground().color();
//     QColor color = QColorDialog::getColor(initialColor, this, tr("글꼴 색상 선택"));

//     if (color.isValid()) {
//         QTextCharFormat format;
//         // 선택된 색상을 전경색(글꼴 색상)으로 설정
//         format.setForeground(QBrush(color));
//         ui->textEdit->mergeCurrentCharFormat(format);
//     }
// }

// void MainWindow::on_actionFont_triggered()
// {
//     // 현재 폰트를 기본값으로 사용
//     QFont initialFont = ui->textEdit->currentCharFormat().font();
//     bool ok;
//     QFont font = QFontDialog::getFont(&ok, initialFont, this, tr("글꼴 선택"));

//     if (ok) {
//         QTextCharFormat format;
//         // 선택된 폰트를 적용
//         format.setFont(font);
//         ui->textEdit->mergeCurrentCharFormat(format);
//     }
// }


// == 이미지 삽입 슬롯 / Image insertion slot  ==
void MainWindow::actionInsertImage()
{
    QString imagePath = QFileDialog::getOpenFileName(this,
                                                     tr("이미지 삽입"),
                                                     QDir::homePath(),
                                                     tr("이미지 파일 (*.png *.jpg *.jpeg *.gif *.bmp)"));

    if (!imagePath.isEmpty()) {
        QImage image(imagePath);

        if (image.isNull()) {
            QMessageBox::critical(this, tr("오류"), tr("이미지 파일을 로드할 수 없습니다."));
            return;
        }

        QTextDocument *doc = ui->textEdit->document();
        QUrl imageUrl = QUrl::fromLocalFile(imagePath);

        doc->addResource(QTextDocument::ImageResource, imageUrl, image);

        QTextImageFormat imageFormat;
        // 기본 삽입 크기를 원본 크기로 설정 / Set default insert size to original size
        imageFormat.setWidth(image.width());
        imageFormat.setHeight(image.height());
        imageFormat.setName(imageUrl.toString());

        QTextCursor cursor = ui->textEdit->textCursor();
        cursor.insertImage(imageFormat);
    }
}

// == 이벤트 필터 구현 (이미지 드래그 리사이즈) / Implementing an event filter (image drag resize) ==
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == ui->textEdit->viewport()) {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
        QTextCursor cursor = ui->textEdit->textCursor();
        QTextCharFormat format = cursor.charFormat();

        // 마우스 누름 이벤트 (Resize 시작 감지) / Mouse press event (detect resize start)
        if (event->type() == QEvent::MouseButtonPress && mouseEvent->button() == Qt::LeftButton) {
            if (format.isImageFormat()) {
                // 이미지가 선택된 위치에서 클릭이 발생한 경우 / If a click occurs at the location where the image is selected
                m_isResizing = true;
                m_dragStartPos = mouseEvent->pos();

                // 현재 이미지 포맷에서 기존 크기를 가져옵니다. / Get the original size from the current image format.
                QTextImageFormat imageFormat = format.toImageFormat();
                m_originalImageWidth = imageFormat.width();
                m_originalImageHeight = imageFormat.height();

                // 리사이즈 중에는 마우스 이벤트를 QTextEdit으로 전달하지 않습니다.
                // Mouse events are not passed to QTextEdit during resizing.
                return true;
            }
        }

        // 마우스 이동 이벤트 (Resize 진행) / Mouse move event (Resize in progress)
        else if (event->type() == QEvent::MouseMove) {
            if (m_isResizing && mouseEvent->buttons() & Qt::LeftButton) {

                // X축 이동 거리를 기반으로 크기를 조절합니다. / Scales based on the distance moved along the X-axis.
                int deltaX = mouseEvent->pos().x() - m_dragStartPos.x();

                // 새로운 너비 계산 (최소 50픽셀 제한) / New width calculation (minimum 50 pixels limit)
                int newWidth = qMax(50, m_originalImageWidth + deltaX);

                // 종횡비 유지하여 새로운 높이 계산 / Calculate new height while maintaining aspect ratio
                // 소수점 연산을 위해 double로 캐스팅 / Cast to double for decimal operations
                int newHeight = (int)((double)m_originalImageHeight * ((double)newWidth / m_originalImageWidth));

                // 현재 커서 위치에 있는 이미지 포맷을 업데이트합니다.
                // Updates the image format at the current cursor position.
                QTextCursor currentCursor = ui->textEdit->textCursor();
                if (currentCursor.charFormat().isImageFormat()) {
                    QTextImageFormat newImageFormat = currentCursor.charFormat().toImageFormat();

                    newImageFormat.setWidth(newWidth);
                    newImageFormat.setHeight(newHeight);

                    // 서식 적용 / Apply Formatting
                    ui->textEdit->mergeCurrentCharFormat(newImageFormat);
                }

                return true; // 이벤트를 소비하여 텍스트 선택 등 기본 동작 방지 / Consuming events to prevent default actions such as text selection
            }
        }

        // 마우스 놓기 이벤트 (Resize 종료) / Mouse release event (Resize ends)
        else if (event->type() == QEvent::MouseButtonRelease) {
            if (m_isResizing && mouseEvent->button() == Qt::LeftButton) {
                m_isResizing = false;
                // 리사이즈 종료 / End of resize
                return true;
            }
        }
    }

    // 필터링하지 않은 모든 이벤트를 대상 객체로 전달합니다.
    // Forward all unfiltered events to the target object.
    return QMainWindow::eventFilter(obj, event);
}


// 커서 위치의 문자 서식이 바뀔 때 호출되는 슬롯
// Slot called when the character format at the cursor position changes

// 툴바 상태 업데이트 슬롯 구현 / Implementing a Toolbar State Update Slot
void MainWindow::updateFormat(const QTextCharFormat &format)
{
    // 현재 서식에서 폰트의 굵기를 확인 / Check the font weight in the current format
    bool isBold = format.font().bold();

    // -- actionBold의 체크 상태를 폰트의 굵기 상태에 맞게 업데이트 / Update the check state of actionBold to match the bold state of the font.
    // -- 이렇게 해야 사용자가 굵은 글씨로 커서를 옮기면 버튼이 눌린 상태로 보입니다. / This way, when the user moves the cursor over the bold text, the button appears pressed.
    ui->actionBold->setChecked(isBold);

    // 다른 서식(Italic, Underline)에 대해서도 이 함수 내에서 동일하게 처리할 수 있습니다.
    // You can handle other formats (Italic, Underline) in the same way within this function.
    // ui->actionItalic->setChecked(format.font().italic());


    // 이탤릭체 상태 업데이트 / Italic status updates
    bool isItalic = format.font().italic();
    ui->actionItalic->setChecked(isItalic);

    // 밑줄 상태 업데이트 / Underline status update
    bool isUnderline = format.font().underline();
    ui->actionUnderline->setChecked(isUnderline);

    // 취소선 상태 업데이트 / Strikethrough status update
    bool isStrike = format.font().strikeOut();
    ui->actionStrike->setChecked(isStrike);
}

// == 도움말 & Help 기능 / Help & Help function ==
void MainWindow::actionHelp()
{
    QMessageBox::information(this,
                             tr("도움말/Help"),
                             tr("<h3>간단한 텍스트 편집기 사용법/How to use a simple text editor</h3>"
                                "<p><strong>파일 메뉴:</strong> 새 파일, 열기, 저장, PDF/Base64 내보내기를 지원합니다.</p>"
                                "<p><strong>File Menu:</strong> Supports New File, Open, Save, and PDF/Base64 Export.</p>"
                                "<p><strong>편집 메뉴:</strong> 찾기 및 바꾸기 기능을 사용할 수 있습니다.</p>"
                                "<p><strong>Edit menu:</strong> You can use the Find and Replace feature.</p>"
                                "<p><strong>뷰 메뉴:</strong> 텍스트 줌인/줌아웃/초기화를 할 수 있습니다.</p>"
                                "<p><strong>View Menu:</strong> You can zoom in/out/reset the text.</p>"
                                "<p><strong>서식 지정:</strong> 텍스트를 굵게, 기울임꼴, 밑줄, 취소선으로 설정하고, 색상 및 폰트를 변경할 수 있습니다.</p>"
                                "<p><strong>Formatting:</strong> You can make text bold, italic, underline, strikethrough, and change the color and font.</p>"
                                "<p><strong>이미지:</strong> 로컬 이미지를 삽입하고 마우스로 크기를 조절할 수 있습니다.</p>"
                                "<p><strong>Image:</strong> Insert a local image and resize it with your mouse.</p>"
                                ),
                             QMessageBox::Ok);
}

// about slot
void MainWindow::actionAbout()
{
    QMessageBox::about(this,
                       tr("Rich Text Editor 정보/Rich Text Editor information"),
                       tr("<h2>Rich Text Editor v1.0 (Qt)</h2>"
                          "<p>Qt 프레임워크를 기반으로 개발된 간단한 텍스트 편집기입니다.</p>"
                          "<p>A Rich text editor developed based on the Qt framework.</p>"
                          "<p>주요 기능: 파일 입출력, 텍스트 서식 지정, 이미지 삽입 및 크기 조절.</p>"
                          "<p>Key features: file input/output, text formatting, image insertion and resizing.</p>"
                          "<p>Copyright &copy; 2025</p>"

                          ));
}


// 메모리해제 / "<p>Key features: file input/output, text formatting, image insertion and resizing.</p>"
MainWindow::~MainWindow()
{
    delete ui;
}