【入門】RustとGTKによるデスクトップアプリケーション開発

By /

はい、承知いたしました。RustとGTKによるデスクトップアプリケーション開発の詳細な入門記事を作成します。約5000語の要件を満たすように、各ステップや概念について詳しく説明します。

【入門】RustとGTKによるデスクトップアプリケーション開発

デスクトップアプリケーション開発は、様々な言語やフレームワークで行うことができます。その中でも、近年注目を集めているのがRustとGTKの組み合わせです。Rustの持つ安全性、パフォーマンス、信頼性という強みと、GTKの高い表現力とクロスプラットフォーム対応を組み合わせることで、堅牢でモダンなデスクトップアプリケーションを開発することが可能になります。

この記事では、RustとGTKを使ってデスクトップアプリケーションを開発するための最初の一歩を踏み出すための詳細な入門ガイドを提供します。Rustのインストールから、基本的なウィンドウ表示、ウィジェットの配置、イベントハンドリング、さらにGtkBuilderを使ったUIデザインまで、順を追って解説していきます。

さあ、RustとGTKの世界へ飛び込みましょう！

1. はじめに：RustとGTKの魅力

なぜRustとGTKの組み合わせがデスクトップアプリケーション開発において魅力的とされるのでしょうか。それぞれの技術が持つ特性を見てみましょう。

Rustの強み

  • 安全性: Rustの最も大きな特徴の一つは、メモリ安全性とスレッド安全性をコンパイル時に保証する点です。所有権システム、借用、ライフタイムといった独自の概念により、ヌルポインタ参照やデータ競合といった深刻なバグを防ぎます。これにより、実行時エラーが少なく、信頼性の高いアプリケーションを構築できます。
  • パフォーマンス: RustはC++に匹敵するゼロコスト抽象化を目指しており、ガベージコレクションを持たないため、実行速度が非常に高速です。システムプログラミングにも適しており、リソースを効率的に利用するアプリケーション開発に向いています。
  • 並行処理: Rustはスレッド安全性をコンパイル時に保証するため、安心して並行処理を記述できます。UIアプリケーションでは応答性のためにバックグラウンド処理が重要になることが多く、この点は大きな利点となります。
  • モダンな言語機能: パターンマッチング、イテレータ、トレイトといったモダンな言語機能が豊富にあり、表現力豊かで保守しやすいコードを書くことができます。
  • 強力なツール: Cargoという優れたビルドシステムとパッケージマネージャーが付属しており、プロジェクトの管理、依存関係の解決、ビルド、テストなどが容易に行えます。

GTKの強み

  • クロスプラットフォーム: GTK (GIMP Toolkit) は、Linux環境で広く使われているウィジェットツールキットですが、WindowsやmacOSでも動作します。これにより、単一のコードベースから主要なデスクトップ環境向けのアプリケーションを開発できます。
  • 高い表現力: GTKは、モダンな外観を持つウィジェットを豊富に提供しており、カスタマイズ性も高いです。複雑なUIも構築可能です。
  • 成熟したライブラリ: GTKは長年にわたって開発されており、安定しており機能も豊富です。アクセシビリティや国際化なども考慮されています。
  • GtkBuilder: UIをXML形式の.uiファイルとして記述し、コードから読み込むことができます。これにより、UIデザインとロジックを分離し、開発効率を高めることができます。GladeやGNOME BuilderといったGUIデザイナツールも利用可能です。

Rust + GTK =？

これらの特性を組み合わせることで、Rustの安全性とパフォーマンスを活かしながら、GTKによるリッチなUIを持つクロスプラットフォームなデスクトップアプリケーションを開発できます。特に、メモリ安全性に関する懸念が少ないため、複雑なUIやバックグラウンド処理を含むアプリケーションでも、より自信を持って開発を進めることができます。

この記事では、Rustの基本的な知識があることを前提としますが、GTKに関する知識は問いません。ゼロからRustでGTKアプリケーションを開発する手順を丁寧に解説します。

2. Rustの準備

まずはRustの開発環境を整えましょう。Rustをインストールするには、公式が推奨するrustupというツールを使用するのが最も一般的です。

Rustのインストール

ウェブブラウザでRustの公式ウェブサイト（https://www.rust-lang.org/ja/）にアクセスし、インストール手順を確認してください。通常は以下のコマンドを実行するだけです。

Linux / macOS:

bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

このコマンドはrustupをダウンロードし、インストールスクリプトを実行します。インストール中に、デフォルトの設定（PATHの設定など）で進めるか尋ねられます。特に理由がなければデフォルト設定で問題ありません。インストール完了後、シェルの設定ファイルを再読み込みするか、新しいターミナルを開いて変更を反映させてください。

Windows:

Windowsでは、公式ウェブサイトからrustup-init.exeをダウンロードして実行します。インストーラーの指示に従って進めてください。Visual StudioのC++ビルドツールが必要になる場合があります。

インストールが完了したら、以下のコマンドを実行してRustのコンパイラ（rustc）とCargo（cargo）のバージョンを確認してみましょう。

bash
rustc --version
cargo --version

バージョン情報が表示されれば、Rustのインストールは成功です。

Cargoとは

Rustのプロジェクト管理は、ほとんどの場合Cargoを使って行います。Cargoは以下の機能を提供します。

  • プロジェクトの作成
  • コードのビルド
  • ライブラリ（クレート）の依存関係の管理とダウンロード
  • テストの実行
  • ドキュメントの生成

新しいRustプロジェクトを作成するには、cargo newコマンドを使用します。

bash
cargo new my_gtk_app
cd my_gtk_app

これにより、my_gtk_appというディレクトリが作成され、その中に以下のファイルとディレクトリが生成されます。

my_gtk_app/
├── Cargo.toml
└── src/
└── main.rs

Cargo.tomlはプロジェクトの設定ファイルです。プロジェクト名、バージョン、依存関係などが記述されます。src/main.rsは、実行可能アプリケーションのメインソースファイルです。ライブラリクレートの場合はsrc/lib.rsが生成されます。

現時点では、Rustの準備はこれで完了です。次にGTKを使えるように準備を進めます。

3. GTKの準備 (gtk-rs)

RustからGTKを利用するためには、GTKライブラリ本体と、RustからGTKの機能を呼び出すためのバインディング（gtk-rsというプロジェクトによって提供されています）が必要です。

GTK本体のインストール

GTK本体のインストール方法はOSによって異なります。

Linux:

Linuxでは、ほとんどの場合パッケージマネージャーを使ってGTKをインストールできます。ディストリビューションによってパッケージ名が異なります。

  • Debian/Ubuntu:
    bash
    sudo apt update
    sudo apt install libgtk-4-dev # GTK 4の場合
    # または libgtk-3-dev # GTK 3の場合
  • Fedora:
    bash
    sudo dnf install gtk4-devel # GTK 4の場合
    # または gtk3-devel # GTK 3の場合
  • Arch Linux:
    bash
    sudo pacman -S gtk4 # GTK 4の場合
    # または gtk3 # GTK 3の場合

この記事では主にGTK 4を対象としますが、GTK 3でも同様の概念で開発できます。お使いの環境に合わせて適切なバージョンをインストールしてください。

Windows:

