Jump to content

# GTK/Development

1 language

- 日本語

From ArchWiki
< GTK

## Write a simple message dialog app

You can write your own GTK message dialog easily in many programming languages through GObject-Introspection or bindings, or you can simply use bash.

The following examples display a simple "Hello world" in a message dialog.

### Ada

- Dependency: gtkadaAUR
- Makedependency: gcc-ada
- Build with: `gnatmake hello_world `gtkada-config``

    hello_world.adb

    with Gtk.Main;
    with Gtk.Dialog;           use Gtk.Dialog;
    with Gtk.Message_Dialog;   use Gtk.Message_Dialog;

    procedure hello_world is
      Dialog   : Gtk_Message_Dialog;
      Response : Gtk_Response_Type;
    begin
      Gtk.Main.Init;
      Gtk_New (Dialog   => Dialog,
               Parent   => null,
               Flags    => 0,
               The_Type => Message_Info,
               Buttons  => Buttons_OK,
               Message  => "Hello world!");
      Format_Secondary_Markup (Dialog, "This is an example dialog.");
      Response := Run (Dialog);
    end hello_world;

### Bash

- Dependency: zenity

    hello_world.sh

    #!/bin/bash
    zenity --info --title='Hello world!' --text='This is an example dialog.'

### BASIC

- Dependency: gtk3
- Makedependency: freebasic-gnomeheadersAUR[broken link: package not found]
- Build with: `fbc hello_world.bas`

    hello_world.bas

    #include "Gir/Gtk-3.0.bi"
    Dim As GtkWidget Ptr hello
    gtk_init (cast(gint ptr, @__fb_argc__), @__fb_argv__)
    hello = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Hello world!")
    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (hello), "This is an example dialog.")
    gtk_dialog_run (GTK_DIALOG (hello))

### Boo

- Dependency: gtk-sharp-3 (and booAUR[broken link: package not found])
- Makedependency: booAUR[broken link: package not found]
- Build with: `booc hello_world.boo`
- Run with: `mono hello_world.exe` (or `booi hello_world.boo`)

    hello_world.boo

    import Gtk from "gtk-sharp"
    Application.Init()
    Hello = MessageDialog(null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!")
    Hello.SecondaryText = "This is an example dialog."
    Hello.Run()

### C

- Dependency: gtk4
- Build with: `gcc -o hello_world $(pkg-config --cflags --libs gtk4) hello_world.c`

    hello_world.c

    #include <gtk/gtk.h>

    static void activate (GtkApplication *app, gpointer user_data) {
      GtkWidget *dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Hello world!");
      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "This is an example dialog.");
      gtk_window_set_application (GTK_WINDOW (dialog), app);
      g_signal_connect (dialog, "response", G_CALLBACK (gtk_window_destroy), dialog);
      gtk_window_present (GTK_WINDOW (dialog));
    }

    int main (int argc, char **argv) {
      GtkApplication *app = gtk_application_new (NULL, G_APPLICATION_DEFAULT_FLAGS);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      return g_application_run (G_APPLICATION (app), argc, argv);
    }

- Dependency: gtk3
- Build with: `gcc -o hello_world $(pkg-config --cflags --libs gtk+-3.0) hello_world.c`

    hello_world.c

    #include <gtk/gtk.h>

    int main (int argc, char *argv[]) {
      gtk_init (&argc, &argv);
      GtkWidget *dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "dialog world!");
      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "This is an example dialog.");
      gtk_dialog_run(GTK_DIALOG (dialog));
      return 0;
    }

### C++

