gtk3.0入门看这一篇就够（十万字总结+源代码）

GTK（GIMP Toolkit）是一套用于创建图形用户界面的跨平台工具包，广泛用于Linux应用开发。以下是如何在Ubuntu系统上开始GTK 3.0开发的入门指南：

一、开发环境搭建

ubunto 22.04.4 桌面版本
下载地址：https://releases.ubuntu.com/22.04/ubuntu-22.04.4-desktop-amd64.iso

1.1 安装GTK3.0开发环境

sudo apt update
sudo apt upgrade
sudo apt install build-essential			// debian包构建工具。
sudo apt install cmake						// cmake编译工具
sudo apt install libgtk-3-dev				// gtk开发依赖工具
sudo apt install libgtkmm-3.0-dev 
sudo apt install qtcreator					// IDE工具，用来查看代码以及调试代码

1.2 编写第一个GTK3.0应用程序

编写main.c文件

#include <gtk/gtk.h>

static void on_activate(GtkApplication* app, gpointer user_data) {
    GtkWidget *window;
    GtkWidget *button;

    // 创建一个新窗口
    window = gtk_application_window_new(app);
    gtk_window_set_title(GTK_WINDOW(window), "Hello GTK");
    gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);

    // 创建一个按钮并添加到窗口
    button = gtk_button_new_with_label("Hello, World!");
    gtk_container_add(GTK_CONTAINER(window), button);

    // 显示窗口和按钮
    gtk_widget_show_all(window);
}

int main(int argc, char **argv) {
    GtkApplication *app;
    int status;

    // 创建一个新的GTK应用程序
    app = gtk_application_new("com.example.GtkApplication", G_APPLICATION_FLAGS_NONE);
    g_signal_connect(app, "activate", G_CALLBACK(on_activate), NULL);

    // 运行应用程序
    status = g_application_run(G_APPLICATION(app), argc, argv);

    // 释放应用程序对象
    g_object_unref(app);

    return status;
}

1.3 编写CMakeLists.txt文件

cmake_minimum_required (VERSION 3.5 FATAL_ERROR)
project(Test)
  
  
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
include_directories(${GTK3_INCLUDE_DIRS})
link_directories(${GTK3_LIBRARY_DIRS})
list(APPEND FC_DEP_LIBS ${GTK3_LIBRARIES})
 
# 生成可执行程序
add_executable(Test main.c)
 
target_link_libraries (Test ${FC_DEP_LIBS})

1.4 编译gtk3项目

mkdir build
cd build
cmake ..
make
./Test

二、GTK3.0窗口

GTK（GIMP Toolkit）是一个用于创建图形用户界面（GUI）的跨平台工具包，主要用于Linux环境。GTK 3.0 是该工具包的一个版本，提供了一系列用于构建现代化、用户友好的应用程序界面的功能。以下是GTK 3.0在Ubuntu环境中关于窗口的主要理论知识点：

2.1. GTK3.0窗口基本概念

GTK+：GTK+ 是一个开源的、跨平台的GUI工具包，广泛用于GNOME桌面环境以及许多其他桌面应用程序。
窗口（Window）：在GTK中，窗口是一个顶层容器，用于承载其他所有的GUI组件。GtkWindow是所有窗口类型的基类。

2.2 窗口的类型

GTK 3.0 提供了几种类型的窗口，每种窗口都可以用于不同的应用场景：

GtkWindow：标准的顶层窗口。
GtkDialog：用于对话框窗口，通常用于用户交互，比如确认、警告、输入等。

2.2.1 GtkWindow

接口	功能描述
set_title(const Glib::ustring& title)	设置窗口的标题。
set_default_size(int width, int height)	设置窗口的默认大小。
resize(int width, int height)	调整窗口大小。
set_resizable(bool resizable)	设置窗口是否可以调整大小。
maximize()	最大化窗口。
unmaximize()	取消窗口最大化。
fullscreen()	将窗口设置为全屏模式。
unfullscreen()	退出全屏模式。
iconify()	最小化窗口。
deiconify()	取消窗口最小化。
present()	将窗口提升到前台并获得焦点。
set_keep_above(bool setting)	设置窗口是否总是在其他窗口之上。
set_keep_below(bool setting)	设置窗口是否总是在其他窗口之下。
set_decorated(bool setting)	设置窗口是否显示装饰（如边框、标题栏等）。
set_modal(bool modal)	设置窗口是否为模态窗口。
set_transient_for(Gtk::Window& parent)	设置窗口的临时父窗口，用于对话框等。
set_type_hint(Gdk::WindowTypeHint hint)	设置窗口类型提示，如普通窗口、对话框等。
set_skip_taskbar_hint(bool setting)	设置窗口是否在任务栏中隐藏。
set_skip_pager_hint(bool setting)	设置窗口是否在分页器中隐藏。
set_opacity(double opacity)	设置窗口的不透明度，范围为0.0到1.0。
move(int x, int y)	移动窗口到指定位置。
set_icon_from_file(const std::string& filename)	从文件设置窗口图标。
set_position(Gtk::WindowPosition position)	设置窗口的初始位置，如居中、鼠标位置等。

源代码：

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GTK+ 3.0 Window Example");
        set_default_size(400, 300);
        set_resizable(true);
        set_keep_above(false);
        set_decorated(true);
        set_modal(false);
        set_opacity(0.9);

        // 将窗口居中显示
        set_position(Gtk::WIN_POS_CENTER);

        // 设置窗口图标
        set_icon_from_file("path/to/icon.png");

        // 移动窗口到屏幕左上角（100, 100）
        move(100, 100);

        // 最大化窗口
        maximize();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkApplication");
    MyWindow window;
    return app->run(window);
}

2.2.2 GtkDialog

• GtkDialog 理论知识

GtkDialog 是 GTK+ 提供的一种顶层窗口，用于创建对话框。对话框通常用于与用户交互，如确认操作、显示消息或获取输入。GtkDialog 提供了一些预定义的对话框类型，如消息对话框、文件选择对话框等，并且可以自定义按钮和内容。

• 主要特性

• 模态对话框：可以设置为模态对话框，阻止用户与其他窗口交互，直到关闭对话框。
• 预定义按钮：可以使用预定义的响应按钮，如“确定”、“取消”等。
• 灵活的内容：可以在对话框中添加任何GTK小部件，如标签、条目、按钮等。

• 主要接口

• set_default_response(int response_id)：设置默认响应。
• add_button(const Glib::ustring& button_text, int response_id)：添加按钮。
• add_action_widget(Gtk::Widget& child, int response_id)：添加自定义按钮。
• get_content_area()：获取内容区域，允许在对话框中添加自定义内容。
• run()：运行对话框并等待用户响应。
• response(int response_id)：手动触发响应信号。

• GtkDialog C++ Demo

以下是一个完整的C++代码示例，展示如何使用 Gtk::Dialog 创建一个简单的对话框。

#include <gtkmm.h>
#include <iosream>
class MyDialog : public Gtk::Dialog {
public:
    MyDialog(Gtk::Window& parent, const Glib::ustring& title) :
        Gtk::Dialog(title, parent, true) { // true 表示模态对话框
        // 设置对话框标题
        set_title(title);

        // 添加按钮
        add_button("_OK", Gtk::RESPONSE_OK);
        add_button("_Cancel", Gtk::RESPONSE_CANCEL);

        // 获取内容区域
        Gtk::Box* content_area = get_content_area();

        // 创建标签并添加到内容区域
        Gtk::Label* label = Gtk::manage(new Gtk::Label("This is a simple dialog."));
        content_area->pack_start(*label);

        // 显示所有小部件
        label->show();
    }

    virtual ~MyDialog() {}
};

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GTK+ Dialog Example");
        set_default_size(400, 200);

        // 创建按钮并连接信号
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Show Dialog"));
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));
        add(*button);

        button->show();
    }

    virtual ~MyWindow() {}

protected:
    void on_button_clicked() {
        // 创建并运行对话框
        MyDialog dialog(*this, "Example Dialog");
        int result = dialog.run();

        // 根据用户响应处理
        switch (result) {
            case Gtk::RESPONSE_OK:
                std::cout << "OK button clicked" << std::endl;
                break;
            case Gtk::RESPONSE_CANCEL:
                std::cout << "Cancel button clicked" << std::endl;
                break;
            default:
                std::cout << "Dialog closed with response: " << result << std::endl;
                break;
        }
    }
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkDialogExample");
    MyWindow window;
    return app->run(window);
}

三、GTK3.0控件使用实例

3.1 GTK3.0基本控件

3.1.1 GTK3.0的GtkLabel标签

• GTK3.0 GtkLabel 基本知识点讲解

GtkLabel 是 GTK+ 3.0 中用于显示文本的控件。它可以用来显示一行或多行的文本，并支持文本对齐、样式设置和格式化。以下是 GtkLabel 的一些主要特性和常用方法：

• 主要特性

  • 文本显示：可以显示简单的字符串文本。
  • 对齐方式：支持文本的左对齐、右对齐、居中对齐等。
  • 文本格式：支持基本的文本格式，如加粗、斜体、下划线等。
  • 自动换行：可以设置是否自动换行。
  • 标记语言：支持 Pango 标记语言，用于复杂的文本格式化。

• 常用方法

  • set_text(const Glib::ustring& text)：设置标签显示的文本。
  • set_markup(const Glib::ustring& markup)：设置带有 Pango 标记语言格式的文本。
  • set_justify(Gtk::Justification justification)：设置文本的对齐方式。
  • set_line_wrap(bool wrap)：设置是否自动换行。
  • set_selectable(bool selectable)：设置文本是否可选择（复制）。
  • set_ellipsize(Pango::EllipsizeMode mode)：设置文本省略方式（如在末尾显示省略号）。

• GtkLabel 代码示例

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkLabel Example");
        set_default_size(300, 200);

        // 创建一个垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));
        add(*vbox);

        // 创建简单文本标签
        Gtk::Label* label1 = Gtk::manage(new Gtk::Label("This is a simple label."));
        vbox->pack_start(*label1);

        // 创建带有格式化文本的标签
        Gtk::Label* label2 = Gtk::manage(new Gtk::Label());
        label2->set_markup("<b>This is bold text</b> and <i>this is italic text</i>.");
        vbox->pack_start(*label2);

        // 创建一个带有自动换行功能的标签
        Gtk::Label* label3 = Gtk::manage(new Gtk::Label("This is a long text that will wrap automatically when it reaches the end of the window width."));
        label3->set_line_wrap(true);
        vbox->pack_start(*label3);

        // 创建一个带有选择功能的标签
        Gtk::Label* label4 = Gtk::manage(new Gtk::Label("This text is selectable. You can copy it."));
        label4->set_selectable(true);
        vbox->pack_start(*label4);

        // 显示所有子控件
        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkLabelExample");

    MyWindow window;

    return app->run(window);
}

• 运行代码

将上述代码保存到 main.cpp 文件中，然后使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

• 运行结果

3.1.2 GTK3.0的GtkImage：图像

• GTK3.0 GtkImage 基本知识点讲解

GtkImage 是 GTK+ 3.0 中用于显示图像的控件。它可以从多种来源加载图像，包括文件、内存中的数据、GdkPixbuf 对象等。GtkImage 可以显示静态图像，也可以显示动画图像（如 GIF）。常用的图像格式包括 PNG、JPEG、GIF 等。

• 主要特性

  • 加载图像：从文件、资源、内存、GdkPixbuf 等加载图像。
  • 显示动画：支持显示动画图像。
  • 自动缩放：根据控件大小自动缩放图像。

• 常用方法

  • set_from_file(const std::string& filename)：从文件加载图像。
  • set_from_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)：从 GdkPixbuf 对象加载图像。
  • set_from_resource(const std::string& resource_path)：从资源路径加载图像。
  • set_from_icon_name(const std::string& icon_name, Gtk::IconSize size)：从图标名称加载图像。
  • clear()：清除当前显示的图像。

• 代码实例

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        // 设置窗口标题
        set_title("GtkImage Example");
        set_default_size(400, 300);

        // 创建一个垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));
        add(*vbox);

        // 从文件加载图像
        Gtk::Image* image1 = Gtk::manage(new Gtk::Image("path/to/image1.png"));
        vbox->pack_start(*image1);

        // 从内存中的 GdkPixbuf 加载图像
        Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create_from_file("path/to/image2.jpg");
        Gtk::Image* image2 = Gtk::manage(new Gtk::Image(pixbuf));
        vbox->pack_start(*image2);

        // 从资源加载图像（需要提前将图像嵌入到资源文件中）
        Gtk::Image* image3 = Gtk::manage(new Gtk::Image("/com/example/app/resource_image.png"));
        vbox->pack_start(*image3);

        // 从图标名称加载图像
        Gtk::Image* image4 = Gtk::manage(new Gtk::Image("application-exit", Gtk::ICON_SIZE_DIALOG));
        vbox->pack_start(*image4);

        // 显示所有子控件
        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkImageExample");

    MyWindow window;

    return app->run(window);
}

以上示例展示了如何使用 Gtk::Image 加载和显示不同来源的图像，包括文件、内存中的 GdkPixbuf、资源和图标名称。确保替换 path/to/image1.png 和 path/to/image2.jpg 为实际图像文件的路径。资源路径 /com/example/app/resource_image.png 也需要根据实际嵌入的资源进行替换。

3.1.3 GTK3.0的GtkProgressBar：进度条

• GtkProgressBar 基本知识点讲解

GtkProgressBar 是 GTK+ 3.0 中用于显示任务进度的控件。它可以以条形或文本形式显示进度，适用于显示长时间运行任务的进度。GtkProgressBar 支持不同的进度模式，包括确定模式（明确的进度值）和不确定模式（任务进行中但进度不明确）。