WindowsでGTKを使うにはいくつかの方法がありますが、ここではMSYS2を使う方法を紹介します。MSYS2は、Windows上でUnix-likeな環境を提供するツールで、パッケージマネージャー（pacman）を使ってGTKを含む多くのライブラリを簡単にインストールできます。

  1. MSYS2の公式ウェブサイト（https://www.msys2.org/）からインストーラーをダウンロードし、指示に従ってインストールします。
  2. MSYS2 MINGW64端末を開きます。
  3. 以下のコマンドを実行して、GTK 4とその開発ファイルをインストールします。
    bash
    pacman -Syu # パッケージリストを更新
    pacman -S mingw-w64-ucrt-x86_64-gtk4 # GTK 4をインストール
    # または pacman -S mingw-w64-ucrt-x86_64-gtk3 # GTK 3の場合
    （注: 使用するMSYS2の環境（MINGW64, MINGW32など）によってパッケージ名が若干異なる場合があります。mingw-w64-ucrt-x86_64は一般的な64bit UCRT環境用です。）

インストール後、MSYS2 MINGW64端末内でRustの開発を行う必要があります。あるいは、Rustの環境変数PKG_CONFIG_PATHなどを設定して、WindowsのコマンドプロンプトやPowerShellからMSYS2のライブラリを参照できるようにする必要がありますが、MSYS2端末内での開発が最も簡単です。

macOS:

macOSでは、Homebrewパッケージマネージャーを使うのが一般的です。

  1. Homebrewをインストールしていない場合は、公式ウェブサイト（https://brew.sh/）の手順に従ってインストールします。
  2. 以下のコマンドを実行してGTK 4をインストールします。
    bash
    brew update
    brew install gtk4 # GTK 4の場合
    # または brew install gtk+3 # GTK 3の場合

Rustバインディング (gtk-rs) の利用

GTK本体がインストールできたら、Cargoを使ってRustバインディング（gtkクレート）をプロジェクトに追加します。

先ほど作成したmy_gtk_appディレクトリに移動し、Cargo.tomlファイルを開きます。[dependencies]セクションにgtkクレートを追加します。GTK 4を使用する場合は、バージョンを指定します。

“`toml
[package]
name = “my_gtk_app”
version = “0.1.0”
edition = “2021”

[dependencies]

GTK 4を使用する場合

gtk = { version = “0.16”, package = “gtk4” }

GTK 3を使用する場合（この記事ではGTK 4を主に扱います）

gtk = { version = “0.17”, package = “gtk3” }

GTKを使う上で必要になることが多いクレートも追加しておきます

gio = “0.16” # GTK 4の場合、gio::Applicationなどが含まれる

gio = “0.17” # GTK 3の場合

glib = “0.16” # GTK 4の場合

glib = “0.17” # GTK 3の場合

“`

gtk-rsプロジェクトは、GTK本体だけでなく、GLib、GIOなどの関連ライブラリのバインディングも提供しています。GTKアプリケーション開発では、これらのライブラリの機能も頻繁に利用するため、通常はgtkクレートに加えてgioやglibクレートも依存関係に追加します。上記の例では、GTK 4に対応するバージョン（執筆時点での最新付近）を指定しています。使用するGTKのバージョンに合わせて、対応するgtk, gio, glibクレートのバージョンを指定してください。gtk-rsの公式ドキュメント（https://gtk-rs.org/）で最新のバージョン情報を確認できます。

Cargo.tomlを保存したら、Cargoが依存関係をダウンロードします。これは通常、次にcargo buildやcargo runコマンドを実行した際に自動的に行われます。

これで、RustとGTKを使うための準備は完了です。

4. 最小限のウィンドウを表示する

それでは、最初のGTKアプリケーションとして、空のウィンドウを表示してみましょう。

src/main.rsファイルを開き、既存のコードをすべて削除して、以下のコードを記述します。

“`rust
use gio::Application;
use gtk::prelude::*;
use gtk::ApplicationWindow;

fn main() -> glib::ExitCode {
// 1. 新しいアプリケーションを作成します。
// アプリケーションIDを指定します。通常はドメイン名を逆順にした形式を使います。
// gio::ApplicationFlags::empty() は特別なフラグがないことを意味します。
let app = Application::builder()
.application_id(“com.example.my_gtk_app”)
.flags(gio::ApplicationFlags::empty())
.build();

// 2. "activate" シグナルに対するハンドラを設定します。
//    このシグナルは、アプリケーションが起動してUIの準備ができたときに発生します。
app.connect_activate(|app| {
    // 3. アプリケーションウィンドウを作成します。
    //    ウィンドウはアプリケーションインスタンスに紐付けられます。
    let window = ApplicationWindow::builder()
        .application(app)
        .title("My First GTK App") // ウィンドウのタイトル
        .default_width(350)      // ウィンドウのデフォルト幅
        .default_height(100)     // ウィンドウのデフォルト高さ
        .build();

    // 4. ウィンドウを表示します。
    window.present();
});

// 5. アプリケーションを実行します。
//    これにより、GUIイベントループが開始され、ウィンドウが表示されます。
//    "activate" シグナルハンドラが呼び出されます。
app.run()

}
“`

コードの解説

この短いコードは、RustとGTKを使ってウィンドウを表示するための基本的な構造を示しています。一つずつ見ていきましょう。

  • use ステートメント:
    rust
    use gio::Application;
    use gtk::prelude::*;
    use gtk::ApplicationWindow;
    必要な型やトレイトをインポートしています。

    • gio::Application: アプリケーション全体を表すオブジェクトです。複数のウィンドウやアプリケーションとしての振る舞い（コマンドライン引数の処理、単一インスタンス実行など）を管理します。
    • gtk::prelude::*: GTK開発で頻繁に使用されるトレイト（例えば、WidgetExt、ButtonExtなど）をまとめてインポートします。これにより、ウィジェットのメソッド（例: window.present()）を呼び出せるようになります。preludeはGTKクレートを使う上で必須とも言えるインポートです。
    • gtk::ApplicationWindow: アプリケーションのメインウィンドウとなるウィジェットです。gio::Applicationに紐付けられます。

  • main 関数:
    rust
    fn main() -> glib::ExitCode { ... }
    Rustの実行可能アプリケーションのエントリーポイントです。GTKアプリケーションの場合、main関数はglib::ExitCode（または単にi32）を返すようにするのが一般的です。これは、アプリケーションの終了コードを表します。

  • アプリケーションの作成:
    rust
    let app = Application::builder()
    .application_id("com.example.my_gtk_app")
    .flags(gio::ApplicationFlags::empty())
    .build();
    gio::Applicationインスタンスを作成します。builder()パターンを使って、プロパティ（アプリケーションIDやフラグ）を設定しています。

    • application_id: アプリケーションを一意に識別するためのIDです。リバースドメイン名形式（例: com.yourcompany.YourAppName）が推奨されます。このIDは、設定の保存や単一インスタンス実行制御などに使用されます。
    • flags: アプリケーションの振る舞いを制御するフラグです。gio::ApplicationFlags::empty()は、特別なフラグを指定しないことを意味します。

  • シグナルハンドラの設定:
    rust
    app.connect_activate(|app| { ... });
    GTKオブジェクト（ウィジェットやアプリケーションなど）は、特定のイベントが発生したときに「シグナル」を発行します。開発者は、これらのシグナルに「ハンドラ」と呼ばれる関数やクロージャを接続（connect）することで、イベントに応じた処理を実行できます。
    ここでは、アプリケーションオブジェクトの "activate" シグナルにハンドラを設定しています。"activate" シグナルは、アプリケーションが正常に起動し、ユーザーインターフェースの準備ができたときに発生します。ウィンドウを作成・表示する処理は、このシグナルハンドラ内で行うのが標準的なパターンです。
    ハンドラとして渡されているのはクロージャ |app| { ... } です。このクロージャは、シグナルを発行したアプリケーションインスタンス自身を受け取ります。

  • ウィンドウの作成と設定:
    rust
    let window = ApplicationWindow::builder()
    .application(app)
    .title("My First GTK App")
    .default_width(350)
    .default_height(100)
    .build();
    gtk::ApplicationWindowインスタンスを、これもbuilder()パターンを使って作成しています。

    • application(app): ウィンドウをどのアプリケーションに紐付けるかを指定します。ここでは、先ほど作成したappインスタンスを渡しています。
    • title("My First GTK App"): ウィンドウのタイトルバーに表示されるテキストを設定します。
    • default_width(350)、default_height(100): ウィンドウの初期サイズを設定します。
      build()を呼び出すことで、設定されたプロパティを持つApplicationWindowオブジェクトが生成されます。

  • ウィンドウの表示:
    rust
    window.present();
    作成したウィンドウを画面に表示します。これがないと、ウィンドウオブジェクトは存在するものの、ユーザーには見えません。

  • アプリケーションの実行:
    rust
    app.run()
    アプリケーションのイベントループを開始します。これにより、GUIが表示され、ユーザー入力（マウス、キーボードなど）やシステムイベント（ウィンドウのリサイズ、閉じるボタンのクリックなど）を処理できるようになります。イベントループは、アプリケーションが終了するまで、あるいは明示的に終了が要求されるまで実行され続けます。アプリケーションが終了すると、run()メソッドは終了コードを返します。

