< 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
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(orbooi 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:
C#
.NET
- Dependencies: dotnet-runtime, gtk3
- Makedependency: dotnet-sdk
- Build with:
dotnet build - Run with:
bin/Debug/net7.0/HelloWorld(ordotnet 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
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
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 HelloWorldorgroovy -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
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)
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.
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)
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_worldorjruby 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
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
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
- 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
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_worldorcargo 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_worldorcargo 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:
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(orscala -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
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);
}
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