• 主要特性

  • 进度值：可以设置和获取当前的进度值（0.0到1.0）。
  • 文本显示：可以在进度条上显示文本信息。
  • 进度方向：支持水平和垂直进度条。
  • 脉冲模式：适用于不确定进度的任务，通过反复移动的块来表示活动。

• 常用方法

  • set_fraction(double fraction)：设置进度值（范围 0.0 到 1.0）。
  • get_fraction()：获取当前的进度值。
  • set_text(const Glib::ustring& text)：设置显示在进度条上的文本。
  • set_show_text(bool show_text)：设置是否显示文本。
  • pulse()：在脉冲模式下移动进度条的块。

• GtkProgressBar C++ Demo

#include <gtkmm.h>
#include <thread>
#include <chrono>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkProgressBar Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        progressbar = Gtk::manage(new Gtk::ProgressBar());  // 创建进度条控件
        vbox->pack_start(*progressbar);  // 将进度条添加到盒子容器中

        // 设置进度条属性
        progressbar->set_show_text(true);  // 显示进度条文本
        progressbar->set_text("Loading...");  // 设置进度条文本

        // 创建并启动一个线程，用于模拟进度更新
        std::thread([this]() {
            for (int i = 0; i <= 100; ++i) {
                std::this_thread::sleep_for(std::chrono::milliseconds(50));  // 模拟任务执行时间
                   progressbar->set_fraction(i / 100.0);  // 更新进度值
            }
        }).detach();  // 分离线程，使其独立运行

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    Gtk::ProgressBar* progressbar;  // 进度条控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkProgressBarExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含进度条的窗口，并使用一个后台线程来模拟任务进度更新。进度条的进度值从 0 增加到 1，并显示相应的文本。

3.1.4 GTK3.0的GtkStatusbar：状态栏

• GtkStatusbar 基本知识点讲解

GtkStatusbar 是 GTK+ 3.0 中用于显示应用程序状态信息的控件。它通常位于窗口的底部，用于显示简短的信息、提示或状态消息。

• 主要特性

• 消息栈：GtkStatusbar 使用消息栈来管理显示的消息。新消息会被推到栈顶，旧消息会被隐藏。消息被移除时，恢复显示之前的消息。
• 上下文 ID：用于区分不同来源的消息。可以为不同的上下文 ID 管理各自的消息栈。

• 常用方法

  • get_context_id(const Glib::ustring& context_description)：获取或创建一个上下文 ID。
  • push(guint context_id, const Glib::ustring& text)：将消息推到状态栏的消息栈顶。
  • pop(guint context_id)：从消息栈中移除顶部的消息。
  • remove(guint context_id, guint message_id)：移除特定的消息。

• GtkStatusbar C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkStatusbar Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        Gtk::Button* button = Gtk::manage(new Gtk::Button("Show Message"));  // 创建按钮控件
        vbox->pack_start(*button);  // 将按钮添加到盒子容器中

        statusbar = Gtk::manage(new Gtk::Statusbar());  // 创建状态栏控件
        vbox->pack_end(*statusbar, Gtk::PACK_SHRINK);  // 将状态栏添加到盒子容器中，并设置为收缩模式

        // 获取状态栏的上下文 ID
        context_id = statusbar->get_context_id("example");

        // 为按钮点击事件连接信号处理函数
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 按钮点击事件处理函数
    void on_button_clicked() {
        // 将消息推送到状态栏
        statusbar->push("Button clicked!");  
    }

    Gtk::Statusbar* statusbar;  // 状态栏控件指针
    guint context_id;  // 状态栏上下文 ID
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkStatusbarExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含按钮和状态栏的窗口。当点击按钮时，会在状态栏中显示一条消息。

3.1.5 GTK3.0的GtkButton：按钮

• GtkButton 基本知识点讲解

GtkButton 是 GTK+ 3.0 中用于创建按钮的控件。按钮是用户界面中最常见的交互元素之一，可以触发特定的动作或事件。GtkButton 可以包含文本标签、图标或两者兼有。

• 主要特性

• 标签和图标：按钮可以显示文本标签、图标或两者结合。
• 信号处理：主要信号是 clicked，当按钮被点击时触发。
• 样式和外观：可以设置按钮的外观、尺寸和行为。

• 常用方法

• set_label(const Glib::ustring& label)：设置按钮的文本标签。
• set_image(Gtk::Widget& image)：设置按钮的图标。
• set_always_show_image(bool always_show)：设置是否总是显示图标。
• signal_clicked().connect(sigc::mem_fun(*this, &MyClass::on_button_clicked))：连接按钮点击事件的信号处理函数。

• GtkButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkButton Example");  // 设置窗口标题
        set_default_size(200, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        button = Gtk::manage(new Gtk::Button("Click Me"));  // 创建按钮控件，设置文本标签
        vbox->pack_start(*button);  // 将按钮添加到盒子容器中

        // 连接按钮点击事件的信号处理函数
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 按钮点击事件处理函数
    void on_button_clicked() {
        button->set_label("Clicked!");  // 当按钮被点击时，修改按钮的文本标签
    }

    Gtk::Button* button;  // 按钮控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含按钮的窗口。当按钮被点击时，按钮的文本标签会改变。

3.1.6 GTK3.0的GtkToggleButton：切换按钮

• GtkToggleButton 基本知识点讲解

GtkToggleButton 是 GTK+ 3.0 中用于创建切换按钮的控件。切换按钮类似于标准按钮，但具有两种状态：按下和未按下。它常用于在两个状态之间切换，例如启用/禁用功能。

• 主要特性

  • 双状态：切换按钮可以处于按下或未按下状态。
  • 信号处理：主要信号是 toggled，当按钮的状态改变时触发。
  • 标签和图标：切换按钮可以显示文本标签、图标或两者结合。

• 常用方法

  • set_active(bool is_active)：设置按钮的状态。
  • get_active()：获取按钮的当前状态。
  • signal_toggled().connect(sigc::mem_fun(*this, &MyClass::on_button_toggled))：连接按钮状态改变事件的信号处理函数。

• GtkToggleButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkToggleButton Example");  // 设置窗口标题
        set_default_size(200, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        toggle_button = Gtk::manage(new Gtk::ToggleButton("Toggle Me"));  // 创建切换按钮控件，设置文本标签
        vbox->pack_start(*toggle_button);  // 将切换按钮添加到盒子容器中

        // 连接切换按钮状态改变事件的信号处理函数
        toggle_button->signal_toggled().connect(sigc::mem_fun(*this, &MyWindow::on_button_toggled));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 切换按钮状态改变事件处理函数
    void on_button_toggled() {
        if (toggle_button->get_active()) {
            toggle_button->set_label("I'm Active");  // 当按钮处于按下状态时，修改按钮的文本标签
        } else {
            toggle_button->set_label("Toggle Me");  // 当按钮处于未按下状态时，修改按钮的文本标签
        }
    }

    Gtk::ToggleButton* toggle_button;  // 切换按钮控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkToggleButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含切换按钮的窗口。当切换按钮的状态改变时，会根据状态修改按钮的文本标签。

3.1.7 GTK3.0的GtkCheckButton：复选按钮

• GtkCheckButton 基本知识点讲解

GtkCheckButton 是 GTK+ 3.0 中用于创建复选按钮的控件。复选按钮是一个可以被选中或取消选中的按钮，通常用于表示一个二元状态（例如，启用/禁用某项设置）。

• 主要特性

  • 双状态：复选按钮可以处于选中或未选中状态。
  • 信号处理：主要信号是 toggled，当按钮的状态改变时触发。
  • 标签：复选按钮可以显示文本标签。

• 常用方法

• set_active(bool is_active)：设置按钮的状态。
• get_active()：获取按钮的当前状态。
• signal_toggled().connect(sigc::mem_fun(*this, &MyClass::on_button_toggled))：连接按钮状态改变事件的信号处理函数。

• GtkCheckButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkCheckButton Example");  // 设置窗口标题
        set_default_size(200, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        check_button = Gtk::manage(new Gtk::CheckButton("Check Me"));  // 创建复选按钮控件，设置文本标签
        vbox->pack_start(*check_button);  // 将复选按钮添加到盒子容器中

        // 连接复选按钮状态改变事件的信号处理函数
        check_button->signal_toggled().connect(sigc::mem_fun(*this, &MyWindow::on_button_toggled));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 复选按钮状态改变事件处理函数
    void on_button_toggled() {
        if (check_button->get_active()) {
            check_button->set_label("I'm Checked");  // 当按钮处于选中状态时，修改按钮的文本标签
        } else {
            check_button->set_label("Check Me");  // 当按钮处于未选中状态时，修改按钮的文本标签
        }
    }

    Gtk::CheckButton* check_button;  // 复选按钮控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkCheckButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含复选按钮的窗口。当复选按钮的状态改变时，会根据状态修改按钮的文本标签。

3.1.8 GTK3.0的GtkRadioButton：单选按钮

• GtkRadioButton 基本知识点讲解

GtkRadioButton 是 GTK+ 3.0 中用于创建单选按钮的控件。单选按钮允许用户在多个选项中选择其中一个，通常以一组互斥的按钮形式出现。

• 主要特性

  • 互斥选择：同一组中的单选按钮是互斥的，选中一个会取消其他按钮的选中状态。
  • 组管理：单选按钮通过共享一个 Gtk::RadioButton::Group 对象来管理组关系。
  • 信号处理：主要信号是 toggled，当按钮的状态改变时触发。

• 常用方法

  • set_active(bool is_active)：设置按钮的状态。
  • get_active()：获取按钮的当前状态。
  • set_group(Gtk::RadioButton::Group& group)：设置按钮所属的组。
  • get_group()：获取按钮所属的组。
  • signal_toggled().connect(sigc::mem_fun(*this, &MyClass::on_button_toggled))：连接按钮状态改变事件的信号处理函数。

• GtkRadioButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkRadioButton Example");  // 设置窗口标题
        set_default_size(200, 150);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        // 创建单选按钮组
        Gtk::RadioButton::Group group;

        // 创建第一个单选按钮，并将其加入组
        radio_button1 = Gtk::manage(new Gtk::RadioButton(group, "Option 1"));
        vbox->pack_start(*radio_button1);  // 将第一个单选按钮添加到盒子容器中

        // 创建第二个单选按钮，并将其加入组
        radio_button2 = Gtk::manage(new Gtk::RadioButton(group, "Option 2"));
        vbox->pack_start(*radio_button2);  // 将第二个单选按钮添加到盒子容器中

        // 创建第三个单选按钮，并将其加入组
        radio_button3 = Gtk::manage(new Gtk::RadioButton(group, "Option 3"));
        vbox->pack_start(*radio_button3);  // 将第三个单选按钮添加到盒子容器中

        // 连接单选按钮状态改变事件的信号处理函数
        radio_button1->signal_toggled().connect(sigc::mem_fun(*this, &MyWindow::on_button_toggled));
        radio_button2->signal_toggled().connect(sigc::mem_fun(*this, &MyWindow::on_button_toggled));
        radio_button3->signal_toggled().connect(sigc::mem_fun(*this, &MyWindow::on_button_toggled));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 单选按钮状态改变事件处理函数
    void on_button_toggled() {
        if (radio_button1->get_active()) {
            set_title("Option 1 selected");  // 当第一个按钮被选中时，修改窗口标题
        } else if (radio_button2->get_active()) {
            set_title("Option 2 selected");  // 当第二个按钮被选中时，修改窗口标题
        } else if (radio_button3->get_active()) {
            set_title("Option 3 selected");  // 当第三个按钮被选中时，修改窗口标题
        }
    }

    Gtk::RadioButton* radio_button1;  // 第一个单选按钮控件指针
    Gtk::RadioButton* radio_button2;  // 第二个单选按钮控件指针
    Gtk::RadioButton* radio_button3;  // 第三个单选按钮控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkRadioButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含三个单选按钮的窗口。每个单选按钮属于同一个组，因此它们是互斥的。当其中一个按钮的状态改变时，窗口标题会根据选中的按钮进行更新。

3.1.9 GTK3.0的GtkSwitch：开关

• GtkSwitch 基本知识点讲解

GtkSwitch 是 GTK+ 3.0 中用于创建开关控件的组件。开关控件类似于一个物理开关，可以在“开”和“关”两种状态之间切换，通常用于表示启用或禁用某个设置。

• 主要特性

  • 双状态：开关控件具有两种状态：“开”和“关”。
  • 信号处理：主要信号是 state-set，当开关的状态改变时触发。
  • 外观：开关控件具有现代的外观，适合触摸屏和桌面应用。

• 常用方法

  • set_active(bool is_active)：设置开关的状态。
  • get_active()：获取开关的当前状态。
  • signal_state_set().connect(sigc::mem_fun(*this, &MyClass::on_switch_state_set))：连接开关状态改变事件的信号处理函数。

• GtkSwitch C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkSwitch Example");  // 设置窗口标题
        set_default_size(200, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        switch_button = Gtk::manage(new Gtk::Switch());  // 创建开关控件
        vbox->pack_start(*switch_button);  // 将开关控件添加到盒子容器中

        // 连接开关状态改变事件的信号处理函数
        switch_button->signal_state_set().connect(sigc::mem_fun(*this, &MyWindow::on_switch_state_set));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 开关状态改变事件处理函数
    bool on_switch_state_set(bool state) {
        if (state) {
            set_title("Switch is ON");  // 当开关处于“开”状态时，修改窗口标题
        } else {
            set_title("Switch is OFF");  // 当开关处于“关”状态时，修改窗口标题
        }
        return true;  // 返回 true 表示接受状态变化
    }

    Gtk::Switch* switch_button;  // 开关控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkSwitchExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含开关控件的窗口。当开关的状态改变时，会根据状态修改窗口的标题，以指示当前开关是“开”还是“关”。

3.1.10 GTK3.0的GtkEntry：文本输入框

• GtkEntry 基本知识点讲解

GtkEntry 是 GTK+ 3.0 中用于创建单行文本输入框的控件。文本输入框允许用户输入和编辑单行文本，通常用于表单、搜索框等场景。

• 主要特性

  • 文本输入：允许用户输入和编辑单行文本。
  • 占位符文本：可以显示占位符文本（提示文本）。
  • 文本限制：可以限制最大输入长度。
  • 文本变化信号：提供文本变化的信号，用于处理用户输入。

• 常用方法

  • set_text(const Glib::ustring& text)：设置输入框的文本内容。
  • get_text() const：获取输入框的当前文本内容。
  • set_placeholder_text(const Glib::ustring& text)：设置占位符文本。
  • set_max_length(gint max)：设置输入框的最大输入长度。
  • signal_changed().connect(sigc::mem_fun(*this, &MyClass::on_entry_changed))：连接文本变化事件的信号处理函数。

• GtkEntry C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkEntry Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        entry = Gtk::manage(new Gtk::Entry());  // 创建文本输入框控件
        entry->set_placeholder_text("Enter text here...");  // 设置占位符文本
        vbox->pack_start(*entry);  // 将文本输入框添加到盒子容器中

        label = Gtk::manage(new Gtk::Label());  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        // 连接文本输入框文本变化事件的信号处理函数
        entry->signal_changed().connect(sigc::mem_fun(*this, &MyWindow::on_entry_changed));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 文本输入框文本变化事件处理函数
    void on_entry_changed() {
        Glib::ustring text = entry->get_text();  // 获取文本输入框的当前文本内容
        label->set_text("You entered: " + text);  // 根据输入内容更新标签
    }

    Gtk::Entry* entry;  // 文本输入框控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkEntryExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含文本输入框和标签的窗口。当用户在文本输入框中输入文本时，标签会实时更新，显示用户输入的内容。

3.1.10 GTK3.0的GtkEntry：密码输入框

• 密码框基本知识点讲解

GtkEntry 可以配置为密码输入框，通过将输入框的属性设置为掩码模式，隐藏用户输入的文本内容。通常用于密码输入，以防止敏感信息被窥视。

• 主要特性

• 掩码模式：隐藏输入的文本，显示为掩码字符（如 * 或 •）。
• 文本输入：允许用户输入和编辑单行文本。
• 占位符文本：可以显示占位符文本（提示文本）。
• 文本限制：可以限制最大输入长度。
• 文本变化信号：提供文本变化的信号，用于处理用户输入。

• 常用方法

• set_visibility(bool visible)：设置输入框的文本是否可见。对于密码框，应设置为 false。
• set_invisible_char(gunichar ch)：设置掩码字符。
• set_text(const Glib::ustring& text)：设置输入框的文本内容。
• get_text() const：获取输入框的当前文本内容。
• set_placeholder_text(const Glib::ustring& text)：设置占位符文本。
• set_max_length(gint max)：设置输入框的最大输入长度。
• signal_changed().connect(sigc::mem_fun(*this, &MyClass::on_entry_changed))：连接文本变化事件的信号处理函数。

• GTK3.0 密码框 C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("Password Entry Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        password_entry = Gtk::manage(new Gtk::Entry());  // 创建文本输入框控件
        password_entry->set_placeholder_text("Enter password here...");  // 设置占位符文本
        password_entry->set_visibility(false);  // 设置输入框为密码模式（隐藏文本）
        password_entry->set_invisible_char('*');  // 设置掩码字符
        vbox->pack_start(*password_entry);  // 将文本输入框添加到盒子容器中

        label = Gtk::manage(new Gtk::Label());  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        // 连接文本输入框文本变化事件的信号处理函数
        password_entry->signal_changed().connect(sigc::mem_fun(*this, &MyWindow::on_entry_changed));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 文本输入框文本变化事件处理函数
    void on_entry_changed() {
        Glib::ustring text = password_entry->get_text();  // 获取文本输入框的当前文本内容
        label->set_text("Password length: " + std::to_string(text.length()));  // 根据输入内容更新标签，显示密码长度
    }

    Gtk::Entry* password_entry;  // 文本输入框控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.PasswordEntryExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含密码输入框和标签的窗口。当用户在密码输入框中输入文本时，标签会实时更新，显示输入密码的长度。密码输入框的文本内容是隐藏的，以保护用户的隐私。

3.1.11 GTK3.0的GtkSearchEntry：搜索输入框

• GtkSearchEntry 基本知识点讲解

GtkSearchEntry 是 GTK+ 3.0 中用于创建搜索输入框的控件。搜索输入框是一个带有搜索图标和清除按钮的单行文本输入框，专门用于实现搜索功能。

• 主要特性
  • 内置搜索图标：在输入框中显示一个搜索图标。
  • 清除按钮：当有输入时，显示一个清除按钮，允许用户清除输入内容。
  • 信号处理：提供文本变化和激活（按下回车键）的信号，用于处理用户的搜索请求。

+常用方法
- set_text(const Glib::ustring& text)：设置输入框的文本内容。
- get_text() const：获取输入框的当前文本内容。
- set_placeholder_text(const Glib::ustring& text)：设置占位符文本。
- signal_search_changed().connect(sigc::mem_fun(*this, &MyClass::on_search_changed))：连接文本变化事件的信号处理函数。
- signal_activate().connect(sigc::mem_fun(*this, &MyClass::on_search_activated))：连接激活事件（如按下回车键）的信号处理函数。

• GtkSearchEntry C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkSearchEntry Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        search_entry = Gtk::manage(new Gtk::SearchEntry());  // 创建搜索输入框控件
        search_entry->set_placeholder_text("Search...");  // 设置占位符文本
        vbox->pack_start(*search_entry);  // 将搜索输入框添加到盒子容器中

        label = Gtk::manage(new Gtk::Label());  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        // 连接搜索输入框文本变化事件的信号处理函数
        search_entry->signal_search_changed().connect(sigc::mem_fun(*this, &MyWindow::on_search_changed));
        // 连接搜索输入框激活事件（按下回车键）的信号处理函数
        search_entry->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_search_activated));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 搜索输入框文本变化事件处理函数
    void on_search_changed() {
        Glib::ustring text = search_entry->get_text();  // 获取搜索输入框的当前文本内容
        label->set_text("Searching for: " + text);  // 根据输入内容更新标签
    }

    // 搜索输入框激活事件（按下回车键）处理函数
    void on_search_activated() {
        Glib::ustring text = search_entry->get_text();  // 获取搜索输入框的当前文本内容
        label->set_text("Search activated: " + text);  // 根据输入内容更新标签，指示搜索被激活
    }

    Gtk::SearchEntry* search_entry;  // 搜索输入框控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkSearchEntryExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含搜索输入框和标签的窗口。当用户在搜索输入框中输入文本时，标签会实时更新，显示当前的搜索内容。当用户按下回车键时，标签会更新，指示搜索操作被激活。

3.1.12 GTK3.0的GtkTextView：多行文本输入

• GtkTextView 基本知识点讲解

GtkTextView 是 GTK+ 3.0 中用于创建多行文本输入和显示区域的控件。它提供了丰富的文本编辑功能，支持多种文本格式和样式。

• 主要特性

  • 多行文本输入和显示：可以显示和编辑多行文本。
  • 文本格式化：支持不同的文本样式、颜色和格式。
  • 滚动支持：可以与 GtkScrolledWindow 结合使用，实现文本区域的滚动。
  • 缓冲区：使用 GtkTextBuffer 管理文本内容和属性。

• 常用方法

  • get_buffer()：获取文本视图的缓冲区对象。
  • set_buffer(const Glib::RefPtr<Gtk::TextBuffer>& buffer)：设置文本视图的缓冲区对象。
  • get_text()：获取文本视图中的文本内容。
  • set_text(const Glib::ustring& text)：设置文本视图的文本内容。
  • signal_changed().connect(sigc::mem_fun(*this, &MyClass::on_text_changed))：连接文本变化事件的信号处理函数。

• GtkTextView C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkTextView Example");  // 设置窗口标题
        set_default_size(400, 300);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        Gtk::ScrolledWindow* scrolled_window = Gtk::manage(new Gtk::ScrolledWindow());  // 创建滚动窗口控件
        scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);  // 设置滚动策略

        text_view = Gtk::manage(new Gtk::TextView());  // 创建文本视图控件
        text_buffer = Gtk::TextBuffer::create();  // 创建文本缓冲区
        text_view->set_buffer(text_buffer);  // 将文本缓冲区设置到文本视图中

        scrolled_window->add(*text_view);  // 将文本视图添加到滚动窗口中
        vbox->pack_start(*scrolled_window);  // 将滚动窗口添加到盒子容器中

        label = Gtk::manage(new Gtk::Label());  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        // 连接文本缓冲区文本变化事件的信号处理函数
        text_buffer->signal_changed().connect(sigc::mem_fun(*this, &MyWindow::on_text_changed));

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 文本缓冲区文本变化事件处理函数
    void on_text_changed() {
        Glib::ustring text = text_buffer->get_text();  // 获取文本缓冲区的当前文本内容
        label->set_text("Text length: " + std::to_string(text.length()));  // 根据输入内容更新标签，显示文本长度
    }

    Gtk::TextView* text_view;  // 文本视图控件指针
    Glib::RefPtr<Gtk::TextBuffer> text_buffer;  // 文本缓冲区对象
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkTextViewExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含多行文本输入框（GtkTextView）和标签的窗口。文本输入框支持多行文本输入，并且包含在一个带滚动条的窗口中。当用户在文本输入框中输入文本时，标签会实时更新，显示当前文本的长度。

3.1.13 GTK3.0的GtkComboBox：下拉列表

• GtkComboBox 基本知识点讲解

GtkComboBox 是 GTK+ 3.0 中用于创建下拉列表的控件。它允许用户从一个选项列表中进行选择，通常用于需要在多个选项中选择一个的情况。

• 主要特性

  • 下拉选择：显示一个可供选择的选项列表。
  • 可编辑模式：可以设置为可编辑模式，允许用户输入自定义选项。
  • 模型-视图-控制器 (MVC) 结构：使用 GtkTreeModel 作为数据模型，可以与 GtkListStore 或 GtkTreeStore 一起使用。

• 常用方法

  • set_model(const Glib::RefPtr<Gtk::TreeModel>& model)：设置下拉列表的数据模型。
  • set_active(int index)：设置当前激活的选项索引。
  • get_active()：获取当前激活的选项索引。
  • signal_changed().connect(sigc::mem_fun(*this, &MyClass::on_combo_changed))：连接选项改变事件的信号处理函数。

• GtkComboBox C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkComboBox Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        // 创建列表存储对象
        list_store = Gtk::ListStore::create(columns);

        // 向列表存储中添加选项
        auto row = *(list_store->append());
        row[columns.m_col_text] = "Option 1";

        row = *(list_store->append());
        row[columns.m_col_text] = "Option 2";

        row = *(list_store->append());
        row[columns.m_col_text] = "Option 3";

        // 创建下拉列表控件并设置数据模型
        combo = Gtk::manage(new Gtk::ComboBox());
        combo->set_model(list_store);
        
        // 创建一个单元格渲染器
        auto renderer = Gtk::manage(new Gtk::CellRendererText());
        
        // 将渲染器添加到下拉列表中
        combo->pack_start(*renderer, true);
        combo->add_attribute(renderer->property_text(), columns.m_col_text);
        
        // 连接下拉列表选项改变事件的信号处理函数
        combo->signal_changed().connect(sigc::mem_fun(*this, &MyWindow::on_combo_changed));
        
        vbox->pack_start(*combo);  // 将下拉列表添加到盒子容器中

        label = Gtk::manage(new Gtk::Label("Select an option"));  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 下拉列表选项改变事件处理函数
    void on_combo_changed() {
        int index = combo->get_active();  // 获取当前激活的选项索引
        if (index >= 0) {
            Gtk::TreeModel::iterator iter = combo->get_active();
            Glib::ustring text = (*iter)[columns.m_col_text];  // 获取选项文本
            label->set_text("Selected: " + text);  // 更新标签显示选中的选项
        }
    }

    // 列模型结构体
    class ModelColumns : public Gtk::TreeModel::ColumnRecord {
    public:
        ModelColumns() {
            add(m_col_text);  // 添加文本列
        }
        Gtk::TreeModelColumn<Glib::ustring> m_col_text;  // 文本列
    };

    ModelColumns columns;  // 列模型实例
    Glib::RefPtr<Gtk::ListStore> list_store;  // 列表存储对象
    Gtk::ComboBox* combo;  // 下拉列表控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkComboBoxExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含下拉列表（GtkComboBox）和标签的窗口。下拉列表中有三个选项，当用户选择不同的选项时，标签会更新，显示当前选中的选项文本。

3.1.14 GTK3.0的GtkComboBoxText：带文本的下拉列表

• GtkComboBoxText 基本知识点讲解

GtkComboBoxText 是 GTK+ 3.0 中一个简单的下拉列表控件，用于显示和选择文本选项。与 GtkComboBox 不同，GtkComboBoxText 更加简化，专门用于显示纯文本项，因此不需要创建复杂的数据模型。

• 主要特性

  • 简单易用：专门用于显示纯文本选项。
  • 添加和移除选项：提供了添加和移除选项的方法。
  • 信号处理：提供选项改变事件的信号，用于处理用户选择变化。

• 常用方法

  • append(const Glib::ustring& text)：添加一个新选项到下拉列表的末尾。
  • prepend(const Glib::ustring& text)：添加一个新选项到下拉列表的开头。
  • insert(int position, const Glib::ustring& text)：在指定位置插入一个新选项。
  • remove(int position)：移除指定位置的选项。
  • get_active_text() const：获取当前选中的选项文本。
  • set_active(int index)：设置当前激活的选项索引。
  • signal_changed().connect(sigc::mem_fun(*this, &MyClass::on_combo_changed))：连接选项改变事件的信号处理函数。

• GtkComboBoxText C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkComboBoxText Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        combo = Gtk::manage(new Gtk::ComboBoxText());  // 创建带文本的下拉列表控件
        combo->append("Option 1");  // 添加选项 1
        combo->append("Option 2");  // 添加选项 2
        combo->append("Option 3");  // 添加选项 3

        combo->signal_changed().connect(sigc::mem_fun(*this, &MyWindow::on_combo_changed));  // 连接选项改变事件的信号处理函数

        vbox->pack_start(*combo);  // 将下拉列表添加到盒子容器中

        label = Gtk::manage(new Gtk::Label("Select an option"));  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 下拉列表选项改变事件处理函数
    void on_combo_changed() {
        Glib::ustring text = combo->get_active_text();  // 获取当前选中的选项文本
        label->set_text("Selected: " + text);  // 更新标签显示选中的选项
    }

    Gtk::ComboBoxText* combo;  // 带文本的下拉列表控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkComboBoxTextExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含带文本的下拉列表（GtkComboBoxText）和标签的窗口。下拉列表中有三个选项，当用户选择不同的选项时，标签会更新，显示当前选中的选项文本。

3.1.15 GTK3.0的GtkScale：滑块

• GtkScale 基本知识点讲解

GtkScale 是 GTK+ 3.0 中用于创建滑块控件的类。滑块控件允许用户通过拖动滑块来选择一个范围内的值，常用于需要输入连续值的情况。

• 主要特性

  • 水平和垂直方向：可以创建水平或垂直的滑块。
  • 值范围：可以设置滑块的最小值和最大值。
  • 步进值：可以设置滑块的步进增量和页面增量。
  • 值显示：可以显示滑块当前的值。

• 常用方法

  • set_range(double min, double max)：设置滑块的最小值和最大值。
  • set_value(double value)：设置滑块的当前值。
  • get_value() const：获取滑块的当前值。
  • set_increments(double step, double page)：设置滑块的步进增量和页面增量。
  • set_digits(int digits)：设置滑块值显示的小数位数。
  • signal_value_changed().connect(sigc::mem_fun(*this, &MyClass::on_value_changed))：连接值改变事件的信号处理函数。

• GtkScale C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkScale Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        scale = Gtk::manage(new Gtk::Scale(Gtk::ORIENTATION_HORIZONTAL));  // 创建水平滑块控件
        scale->set_range(0.0, 100.0);  // 设置滑块的最小值和最大值
        scale->set_value(50.0);  // 设置滑块的初始值
        scale->set_increments(1.0, 10.0);  // 设置滑块的步进增量和页面增量
        scale->set_digits(0);  // 设置滑块值显示的小数位数

        scale->signal_value_changed().connect(sigc::mem_fun(*this, &MyWindow::on_value_changed));  // 连接值改变事件的信号处理函数

        vbox->pack_start(*scale);  // 将滑块控件添加到盒子容器中

        label = Gtk::manage(new Gtk::Label("Value: 50"));  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 滑块值改变事件处理函数
    void on_value_changed() {
        double value = scale->get_value();  // 获取滑块的当前值
        label->set_text("Value: " + std::to_string(static_cast<int>(value)));  // 更新标签显示滑块的当前值
    }

    Gtk::Scale* scale;  // 滑块控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkScaleExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含水平滑块（GtkScale）和标签的窗口。滑块的范围是从 0 到 100，当用户拖动滑块时，标签会更新，显示当前滑块的值。

3.1.16 GTK3.0的GtkScrollbar：滚动条

• GtkScrollbar 基本知识点讲解

GtkScrollbar 是 GTK+ 3.0 中用于创建滚动条控件的类。滚动条控件允许用户滚动内容，例如在文本视图或图像视图中移动视图窗口。

• 主要特性

  • 水平和垂直方向：可以创建水平或垂直的滚动条。
  • 调整对象：使用 GtkAdjustment 对象来控制滚动条的范围和位置。
  • 步进值：可以设置滚动条的步进增量和页面增量。

• 常用方法

  • set_adjustment(GtkAdjustment* adjustment)：设置滚动条的调整对象。
  • get_adjustment() const：获取滚动条的调整对象。
  • set_orientation(GtkOrientation orientation)：设置滚动条的方向（水平或垂直）。
  • set_value(double value)：设置滚动条的位置。
  • get_value() const：获取滚动条的位置。

• GtkScrollbar C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkScrollbar Example");  // 设置窗口标题
        set_default_size(300, 100);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        // 创建调整对象
        adjustment = Gtk::Adjustment::create(0.0, 0.0, 100.0, 1.0, 10.0, 10.0);

        // 创建滚动条控件
        scrollbar = Gtk::manage(new Gtk::Scrollbar(Gtk::ORIENTATION_HORIZONTAL));
        scrollbar->set_adjustment(adjustment);  // 设置滚动条的调整对象

        scrollbar->signal_value_changed().connect(sigc::mem_fun(*this, &MyWindow::on_value_changed));  // 连接值改变事件的信号处理函数

        vbox->pack_start(*scrollbar);  // 将滚动条添加到盒子容器中

        label = Gtk::manage(new Gtk::Label("Value: 0"));  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 滚动条值改变事件处理函数
    void on_value_changed() {
        double value = scrollbar->get_value();  // 获取滚动条的当前值
        label->set_text("Value: " + std::to_string(static_cast<int>(value)));  // 更新标签显示滚动条的当前值
    }

    Glib::RefPtr<Gtk::Adjustment> adjustment;  // 调整对象
    Gtk::Scrollbar* scrollbar;  // 滚动条控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkScrollbarExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含水平滚动条（GtkScrollbar）和标签的窗口。滚动条的范围是从 0 到 100，当用户移动滚动条时，标签会更新，显示当前滚动条的位置。

3.1.17 GTK3.0的GtkFileChooserButton：文件选择按钮

• GtkFileChooserButton 基本知识点讲解

GtkFileChooserButton 是 GTK+ 3.0 中用于创建文件选择按钮的类。该按钮可以弹出一个文件选择对话框，允许用户选择文件或目录。

• 主要特性

  • 文件选择：允许用户选择文件或目录。
  • 过滤器：可以添加过滤器，以便用户只能选择特定类型的文件。
  • 模式：可以设置为打开文件、保存文件或选择文件夹模式。
  • 预设文件名：在保存文件模式下，可以设置默认文件名。

• 常用方法

  • set_action(GtkFileChooserAction action)：设置文件选择操作类型（如打开文件、保存文件等）。
  • set_filename(const Glib::ustring& filename)：设置默认文件名。
  • get_filename() const：获取当前选中的文件名。
  • add_filter(const Glib::RefPtr<Gtk::FileFilter>& filter)：添加文件过滤器。
  • signal_file_set().connect(sigc::mem_fun(*this, &MyClass::on_file_set))：连接文件选择完成事件的信号处理函数。

• GtkFileChooserButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkFileChooserButton Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));  // 创建垂直盒子容器
        add(*vbox);  // 将盒子容器添加到窗口

        file_chooser_button = Gtk::manage(new Gtk::FileChooserButton("Select a File", Gtk::FILE_CHOOSER_ACTION_OPEN));  // 创建文件选择按钮
        file_chooser_button->signal_file_set().connect(sigc::mem_fun(*this, &MyWindow::on_file_set));  // 连接文件选择完成事件的信号处理函数

        vbox->pack_start(*file_chooser_button);  // 将文件选择按钮添加到盒子容器中

        label = Gtk::manage(new Gtk::Label("No file selected"));  // 创建标签控件
        vbox->pack_start(*label);  // 将标签添加到盒子容器中

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}