ビルドと実行

コードを記述したら、Cargoを使ってビルドし、実行してみましょう。プロジェクトのルートディレクトリ（Cargo.tomlがある場所）で、以下のコマンドを実行します。

bash
cargo run

Cargoは依存関係をダウンロードし（初回のみ）、コードをコンパイルして、実行可能ファイルを生成し、それを実行します。すべてがうまくいけば、「My First GTK App」というタイトルの小さなウィンドウが表示されるはずです。

ウィンドウを閉じると、アプリケーションが終了し、cargo runコマンドも終了します。

これで、RustとGTKを使ったデスクトップアプリケーション開発の最初のステップが完了しました！

5. 基本的なウィジェットの配置

空のウィンドウが表示できるようになったので、次にウィンドウの中に何か表示してみましょう。GTKでは、GUIを構成する様々な部品を「ウィジェット」と呼びます。ボタン、ラベル、テキスト入力欄などがウィジェットの例です。

ウィジェットは通常、他のウィジェットの中に配置されます。特に、複数のウィジェットを整列させるためには、「コンテナウィジェット」を使います。代表的なコンテナウィジェットには、Box（ウィジェットを垂直または水平に並べる）やGrid（ウィジェットを格子状に配置する）があります。

ここでは、ウィンドウ内に簡単なラベルとボタンを配置してみましょう。

src/main.rsファイルを以下のように修正します。

“`rust
use gio::Application;
use gtk::prelude::*;
use gtk::{ApplicationWindow, Button, Label, Box as GtkBox, Orientation}; // BoxをGtkBoxとしてインポート

fn main() -> glib::ExitCode {
let app = Application::builder()
.application_id(“com.example.my_gtk_app”)
.flags(gio::ApplicationFlags::empty())
.build();

app.connect_activate(|app| {
    // ラベルとボタンを作成
    let label = Label::new(Some("Hello, GTK!"));
    let button = Button::with_label("Click Me!");

    // 垂直方向のBoxコンテナを作成
    // ウィジェット間に12ピクセルのスペースを設けます
    let vbox = GtkBox::builder()
        .orientation(Orientation::Vertical) // 垂直方向
        .spacing(12)                       // ウィジェット間のスペース
        .build();

    // Boxにラベルとボタンを追加
    // pack_startは、コンテナの開始位置（垂直Boxなら上端）からウィジェットを追加します
    // expand: trueならウィジェットが利用可能なスペースを埋めるように拡大
    // fill: trueならウィジェットの大きさが拡大しても内容は拡大
    // padding: ウィジェットの外側のスペース
    // GTK 4ではpack_start/endは非推奨になり、appendやprependが使われます。
    // appendはコンテナの末尾に追加します。
    vbox.append(&label);
    vbox.append(&button);

    // アプリケーションウィンドウを作成
    let window = ApplicationWindow::builder()
        .application(app)
        .title("Widgets Example")
        .default_width(300)
        .default_height(150)
        .child(&vbox) // ウィンドウの子ウィジェットとしてBoxコンテナを設定
        .build();

    window.present();
});

app.run()

}
“`

コードの解説

追加・変更された部分を中心に見ていきましょう。

  • 追加のインポート:
    rust
    use gtk::{Button, Label, Box as GtkBox, Orientation};
    新しく使用するウィジェットや列挙型をインポートしています。Boxは標準ライブラリにもあるため、GtkBox as GtkBoxとしてリネームしてインポートしています。OrientationはBoxの方向（垂直か水平か）を指定するために使います。

  • ウィジェットの作成:
    rust
    let label = Label::new(Some("Hello, GTK!"));
    let button = Button::with_label("Click Me!");
    Label::new()で静的なテキストを表示するラベルウィジェットを作成します。引数は表示するテキストです（Option<T>型なので、Some("...")またはNone）。
    Button::with_label()でテキスト付きのボタンウィジェットを作成します。

  • コンテナウィジェットの作成と設定:
    rust
    let vbox = GtkBox::builder()
    .orientation(Orientation::Vertical)
    .spacing(12)
    .build();
    GtkBoxをbuilder()パターンで作成します。

    • orientation(Orientation::Vertical): このBoxがウィジェットを垂直方向に並べることを指定します。Orientation::Horizontalを指定すれば水平に並べます。
    • spacing(12): Box内のウィジェット間に12ピクセルの間隔を設けます。

  • ウィジェットをコンテナに追加:
    rust
    vbox.append(&label);
    vbox.append(&button);
    GTK 4では、コンテナに子ウィジェットを追加するためにappend()メソッドを使用します。GTK 3ではpack_start()やpack_end()が使われていましたが、GTK 4では非推奨になりました。append()は、コンテナの既存の子ウィジェットの末尾に新しいウィジェットを追加します。引数にはウィジェットへの参照（&）を渡します。

  • ウィンドウにコンテナを設定:
    rust
    let window = ApplicationWindow::builder()
    // ... 省略 ...
    .child(&vbox) // ウィンドウの子ウィジェットとしてBoxコンテナを設定
    .build();
    ApplicationWindowは通常、子ウィジェットを一つだけ持つことができます（その子がさらにコンテナウィジェットであれば、事実上複数のウィジェットを配置できます）。ここでは、作成した垂直Boxコンテナvboxをウィンドウの子として設定しています。

実行

コードを保存し、再びcargo runを実行してみましょう。

bash
cargo run