- Dependency: gtkmm-4.0
- Build with: `g++ -o hello_world $(pkg-config --cflags --libs gtkmm-4.0) hello_world.cc`

    hello_world.cc

    #include <gtkmm.h>

    class MyDialog : public Gtk::MessageDialog {
      public:
        MyDialog() : MessageDialog("Hello world!", false, Gtk::MessageType::INFO, Gtk::ButtonsType::OK, false) {
          set_secondary_text("This is an example dialog.");
          signal_response().connect(sigc::hide(sigc::mem_fun(*this, &Gtk::Window::destroy)));
        };
    };

    int main(int argc, char* argv[]) {
      auto app = Gtk::Application::create();
      return app->make_window_and_run<MyDialog>(argc, argv);
    }

- Dependency: gtkmm3
- Build with: `g++ -o hello_world $(pkg-config --cflags --libs gtkmm-3.0) hello_world.cc`

    hello_world.cc

    #include <gtkmm/main.h>
    #include <gtkmm/messagedialog.h>
    int main(int argc, char *argv[]) {
    	Gtk::Main kit(argc, argv);
    	Gtk::MessageDialog Hello("Hello world!", false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK);
    	Hello.set_secondary_text("This is an example dialog.");
    	Hello.run();
    	return 0;
    }

See also:

- gtkmm API Reference Manual
- Programming with gtkmm 4

### C#

#### .NET

