GTK/Development - ArchWiki

Jump to content

# GTK/Development

From ArchWiki
< GTK

## Write a simple message dialog app

You can write your own GTK 3 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
- 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)
- Makedependency: booAUR
- 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: 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 *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));
            return 0;
    }

### C++

- 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;
    }

### C#

- 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: gtk3
- Makedependency: vala
- Build with: `valac --pkg gtk+-3.0 hello_world.gs`

    hello_world.gs

    uses
    	Gtk
    init
    	Gtk.init (ref args)
    	var Hello=new MessageDialog (null, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Hello world!")
    	Hello.format_secondary_text ("This is an example dialog.")
    	Hello.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: gtk3
- Makedependency: haskell-gtk3
- Build with: `ghc 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: 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()

Node.js:

- Dependencies: gtk3, nodejs, node-gtk

    hello_world.js

    #!/usr/bin/env node
    const gi = require('node-gtk')
    const Gtk = gi.require('Gtk', '3.0')
    Gtk.init()
    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-gitAUR

    hello_world.lua

    #!/usr/bin/env lua
    lgi = require 'lgi'
    Gtk = lgi.require('Gtk')
    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

- 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
- 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: 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()

### Ruby

- Dependency: gtk3, ruby-gir_ffi-gtkAUR

    hello_world.rb

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

- Dependency: ruby-gtk3

    hello_world.rb

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

### Rust

Using Gtk-rs.

- 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::*;
    use gtk::{ButtonsType, DialogFlags, MessageType, MessageDialog, Window};

    fn main() {
        let _ = gtk::init();
        MessageDialog::new(None::<&Window>,
                           DialogFlags::empty(),
                           MessageType::Info,
                           ButtonsType::Ok,
                           "Hello world!").run();
    }

### Scala

- Dependency: java-gnomeAUR (and scala)
- Makedependency: scala
- 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()
      }
    }

### Vala

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

    hello_world.vala

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

### 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 Developer Center
- GTK 3 Reference Manual
- gtkmm 3 Tutorial

Category:

- Widget toolkits