今度は、ウィンドウの中に「Hello, GTK!」というラベルと、「Click Me!」というボタンが垂直に並んで表示されるはずです。

この例では、LabelとButton、そしてコンテナとしてBoxを使いました。他にも、テキスト入力用のEntry、チェックボックスのCheckButton、ラジオボタンのRadioButton、スライダーのScaleなど、様々なウィジェットが用意されています。

また、レイアウトのためのコンテナウィジェットとして、Gridもよく使われます。Gridを使うと、ウィジェットを行と列を指定して配置できます。

例えば、簡単なグリッドレイアウトを作成する場合：

“`rust
// … 既存のuseとmain関数内のapplication作成部分は省略 …

app.connect_activate(|app| {
let button1 = Button::with_label(“Button 1”);
let button2 = Button::with_label(“Button 2”);
let button3 = Button::with_label(“Button 3”);
let button4 = Button::with_label(“Button 4”);

// Gridコンテナを作成
let grid = gtk::Grid::builder()
    .row_spacing(6)    // 行間のスペース
    .column_spacing(6) // 列間のスペース
    .build();

// Gridにウィジェットを配置 (ウィジェット, 左からの位置(列), 上からの位置(行), 幅(列数), 高さ(行数))
grid.attach(&button1, 0, 0, 1, 1); // (0, 0) にButton 1 (1x1マス)
grid.attach(&button2, 1, 0, 1, 1); // (1, 0) にButton 2 (1x1マス)
grid.attach(&button3, 0, 1, 2, 1); // (0, 1) にButton 3 (2x1マス)
// button4は配置しない例

let window = ApplicationWindow::builder()
    .application(app)
    .title("Grid Example")
    .child(&grid) // ウィンドウの子ウィジェットとしてGridコンテナを設定
    .build();

window.present();

});

app.run() // … 以下省略 …
“`

Grid::attach()メソッドを使って、ウィジェットをグリッドの指定した位置に、指定したマス数だけ占めるように配置します。

このように、コンテナウィジェットを使ってウィジェットを階層的に配置していくことで、複雑なUI構造を構築できます。

6. シグナルとイベントハンドリング

UIアプリケーションは、ユーザーの操作に応答して動的な振る舞いをすることが求められます。GTKでは、ユーザーの操作（ボタンクリック、テキスト入力など）やシステムイベント（ウィンドウのリサイズなど）によって「シグナル」が発行されます。私たちは、これらのシグナルに対応するハンドラ関数やクロージャを接続（connect）することで、イベントに応じた処理を記述します。

先ほどの例のボタンをクリックしたときに、ラベルのテキストが変化するようにしてみましょう。

まず、ボタンの "clicked" シグナルにハンドラを接続します。

src/main.rsファイルを以下のように修正します。

“`rust
use gio::Application;
use gtk::prelude::*;
use gtk::{ApplicationWindow, Button, Label, Box as GtkBox, Orientation};
use std::cell::RefCell; // Mutably borrow from an immutable context
use std::rc::Rc; // Multiple ownership

fn main() -> glib::ExitCode {
let app = Application::builder()
.application_id(“com.example.my_gtk_app”)
.flags(gio::ApplicationFlags::empty())
.build();

app.connect_activate(|app| {
    let label = Label::new(Some("Hello, GTK!"));
    let button = Button::with_label("Click Me!");

    // ラベルオブジェクトを複数のクロージャ（この場合はボタンのクリックハンドラ）から
    // 参照・変更できるように、RcとRefCellでラップします。
    let label_clone = Rc::new(RefCell::new(label));

    button.connect_clicked(move |_| { // ボタンがクリックされたときのハンドラ
        // RcとRefCellを使ってラベルオブジェクトへの可変参照を取得し、テキストを変更します。
        let label_ref = label_clone.borrow_mut();
        label_ref.set_text("Button was clicked!");
    });

    let vbox = GtkBox::builder()
        .orientation(Orientation::Vertical)
        .spacing(12)
        .build();

    // ラベルは一度Boxに追加されると、Boxがその所有権を持つようになります。
    // そのため、後でボタンのクロージャから参照するために、
    // ここではclone_cloneを使って取得したRc<RefCell<Label>>の内部にある
    // ラベルウィジェットの参照をappendに渡します。
    // GTKウィジェットは通常Cloneトレイトを実装しており、これは参照カウントをインクリメントするクローンです。
    vbox.append(&label_clone.borrow().clone()); // ラベルの参照のクローンをappendに渡す
    vbox.append(&button);

    let window = ApplicationWindow::builder()
        .application(app)
        .title("Signal Handling Example")
        .default_width(300)
        .default_height(150)
        .child(&vbox)
        .build();

    window.present();
});

app.run()

}
“`

コードの解説

  • 追加のインポート:
    rust
    use std::cell::RefCell;
    use std::rc::Rc;
    Rustの所有権システムとGTKのシグナルハンドリングの仕組みを組み合わせる際に必要になるstd::rc::Rcとstd::cell::RefCellをインポートしています。これらについては後述します。

  • ボタンシグナルへの接続:
    rust
    button.connect_clicked(move |_| { ... });
    buttonウィジェットの"clicked"シグナルにクロージャを接続しています。ボタンがクリックされると、このクロージャが実行されます。
    クロージャの引数の _ は、シグナルハンドラに渡される引数ですが、ここでは使用しないため _ としています（このシグナルでは、シグナルを発行したボタンウィジェット自身が引数として渡されます）。

  • move キーワード:
    クロージャの前に付けられた move キーワードは、クロージャがその外部スコープから参照している変数（この例では label_clone）の所有権をクロージャ自身に移すことを意味します。シグナルハンドラとして渡されるクロージャは、イベントループによって後で非同期的に実行される可能性があるため、必要な値（この場合はラベルへの参照）がその時点でも有効であることを保証するために move がよく使われます。

  • クロージャ内でのウィジェット状態の変更（Rc と RefCell）:
    ボタンがクリックされたときにラベルのテキストを変更したいのですが、ここで問題が発生します。

    1. labelウィジェットはローカル変数として作成されていますが、ボタンのクリックハンドラクロージャから参照する必要があります。クロージャは通常、環境から値を借用しますが、シグナルハンドラとして登録されるクロージャは、その寿命が関数のスコープを超えるため、単純な借用ではライフタイムの問題が発生します。moveを使うことで所有権をクロージャに移すことができますが、ラベルを所有しているのはクロージャだけになり、他の場所（例えばBoxコンテナ）からは参照できなくなります。
    2. GTKウィジェットは通常、イミュータブルな参照（&Widget）を通じて操作されます。しかし、テキストを変更するにはミュータブルな参照（&mut Label）が必要です。シグナルハンドラクロージャはGTKの内部コードから呼び出されるため、通常はウィジェットへのイミュータブルな参照しか受け取れません。また、複数の場所から同じウィジェットに対して同時にミュータブルな操作を行おうとするとデータ競合のリスクがあります。

    これらの問題を解決するために、RustではRcとRefCellという型がよく使われます。
    * Rc<T> (Reference Counting): 同じデータに対する複数の所有者を持つことを可能にします。クローンを作成するたびに参照カウントが増加し、Rcの最後のクローンがドロップされたときに内包するデータが解放されます。これにより、複数のクロージャやデータ構造から同じウィジェットオブジェクトを共有できます。
    * RefCell<T>: 実行時に借用規則をチェックし、イミュータブルな参照からミュータブルな内部状態へのアクセス（内部可変性）を可能にします。コンパイル時には借用規則をパスするコードでも、実行時に複数のミュータブルな参照を取得しようとするとパニックします。

    この例では、let label_clone = Rc::new(RefCell::new(label)); のように、LabelウィジェットをRefCellでラップし、さらにそれをRcでラップしています。
    * RefCell::new(label): ラベルをRefCellの中に置くことで、後でイミュータブルなRc参照からラベルへのミュータブルなアクセス (borrow_mut()) が可能になります。
    * Rc::new(...): RefCell<Label>をRcの中に置くことで、複数の場所（ここではボタンのクリックハンドラクロージャと、Boxコンテナへの追加）から同じRcインスタンス（の実質的なクローン）を持つことができます。

    ボタンのクリックハンドラ内では、label_clone.borrow_mut() を呼び出してRefCellからラベルへの可変参照を取得し、その参照に対してset_text()メソッドを呼び出しています。

  • コンテナへのウィジェット追加と所有権:
    rust
    vbox.append(&label_clone.borrow().clone());
    vbox.append(&button);
    append()メソッドは、ウィジェットへの参照を受け取ります。しかし、ウィジェットをコンテナに追加すると、通常はそのコンテナがウィジェットの所有権を持つことになります。
    私たちの例では、labelウィジェットの所有権は、Rc<RefCell<Label>>インスタンスである label_clone にラップされています。vbox.append(&label) のように直接参照を渡すと、vboxがlabelの所有権を要求しますが、labelはすでにRcによって所有されているためエラーになります。
    GTKウィジェットのRustバインディングでは、多くのウィジェット型がCloneトレイトを実装しており、このclone()メソッドはウィジェットオブジェクト自体の参照カウントを増やす操作を行います（内部的にはGObjectの参照カウントを操作しています）。したがって、label_clone.borrow().clone() は、RcやRefCellの外にある、GTK側のLabelオブジェクトへの新しい参照を作成し、その参照をappend()に渡します。これにより、vboxはこの新しい参照の所有権を持つことができます。

    ボタン (button) は他の場所で参照する必要がないため、そのままappend(&button)で渡しています。buttonの所有権はvboxに移ります。