protected:
    // 文件选择完成事件处理函数
    void on_file_set() {
        Glib::ustring filename = file_chooser_button->get_filename();  // 获取选中的文件名
        label->set_text("Selected file: " + filename);  // 更新标签显示选中的文件名
    }

    Gtk::FileChooserButton* file_chooser_button;  // 文件选择按钮控件指针
    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkFileChooserButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含文件选择按钮（GtkFileChooserButton）和标签的窗口。当用户通过文件选择按钮选择一个文件后，标签会更新，显示当前选中的文件名。

3.2 GTK3.0菜单和工具栏类控件

3.2.1 GTK3.0的GtkMenuBar：菜单栏

• GtkMenuBar 基本知识点讲解

GtkMenuBar 是 GTK+ 3.0 中用于创建菜单栏控件的类。菜单栏通常放置在窗口的顶部，包含多个下拉菜单，每个下拉菜单又包含菜单项。

• 主要特性

  • 菜单项：包含多个菜单项，可以是子菜单或动作。
  • 子菜单：菜单项可以包含子菜单，形成多级菜单结构。
  • 分隔符：可以使用分隔符菜单项来分隔不同组的菜单项。

• 常用方法

  • append(Gtk::MenuItem& menu_item)：将一个菜单项添加到菜单栏。
  • remove(Gtk::MenuItem& menu_item)：从菜单栏移除一个菜单项。
  • popup(Gtk::MenuPositionFunc func, guint button, guint32 activate_time)：弹出菜单，用于右键上下文菜单。