- Dependencies: dotnet-runtime, gtk3
- Makedependency: dotnet-sdk
- Build with: `dotnet build`
- Run with: `bin/Debug/net7.0/HelloWorld` (or `dotnet run`)

    HelloWorld.csproj

    <Project Sdk="Microsoft.NET.Sdk">
      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net7.0</TargetFramework>
      </PropertyGroup>
      <ItemGroup>
        <PackageReference Include="GtkSharp" Version="3.24.24.38" />
      </ItemGroup>
    </Project>

    HelloWorld.cs

    using Gtk;
    public class HelloWorld {
    	static void Main() {
    		Application.Init ();
    		MessageDialog Hello = new MessageDialog (null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!");
    		Hello.SecondaryText="This is an example dialog.";
    		Hello.Run ();
    	}
    }

#### Mono

- Dependency: gtk-sharp-3
- Build with: `mcs -pkg:gtk-sharp-3.0 hello_world.cs`
- Run with: `mono hello_world.exe`

    hello_world.cs

    using Gtk;
    public class HelloWorld {
    	static void Main() {
    		Application.Init ();
    		MessageDialog Hello = new MessageDialog (null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!");
    		Hello.SecondaryText="This is an example dialog.";
    		Hello.Run ();
    	}
    }

### Clojure

- Dependencies: java-gnomeAUR, leiningen
- Run with: `lein run`

    project.clj

    (defproject hello-world "0.1.0-SNAPSHOT"
      :main hello-world.core
      :dependencies [[org.clojure/clojure "1.10.3"]]
      :resource-paths ["/usr/share/java/gtk.jar"])

    src/hello_world/core.clj

    (ns hello-world.core
      (:import [org.gnome.gtk Gtk InfoMessageDialog]))

    (defonce gtk-init (Gtk/init (make-array String 0)))

    (defn -main []
      (doto (InfoMessageDialog. nil "Hello world!" "This is an example dialog.").run))

### Crystal

- Dependency: gtk3
- Makedependencies: crystal, crystal-gobject
- Build with: `crystal build hello_world.cr`

    hello_world.cr

    require "gobject/gtk/autorun"

    dialog = Gtk::MessageDialog.new text: "Hello world!", message_type: :info, buttons: :ok, secondary_text: "This is an example dialog."
    dialog.on_response do
      Gtk.main_quit
    end
    dialog.show

### D

- Dependency: gtkd
- Makedependency: ldc
- Build with: `ldc hello_world $(pkg-config --cflags --libs gtkd-3)`

    hello_world.d

    import gtk.Main;
    import gtk.MessageDialog;

    void main(string[] args)
    {
    	Main.init(args);
    	MessageDialog dialog = new MessageDialog(null, GtkDialogFlags.MODAL, MessageType.INFO, ButtonsType.OK, "Hello world!");
    	dialog.run();
    }

### F#

- Dependency: dotnet-sdk
- Run with: `dotnet fsi hello_world.fsx`

    hello_world.fsx

    #r "nuget: GtkSharp"
    open Gtk

    let main () =
      Application.Init()
      let Hello = new MessageDialog(null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!")
      Hello.SecondaryText <- "This is an example dialog."
      Hello.Run() |> ignore

    main ()

### Fortran

- Dependency: gtk-3-fortran-gitAUR
- Makedependency: gcc-fortran
- Build with: `gfortran -o hello_world $(pkg-config --cflags --libs gtk-3-fortran) hello_world.f90`

    hello_world.f90

    program hello_world
      use gtk_hl
      use gtk, only: gtk_init

      integer(c_int) :: resp
      character(40), dimension(2) :: msg

      call gtk_init()
      msg(1) ="Hello world!"
      msg(2) = "This is an example dialog."
      resp = hl_gtk_message_dialog_show(msg, GTK_BUTTONS_OK, type=GTK_MESSAGE_INFO)
    end program hello_world

### Genie

- Dependency: gtk4
- Makedependency: vala
- Build with: `valac --pkg gtk4 hello_world.gs`

    hello_world.gs

    class Application
    	application: Gtk.Application
    	dialog: Gtk.MessageDialog

    	construct ()
    		application = new Gtk.Application (null, GLib.ApplicationFlags.FLAGS_NONE)
    		application.activate.connect (on_activate)
    		application.run ()

    	def on_activate ()
    		dialog = new Gtk.MessageDialog (null, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Hello world!")
    		dialog.application = application
    		dialog.format_secondary_text ("This is an example dialog.")
    		dialog.response.connect (on_response)
    		dialog.present ()

    	def on_response ()
    		dialog.destroy ()

    init
    	new Application

- Dependency: gtk3
- Makedependency: vala
- Build with: `valac --pkg gtk+-3.0 hello_world.gs`

    hello_world.gs

    init
    	Gtk.init (ref args)
    	var dialog = new Gtk.MessageDialog (null, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Hello world!")
    	dialog.format_secondary_text ("This is an example dialog.")
    	dialog.run ()

### Go

- Dependency: gtk3
- Makedependency: gotk3-gitAUR or `go get github.com/gotk3/gotk3/gtk`
- Build with: `go build hello_world.go`
- (Or run with: `go run hello_world.go`)

    hello_world.go

    package main
    import ("github.com/gotk3/gotk3/gtk")

    func main() {
    	gtk.Init(nil)
    	dialog := gtk.MessageDialogNew(nil, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Hello world!")
    	dialog.FormatSecondaryText("This is an example notification.")
    	dialog.Run()
    }

### Groovy

- Dependencies: groovy, java-gnomeAUR
- Build with: `groovyc -cp /usr/share/java/gtk.jar HelloWorld.groovy && jar cfe HelloWorld.jar HelloWorld HelloWorld.class`
- Run with: `java -cp /usr/share/groovy/embeddable/groovy-all.jar:/usr/share/java/gtk.jar:HelloWorld.jar HelloWorld` or `groovy -cp /usr/share/java/gtk.jar HelloWorld.groovy`

    HelloWorld.groovy

    import org.gnome.gtk.*
    Gtk.init()
    def Hello = new InfoMessageDialog(null, "Hello world!", "This is an example dialog.")
    Hello.run()

### Haskell

- Dependency: haskell-gi-gtk
- Makedependency: ghc
- Build with: `ghc -dynamic hello_world`

    hello_world.hs

    {-# LANGUAGE OverloadedStrings, OverloadedLabels, ImplicitParams #-}
    import Control.Monad (void)
    import qualified GI.Gtk as Gtk
    import Data.GI.Base

    activate app = do
      dialog <- new Gtk.MessageDialog [ #application := app,
                                        #buttons := Gtk.ButtonsTypeOk,
                                        #title := "Hello world!",
                                        #text := "This is an example dialog.",
                                        #messageType := Gtk.MessageTypeInfo ]
      on dialog #response $ \_ -> #destroy dialog
      #show dialog

    main = do
      app <- new Gtk.Application [On #activate (activate ?self)]
      #run app Nothing

- Dependency: haskell-gi-gtk3
- Makedependency: ghc
- Build with: `ghc -dynamic hello_world`

    hello_world.hs

    {-# LANGUAGE OverloadedStrings, OverloadedLabels, ImplicitParams #-}
    import Control.Monad (void)
    import qualified GI.Gtk as Gtk
    import Data.GI.Base

    main = do
      _ <- Gtk.init Nothing
      dialog <- new Gtk.MessageDialog [ #buttons := Gtk.ButtonsTypeOk,
                                        #title := "Hello world!",
                                        #text := "This is an example dialog.",
                                        #messageType := Gtk.MessageTypeInfo ]
      #run dialog

- Dependency: haskell-gtk3
- Makedependency: ghc
- Build with: `ghc -dynamic hello_world`

    hello_world.hs

    import Graphics.UI.Gtk
    main = do
             initGUI
             dialog <- messageDialogNew Nothing [DialogModal] MessageInfo ButtonsOk "Hello world!"
             messageDialogSetSecondaryText dialog "This is an example dialog."
             _res <- dialogRun dialog
             return 0

### IronPython

- Dependencies: gtk-sharp-3, ironpythonAUR
- Run with: `ipy hello_world.py`

    hello_world.py

    import clr
    clr.AddReference('gtk-sharp')
    import Gtk
    Gtk.Application.Init()
    Hello = Gtk.MessageDialog (None, Gtk.DialogFlags.Modal, Gtk.MessageType.Info, Gtk.ButtonsType.Ok, "Hello world!")
    Hello.SecondaryText="This is an example dialog."
    Hello.Run()

### Java

- Dependency: java-gnomeAUR
- Makedependency: java-environment
- Build with: `javac -cp /usr/share/java/gtk.jar HelloWorld.java && jar cfe HelloWorld.jar HelloWorld HelloWorld.class`
- Run with: `java -cp /usr/share/java/gtk.jar:HelloWorld.jar HelloWorld`

    HelloWorld.java

    import org.gnome.gtk.Gtk;
    import org.gnome.gtk.Dialog;
    import org.gnome.gtk.InfoMessageDialog;

    public class HelloWorld {
        public static void main(String[] args) {
            Gtk.init(args);
            Dialog Hello = new InfoMessageDialog(null, "Hello world!", "This is an example dialog.");
            Hello.run();
        }
    }

### JavaScript

#### GJS

- Dependencies: gtk4, gjs

    hello_world.js

    #!/usr/bin/env -S gjs -m
    import Gtk from 'gi://Gtk?version=4.0'

    const application = new Gtk.Application()

    application.connect("activate", () => {
      const dialog = new Gtk.MessageDialog({
        application,
        message_type: Gtk.MessageType.INFO,
        buttons: Gtk.ButtonsType.OK,
        text: "Hello world!",
        "secondary-text": "This is an example dialog."
      })
      dialog.connect("response", () => {
        dialog.destroy()
      })
      dialog.present()
    })

    application.run(null)

- Dependencies: gtk3, gjs

    hello_world.js

    #!/usr/bin/env gjs
    imports.gi.versions.Gtk = "3.0"
    const Gtk = imports.gi.Gtk

    Gtk.init(null)

    const Hello = new Gtk.MessageDialog({
      type: Gtk.MessageType.INFO,
      buttons: Gtk.ButtonsType.OK,
      text: "Hello world!",
      "secondary-text": "This is an example dialog."
    })

    Hello.run()

See also:

- DevDocs for GJS — API documentation browser for the GNOME JavaScript platform
- GJS Guide — A Guide to JavaScript for GNOME
- GTK4 + GJS — Learn to build a GTK4 application with GJS

#### Node.js

Using node-gtk.

- Dependencies: gtk4, nodejs
- Makedependency: npm
- Build with: `npm install`

    package.json

    {
      "dependencies": {
        "node-gtk": "^0.11.0"
      }
    }

    hello_world.js

    #!/usr/bin/env node
    const gi = require('node-gtk')
    const Gtk = gi.require('Gtk', '4.0')

    const application = new Gtk.Application()

    application.connect("activate", () => {
      const dialog = new Gtk.MessageDialog({
        application,
        message_type: Gtk.MessageType.INFO,
        buttons: Gtk.ButtonsType.OK,
        text: "Hello world!",
        "secondary-text": "This is an example dialog."
      })
      dialog.connect("response", () => {
        dialog.destroy()
      })
      dialog.present()
    })

    application.run(null)

- Dependencies: gtk3, nodejs,
- Makedependency: npm
- Build with: `npm install`

    package.json

    {
      "dependencies": {
        "node-gtk": "^0.11.0"
      }
    }

    hello_world.js

    #!/usr/bin/env node
    const gi = require('node-gtk')
    const Gtk = gi.require('Gtk', '3.0')

    Gtk.init(null)

    const Hello = new Gtk.MessageDialog({
      type: Gtk.MessageType.INFO,
      buttons: Gtk.ButtonsType.OK,
      text: "Hello world!",
      "secondary-text": "This is an example dialog."
    })

    Hello.run()

### JRuby

- Dependencies: java-gnomeAUR, jruby
- Build with: `jrubyc hello_world.rb && jar cfe hello_world.jar hello_world hello_world.class`
- Run with: `java -cp /opt/jruby/lib/jruby.jar:hello_world.jar hello_world` or `jruby hello_world.rb`

    hello_world.rb

    require '/usr/share/java/gtk.jar'
    import Java::OrgGnomeGtk::Gtk
    import Java::OrgGnomeGtk::Dialog
    import Java::OrgGnomeGtk::InfoMessageDialog

    Gtk.init(nil)
    Hello = InfoMessageDialog.new(nil, "Hello world!", "This is an example dialog.")
    Hello.run

### Julia

- Dependencies: julia, Gtk.jl
- Run with: `julia hello_world.jl`

    hello_world.jl

    using Gtk
    info_dialog("Hello world!\n\nThis is an example dialog.")

### Jython

- Dependencies: java-gnomeAUR, jython
- Run with: `jython -Dpython.path=/usr/share/java/gtk.jar hello_world.py`

    hello_world.py

    from org.gnome.gtk import Gtk, InfoMessageDialog
    Gtk.init(None)
    Hello=InfoMessageDialog(None, "Hello world!", "This is an example dialog.")
    Hello.run()

### Kotlin

- Dependency: java-gnomeAUR
- Makedependency: kotlin
- Build with: `kotlinc -cp /usr/share/java/gtk.jar HelloWorld.kt -include-runtime -d HelloWorld.jar`
- Run with: `java -cp /usr/share/java/gtk.jar:HelloWorld.jar HelloWorldKt`

    HelloWorld.kt

    import org.gnome.gtk.*

    fun main(args : Array<String>) {
            Gtk.init(args);
            val Hello = InfoMessageDialog(null, "Hello world!", "This is an example dialog.");
            Hello.run();
    }

### Lua

- Dependencies: gtk3, lua-lgi

    hello_world.lua

    #!/usr/bin/env lua
    lgi = require 'lgi'
    Gtk = lgi.require('Gtk', '3.0')
    Gtk.init()
    Hello=Gtk.MessageDialog {message_type = Gtk.MessageType.INFO,
                             buttons = Gtk.ButtonsType.OK,
                             text = "Hello world!",
                             secondary_text = "This is an example dialog."}
    Hello:run()

### Nemerle

- Dependency: gtk-sharp-3
- Makedependency: nemerleAUR
- Build with: `ncc -pkg:gtk-sharp-3.0 -out:hello_world.exe hello_world.n`
- Run with: `mono hello_world.exe`

    hello_world.n

    using Gtk;
    public class HelloWorld {
    	static Main() : void {
    		Application.Init ();
    		def Hello = MessageDialog (null, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!");
    		Hello.SecondaryText = "This is an example dialog.";
    		_ = Hello.Run ();
    	}
    }

### OCaml

- Dependency: gtk3
- Makedependency: lablgtk3
- Build with: `ocamlopt -I +lablgtk3 lablgtk3.cmxa hello_world.ml -o hello_world`

    hello_world.ml

    let main () =
      GMain.init ();
      let hello = GWindow.message_dialog ~message:"Hello world!" ~message_type:`INFO ~buttons:GWindow.Buttons.ok () in
        hello#set_secondary_text("This is an example dialog.");
        hello#run ()

    let _ = main ()

### Pascal

- Dependency: gtk3
- Makedependencies: fpc, GTK 3.0 bindings
- Build with: `fpc hello_world`

    hello_world.pas

    program	hello_world;
    uses	Math, Gtk3;
    var	dialog: PGtkWidget;
    begin
    	SetExceptionMask([exInvalidOp, exDenormalized, exZeroDivide, exOverflow, exUnderflow, exPrecision]);
    	gtk_init(@argc, @argv);
    	dialog := gtk_message_dialog_new(nil, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, '%s', ['Hello world!']);
    	gtk_message_dialog_format_secondary_text(PGtkMessageDialog(dialog), '%s', ['This is an example dialog.']);
    	gtk_dialog_run(PGtkDialog(dialog));
    end.

### Perl

- Dependencies: gtk4, perl-glib-object-introspection

    hello_world.pl

    #!/usr/bin/env perl
    use Glib::Object::Introspection;
    Glib::Object::Introspection->setup(basename => 'Gio', version => '2.0', package => 'Glib::IO');
    Glib::Object::Introspection->setup(basename => 'Gtk', version => '4.0', package => 'Gtk4');

    my $application = Glib::Object::new('Gtk4::Application');

    $application->signal_connect(activate => sub {
      my $dialog = Glib::Object::new ('Gtk4::MessageDialog',
                                      message_type => 'info',
                                      buttons => 'ok',
                                      text => "Hello world!",
                                      secondary_text => 'This is an example dialog.');
      $dialog->set_application($application);
      $dialog->signal_connect(response => sub { $dialog->close(); });
      $dialog->present();
    });

    $application->run();

- Dependency: perl-gtk3

    hello_world.pl

    #!/usr/bin/env perl
    use Gtk3 -init;
    my $hello = Gtk3::MessageDialog->new (undef, 'modal', 'info', 'ok', "Hello world!");
    $hello->set ('secondary-text' => 'This is an example dialog.');
    $hello->run;

### Prolog

- Dependency: plgiAUR[broken link: package not found]
- Run with: `swipl hello_world.pl`

    hello_world.pl

    :- use_module(library(plgi)).
    :- plgi_use_namespace('Gtk').

    main :-
    	g_object_new('GtkMessageDialog',
    	             ['message-type'='GTK_MESSAGE_INFO',
    	              'buttons'='GTK_BUTTONS_OK',
    	              'text'='Hello world!',
    	              'secondary-text'='This is an example dialog.'],
    	             Dialog),
    	gtk_dialog_run(Dialog, _),
    	halt.
    :- main.

### Python

- Dependencies: gtk4, python-gobject

    hello_world.py

    #!/usr/bin/env python
    import gi
    gi.require_version('Gtk', '4.0')
    from gi.repository import Gtk

    def on_activate(application):
        dialog = Gtk.MessageDialog(application=application,
                                   message_type=Gtk.MessageType.INFO,
                                   buttons=Gtk.ButtonsType.OK,
                                   text="Hello world!",
                                   secondary_text="This is an example dialog.")
        dialog.connect("response", lambda d, self: d.destroy())
        dialog.present()

    application = Gtk.Application()
    application.connect('activate', on_activate)
    application.run(None)

- Dependencies: gtk3, python-gobject

    hello_world.py

    #!/usr/bin/env python
    import gi
    gi.require_version('Gtk', '3.0')
    from gi.repository import Gtk
    Gtk.init(None)
    Hello = Gtk.MessageDialog(message_type=Gtk.MessageType.INFO,
                              buttons=Gtk.ButtonsType.OK,
                              text="Hello world!",
                              secondary_text="This is an example dialog.")
    Hello.run()

See also:

- PyGObject API Reference
- The Python GTK+ 3 Tutorial — An introduction to developing GTK+ 3 applications in Python with PyGObject.

### Ruby

- Dependency: ruby-gtk4

    hello_world.rb

    #!/usr/bin/env ruby
    require 'gtk4'

    application = Gtk::Application.new()

    application.signal_connect "activate" do
      dialog = Gtk::MessageDialog.new(:type => :info,
                                      :buttons_type => :ok,
                                      :message => "Hello world!")
      dialog.secondary_text = "This is an example dialog."
      dialog.application = application
      dialog.signal_connect "response" do
        dialog.destroy
      end
      dialog.present
    end

    application.run

- Dependency: ruby-gtk3

    hello_world.rb

    #!/usr/bin/env ruby
    require 'gtk3'
    Gtk.init
    dialog = Gtk::MessageDialog.new(:type => :info,
                                   :buttons_type => :ok,
                                   :message => "Hello world!")
    dialog.secondary_text = "This is an example dialog."
    dialog.run

- Dependency: gtk3, ruby-gir_ffi-gtkAUR[broken link: package not found]

    hello_world.rb

    #!/usr/bin/env ruby
    require 'gir_ffi-gtk3'
    Gtk.init
    dialog = Gtk::MessageDialog.new nil, :modal, :info, :ok, "Hello world!"
    dialog.secondary_text = "This is an example dialog."
    dialog.run

### Rust

Using gtk-rs.

- Dependency: gtk4
- Makedependency: rust
- Build with: `cargo build`
- Run with: `target/debug/hello_world` or `cargo run`

    Cargo.toml

    [package]
    name = "hello_world"
    version = "0.1.0"

    [dependencies]
    gtk4 = "^0"

    src/main.rs

    extern crate gtk4;
    use gtk4::prelude::*;

    fn main() {
        let app = gtk4::Application::builder()
            .build();
        app.connect_activate(|application| {
            let dialog = gtk4::MessageDialog::builder()
                .application(application)
                .message_type(gtk4::MessageType::Info)
                .buttons(gtk4::ButtonsType::Ok)
                .text("Hello world!")
                .secondary_text("This is an example dialog.")
                .build();
            dialog.connect_response(|dialog, _| dialog.destroy());
            dialog.present();
        });
        app.run();
    }

- Dependency: gtk3
- Makedependency: rust
- Build with: `cargo build`
- Run with: `target/debug/hello_world` or `cargo run`

    Cargo.toml

    [package]
    name = "hello_world"
    version = "0.1.0"

    [dependencies]
    gtk = "^0"

    src/main.rs

    extern crate gtk;
    use gtk::prelude::*;

    fn main() {
        let _ = gtk::init();
        let dialog = gtk::MessageDialog::builder()
            .message_type(gtk::MessageType::Info)
            .buttons(gtk::ButtonsType::Ok)
            .text("Hello world!")
            .secondary_text("This is an example dialog.")
            .build();
        dialog.run();
    }

See also:

- Rust GTK 4 bindings API reference
- GUI development with Rust and GTK 4

### Scala

- Dependency: java-gnomeAUR (and scalaAUR)
- Makedependency: scalaAUR
- Build with: `scalac -cp /usr/share/java/gtk.jar -d HelloWorld.jar HelloWorld.scala`
- Run with: `java -cp /usr/share/java/gtk.jar:HelloWorld.jar HelloWorld` (or `scala -cp /usr/share/java/gtk.jar HelloWorld.scala`)

    HelloWorld.scala

    import org.gnome.gtk._

    object HelloWorld {
      def main(args: Array[String]) {
        Gtk.init(args)
        var hello = new InfoMessageDialog(null, "Hello world!", "This is an example dialog.")
        hello.run()
      }
    }

### Scheme

- Dependencies: gtk4, guile-gi-gitAUR

    hello-world.scm

    #!/usr/bin/env guile
    !#
    (use-modules (gi)
                 (gi util))
    (push-duplicate-handler! 'merge-generics)
    (use-typelibs ("Gio" "2.0")
                  ("Gtk" "4.0"))

    (define (activate app)
      (let ((dialog (make <GtkMessageDialog> #:application app #:message-type 'info #:buttons 'ok #:text "Hello world!" #:secondary-text "This is an example dialog.")))
        (connect dialog response (lambda (a, b) (destroy dialog)))
        (present dialog)))

    (let ((app (make <GtkApplication>)))
      (connect app application:activate activate)
      (run app '()))

- Dependencies: gtk3, guile-gi-gitAUR

    hello-world.scm

    #!/usr/bin/env guile
    !#
    (use-modules (gi))
    (use-typelibs ("Gtk" "3.0"))
    (init!)
    (let ((dialog (make <GtkMessageDialog> #:message-type 'info #:buttons 'ok #:text "Hello world!" #:secondary-text "This is an example dialog.")))
    (run dialog))

### Vala

- Dependency: gtk4
- Makedependency: vala
- Build with: `valac --pkg gtk4 hello_world.vala`

    hello_world.vala

    int main (string[] argv) {
    	var application = new Gtk.Application (null, GLib.ApplicationFlags.FLAGS_NONE);

    	application.activate.connect (() => {
    		var dialog = new Gtk.MessageDialog (null, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Hello world!");
    		dialog.application = application;
    		dialog.format_secondary_text ("This is an example dialog.");
    		dialog.response.connect (() => {
    			dialog.destroy ();
    		});
    		dialog.present ();
    	});

    	return application.run (argv);
    }

- Dependency: gtk3
- Makedependency: vala
- Build with: `valac --pkg gtk+-3.0 hello_world.vala`

    hello_world.vala

    static void main (string[] args) {
    	Gtk.init (ref args);
    	var dialog = new Gtk.MessageDialog (null, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Hello world!");
    	dialog.format_secondary_text ("This is an example dialog.");
    	dialog.run ();
    }

See also:

- Valadoc — API documentation
- Official Vala Tutorial
- Unofficial Vala Tutorial

### Visual Basic

- Dependency: gtk-sharp-3
- Makedependency: mono-basicAUR
- Build with: `vbnc -r:/usr/lib/mono/gtk-sharp-3.0/gtk-sharp.dll hello_world.vb`
- Run with: `mono hello_world.exe`

    hello_world.vb

    Imports Gtk
    Public Class Hello
    	Inherits MessageDialog
    	Public Sub New
    		MyBase.New(Me, DialogFlags.Modal, MessageType.Info, ButtonsType.Ok, "Hello world!")
    		Me.SecondaryText = "This is an example dialog."
    	End Sub
    	Public Shared Sub Main
    		Application.Init
    		Dim Dialog As New Hello
    		Dialog.Run
    	End Sub
    End Class

## See also

- GNOME Development
- GTK API reference

Category:

- Widget toolkits

Hidden category:

- Pages with broken package links