このパターン（Rc<RefCell<WidgetType>>）は、複数のシグナルハンドラやアプリケーション内の異なる部分から、同じウィジェットの状態を参照したり変更したりする必要がある場合に非常に一般的です。

実行

コードを保存し、cargo runを実行します。

bash
cargo run

ウィンドウが表示され、「Hello, GTK!」というラベルと「Click Me!」ボタンが表示されます。「Click Me!」ボタンをクリックすると、ラベルのテキストが「Button was clicked!」に変化するはずです。

これで、ユーザーのアクションにアプリケーションが応答できるようになりました。

7. UIデザインと.uiファイル (GtkBuilder)

コード内でウィジェットを作成し、レイアウトコンテナに追加していく方法は、単純なUIには適していますが、UIが複雑になるにつれてコードが長くなり、UIの構造を把握しづらくなります。また、UIの見た目を少し変えるだけでもコードを修正・コンパイルし直す必要があり、デザインの試行錯誤が難しくなります。

この問題を解決するために、GTKにはGtkBuilderという仕組みがあり、UIの構造とプロパティをXML形式の.uiファイルに記述できます。そして、アプリケーションコードからこの.uiファイルを読み込み、そこに記述されたウィジェットのインスタンスを生成して利用します。

GtkBuilderを利用することで、UIのデザインとアプリケーションのロジックを分離できます。さらに、GNOME BuilderやGladeといったGUIデザイナツールを使えば、コードを書かずにビジュアルにUIを設計することも可能です。

ここでは、簡単なUIを.uiファイルで定義し、Rustコードから読み込んで表示してみましょう。

.uiファイルの作成

プロジェクトのルートディレクトリにuiという新しいディレクトリを作成し、その中にapp_window.uiというファイルを作成します。

my_gtk_app/
├── Cargo.toml
├── src/
│ └── main.rs
└── ui/
└── app_window.ui

ui/app_window.uiファイルに以下の内容を記述します。

“`xml




UI File Example 400 200
vertical 12 12 12 12 12
Initial text


Change Label


“`

このXMLファイルは、以下のUI構造を定義しています。

  • ルート要素は<interface>です。
  • <requires>タグで、必要なライブラリとバージョン（ここではGTK 4.0）を指定します。
  • <object>タグでウィジェットのインスタンスを定義します。
    • class属性でウィジェットの型名（例: GtkApplicationWindow, GtkBox, GtkLabel, GtkButton）を指定します。
    • id属性で、コードからこのウィジェットを参照するためのユニークなIDを指定します。これは非常に重要です。
    • <property>タグでウィジェットのプロパティ（例: title, default-width, orientation, label）を設定します。プロパティ名はGTKのドキュメントを参照してください。ハイフン区切り（default-width）で記述します。
    • <child>タグで、コンテナウィジェットの中に子ウィジェットを配置します。

この.uiファイルは、前のセクションでコードで作成したUI（ウィンドウ、垂直Box、ラベル、ボタン）とほぼ同じ構造を定義しています。各ウィジェットにid属性（app_window, main_box, my_label, my_button）が付与されている点に注目してください。これらのIDをコードから使用します。

Rustコードからの.uiファイルの読み込み

次に、Rustコードを修正して、この.uiファイルを読み込み、ウィジェットにアクセスするようにします。

src/main.rsを以下のように変更します。

“`rust
use gio::Application;
use gtk::prelude::*; // WidgetExt, ButtonExt, LabelExtなどが含まれる
use gtk::{ApplicationWindow, Builder}; // GtkBuilderの代わりにBuilderを使う

fn main() -> glib::ExitCode {
let app = Application::builder()
.application_id(“com.example.my_gtk_app”)
.flags(gio::ApplicationFlags::empty())
.build();

app.connect_activate(|app| {
    // 1. Builderオブジェクトを作成し、UIファイルを読み込みます。
    //    unwrap() はエラーが発生した場合にパニックさせますが、
    //    実際のアプリケーションではエラーハンドリングが必要です。
    let builder = Builder::from_file("ui/app_window.ui");

    // 2. BuilderからIDを使ってウィジェットを取得します。
    //    get_object::<WidgetType>("widget_id") を使います。
    //    Option<T> を返すので、unwrap() または適切なエラーハンドリングが必要です。
    let window: ApplicationWindow = builder
        .object("app_window")
        .expect("Could not get window");
    let button: gtk::Button = builder
        .object("my_button")
        .expect("Could not get button");
    let label: gtk::Label = builder
        .object("my_label")
        .expect("Could not get label");

    // 3. ウィジェットに対するシグナルハンドラを設定します。
    //    ここではRc/RefCellは不要です。シグナルハンドラに渡されるボタンウィジェット自身から、
    //    Builder経由で取得したラベルウィジェットへの参照をキャプチャできます。
    //    ただし、ラベル自体はBuilderから取得したOption<Label>をunwrap()して得た所有権を持つので、
    //    シグナルハンドラで変更するには、ここでも Rc<RefCell<Label>> を使うか、
    //    またはラベルウィジェット自体をBuilderから取得したものを直接渡すかします。
    //    ここでは、最も一般的なパターンとして、必要なウィジェットを事前に取得し、
    //    それらをクロージャ内で利用する方法を示します。
    //    ラベルの状態をクロージャ内で変更するため、Rc<RefCell<Label>> を使用します。
    let label_clone = std::rc::Rc::new(std::cell::RefCell::new(label));

    button.connect_clicked(move |_| {
        let mut label_ref = label_clone.borrow_mut();
        label_ref.set_text("Label changed by button!");
    });

    // 4. ウィンドウをアプリケーションに紐付けます。
    //    .uiファイルでApplicationWindowを定義した場合、通常Builderから取得した後に
    //    これを手動で行う必要があります。
    window.set_application(Some(app));

    // 5. ウィンドウを表示します。
    window.present();
});

app.run()

}
“`