• GtkMenuBar C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkMenuBar Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建菜单栏
        Gtk::MenuBar* menubar = Gtk::manage(new Gtk::MenuBar());
        vbox->pack_start(*menubar, Gtk::PACK_SHRINK);

        // 创建文件菜单
        Gtk::MenuItem* file_menu_item = Gtk::manage(new Gtk::MenuItem("_File", true));
        menubar->append(*file_menu_item);

        // 创建文件菜单的子菜单
        Gtk::Menu* file_menu = Gtk::manage(new Gtk::Menu());
        file_menu_item->set_submenu(*file_menu);

        // 创建新建菜单项
        Gtk::MenuItem* new_menu_item = Gtk::manage(new Gtk::MenuItem("_New", true));
        new_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_new));
        file_menu->append(*new_menu_item);

        // 创建打开菜单项
        Gtk::MenuItem* open_menu_item = Gtk::manage(new Gtk::MenuItem("_Open", true));
        open_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_open));
        file_menu->append(*open_menu_item);

        // 创建分隔符菜单项
        Gtk::SeparatorMenuItem* sep = Gtk::manage(new Gtk::SeparatorMenuItem());
        file_menu->append(*sep);

        // 创建退出菜单项
        Gtk::MenuItem* quit_menu_item = Gtk::manage(new Gtk::MenuItem("_Quit", true));
        quit_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_quit));
        file_menu->append(*quit_menu_item);

        // 创建编辑菜单
        Gtk::MenuItem* edit_menu_item = Gtk::manage(new Gtk::MenuItem("_Edit", true));
        menubar->append(*edit_menu_item);

        // 创建编辑菜单的子菜单
        Gtk::Menu* edit_menu = Gtk::manage(new Gtk::Menu());
        edit_menu_item->set_submenu(*edit_menu);

        // 创建剪切菜单项
        Gtk::MenuItem* cut_menu_item = Gtk::manage(new Gtk::MenuItem("Cu_t", true));
        cut_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_edit_cut));
        edit_menu->append(*cut_menu_item);

        // 创建复制菜单项
        Gtk::MenuItem* copy_menu_item = Gtk::manage(new Gtk::MenuItem("_Copy", true));
        copy_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_edit_copy));
        edit_menu->append(*copy_menu_item);

        // 创建粘贴菜单项
        Gtk::MenuItem* paste_menu_item = Gtk::manage(new Gtk::MenuItem("_Paste", true));
        paste_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_edit_paste));
        edit_menu->append(*paste_menu_item);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Select a menu item"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 文件菜单项的回调函数
    void on_menu_file_new() {
        label->set_text("New File selected");
    }

    void on_menu_file_open() {
        label->set_text("Open File selected");
    }

    void on_menu_file_quit() {
        hide();  // 退出程序
    }

    // 编辑菜单项的回调函数
    void on_menu_edit_cut() {
        label->set_text("Cut selected");
    }

    void on_menu_edit_copy() {
        label->set_text("Copy selected");
    }

    void on_menu_edit_paste() {
        label->set_text("Paste selected");
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkMenuBarExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含菜单栏（GtkMenuBar）和标签的窗口。菜单栏包括 “File” 和 “Edit” 菜单，其中包含多个菜单项。选择菜单项时，标签会更新显示相应的消息。

3.2.2 GTK3.0的GtkMenuItem：菜单项

• GtkMenuItem 基本知识点讲解

GtkMenuItem 是 GTK+ 3.0 中用于创建菜单项的类。菜单项是菜单中的一个条目，可以包含子菜单或者触发一个动作。菜单项通常放置在 GtkMenu 中，GtkMenu 则可以嵌入 GtkMenuBar 或 GtkMenuItem 中。

• 主要特性

  • 标签：菜单项可以带有文本标签。
  • 子菜单：菜单项可以包含子菜单，从而形成多级菜单。
  • 敏感度：可以设置菜单项是否可用。
  • 信号：菜单项可以连接激活信号，当用户点击该菜单项时触发。

• 常用方法

  • set_label(const Glib::ustring& label)：设置菜单项的文本标签。
  • get_label() const：获取菜单项的文本标签。
  • set_submenu(Gtk::Menu& submenu)：设置子菜单。
  • signal_activate().connect(sigc::mem_fun(*this, &MyClass::on_menu_item_activate))：连接菜单项激活信号的回调函数。

• GtkMenuItem C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkMenuItem Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建菜单栏
        Gtk::MenuBar* menubar = Gtk::manage(new Gtk::MenuBar());
        vbox->pack_start(*menubar, Gtk::PACK_SHRINK);

        // 创建文件菜单
        Gtk::MenuItem* file_menu_item = Gtk::manage(new Gtk::MenuItem("_File", true));
        menubar->append(*file_menu_item);

        // 创建文件菜单的子菜单
        Gtk::Menu* file_menu = Gtk::manage(new Gtk::Menu());
        file_menu_item->set_submenu(*file_menu);

        // 创建新建菜单项
        Gtk::MenuItem* new_menu_item = Gtk::manage(new Gtk::MenuItem("_New", true));
        new_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_new));
        file_menu->append(*new_menu_item);

        // 创建打开菜单项
        Gtk::MenuItem* open_menu_item = Gtk::manage(new Gtk::MenuItem("_Open", true));
        open_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_open));
        file_menu->append(*open_menu_item);

        // 创建分隔符菜单项
        Gtk::SeparatorMenuItem* sep = Gtk::manage(new Gtk::SeparatorMenuItem());
        file_menu->append(*sep);

        // 创建退出菜单项
        Gtk::MenuItem* quit_menu_item = Gtk::manage(new Gtk::MenuItem("_Quit", true));
        quit_menu_item->signal_activate().connect(sigc::mem_fun(*this, &MyWindow::on_menu_file_quit));
        file_menu->append(*quit_menu_item);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Select a menu item"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 文件菜单项的回调函数
    void on_menu_file_new() {
        label->set_text("New File selected");
    }

    void on_menu_file_open() {
        label->set_text("Open File selected");
    }

    void on_menu_file_quit() {
        hide();  // 退出程序
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkMenuItemExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含菜单栏（GtkMenuBar）、菜单项（GtkMenuItem）和标签的窗口。菜单栏包括一个 “File” 菜单，其中包含多个菜单项。选择菜单项时，标签会更新显示相应的消息。

3.2.3 GTK3.0的GtkToolBar：工具栏

• GtkToolBar 基本知识点讲解

GtkToolBar 是 GTK+ 3.0 中用于创建工具栏的类。工具栏通常包含一组按钮或其他小部件，提供快速访问常用功能。

• 主要特性

  • 按钮和工具项：工具栏可以包含多种工具项，如按钮、切换按钮、分隔符等。
  • 方向：可以设置工具栏的方向（水平或垂直）。
  • 样式：可以设置工具栏的样式，如图标、文字或图标加文字。

• 常用方法

  • append(Gtk::ToolItem& item)：将工具项添加到工具栏。
  • insert(Gtk::ToolItem& item, int pos)：在指定位置插入工具项。
  • set_style(Gtk::ToolbarStyle style)：设置工具栏的样式。
  • set_orientation(Gtk::Orientation orientation)：设置工具栏的方向。

• GtkToolBar C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkToolBar Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建工具栏
        Gtk::Toolbar* toolbar = Gtk::manage(new Gtk::Toolbar());
        vbox->pack_start(*toolbar, Gtk::PACK_SHRINK);

        // 创建工具按钮
        Gtk::ToolButton* new_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::NEW));
        new_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_new_button_clicked));
        toolbar->append(*new_button);

        Gtk::ToolButton* open_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::OPEN));
        open_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_open_button_clicked));
        toolbar->append(*open_button);

        Gtk::ToolButton* save_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::SAVE));
        save_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_save_button_clicked));
        toolbar->append(*save_button);

        // 创建分隔符
        Gtk::SeparatorToolItem* sep = Gtk::manage(new Gtk::SeparatorToolItem());
        toolbar->append(*sep);

        // 创建退出按钮
        Gtk::ToolButton* quit_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::QUIT));
        quit_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_quit_button_clicked));
        toolbar->append(*quit_button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Toolbar example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 工具按钮的回调函数
    void on_new_button_clicked() {
        label->set_text("New button clicked");
    }

    void on_open_button_clicked() {
        label->set_text("Open button clicked");
    }

    void on_save_button_clicked() {
        label->set_text("Save button clicked");
    }

    void on_quit_button_clicked() {
        hide();  // 退出程序
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkToolBarExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含工具栏（GtkToolBar）和标签的窗口。工具栏包括多个工具按钮和一个分隔符。点击工具按钮时，标签会更新显示相应的消息。

3.2.4 GTK3.0的GtkToolButton：工具按钮

• GtkToolButton 基本知识点讲解

GtkToolButton 是 GTK+ 3.0 中用于创建工具按钮的类。工具按钮通常放置在工具栏中，带有图标和/或标签，提供对常用功能的快捷访问。

• 主要特性

  • 图标：可以为工具按钮设置图标。
  • 标签：可以为工具按钮设置文本标签。
  • 信号：可以连接按钮点击信号的回调函数。

• 常用方法

  • set_icon_widget(Gtk::Widget& icon_widget)：设置工具按钮的图标部件。
  • set_label(const Glib::ustring& label)：设置工具按钮的文本标签。
  • set_icon_name(const Glib::ustring& icon_name)：设置工具按钮的图标名称。
  • signal_clicked().connect(sigc::mem_fun(*this, &MyClass::on_button_clicked))：连接按钮点击信号的回调函数。

• GtkToolButton C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkToolButton Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建工具栏
        Gtk::Toolbar* toolbar = Gtk::manage(new Gtk::Toolbar());
        vbox->pack_start(*toolbar, Gtk::PACK_SHRINK);

        // 创建新建工具按钮
        Gtk::ToolButton* new_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::NEW));
        new_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_new_button_clicked));
        toolbar->append(*new_button);

        // 创建打开工具按钮
        Gtk::ToolButton* open_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::OPEN));
        open_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_open_button_clicked));
        toolbar->append(*open_button);

        // 创建保存工具按钮
        Gtk::ToolButton* save_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::SAVE));
        save_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_save_button_clicked));
        toolbar->append(*save_button);

        // 创建分隔符
        Gtk::SeparatorToolItem* sep = Gtk::manage(new Gtk::SeparatorToolItem());
        toolbar->append(*sep);

        // 创建退出工具按钮
        Gtk::ToolButton* quit_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::QUIT));
        quit_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_quit_button_clicked));
        toolbar->append(*quit_button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Toolbar example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 工具按钮的回调函数
    void on_new_button_clicked() {
        label->set_text("New button clicked");
    }

    void on_open_button_clicked() {
        label->set_text("Open button clicked");
    }

    void on_save_button_clicked() {
        label->set_text("Save button clicked");
    }

    void on_quit_button_clicked() {
        hide();  // 退出程序
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkToolButtonExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含工具栏（GtkToolBar）、工具按钮（GtkToolButton）和标签的窗口。工具栏包括多个工具按钮和一个分隔符。点击工具按钮时，标签会更新显示相应的消息。

3.2.5 GTK3.0的GtkSeparatorToolItem：工具栏分隔符

• GtkSeparatorToolItem 基本知识点讲解

GtkSeparatorToolItem 是 GTK+ 3.0 中用于在工具栏中创建分隔符的类。分隔符用于在工具栏中的工具项之间创建视觉间隔，可以是水平或垂直的。

• 主要特性

  • 分隔符样式：可以是水平或垂直的线条，用于分隔工具栏中的工具项。
  • 扩展功能：可以设置是否扩展以填充工具栏中的空白区域。

• 常用方法

  • set_expand(bool expand)：设置分隔符是否扩展以填充工具栏中的空白区域。
  • get_expand() const：获取分隔符是否扩展的状态。

• GtkSeparatorToolItem C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkSeparatorToolItem Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建工具栏
        Gtk::Toolbar* toolbar = Gtk::manage(new Gtk::Toolbar());
        vbox->pack_start(*toolbar, Gtk::PACK_SHRINK);

        // 创建工具按钮
        Gtk::ToolButton* new_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::NEW));
        new_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_new_button_clicked));
        toolbar->append(*new_button);

        Gtk::ToolButton* open_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::OPEN));
        open_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_open_button_clicked));
        toolbar->append(*open_button);

        // 创建分隔符
        Gtk::SeparatorToolItem* sep = Gtk::manage(new Gtk::SeparatorToolItem());
        sep->set_expand(true);  // 设置分隔符扩展填充
        toolbar->append(*sep);

        // 创建保存工具按钮
        Gtk::ToolButton* save_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::SAVE));
        save_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_save_button_clicked));
        toolbar->append(*save_button);

        // 创建退出工具按钮
        Gtk::ToolButton* quit_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::QUIT));
        quit_button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_quit_button_clicked));
        toolbar->append(*quit_button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Toolbar with separator example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 工具按钮的回调函数
    void on_new_button_clicked() {
        label->set_text("New button clicked");
    }

    void on_open_button_clicked() {
        label->set_text("Open button clicked");
    }

    void on_save_button_clicked() {
        label->set_text("Save button clicked");
    }

    void on_quit_button_clicked() {
        hide();  // 退出程序
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkSeparatorToolItemExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含工具栏（GtkToolBar）、工具按钮（GtkToolButton）、分隔符（GtkSeparatorToolItem）和标签的窗口。工具栏包括多个工具按钮和一个分隔符。分隔符设置为扩展以填充工具栏中的空白区域。点击工具按钮时，标签会更新显示相应的消息。

3.3 GTK3.0对话框类控件

3.3.1 GTK3.0的GtkDialog：对话框

• GtkDialog 基本知识点讲解

GtkDialog 是 GTK+ 3.0 中用于创建对话框窗口的类。对话框是一种临时窗口，用于与用户进行简单的交互，如显示消息、获取输入或确认操作。GtkDialog 继承自 GtkWindow，并提供了一些专门用于对话框的功能。

• 主要特性

  • 对话框按钮：可以添加常用的对话框按钮，如确定、取消、是、否等。
  • 响应 ID：每个按钮可以设置一个响应 ID，表示按钮的作用。
  • 模式对话框：可以设置对话框为模式对话框，阻止用户与其他窗口交互。
  • 消息对话框：可以快速创建消息对话框，显示简单的消息和按钮。

• 常用方法

  • add_button(const Glib::ustring& button_text, int response_id)：向对话框添加一个按钮。
  • set_default_response(int response_id)：设置默认响应按钮。
  • set_response_sensitive(int response_id, bool setting)：设置按钮是否敏感。
  • run()：运行对话框，并等待用户响应。
  • response_signal().connect(sigc::mem_fun(*this, &MyClass::on_response))：连接对话框的响应信号。

• GtkDialog C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkDialog Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建按钮，点击时弹出对话框
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Show Dialog"));
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));
        vbox->pack_start(*button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Dialog example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 按钮点击回调函数，弹出对话框
    void on_button_clicked() {
        // 创建对话框
        Gtk::Dialog dialog("My Dialog", *this);
        dialog.set_default_size(300, 150);  // 设置对话框默认大小

        // 添加按钮
        dialog.add_button("_OK", Gtk::RESPONSE_OK);
        dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);

        // 连接响应信号
        dialog.signal_response().connect(sigc::mem_fun(*this, &MyWindow::on_dialog_response));

        // 运行对话框
        dialog.run();
    }

    // 对话框响应回调函数
    void on_dialog_response(int response_id) {
        switch (response_id) {
            case Gtk::RESPONSE_OK:
                label->set_text("OK button clicked");
                break;
            case Gtk::RESPONSE_CANCEL:
                label->set_text("Cancel button clicked");
                break;
            default:
                label->set_text("Dialog closed");
                break;
        }
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkDialogExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含按钮（Gtk::Button）和标签（Gtk::Label）的窗口。点击按钮时，会弹出一个对话框（Gtk::Dialog），对话框包含 “OK” 和 “Cancel” 按钮。点击对话框的按钮时，标签会更新显示相应的消息。

3.3.2 GTK3.0的GtkMessageDialog：消息对话框

• GtkMessageDialog 基本知识点讲解

GtkMessageDialog 是 GTK+ 3.0 中用于显示消息对话框的类。消息对话框是一种简化的对话框，通常用于向用户显示信息、警告或错误消息，并提供简单的用户交互按钮（如 OK、Cancel）。

• 主要特性

  • 消息类型：可以设置消息类型，如信息、警告、问题、错误等。
  • 按钮类型：可以设置对话框的按钮类型，如 OK、Cancel、Yes、No 等。
  • 模式对话框：可以设置为模式对话框，阻止用户与其他窗口交互。
  • 对话框文本：可以设置对话框的主要文本和次要文本。

• 常用方法

  • Gtk::MessageDialog(Gtk::Window& parent, const Glib::ustring& message, bool use_markup = false, Gtk::MessageType type = Gtk::MESSAGE_INFO, Gtk::ButtonsType buttons = Gtk::BUTTONS_OK, bool modal = true)：构造函数，用于创建消息对话框。
  • set_secondary_text(const Glib::ustring& message, bool use_markup = false)：设置对话框的次要文本。
  • run()：运行对话框，并等待用户响应。
  • response_signal().connect(sigc::mem_fun(*this, &MyClass::on_response))：连接对话框的响应信号。

• GtkMessageDialog C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkMessageDialog Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建按钮，点击时弹出消息对话框
        Gtk::Button* button_info = Gtk::manage(new Gtk::Button("Show Info Message"));
        button_info->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_info_clicked));
        vbox->pack_start(*button_info);

        Gtk::Button* button_warning = Gtk::manage(new Gtk::Button("Show Warning Message"));
        button_warning->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_warning_clicked));
        vbox->pack_start(*button_warning);

        Gtk::Button* button_error = Gtk::manage(new Gtk::Button("Show Error Message"));
        button_error->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_error_clicked));
        vbox->pack_start(*button_error);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("Message Dialog example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 信息消息按钮的回调函数
    void on_button_info_clicked() {
        Gtk::MessageDialog dialog(*this, "This is an information message", false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK, true);
        dialog.set_secondary_text("This is additional information.");
        dialog.run();
        label->set_text("Info dialog closed");
    }

    // 警告消息按钮的回调函数
    void on_button_warning_clicked() {
        Gtk::MessageDialog dialog(*this, "This is a warning message", false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, true);
        dialog.set_secondary_text("This is additional warning information.");
        dialog.run();
        label->set_text("Warning dialog closed");
    }

    // 错误消息按钮的回调函数
    void on_button_error_clicked() {
        Gtk::MessageDialog dialog(*this, "This is an error message", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
        dialog.set_secondary_text("This is additional error information.");
        dialog.run();
        label->set_text("Error dialog closed");
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkMessageDialogExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含三个按钮（Gtk::Button）和一个标签（Gtk::Label）的窗口。点击按钮时，会弹出相应类型的消息对话框（信息、警告、错误）。关闭对话框后，标签会更新显示相应的消息。

3.3.3 GTK3.0的GtkFileChooserDialog：文件选择对话框

• GtkFileChooserDialog 基本知识点讲解

GtkFileChooserDialog 是 GTK+ 3.0 中用于文件选择的对话框类。它允许用户选择文件或目录，提供了标准的文件选择用户界面。

• 主要特性

  • 文件模式：可以选择打开文件、保存文件或选择目录。
  • 过滤器：可以添加文件过滤器，以便用户只能看到特定类型的文件。
  • 多选：可以设置为允许选择多个文件。
  • 响应按钮：可以添加标准的对话框按钮，如打开、取消、保存等。
  • 文件预览：可以设置自定义文件预览小部件。

• 常用方法

  • Gtk::FileChooserDialog(Gtk::Window& parent, const Glib::ustring& title, Gtk::FileChooserAction action)：构造函数，用于创建文件选择对话框。
  • add_button(const Glib::ustring& button_text, int response_id)：向对话框添加一个按钮。
  • set_select_multiple(bool select_multiple)：设置是否允许多选。
  • set_filter(Gtk::FileFilter& filter)：设置文件过滤器。
  • run()：运行对话框，并等待用户响应。
  • get_filename()：获取用户选择的文件名。
  • get_filenames()：获取用户选择的所有文件名（多选模式下）。

• GtkFileChooserDialog C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkFileChooserDialog Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建按钮，点击时弹出文件选择对话框
        Gtk::Button* button_open = Gtk::manage(new Gtk::Button("Open File"));
        button_open->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_open_clicked));
        vbox->pack_start(*button_open);

        Gtk::Button* button_save = Gtk::manage(new Gtk::Button("Save File"));
        button_save->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_save_clicked));
        vbox->pack_start(*button_save);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("FileChooserDialog example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 打开文件按钮的回调函数
    void on_button_open_clicked() {
        // 创建文件选择对话框，设置为打开文件模式
        Gtk::FileChooserDialog dialog(*this, "Open File", Gtk::FILE_CHOOSER_ACTION_OPEN);
        dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
        dialog.add_button("_Open", Gtk::RESPONSE_OK);

        // 添加文件过滤器
        auto filter_text = Gtk::FileFilter::create();
        filter_text->set_name("Text files");
        filter_text->add_mime_type("text/plain");
        dialog.add_filter(filter_text);

        auto filter_any = Gtk::FileFilter::create();
        filter_any->set_name("Any files");
        filter_any->add_pattern("*");
        dialog.add_filter(filter_any);

        // 运行对话框并等待用户响应
        int result = dialog.run();

        // 处理用户响应
        if (result == Gtk::RESPONSE_OK) {
            // 获取选择的文件名并更新标签
            std::string filename = dialog.get_filename();
            label->set_text("Selected file: " + filename);
        } else {
            label->set_text("File selection cancelled");
        }
    }

    // 保存文件按钮的回调函数
    void on_button_save_clicked() {
        // 创建文件选择对话框，设置为保存文件模式
        Gtk::FileChooserDialog dialog(*this, "Save File", Gtk::FILE_CHOOSER_ACTION_SAVE);
        dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
        dialog.add_button("_Save", Gtk::RESPONSE_OK);
        dialog.set_do_overwrite_confirmation(true);

        // 添加文件过滤器
        auto filter_text = Gtk::FileFilter::create();
        filter_text->set_name("Text files");
        filter_text->add_mime_type("text/plain");
        dialog.add_filter(filter_text);

        auto filter_any = Gtk::FileFilter::create();
        filter_any->set_name("Any files");
        filter_any->add_pattern("*");
        dialog.add_filter(filter_any);

        // 运行对话框并等待用户响应
        int result = dialog.run();

        // 处理用户响应
        if (result == Gtk::RESPONSE_OK) {
            // 获取选择的文件名并更新标签
            std::string filename = dialog.get_filename();
            label->set_text("File saved as: " + filename);
        } else {
            label->set_text("File save cancelled");
        }
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkFileChooserDialogExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含两个按钮（Gtk::Button）和一个标签（Gtk::Label）的窗口。点击“Open File”按钮时，会弹出一个打开文件的对话框（Gtk::FileChooserDialog），点击“Save File”按钮时，会弹出一个保存文件的对话框。选择文件或保存文件后，标签会更新显示相应的文件路径。

3.3.4 GTK3.0的GtkColorChooserDialog：颜色选择对话框

• GtkColorChooserDialog 基本知识点讲解

GtkColorChooserDialog 是 GTK+ 3.0 中用于选择颜色的对话框类。它提供了一个标准的颜色选择用户界面，允许用户选择颜色。

• 主要特性

  • 颜色选择：允许用户从调色板中选择颜色，或直接输入颜色值。
  • 响应按钮：可以添加标准的对话框按钮，如 OK、Cancel。
  • 初始颜色：可以设置对话框打开时的初始颜色。
  • 获取颜色：用户选择颜色后，可以获取到选定的颜色值。

• 常用方法

  • Gtk::ColorChooserDialog(const Glib::ustring& title, Gtk::Window& parent)：构造函数，用于创建颜色选择对话框。
  • set_rgba(const Gdk::RGBA& rgba)：设置对话框的初始颜色。
  • get_rgba(Gdk::RGBA& rgba)：获取用户选择的颜色。
  • add_button(const Glib::ustring& button_text, int response_id)：向对话框添加一个按钮。
  • run()：运行对话框，并等待用户响应。

• GtkColorChooserDialog C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkColorChooserDialog Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建按钮，点击时弹出颜色选择对话框
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Choose Color"));
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));
        vbox->pack_start(*button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("ColorChooserDialog example"));
        vbox->pack_start(*label);

        // 创建颜色展示区域
        color_area = Gtk::manage(new Gtk::DrawingArea());
        color_area->set_size_request(100, 100);
        vbox->pack_start(*color_area);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 按钮点击回调函数，弹出颜色选择对话框
    void on_button_clicked() {
        Gtk::ColorChooserDialog dialog("Choose a Color", *this);

        // 设置初始颜色
        Gdk::RGBA initial_color;
        initial_color.set_rgba(0.5, 0.5, 0.5, 1.0);  // 灰色
        dialog.set_rgba(initial_color);

        // 添加按钮
        dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
        dialog.add_button("_OK", Gtk::RESPONSE_OK);

        // 运行对话框并等待用户响应
        int result = dialog.run();

        // 处理用户响应
        if (result == Gtk::RESPONSE_OK) {
            Gdk::RGBA chosen_color;
            dialog.get_rgba(chosen_color);

            // 更新标签和颜色展示区域背景色
            label->set_text("Selected color: " + chosen_color.to_string());
            color_area->override_background_color(chosen_color, Gtk::STATE_FLAG_NORMAL);
        } else {
            label->set_text("Color selection cancelled");
        }
    }

    Gtk::Label* label;  // 标签控件指针
    Gtk::DrawingArea* color_area;  // 颜色展示区域指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkColorChooserDialogExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含按钮（Gtk::Button）、标签（Gtk::Label）和颜色展示区域（Gtk::DrawingArea）的窗口。点击按钮时，会弹出颜色选择对话框（Gtk::ColorChooserDialog）。选择颜色后，标签会更新显示选定的颜色值，并且颜色展示区域的背景色会变为选定的颜色。

3.3.5 GTK3.0的GtkFontChooserDialog：字体选择对话框

• GtkFontChooserDialog 基本知识点讲解

GtkFontChooserDialog 是 GTK+ 3.0 中用于选择字体的对话框类。它提供了一个标准的字体选择用户界面，允许用户选择字体家族、字体样式和大小。

• 主要特性

  • 字体选择：允许用户从系统字体中选择字体。
  • 预览：提供了字体预览区域，用户可以看到所选字体的效果。
  • 响应按钮：可以添加标准的对话框按钮，如 OK、Cancel。
  • 获取字体：用户选择字体后，可以获取到选定的字体名称。

• 常用方法

  • Gtk::FontChooserDialog(const Glib::ustring& title, Gtk::Window& parent)：构造函数，用于创建字体选择对话框。
  • set_font(const Glib::ustring& fontname)：设置对话框的初始字体。
  • get_font()：获取用户选择的字体名称。
  • add_button(const Glib::ustring& button_text, int response_id)：向对话框添加一个按钮。
  • run()：运行对话框，并等待用户响应。

• GtkFontChooserDialog C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkFontChooserDialog Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建主垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建按钮，点击时弹出字体选择对话框
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Choose Font"));
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));
        vbox->pack_start(*button);

        // 创建标签
        label = Gtk::manage(new Gtk::Label("FontChooserDialog example"));
        vbox->pack_start(*label);

        show_all_children();
    }

    virtual ~MyWindow() {}

protected:
    // 按钮点击回调函数，弹出字体选择对话框
    void on_button_clicked() {
        Gtk::FontChooserDialog dialog("Choose a Font", *this);

        // 设置初始字体
        dialog.set_font("Sans 12");

        // 添加按钮
        dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
        dialog.add_button("_OK", Gtk::RESPONSE_OK);

        // 运行对话框并等待用户响应
        int result = dialog.run();

        // 处理用户响应
        if (result == Gtk::RESPONSE_OK) {
            // 获取选择的字体名并更新标签
            Glib::ustring fontname = dialog.get_font();
            label->set_text("Selected font: " + fontname);
            label->override_font(Pango::FontDescription(fontname));
        } else {
            label->set_text("Font selection cancelled");
        }
    }

    Gtk::Label* label;  // 标签控件指针
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkFontChooserDialogExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含按钮（Gtk::Button）和标签（Gtk::Label）的窗口。点击按钮时，会弹出字体选择对话框（Gtk::FontChooserDialog）。选择字体后，标签会更新显示选定的字体名称，并且标签的字体会变为选定的字体。

3.4 GTK3.0布局管理（容器）

3.4.1 GTK3.0的GtkBox：盒子（可以水平或垂直排列子控件）

• GtkBox 基本知识点讲解

GtkBox 是 GTK+ 3.0 中的一种容器控件，可以水平或垂直排列子控件。它是一个非常灵活的布局管理器，允许你在其内部添加多个子控件，并按照指定的方向进行排列。

• 主要特性

  • 方向：可以设置为水平 (Gtk::ORIENTATION_HORIZONTAL) 或垂直 (Gtk::ORIENTATION_VERTICAL) 排列子控件。
  • 间距：可以设置子控件之间的间距。
  • 扩展和填充：可以控制子控件是否扩展和填充可用空间。

• 常用方法

  • Gtk::Box(Gtk::Orientation orientation, int spacing)：构造函数，用于创建一个新的 GtkBox 实例，指定方向和间距。
  • pack_start(Gtk::Widget& child, bool expand = true, bool fill = true, guint padding = 0)：将控件添加到 GtkBox 的起始位置。
  • pack_end(Gtk::Widget& child, bool expand = true, bool fill = true, guint padding = 0)：将控件添加到 GtkBox 的末尾。
  • set_homogeneous(bool homogeneous)：设置是否所有子控件均分空间。
  • set_spacing(int spacing)：设置子控件之间的间距。

• GtkBox C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkBox Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 10));
        add(*vbox);

        // 创建一个标签，并添加到垂直盒子中
        Gtk::Label* label = Gtk::manage(new Gtk::Label("This is a label"));
        vbox->pack_start(*label, Gtk::PACK_SHRINK);

        // 创建一个按钮，并添加到垂直盒子中
        Gtk::Button* button1 = Gtk::manage(new Gtk::Button("Button 1"));
        vbox->pack_start(*button1, Gtk::PACK_EXPAND_WIDGET);

        // 创建另一个按钮，并添加到垂直盒子中
        Gtk::Button* button2 = Gtk::manage(new Gtk::Button("Button 2"));
        vbox->pack_start(*button2, Gtk::PACK_EXPAND_WIDGET);

        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkBoxExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含三个子控件的窗口：一个标签（Gtk::Label）和两个按钮（Gtk::Button）。这些控件被添加到一个垂直盒子容器（Gtk::Box）中，标签被设置为不扩展和填充可用空间，而两个按钮被设置为扩展和填充可用空间，并且子控件之间有一定的间距。

3.5.2 GTK3.0的GtkGrid：网格（表格布局）

• GtkGrid 基本知识点讲解

GtkGrid 是 GTK+ 3.0 中用于创建网格（表格）布局的容器控件。它允许你在一个二维网格中排列控件，可以通过指定行和列来精确控制每个控件的位置。

• 主要特性

  • 行和列：可以在指定的行和列中放置控件。
  • 跨行和跨列：可以让控件跨越多行或多列。
  • 对齐和填充：可以控制控件在网格单元格中的对齐方式和填充方式。
  • 间距：可以设置行间距和列间距。

• 常用方法

  • attach(Gtk::Widget& child, int left, int top, int width, int height)：将控件添加到网格的指定位置，其中 left 和 top 指定控件的起始位置，width 和 height 指定控件跨越的列数和行数。
  • set_row_spacing(int spacing)：设置行间距。
  • set_column_spacing(int spacing)：设置列间距。
  • set_row_homogeneous(bool homogeneous)：设置行是否均匀分布。
  • set_column_homogeneous(bool homogeneous)：设置列是否均匀分布。