コードの解説

  • 追加・変更されたインポート:
    rust
    use gtk::{ApplicationWindow, Builder}; // GtkBuilderの代わりにBuilderを使う
    GTKバインディングでは、GtkBuilderの機能を提供する型はgtk::Builderという名前で提供されています。

  • Builder::from_file():
    rust
    let builder = Builder::from_file("ui/app_window.ui");
    .uiファイルを指定してBuilderインスタンスを作成します。この時点で、.uiファイルに記述されたウィジェットがメモリ上に生成されます（ただし、まだウィンドウには配置されていません）。ファイルが見つからない、あるいはXMLの記述が不正な場合はエラーが発生します。

  • builder.object::<WidgetType>("widget_id"):
    rust
    let window: ApplicationWindow = builder.object("app_window").expect("...");
    let button: gtk::Button = builder.object("my_button").expect("...");
    let label: gtk::Label = builder.object("my_label").expect("...");
    builder.object()メソッドを使って、.uiファイルで指定したID ("app_window", "my_button", "my_label") に対応するウィジェットのインスタンスを取得します。
    このメソッドはOption<glib::Object>を返すため、取得したいウィジェットの具体的な型にキャストする必要があります (::<WidgetType>)。また、ウィジェットが見つからなかったり、型が一致しない場合にNoneを返すため、expect()や他のエラーハンドリングでOptionを処理する必要があります。

  • シグナルハンドラ:
    rust
    let label_clone = std::rc::Rc::new(std::cell::RefCell::new(label));
    button.connect_clicked(move |_| {
    let mut label_ref = label_clone.borrow_mut();
    label_ref.set_text("Label changed by button!");
    });
    ここでは、Builderから取得したbuttonとlabelウィジェットに対して、前と同じようにシグナルハンドラを設定しています。labelウィジェットの状態をクロージャ内で変更するために、ここでもRc<RefCell<Label>>パターンを使用しています。これは、Builderから取得したウィジェットも他のRustオブジェクトと同様に扱えることを示しています。

  • ウィンドウとアプリケーションの紐付け:
    rust
    window.set_application(Some(app));
    .uiファイルでGtkApplicationWindowを定義した場合、Builderから取得した後に、どのgio::Applicationに属するかを手動で設定する必要があります。これは、ApplicationWindow::builder().application(app) をコードで行う操作に相当します。

  • ウィンドウの表示:
    rust
    window.present();
    Builderから取得したウィンドウオブジェクトを表示します。.uiファイル内で<property name="visible">true</property>のように設定することも可能ですが、通常はコードで明示的に表示します。

実行

.uiファイルとRustコードを保存し、cargo runを実行します。

bash
cargo run

今度は、.uiファイルで定義されたUIが表示されるはずです。ボタンをクリックすると、ラベルのテキストが変化します。

まとめ：UIファイルとコードの役割分担

GtkBuilderと.uiファイルを使うことで、UIのデザイン（ウィジェットの種類、プロパティ、レイアウト）とアプリケーションのロジック（イベント処理、データの表示・更新）を明確に分離できます。

  • .uiファイル: UIの外観と構造を静的に定義します。
  • Rustコード:
    • アプリケーション全体（gio::Application）を管理します。
    • .uiファイルを読み込み、ウィジェットインスタンスを取得します。
    • 取得したウィジェットに対して、シグナルハンドラを設定し、イベントに応じた処理を記述します。
    • ウィジェットのプロパティを動的に変更したり、状態を管理したりします。

この分離により、UIデザイナとプログラマーが並行して作業しやすくなり、保守性も向上します。複雑なUIを持つアプリケーションでは、.uiファイルを積極的に活用することをお勧めします。

8. より複雑なUI要素とパターン

ここまでは基本的なウィジェットとレイアウト、イベント処理を見てきました。実際のアプリケーション開発では、より多様なウィジェットや高度なパターンが必要になります。

よく使うウィジェットとコンテナ

  • 入力: Entry (一行テキスト), TextView (複数行テキスト), SpinButton (数値入力)
  • 選択: CheckButton, RadioButton, ComboBoxText (ドロップダウンリスト), ListBox (シンプルリスト), ListView / ColumnView (高機能リスト/テーブル)
  • 表示: Image (画像), ProgressBar (進捗バー), revealer (表示/非表示アニメーション付きコンテナ)
  • レイアウト: Stack (複数のページを重ねて表示), Paned (サイズ変更可能な分割), ScrolledWindow (スクロール可能領域)
  • ダイアログ: MessageDialog, FileChooserDialog, AboutDialog など。これらは通常、コードから生成して表示します。
  • メニュー: MenuButton, Popoverなどを組み合わせて作成します。

データ表示のためのリスト/テーブル (ListView, ColumnView)

多くのアプリケーションで、データのリストやテーブルを表示する機能が必要です。GTK 4では、ListViewやColumnViewといった新しいウィジェットが推奨されています。これらは、表示するデータの「モデル」と、各データの表示方法を定義する「ファクトリー」を組み合わせて使用します。

  • モデル: 表示するデータの集合です。gio::ListStoreなどの型が使われます。
  • ファクトリー: 各データの項目をどのようなウィジェットとして表示するかを定義します。gtk::SignalListItemFactoryなどが使われます。

例：文字列のリストを表示するListView (概念的な説明に留めます)

“`rust
use gio::Application;
use gtk::prelude::*;
use gtk::{ApplicationWindow, ListView};
use gio::ListStore; // データのモデル

fn main() -> glib::ExitCode {
let app = Application::builder()
.application_id(“com.example.list_app”)
.flags(gio::ApplicationFlags::empty())
.build();

app.connect_activate(|app| {
    // データモデルを作成
    let model = ListStore::new::<glib::GString>(); // 文字列のリストを保持するモデル

    // モデルにデータを追加
    model.append(&"Item 1".into());
    model.append(&"Item 2".into());
    model.append(&"Item 3".into());

    // 表示用のファクトリーを作成
    // データ項目（文字列）をどのように表示するか（ラベルとして表示）を定義
    let factory = gtk::SignalListItemFactory::new();
    factory.connect_setup(move |_, list_item| {
        // list_item は表示される各項目を表す
        // ここで表示用のウィジェットを作成・設定する
        let label = gtk::Label::new(None);
        list_item.set_child(Some(&label));
    });
    factory.connect_bind(move |_, list_item| {
        // list_item にデータが割り当てられたときに、ウィジェットにデータをバインドする
        let item = list_item.item().unwrap(); // モデルからデータ項目を取得
        let text = item.downcast_ref::<glib::GString>().unwrap(); // GStringにダウンキャスト
        let label = list_item.child().unwrap().downcast_ref::<gtk::Label>().unwrap(); // ラベルウィジェットを取得
        label.set_text(text); // ラベルにテキストを設定
    });


    // ListViewを作成し、モデルとファクトリーを設定
    let list_view = ListView::new(Some(&model), Some(&factory));

    // スクロール可能にするためにScrolledWindowに入れることが多い
    let scrolled_window = gtk::ScrolledWindow::builder()
        .child(&list_view)
        .has_frame(true)
        .build();

    // ウィンドウに配置
    let window = ApplicationWindow::builder()
        .application(app)
        .title("List View Example")
        .default_width(300)
        .default_height(300)
        .child(&scrolled_window)
        .build();

    window.present();
});

app.run()

}
``
この例は簡略化されていますが、ListView`はデータと表示ロジックを分離し、大量のデータを効率的に表示するのに適しています。

ダイアログ

ファイル選択ダイアログやメッセージダイアログは、ユーザーからの追加入力や情報の表示に使われます。これらは通常、特定のイベント（メニュー項目の選択、ボタンクリックなど）に応じてコードから動的に生成され、モーダルとして表示されます。

例：ボタンクリックでメッセージダイアログを表示 (概念的な説明に留めます)

“`rust
// … 既存のuseとmain関数内のapplication作成部分は省略 …
use gtk::{MessageDialog, DialogFlags, MessageType, ButtonsType};

app.connect_activate(|app| {
let button = gtk::Button::with_label(“Show Dialog”);
let window = ApplicationWindow::builder()
.application(app)
.title(“Dialog Example”)
.child(&button)
.build();

let window_clone = window.clone(); // ダイアログの親としてウィンドウへの参照が必要なためクローン

button.connect_clicked(move |_| {
    // メッセージダイアログを作成
    let dialog = MessageDialog::new(
        Some(&window_clone), // 親ウィンドウ (モーダルにするため)
        DialogFlags::MODAL,  // モーダルダイアログ
        MessageType::Info,   // アイコンタイプ (情報)
        ButtonsType::Ok,     // ボタンタイプ (OKボタン)
        "Hello from Dialog!" // メッセージ本文
    );

    // ダイアログを表示し、ユーザーのアクション（ボタンクリック）を待つ
    dialog.run();

    // ダイアログを破棄
    dialog.close(); // run()の後に呼ばれる
});

window.present();

});

app.run() // … 以下省略 …
``
ダイアログクラスのコンストラクタやメソッドを使って設定を行い、run()メソッドで表示します。run()`はダイアログが閉じられるまでブロックします（これはUIスレッドをブロックすることになるため、非同期で扱う方法もあります）。ダイアログが閉じられた後に、その結果（どのボタンが押されたかなど）を処理し、ダイアログオブジェクトを破棄します。

9. データ管理とスレッド

GTKのようなGUIツールキットは、通常「シングルスレッド」モデルで動作します。つまり、UIの描画やイベント処理はすべて「UIスレッド」と呼ばれる一つの特定のスレッドで行われます。

時間がかかる処理（ファイルI/O、ネットワーク通信、複雑な計算など）をUIスレッドで直接実行すると、UIがフリーズしてユーザー操作に反応しなくなってしまいます（「UIが固まる」状態）。これを避けるためには、時間のかかる処理をバックグラウンドの別スレッドで行う必要があります。

しかし、GTKウィジェットへのアクセスや変更はUIスレッドからしか安全に行えません。バックグラウンドスレッドから直接UIウィジェットを操作しようとすると、クラッシュや予期しない振る舞いを引き起こす可能性があります。

非同期処理とUI更新

Rustとgtk-rsでは、GLibの非同期機能を活用して、UIスレッドをブロックせずにバックグラウンド処理を行い、その結果をUIに反映させることができます。これは、glib::spawn_future や gio::spawn_future といった関数と、Rustのasync/await構文を組み合わせることで実現されます。

基本的な考え方は以下の通りです。

  1. UIスレッドのイベントハンドラ内で、時間のかかる処理を非同期タスクとしてスポーン（開始）します。
  2. この非同期タスクは、必要に応じてバックグラウンドスレッドプールなどで実行されます（GLibの非同期ランタイムが管理します）。
  3. 非同期タスクは、実行中にUIの状態を参照する必要がある場合（例: どのファイルを読み込むか）、gio::ApplicationなどのUIスレッドで安全にアクセスできるオブジェクトを通じて行います。UIウィジェット自体へのアクセスは避けます。
  4. 非同期タスクが完了し、UIを更新する必要がある場合、UIスレッドに処理を戻す必要があります。glib::idle_add_localやglib::timeout_add_local、あるいはチャネルなどのIPC機構を使って、UIスレッドにメッセージを送信し、UIスレッド上でUI更新コードを実行させます。gtk-rsの非同期関数 (glib::spawn_futureなど) を使うと、完了時にUIスレッドで実行されるように自動的にスケジュールしてくれることが多いです。

例：非同期処理でラベルを更新 (概念的な説明に留めます)

“`rust
use gio::Application;
use gtk::prelude::*;
use gtk::{ApplicationWindow, Button, Label, Box as GtkBox, Orientation};
use std::cell::RefCell;
use std::rc::Rc;
use futures::FutureExt; // .boxed_local() のために必要

fn main() -> glib::ExitCode {
let app = Application::builder()
.application_id(“com.example.async_app”)
.flags(gio::ApplicationFlags::empty())
.build();

app.connect_activate(|app| {
    let label = Label::new(Some("Waiting..."));
    let button = Button::with_label("Start Task");

    let label_clone = Rc::new(RefCell::new(label));

    let label_clone_for_button = label_clone.clone(); // ボタンのクロージャ用

    button.connect_clicked(move |_| {
        println!("Task started!");

        // UIを更新するためのラベルへの参照をキャプチャ
        let label_clone_for_async = label_clone_for_button.clone();

        // 非同期タスクをスポーン
        glib::spawn_future_local(async move {
            // 時間のかかるダミー処理 (ここでは単純に待機)
            // async block 内では .await を使える
            glib::timeout_future(std::time::Duration::from_secs(3)).await;

            // バックグラウンド処理の結果をUIに反映
            // glib::spawn_future_local は UIスレッドで完了ハンドラを実行するため安全
            let mut label_ref = label_clone_for_async.borrow_mut();
            label_ref.set_text("Task finished!");
            println!("Label updated!");
        }.boxed_local()); // GIO/GLibのexecutorで実行するために必要
    });

    let vbox = GtkBox::builder()
        .orientation(Orientation::Vertical)
        .spacing(12)
        .build();

    vbox.append(&label_clone.borrow().clone());
    vbox.append(&button);

    let window = ApplicationWindow::builder()
        .application(app)
        .title("Async Example")
        .default_width(300)
        .default_height(150)
        .child(&vbox)
        .build();

    window.present();
});

app.run()

}
``
この例では、ボタンをクリックすると3秒間待機した後、ラベルのテキストを変更します。待機中はUIがフリーズせず、ウィンドウを動かしたり閉じたりできます。glib::spawn_future_local`は、非同期タスクを指定されたGlibメインループ（この場合はUIスレッドのメインループ）で実行するようにスケジュールします。完了時にUIを更新するコードは、UIスレッド上で実行されるため安全です。