• GtkGrid C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkGrid Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个网格容器
        Gtk::Grid* grid = Gtk::manage(new Gtk::Grid());
        add(*grid);

        // 设置网格行间距和列间距
        grid->set_row_spacing(10);
        grid->set_column_spacing(10);

        // 创建标签，并将其添加到网格的第0行第0列，跨越1列1行
        Gtk::Label* label = Gtk::manage(new Gtk::Label("Label"));
        grid->attach(*label, 0, 0, 1, 1);

        // 创建按钮1，并将其添加到网格的第0行第1列，跨越1列1行
        Gtk::Button* button1 = Gtk::manage(new Gtk::Button("Button 1"));
        grid->attach(*button1, 1, 0, 1, 1);

        // 创建按钮2，并将其添加到网格的第1行第0列，跨越2列1行
        Gtk::Button* button2 = Gtk::manage(new Gtk::Button("Button 2"));
        grid->attach(*button2, 0, 1, 2, 1);

        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkGridExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含三个控件的窗口：一个标签（Gtk::Label）和两个按钮（Gtk::Button）。这些控件被添加到一个网格容器（Gtk::Grid）中，标签被放置在网格的第0行第0列，按钮1被放置在网格的第0行第1列，按钮2被放置在网格的第1行第0列，并跨越两列。网格的行和列之间设置了间距，以便更好地显示控件。

3.5.3 GTK3.0的GtkFixed：固定位置布局

• GtkFixed 基本知识点讲解

GtkFixed 是 GTK+ 3.0 中的一种容器控件，允许你在容器中以绝对位置放置子控件。使用 GtkFixed 布局，你可以指定每个子控件的精确位置和大小。

• 主要特性

  • 绝对位置：可以通过指定 x 和 y 坐标来精确控制子控件的位置。
  • 大小控制：可以通过设置宽度和高度来控制子控件的大小。
  • 简单布局：适用于需要精确控制子控件位置的简单布局。

• 常用方法

  • put(Gtk::Widget& child, int x, int y)：将控件放置在固定容器的指定位置。
  • move(Gtk::Widget& child, int x, int y)：移动已经放置在固定容器中的控件到新的位置。

• GtkFixed C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkFixed Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个固定容器
        Gtk::Fixed* fixed = Gtk::manage(new Gtk::Fixed());
        add(*fixed);

        // 创建标签，并将其放置在固定容器中的位置 (50, 50)
        Gtk::Label* label = Gtk::manage(new Gtk::Label("Label"));
        fixed->put(*label, 50, 50);

        // 创建按钮1，并将其放置在固定容器中的位置 (150, 50)
        Gtk::Button* button1 = Gtk::manage(new Gtk::Button("Button 1"));
        fixed->put(*button1, 150, 50);

        // 创建按钮2，并将其放置在固定容器中的位置 (50, 150)
        Gtk::Button* button2 = Gtk::manage(new Gtk::Button("Button 2"));
        fixed->put(*button2, 50, 150);

        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkFixedExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含三个控件的窗口：一个标签（Gtk::Label）和两个按钮（Gtk::Button）。这些控件被添加到一个固定容器（Gtk::Fixed）中，并且每个控件都被放置在指定的绝对位置。标签被放置在位置 (50, 50)，按钮1 被放置在位置 (150, 50)，按钮2 被放置在位置 (50, 150)。这样，你可以看到如何使用 GtkFixed 容器来精确控制子控件的位置。

3.5.4 GTK3.0的GtkStack：堆栈（允许在多个控件之间切换）

• GtkStack 基本知识点讲解

GtkStack 是 GTK+ 3.0 中的一种容器控件，允许你在多个控件之间切换。它的设计类似于堆栈，每个子控件可以被堆叠起来，并且可以根据需要显示其中一个控件。GtkStack 常与 GtkStackSwitcher 一起使用，后者提供了一种简单的方式来切换 GtkStack 中显示的控件。

• 主要特性

• 控件切换：可以在多个子控件之间进行切换。
• 过渡动画：支持不同类型的过渡动画（例如：淡入淡出，滑动）。
• 命名子控件：每个子控件都有一个唯一的名称，可以通过名称来显示对应的控件。

• 常用方法

• add_named(Gtk::Widget& child, const Glib::ustring& name)：将控件添加到堆栈中，并为其指定一个名称。
• set_visible_child_name(const Glib::ustring& name)：显示具有指定名称的控件。
• set_transition_type(Gtk::StackTransitionType transition)：设置过渡动画类型。
• set_transition_duration(guint duration)：设置过渡动画的持续时间（毫秒）。

• GtkStack C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkStack Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建一个堆栈切换器
        Gtk::StackSwitcher* stack_switcher = Gtk::manage(new Gtk::StackSwitcher());
        vbox->pack_start(*stack_switcher, Gtk::PACK_SHRINK);

        // 创建一个堆栈容器
        Gtk::Stack* stack = Gtk::manage(new Gtk::Stack());
        vbox->pack_start(*stack);

        // 将堆栈切换器连接到堆栈
        stack_switcher->set_stack(*stack);

        // 创建第一个标签，并将其添加到堆栈中，命名为 "page1"
        Gtk::Label* label1 = Gtk::manage(new Gtk::Label("This is page 1"));
        stack->add_named(*label1, "page1");

        // 创建第二个标签，并将其添加到堆栈中，命名为 "page2"
        Gtk::Label* label2 = Gtk::manage(new Gtk::Label("This is page 2"));
        stack->add_named(*label2, "page2");

        // 设置过渡动画类型和持续时间
        stack->set_transition_type(Gtk::STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
        stack->set_transition_duration(1000);

        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkStackExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含堆栈切换器（Gtk::StackSwitcher）和堆栈容器（Gtk::Stack）的窗口。堆栈容器中有两个标签（Gtk::Label），分别命名为 “page1” 和 “page2”。通过堆栈切换器，用户可以在两个标签之间切换，切换时会有滑动的过渡动画效果。

3.5.5 GTK3.0的GtkNotebook：笔记本（带选项卡的多页控件）

• GtkNotebook 基本知识点讲解

GtkNotebook 是 GTK+ 3.0 中的一种多页控件，使用选项卡（标签）来在多个页面之间进行切换。每个选项卡代表一个页面，用户可以通过点击选项卡来切换到对应的页面。

• 主要特性

  • 选项卡管理：可以添加、移除、重命名和重新排序选项卡。
  • 页面管理：可以添加、移除和管理页面内容。
  • 选项卡位置：可以设置选项卡的位置（顶部、底部、左侧、右侧）。
  • 可关闭选项卡：选项卡可以配置为可关闭状态。

• 常用方法

  • append_page(Gtk::Widget& child, const Glib::ustring& tab_label)：在末尾添加一个页面，并为其设置标签。
  • prepend_page(Gtk::Widget& child, const Glib::ustring& tab_label)：在起始位置添加一个页面，并为其设置标签。
  • insert_page(Gtk::Widget& child, const Glib::ustring& tab_label, int position)：在指定位置插入一个页面，并为其设置标签。
  • remove_page(int page_num)：移除指定页面。
  • set_tab_pos(Gtk::PositionType pos)：设置选项卡的位置。

• GtkNotebook C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkNotebook Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个垂直盒子容器
        Gtk::Box* vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0));
        add(*vbox);

        // 创建一个笔记本控件
        Gtk::Notebook* notebook = Gtk::manage(new Gtk::Notebook());
        vbox->pack_start(*notebook);

        // 创建第一个页面内容，并将其添加到笔记本中
        Gtk::Label* label1 = Gtk::manage(new Gtk::Label("Content of Page 1"));
        notebook->append_page(*label1, "Page 1");

        // 创建第二个页面内容，并将其添加到笔记本中
        Gtk::Label* label2 = Gtk::manage(new Gtk::Label("Content of Page 2"));
        notebook->append_page(*label2, "Page 2");

        // 设置选项卡位置为顶部
        notebook->set_tab_pos(Gtk::POS_TOP);

        show_all_children();
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkNotebookExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含笔记本控件（Gtk::Notebook）的窗口。笔记本控件中有两个页面，每个页面都有一个标签，分别命名为 “Page 1” 和 “Page 2”。用户可以通过点击选项卡来切换页面，选项卡的位置被设置在顶部。

3.5.6 GTK3.0的GtkScrolledWindow：滚动窗口

• GtkScrolledWindow 基本知识点讲解

GtkScrolledWindow 是 GTK+ 3.0 中的一个容器控件，用于在有限的空间内显示大内容。它提供了水平和垂直滚动条，使用户能够滚动查看内容超出窗口大小的部分。通常与其他控件（例如文本视图、树视图）一起使用，这些控件可能包含超出视窗大小的数据。

• 主要特性

  • 滚动条：自动添加和管理水平和垂直滚动条。
  • 策略控制：可以设置滚动条的显示策略（自动、总是、从不）。
  • 平滑滚动：支持平滑滚动以提高用户体验。

• 常用方法

  • set_policy(Gtk::PolicyType hscrollbar_policy, Gtk::PolicyType vscrollbar_policy)：设置水平和垂直滚动条的策略。
  • add(Gtk::Widget& widget)：将控件添加到滚动窗口中。
  • set_min_content_width(gint width)：设置内容的最小宽度。
  • set_min_content_height(gint height)：设置内容的最小高度。

• GtkScrolledWindow C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkScrolledWindow Example");  // 设置窗口标题
        set_default_size(400, 300);  // 设置窗口默认大小

        // 创建一个滚动窗口
        Gtk::ScrolledWindow* scrolled_window = Gtk::manage(new Gtk::ScrolledWindow());
        scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);  // 设置滚动条策略

        // 创建一个文本视图并设置一些长文本
        Gtk::TextView* text_view = Gtk::manage(new Gtk::TextView());
        text_view->get_buffer()->set_text("This is a long text that will exceed the window size. "
                                          "You can use the scrollbars to scroll through the content.\n\n"
                                          "More text here...\n"
                                          "Even more text...\n"
                                          "Scrolling is useful!\n"
                                          "Keep adding text to test the scroll functionality...\n"
                                          "This is a demonstration of GtkScrolledWindow.\n"
                                          "Enjoy scrolling!\n\n"
                                          "End of the long text.");

        // 将文本视图添加到滚动窗口中
        scrolled_window->add(*text_view);

        // 将滚动窗口添加到主窗口中
        add(*scrolled_window);

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkScrolledWindowExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含滚动窗口（Gtk::ScrolledWindow）的窗口。在滚动窗口中放置了一个文本视图（Gtk::TextView），并在文本视图中设置了一些超出窗口大小的长文本。滚动窗口的滚动条策略设置为自动，这样当内容超出窗口大小时，会自动显示滚动条。用户可以使用滚动条来查看整个内容。

3.5.7 GTK3.0的GtkPaned：可调整大小的面板（水平或垂直分隔）

• GtkPaned 基本知识点讲解

GtkPaned 是 GTK+ 3.0 中的一个容器控件，允许用户通过拖动分隔条来调整两个子控件的大小。GtkPaned 可以是水平的（Gtk::HPaned），也可以是垂直的（Gtk::VPaned）。这个控件常用于需要动态调整布局的应用程序中。

• 主要特性

  • 可调整大小：用户可以通过拖动分隔条来调整子控件的大小。
  • 水平或垂直布局：支持水平和垂直两种布局方式。
  • 分隔条位置：可以设置初始分隔条的位置。
  • 最小和最大大小：可以设置子控件的最小和最大大小。

• 常用方法

  • add1(Gtk::Widget& child)：添加第一个子控件。
  • add2(Gtk::Widget& child)：添加第二个子控件。
  • set_position(int position)：设置分隔条的位置。
  • set_wide_handle(bool wide)：设置是否使用宽分隔条。

• GtkPaned C++ Demo

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("GtkPaned Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个水平分隔面板
        Gtk::Paned* hpaned = Gtk::manage(new Gtk::HPaned());
        add(*hpaned);

        // 创建第一个标签，并将其添加到水平分隔面板的左侧
        Gtk::Label* label1 = Gtk::manage(new Gtk::Label("Left pane content"));
        hpaned->add1(*label1);

        // 创建第二个标签，并将其添加到水平分隔面板的右侧
        Gtk::Label* label2 = Gtk::manage(new Gtk::Label("Right pane content"));
        hpaned->add2(*label2);

        // 设置分隔条的位置
        hpaned->set_position(200);

        show_all_children();  // 显示所有子控件
    }

    virtual ~MyWindow() {}
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.GtkPanedExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个包含水平分隔面板（Gtk::HPaned）的窗口。在水平分隔面板的左侧放置了一个标签（Gtk::Label），显示 “Left pane content”；在右侧放置了另一个标签，显示 “Right pane content”。分隔条的位置被设置为 200 像素，用户可以通过拖动分隔条来调整左右两侧的大小。

四、GTK3.0事件驱动

4.1 GTK3.0事件传播机制

• GTK3.0 事件传播机制 基本知识点讲解

GTK3.0 中的事件传播机制主要通过信号和事件对象来实现。事件传播机制包括以下几个主要部分：

1. 捕获阶段（Capture Phase）：事件从顶层窗口向目标控件传播。在这个阶段，父控件有机会先处理事件。
2. 目标阶段（Target Phase）：事件到达目标控件并处理。
3. 冒泡阶段（Bubble Phase）：事件从目标控件向上层控件传播。在这个阶段，父控件也有机会处理事件。

• 事件对象

  • GdkEvent：所有事件对象的基类。
  • GdkEventButton：鼠标按钮事件。
  • GdkEventKey：键盘事件。
  • GdkEventMotion：鼠标移动事件。

• 信号

  信号是 GTK 事件系统的核心。常见信号有：

  • button-press-event：鼠标按钮按下事件。
  • key-press-event：键盘按下事件。
  • motion-notify-event：鼠标移动事件。

• 信号连接

  使用 signal_connect 方法将信号连接到回调函数。例如：

  widget->signal_button_press_event().connect(sigc::mem_fun(*this, &MyClass::on_button_press));
  

• 事件传播控制

  可以在回调函数中通过返回 true 或 false 来控制事件是否继续传播：

  • 返回 true：事件停止传播。
  • 返回 false：事件继续传播。

• GtkWidget 事件传播示例

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("Event Propagation Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个按钮
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Click me"));
        button->signal_button_press_event().connect(sigc::mem_fun(*this, &MyWindow::on_button_press));
        
        // 将按钮添加到窗口
        add(*button);

        // 将窗口的鼠标按钮按下事件连接到回调函数
        signal_button_press_event().connect(sigc::mem_fun(*this, &MyWindow::on_window_button_press));

        show_all_children();  // 显示所有子控件
    }

protected:
    // 按钮的鼠标按钮按下事件处理函数
    bool on_button_press(GdkEventButton* event) {
        g_print("Button pressed\n");
        return false;  // 继续传播事件
    }

    // 窗口的鼠标按钮按下事件处理函数
    bool on_window_button_press(GdkEventButton* event) {
        g_print("Window button press\n");
        return false;  // 继续传播事件
    }
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.EventPropagationExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序展示了 GTK3.0 的事件传播机制。在这个示例中，窗口和按钮都连接了鼠标按钮按下事件（button-press-event）。当用户点击按钮时，首先触发按钮的事件处理函数，然后事件继续传播到窗口的事件处理函数。通过在回调函数中返回 false，事件得以继续传播。

4.1 GTK3.0 键盘和鼠标事件

• GTK3.0 键盘和鼠标事件 基本知识点讲解

GTK3.0 中，键盘和鼠标事件是通过信号和事件对象处理的。以下是一些基本知识点：

• 键盘事件

  • 键盘事件信号：包括 key-press-event 和 key-release-event。
  • 键盘事件对象：GdkEventKey，包含按键的详细信息，如键码、状态（Shift、Ctrl 等）。

• 鼠标事件

  • 鼠标事件信号：包括 button-press-event、button-release-event、motion-notify-event 等。
  • 鼠标事件对象：GdkEventButton，包含鼠标按键的详细信息，如按键、位置、点击次数等。

• 信号连接
  使用 signal_connect 方法将信号连接到回调函数。例如：

  widget->signal_key_press_event().connect(sigc::mem_fun(*this, &MyClass::on_key_press_event));
  widget->signal_button_press_event().connect(sigc::mem_fun(*this, &MyClass::on_button_press_event));
  

• 回调函数
  回调函数用于处理特定的事件，通常返回 true 或 false 以控制事件的传播：

  • 返回 true：事件停止传播。
  • 返回 false：事件继续传播。

• 键盘和鼠标事件示例

#include <gtkmm.h>

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("Keyboard and Mouse Events Example");  // 设置窗口标题
        set_default_size(400, 300);  // 设置窗口默认大小

        // 创建一个标签，用于显示事件信息
        label.set_text("Press any key or click the mouse");
        label.set_margin(10);
        add(label);  // 将标签添加到窗口

        // 连接窗口的键盘按下事件到回调函数
        signal_key_press_event().connect(sigc::mem_fun(*this, &MyWindow::on_key_press_event));

        // 连接窗口的鼠标按钮按下事件到回调函数
        signal_button_press_event().connect(sigc::mem_fun(*this, &MyWindow::on_button_press_event));

        show_all_children();  // 显示所有子控件
    }

protected:
    // 键盘按下事件处理函数
    bool on_key_press_event(GdkEventKey* event) {
        // 获取按下的键的名称
        gchar* keyname = gdk_keyval_name(event->keyval);
        // 显示按键信息
        label.set_text(Glib::ustring::compose("Key pressed: %1", keyname));
        g_free(keyname);  // 释放键名字符串
        return false;  // 继续传播事件
    }

    // 鼠标按钮按下事件处理函数
    bool on_button_press_event(GdkEventButton* event) {
        // 获取鼠标点击的位置信息
        int x = static_cast<int>(event->x);
        int y = static_cast<int>(event->y);
        // 显示鼠标点击信息
        label.set_text(Glib::ustring::compose("Mouse button pressed at: (%1, %2)", x, y));
        return false;  // 继续传播事件
    }

private:
    Gtk::Label label;  // 用于显示事件信息的标签
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.KeyboardMouseEventsExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序创建了一个窗口，其中包含一个标签用于显示键盘和鼠标事件的信息。当用户按下键盘按键或点击鼠标按钮时，标签会更新并显示相应的事件信息。键盘按下事件和鼠标按钮按下事件分别连接到各自的回调函数，通过这些回调函数处理并显示事件详细信息。

4.2 GTK3.0信号过滤器

• GTK3.0 信号过滤器 基本知识点讲解

GTK3.0 中，信号过滤器用于在信号到达信号处理函数之前，对信号进行预处理或过滤。信号过滤器允许开发者在某些特定条件下阻止信号的传播或修改信号的参数。信号过滤器的典型用法包括拦截键盘或鼠标事件，进行预处理，并根据需要决定是否继续传播该信号。

• 信号过滤器的主要知识点：

1. 安装信号过滤器：

   • 使用 g_signal_add_emission_hook() 方法在信号的发射路径上添加过滤器。
   • 过滤器会在信号处理函数之前被调用。

2. 过滤器回调函数：

   • 过滤器回调函数通常返回 GDK_EVENT_STOP 或 GDK_EVENT_PROPAGATE。
   • GDK_EVENT_STOP：停止信号的进一步传播。
   • GDK_EVENT_PROPAGATE：允许信号继续传播。

3. 过滤器参数：

   • 过滤器回调函数可以接收信号的详细信息，例如信号名称、参数和目标对象。

4. 移除信号过滤器：

   • 使用 g_signal_remove_emission_hook() 方法移除已安装的过滤器。

• GTK3.0 信号过滤器示例

#include <gtkmm.h>

// 信号过滤器回调函数
static GdkFilterReturn on_filter_event(GdkXEvent* xevent, GdkEvent* event, gpointer data) {
    if (event->type == GDK_KEY_PRESS) {
        GdkEventKey* key_event = (GdkEventKey*)event;
        // 拦截并显示按下的键
        g_print("Key Pressed: %s\n", gdk_keyval_name(key_event->keyval));
        // 阻止信号进一步传播
        return GDK_FILTER_REMOVE;
    }
    return GDK_FILTER_CONTINUE;  // 继续传播信号
}

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("Signal Filter Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个标签
        Gtk::Label* label = Gtk::manage(new Gtk::Label("Press any key to see the filter in action"));
        label->set_margin(10);
        add(*label);  // 将标签添加到窗口

        // 将信号过滤器添加到窗口
        g_signal_add_emission_hook(g_signal_lookup("key-press-event", GTK_TYPE_WIDGET),
                                   0,
                                   on_filter_event,
                                   nullptr,
                                   nullptr);

        show_all_children();  // 显示所有子控件
    }

    ~MyWindow() {
        // 移除信号过滤器
        g_signal_remove_emission_hook(g_signal_lookup("key-press-event", GTK_TYPE_WIDGET), 0);
    }
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.SignalFilterExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序展示了如何在 GTK3.0 中使用信号过滤器。当用户按下键盘按键时，信号过滤器会拦截 key-press-event 信号，并打印按键名称，同时阻止信号进一步传播。这样可以实现对信号的预处理或条件性过滤。

4.3 GTK3.0自定义信号

• GTK3.0 自定义信号 基本知识点讲解

在 GTK3.0 中，自定义信号可以让开发者定义特定的事件，并为这些事件提供相应的处理函数。这些自定义信号可以在应用程序的任何地方发射，类似于 GTK 内建的信号。

• 自定义信号的主要知识点：

  1. 定义自定义信号：

     • 使用 GObject 信号系统定义自定义信号。
     • 自定义信号通常在类初始化函数中定义。

  2. 信号的参数和返回值：

     • 自定义信号可以携带参数，并且可以有返回值。

  3. 发射自定义信号：

     • 使用 g_signal_emit() 或者 g_signal_emit_by_name() 函数发射自定义信号。

  4. 连接自定义信号到回调函数：

     • 使用 g_signal_connect() 函数将信号连接到相应的回调函数。

• 自定义信号示例

#include <gtkmm.h>

// 自定义信号类
class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title("Custom Signal Example");  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个按钮
        Gtk::Button* button = Gtk::manage(new Gtk::Button("Click Me"));
        button->signal_clicked().connect(sigc::mem_fun(*this, &MyWindow::on_button_clicked));
        add(*button);  // 将按钮添加到窗口

        show_all_children();  // 显示所有子控件
    }

    // 定义自定义信号
    typedef sigc::signal<void, const Glib::ustring&> type_signal_custom;
    type_signal_custom signal_custom() {
        return m_signal_custom;
    }

protected:
    // 按钮点击事件处理函数
    void on_button_clicked() {
        // 当按钮被点击时发射自定义信号
        m_signal_custom.emit("Button was clicked");
    }

    // 自定义信号回调函数
    void on_custom_signal(const Glib::ustring& message) {
        g_print("%s\n", message.c_str());  // 打印自定义信号的消息
    }

private:
    type_signal_custom m_signal_custom;  // 自定义信号对象
};

int main(int argc, char *argv[]) {
    auto app = Gtk::Application::create(argc, argv, "com.example.CustomSignalExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    // 连接自定义信号到回调函数
    window.signal_custom().connect(sigc::mem_fun(window, &MyWindow::on_custom_signal));

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件，并使用以下命令进行编译和运行：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

这个示例程序展示了如何在 GTK3.0 中定义和使用自定义信号。当用户点击按钮时，会发射自定义信号，信号携带一条消息。该信号连接到自定义信号回调函数，该函数将打印消息到控制台。通过这种方式，可以在应用程序中实现更复杂和灵活的事件处理机制。

五、GTK3.0国际化和本地化

5.1 GTK3.0 国际化和本地化 基本知识点讲解

国际化（i18n）和本地化（l10n）是开发支持多语言应用程序的关键步骤。GTK3.0 使用 GNU gettext 库进行国际化和本地化。以下是基本知识点：

5.2 基本知识点：

1. 国际化（i18n）：

   • 国际化是指在应用程序中准备好可以翻译的文本字符串，使其可以支持多语言。
   • 在源代码中，使用 _() 或 gettext() 函数来标记需要翻译的字符串。例如：_("Hello World")。

2. 本地化（l10n）：

   • 本地化是指将应用程序翻译成特定语言的过程。
   • 使用 msgfmt 工具将 .po 文件（翻译文件）编译成 .mo 文件（机器可读文件）。

3. gettext 库：

   • gettext() 函数用于获取翻译后的字符串。
   • bindtextdomain() 函数用于设置包含翻译文件的目录。
   • textdomain() 函数用于设置应用程序的文本域。

4. 消息文件：

   • .pot 文件：模板文件，包含所有待翻译的字符串。
   • .po 文件：包含翻译后的字符串。
   • .mo 文件：编译后的翻译文件，应用程序运行时使用。

5.3 国际化和本地化示例

5.3.1. 准备源代码：

#include <gtkmm.h>
#include <libintl.h>
#include <locale.h>

#define _(STRING) gettext(STRING)  // 宏定义，用于简化 gettext 函数的使用

class MyWindow : public Gtk::Window {
public:
    MyWindow() {
        set_title(_("Internationalization Example"));  // 设置窗口标题
        set_default_size(400, 200);  // 设置窗口默认大小

        // 创建一个标签
        Gtk::Label* label = Gtk::manage(new Gtk::Label(_("Hello, World!")));
        label->set_margin(10);
        add(*label);  // 将标签添加到窗口

        show_all_children();  // 显示所有子控件
    }
};

int main(int argc, char *argv[]) {
    // 设置本地化环境
    setlocale(LC_ALL, "");
    bindtextdomain("myapp", "/usr/local/share/locale");  // 设置翻译文件目录
    textdomain("myapp");  // 设置文本域

    auto app = Gtk::Application::create(argc, argv, "com.example.InternationalizationExample");  // 创建 GTK 应用程序实例

    MyWindow window;  // 创建主窗口实例

    return app->run(window);  // 运行应用程序
}

将上述代码保存为 main.cpp 文件。

5.3.2. 提取待翻译字符串：

使用 xgettext 工具从源代码中提取待翻译的字符串：

xgettext -k_ -o myapp.pot main.cpp

5.3.3. 创建翻译文件：

复制 myapp.pot 文件并重命名为 zh_CN.po（用于中文翻译）：

cp myapp.pot zh_CN.po

编辑 zh_CN.po 文件，添加翻译：

msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Language: zh_CN\n"

msgid "Internationalization Example"
msgstr "国际化示例"

msgid "Hello, World!"
msgstr "你好，世界！"

5.3.4. 编译翻译文件：

使用 msgfmt 工具将 .po 文件编译成 .mo 文件：

msgfmt zh_CN.po -o zh_CN.mo

将 zh_CN.mo 文件放到 /usr/local/share/locale/zh_CN/LC_MESSAGES/ 目录，并重命名为 myapp.mo：

mkdir -p /usr/local/share/locale/zh_CN/LC_MESSAGES/
mv zh_CN.mo /usr/local/share/locale/zh_CN/LC_MESSAGES/myapp.mo

5.3.5. 编译和运行应用程序：

使用以下命令编译和运行应用程序：

g++ main.cpp -o myapp `pkg-config --cflags --libs gtkmm-3.0`
./myapp

运行应用程序时，如果系统的语言设置为中文（zh_CN），应用程序的文本将显示为中文翻译后的字符串。

通过以上步骤，示例程序展示了如何使用 GTK3.0 和 GNU gettext 实现国际化和本地化。