非同期処理とスレッドはGUI開発において非常に重要なトピックですが、概念がやや複雑です。詳細については、gtk-rsのドキュメントやRustの非同期プログラミングに関する資料を参照してください。

10. ビルドと配布

アプリケーションが完成したら、ビルドして他のユーザーに配布したいと考えるでしょう。

リリースビルド

開発中はデバッグビルド（cargo buildまたはcargo run）を使用しますが、配布する際には最適化されたリリースビルドを作成します。

bash
cargo build --release

これにより、実行可能ファイルがtarget/release/ディレクトリに生成されます。リリースビルドは最適化が施されるため、ビルドに時間がかかりますが、実行速度はデバッグビルドよりも格段に速くなります。

配布

Rustでビルドした実行可能ファイルは、基本的に静的にリンクされていない限り、依存するライブラリ（GTK本体とその依存関係）が必要です。GTKアプリケーションの配布方法はOSによって異なります。

  • Linux: 最も一般的な方法はFlatpakです。Flatpakはアプリケーションとその依存関係をバンドルし、様々なLinuxディストリビューションで一貫して実行できるようにします。
  • Windows: MSYS2環境でビルドした場合、生成された実行可能ファイルはMSYS2のDLLに依存します。これらのDLLを実行可能ファイルと一緒に配布する必要があります。インストーラー（Inno Setupなど）を作成して、依存DLLを含めるのが一般的です。あるいは、vcpkgを使ってビルドし、よりネイティブなWindows環境で配布する方法もあります。
  • macOS: .appバンドルとして配布します。GTKとその依存関係をバンドル内に含める必要があります。HomebrewでインストールしたGTKを使用した場合、Homebrewのライブラリを参照することになるため、配布用に別途依存関係を収集・バンドルする必要があります。

クロスコンパイル（あるOSで別のOS向けの実行可能ファイルをビルドすること）は可能ですが、GTKのようなシステムライブラリに依存するアプリケーションの場合、ターゲットOS向けのGTK開発ライブラリを用意する必要があるため、設定が複雑になることがあります。

配布に関する詳細な手順は、アプリケーションの性質やターゲットプラットフォームによって大きく異なるため、ここでは概要に留めます。gtk-rsのドキュメントや各プラットフォームのアプリケーション配布に関する資料を参照してください。

11. さらに学ぶために

この記事では、RustとGTKを使ったデスクトップアプリケーション開発の基礎の基礎を解説しました。GTKには他にも多くのウィジェット、レイアウトコンテナ、ユーティリティ機能があります。より高度なトピックとしては、カスタムウィジェットの作成、CSSを使ったスタイリング、ドラッグ＆ドロップ、アクセシビリティ対応、国際化などがあります。

さらに学習を進めるためには、以下のリソースが役立ちます。

  • gtk-rs 公式ドキュメント: https://gtk-rs.org/ – Rustバインディングの最新情報、チュートリアル、APIリファレンスが揃っています。特に「Book」セクションは、より詳細なトピックを学ぶのに最適です。
  • gtk-rs Examples: https://github.com/gtk-rs/examples – 様々なGTKウィジェットや機能の使用方法を示す豊富なサンプルコード集です。特定の機能を実装したい場合に参考にすると良いでしょう。
  • GTK 公式ドキュメント: https://docs.gtk.org/ – GTKライブラリ本体の公式ドキュメントです。RustバインディングはこのCライブラリの上に構築されているため、GTK自体の概念やウィジェットのプロパティ、シグナルなどを深く理解するのに役立ちます。ただし、C言語のAPIとして記述されているため、Rustでの対応するAPIを探す必要があります。
  • The Rust Programming Language Book: https://doc.rust-lang.org/book/ – Rustの基本的な文法や概念を体系的に学びたい場合に必読です。特に所有権、借用、ライフタイム、トレイト、エラーハンドリング、並行処理の章は、GTK開発に限らずRustプログラミング全般で非常に重要です。
  • コミュニティ: gtk-rsのMatrixチャネルやRustの公式Discord/Usersフォーラムなどで質問したり、他の開発者と交流したりできます。

他のRust GUIツールキット

RustにはGTK以外にも、いくつかGUIツールキットの選択肢があります。それぞれに特徴があります。

  • iced: 関数型リアクティブプログラミングに影響を受けた、モダンでクロスプラットフォームなGUIライブラリです。学習コストはやや高いですが、Declarative UIスタイルで記述できます。
  • druid: Xilemプロジェクトの前身となった、シンプルでデータ指向のGUIライブラリです。
  • egui: 主にゲームやツール向けのイミディエイトモードGUIライブラリです。シンプルで組み込みやすいのが特徴です。
  • tauri / electron-rs: Web技術 (HTML, CSS, JavaScript/TypeScript) を使ってUIを構築し、Rustでバックエンドロジックを書くフレームワークです。Web開発の経験がある場合に選択肢となります。

GTKは、Linuxデスクトップ環境との親和性が高く、成熟しており機能が豊富です。既存のGTKアプリケーションとの連携が必要な場合や、ネイティブなルック＆フィールを重視する場合に適しています。

12. まとめ

この記事では、RustとGTKを使ってデスクトップアプリケーション開発を始めるための基本的なステップを詳細に解説しました。

  1. RustとCargoをインストールし、プロジェクトを作成しました。
  2. OSに応じてGTK本体をインストールし、gtk-rsクレートをCargoプロジェクトに追加しました。
  3. 最小限のコードで空のウィンドウを表示し、gio::Application、gtk::ApplicationWindow、シグナルハンドリングの基本を学びました。
  4. gtk::Labelやgtk::Buttonといった基本的なウィジェットを作成し、gtk::Boxコンテナを使ってウィンドウ内に配置しました。
  5. ボタンの"clicked"シグナルにハンドラを設定し、Rc<RefCell<T>>パターンを使って、複数の場所からウィジェットの状態を安全に変更する方法を学びました。
  6. GtkBuilderと.uiファイルを使ってUIデザインを記述し、Rustコードからそれを読み込んでウィジェットにアクセスする方法を学び、UIとロジックの分離の重要性を理解しました。
  7. リスト表示、ダイアログ、非同期処理といった、より高度なGUI開発のための概念にも触れました。
  8. ビルドと配布、そしてさらなる学習のためのリソースを紹介しました。

Rustの安全性とパフォーマンス、GTKの成熟した機能とクロスプラットフォーム対応は、デスクトップアプリケーション開発において非常に強力な組み合わせです。この記事が、皆さんがRustとGTKを使ったGUIプログラミングの旅を始めるための一助となれば幸いです。

最初から複雑なアプリケーションを開発しようとせず、小さなウィジェットを試したり、サンプルコードを動かしたりしながら、一歩ずつ慣れていくことをお勧めします。Rustの概念（特に所有権システム）とGTKのオブジェクトシステムやシグナル/プロパティシステムは最初は少し難しく感じるかもしれませんが、慣れるほどにその強力さを実感できるでしょう。

さあ、学んだことを活かして、自分だけの素晴らしいデスクトップアプリケーションを開発しましょう！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール