Hello world/Graphical

In this User Output task, the goal is to display the string "Goodbye, World!" on a GUI object (alert box, plain window, text area, etc.).

ActionScript

trace("Goodbye, World!");

AppleScript

display dialog "Goodbye, World!" buttons {"Bye"}

<lang autohotkey> MsgBox, Goodbye`, World! </lang> <lang autohotkey> ToolTip, Goodbye`, World! </lang> <lang autohotkey> Gui, Add, Text, x4 y4, To be announced: Gui, Add, Edit, xp+90 yp-3, Goodbye, World! Gui, Add, Button, xp+98 yp-1, OK Gui, Show, w226 h22 , Rosetta Code Return </lang> <lang autohotkey> SplashTextOn, 100, 100, Rosetta Code, Goodbye, World! </lang>

BASIC

Works with: FreeBASIC

<lang basic>' Demonstrate a simple Windows application using FreeBasic

include once "windows.bi"

Declare Function WinMain(ByVal hInst As HINSTANCE, _

     ByVal hPrev As HINSTANCE, _
     ByVal szCmdLine as String, _
     ByVal iCmdShow As Integer) As Integer

End WinMain( GetModuleHandle( null ), null, Command( ), SW_NORMAL )

Function WinMain (ByVal hInst As HINSTANCE, _

                 ByVal hPrev As HINSTANCE, _
                 ByVal szCmdLine As String, _
                 ByVal iCmdShow As Integer) As Integer
   MessageBox(NULL, "Goodbye World", "Goodbye World", MB_ICONINFORMATION)
   function = 0

End Function</lang>

C

Library: GTK

#include <gtk/gtk.h>

int main (int argc, char **argv) {
  GtkWidget *window;
  gtk_init(&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Goodbye, World");
  g_signal_connect (G_OBJECT (window), "delete-event", gtk_main_quit, NULL);
  gtk_widget_show_all (window);

  gtk_main();
  return 0;
}

Library: Win32

Where hWnd is a valid window handle corresponding to a control in the application

#include "windows.h"
void SayGoodbyeWorld(HWND hWnd)
{
  SetWindowText(hWwnd, _T("Goodbye, World!"));
}

C#

Winforms

<lang csharp>using System; using System.Windows.Forms;

class Program {

   static void Main(string[] args) {
       Application.EnableVisualStyles(); //Optional.
       MessageBox.Show("Hello World!");
   }

}</lang>

Gtk

<lang csharp>using Gtk; using GtkSharp;

public class GoodbyeWorld {

 public static void Main(string[] args) {
   Gtk.Window window = new Gtk.Window();
   window.Title = "Goodbye, World";
   window.DeleteEvent += delegate { Application.Quit(); };
   window.ShowAll();
   Application.Run();
 }

}</lang>

C++

Works with: GCC version 3.3.5

Library: GTK

#include <gtkmm.h>
int main(int argc, char *argv[])
{
   Gtk::Main app(argc, argv);
   Gtk::MessageDialog msg("Goodbye, World!");
   msg.run();
}

Library: Win32

All Win32 APIs work in C++ the same way as they do in C. See the C example.

Library: MFC

Where pWnd is a pointer to a CWnd object corresponding to a valid window in the application.

#include "afx.h"
void ShowGoodbyeWorld(CWnd* pWnd)
{
    pWnd->SetWindowText(_T("Goodbye, World!"));
}

Clean

Library: Object I/O

import StdEnv, StdIO

Start :: *World -> *World
Start world = startIO NDI Void (snd o openDialog undef hello) [] world
where
    hello = Dialog "" (TextControl "Goodbye, World!" []) 
                                     [WindowClose (noLS closeProcess)]

Common Lisp

This can be done using the extension package ltk that provides an interface to the Tk library.

Library: Tk

<lang lisp>(use-package :ltk)

(defun show-message (text)

 "Show message in a label on a Tk window"
 (with-ltk ()
     (let* ((label (make-instance 'label :text text))
            (button (make-instance 'button :text "Done"
                                   :command (lambda () 
                                              (ltk::break-mainloop)
                                              (ltk::update)))))
             (pack label :side :top :expand t :fill :both)
             (pack button :side :right)
             (mainloop))))

(show-message "Goodbye World")</lang>

D

Library: gtkD

<lang D>import gtk.MainWindow; import gtk.Label; import gtk.Main;

class GoodbyeWorld : MainWindow {

       this()
       {
               super("GtkD");
               add(new Label("Goodbye World"));
               showAll();
       }

}

void main(string[] args) {

       Main.init(args);
       new GoodbyeWorld();
       Main.run();

}</lang>

E

Library: SWT

This is a complete application. If it were part of a larger application, the portions related to interp would be removed.

def frame := <widget:makeShell>(currentDisplay)

 frame.setText("Rosetta Code")
 frame.setBounds(30, 30, 230, 60)
 frame.addDisposeListener(def _ { to widgetDisposed(event) {
   interp.continueAtTop()
 }})

def label := <widget:makeLabel>(frame, SWT.getLEFT())

 label.setText("Goodbye, World!")
 swtGrid`$frame: $label`

frame.open()

interp.blockAtTop()</lang>

eC

MessageBox:

import "ecere"
MessageBox goodBye { contents = "Goodbye, World!" };

Label:

import "ecere"
Label label { text = "Goodbye, World!", hasClose = true, opacity = 1, size = { 320, 200 } };

Titled Form + Surface Output:

import "ecere"

class GoodByeForm : Window
{
   text = "Goodbye, World!";
   size = { 320, 200 };
   hasClose = true;

   void OnRedraw(Surface surface)
   {
      surface.WriteTextf(10, 10, "Goodbye, World!");
   }
}

GoodByeForm form {};

F#

Just display the text in a message box.

#light
open System
open System.Windows.Forms
[<EntryPoint>]
let main _ =
    MessageBox.Show("Hello World!") |> ignore
    0

Icon

link graphics
procedure main() 
   WOpen("size=80,20") | stop("No window")
   WWrites("goodbye world")
   WDone()
end

J

wdinfo'Goodbye, World!'

Java

Library: Swing

<lang java>import javax.swing.*; public class OutputSwing {

   public static void main(String[] args) throws Exception {
       JOptionPane.showMessageDialog (null, "Goodbye, World!");//alert box
       JFrame window = new JFrame("Goodbye, World!");//text on title bar
   	JTextArea text = new JTextArea();
   	text.setText("Goodbye, World!");//text in editable area
   	JButton button = new JButton("Goodbye, World!");//text on button
   	
   	//so the button and text area don't overlap
   	window.setLayout(new FlowLayout());
   	window.add(button);//put the button on first
   	window.add(text);//then the text area
   	
   	window.pack();//resize the window so it's as big as it needs to be
   	
   	window.setVisible(true);//show it
   	//stop the program when the window is closed
   	window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }

}</lang>

JavaScript

Works with: Firefox version 2.0

This pops up a small dialog, so it might be termed GUI display.

alert("Goodbye, World!");

MAXScript

messageBox "Goodbye world"

Objective-C

To show a modal alert:

NSAlert *alert = [[[NSAlert alloc] init] autorelease];
[alert setMessageText:@"Goodbye, World!"];
[alert runModal];

Modula-3

Library: Trestle

<lang modula3>MODULE GUIHello EXPORTS Main;

IMPORT TextVBT, Trestle;

<*FATAL ANY*>

VAR v := TextVBT.New("Goodbye, World!");

BEGIN

 Trestle.Install(v);
 Trestle.AwaitDelete(v);

END GUIHello.</lang> This code requires an m3makefile.

import ("ui")
implementation ("GUIHello")
program ("Hello")

This tells the compiler to link with the UI library, the file name of the implementation code, and to output a program named "Hello".

OCaml

Library: GTK

<lang ocaml>let delete_event evt = false

let destroy () = GMain.Main.quit ()

let main () =

 let window = GWindow.window in
 let _ = window#set_title "Goodbye, World" in
 let _ = window#event#connect#delete ~callback:delete_event in
 let _ = window#connect#destroy ~callback:destroy in
 let _ = window#show () in
 GMain.Main.main ()

let _ = main () ;; </lang>

Library: OCaml-Xlib

Simple window with OCaml and Xlib

Library: Tk

ocaml -I +labltk labltk.cma

Just output as a label in a window: <lang ocaml>let () =

 let main_widget = Tk.openTk () in
 let lbl = Label.create ~text:"Goodbye, World" main_widget in
 Tk.pack [lbl];
 Tk.mainLoop();;</lang>

Output as text on a button that exits the current application: <lang ocaml>let () =

 let action () = exit 0 in
 let main_widget = Tk.openTk () in
 let bouton_press =
   Button.create main_widget ~text:"Goodbye, World" ~command:action in
 Tk.pack [bouton_press];
 Tk.mainLoop();;</lang>

Perl

Works with: Perl version 5.8.8

Library: Tk

Just output as a label in a window:

use Tk;

$main = MainWindow->new;
$main->Label(-text => 'Goodbye, World')->pack;
MainLoop();

Output as text on a button that exits the current application:

use Tk;

$main = MainWindow->new;
$main->Button(
  -text => 'Goodbye, World',
  -command => \&exit,
)->pack;
MainLoop();

Library: Gtk2

use Gtk2 '-init';

$window = Gtk2::Window->new;
$window->set_title('Goodbye world');
$window->signal_connect(
  'destroy' => sub { Gtk2->main_quit; }
);

$label = Gtk2::Label->new('Goodbye, world');
$window->add($label);

$window->show_all;
Gtk2->main;

PHP

Library: PHP-GTK

if (!class_exists('gtk')) 
{
    die("Please load the php-gtk2 module in your php.ini\r\n");
}

$wnd = new GtkWindow();
$wnd->set_title('Goodbye world');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));
 
$lblHello = new GtkLabel("Goodbye, World!");
$wnd->add($lblHello);
 
$wnd->show_all();
Gtk::main();

PostScript

In the geenral Postscript context, the show command will render the string that is topmost on the stack at the currentpoint in the previously setfont. Thus a minimal PostScript file that will print on a PostScript printer or previewer might look like this:

%!PS
% render in Helvetica, 12pt:
/Helvetica findfont 12 scalefont setfont
% somewhere in the lower left-hand corner:
50 dup moveto
% render text
(Goodbye World) show
% wrap up page display:
showpage

Python

Works with: Python version 2.5

Library: Tkinter

 import tkMessageBox
 
 result = tkMessageBox.showinfo("Some Window Label", "Goodbye, World!")

Note: The result is a string of the button that was pressed.

Library: GTK

import pygtk
pygtk.require('2.0')
import gtk

window = gtk.Window()
window.set_title('Goodbye, World')
window.connect('delete-event', gtk.main_quit)
window.show_all()
gtk.main()

RapidQ

MessageBox("Goodbye, World!", "RapidQ example", 0)

R

Library: GTK

Rather minimalist, but working... <lang R>library(RGtk2) # bindings to Gtk w <- gtkWindowNew() l <- gtkLabelNew("Goodbye, World!") w$add(l)</lang>

Ruby

Library: GTK

<lang ruby>require 'gtk2'

window = Gtk::Window.new window.title = 'Goodbye, World' window.signal_connect(:delete-event) { Gtk.main_quit } window.show_all

Gtk.main</lang>

Library: Ruby/Tk

<lang ruby>require 'tk' root = TkRoot.new("title" => "User Output") TkLabel.new(root, "text"=>"goodbye world").pack("side"=>'top') Tk.mainloop</lang>

Smalltalk

MessageBox show: 'Goodbye, world.'

Tcl

Library: Tk

Just output as a label in a window: <lang tcl>pack [label .l -text "Goodbye, World"]</lang>

Output as text on a button that exits the current application: <lang tcl>pack [button .b -text "Goodbye, World" -command exit]</lang>

Or as a message box: <lang tcl>tk_messageBox -message "Goodbye, World"</lang>

Vedit macro language

Displaying the message on status line. The message remains visible until the next keystroke, but macro execution continues.

Statline_Message("Goodbye, World!")

Displaying a dialog box with the message and default OK button:

Dialog_Input_1(1,"`Vedit example`,`Goodbye, World!`")

Visual Basic .NET

Works with: Visual Basic version 2005

Module GoodbyeWorld
    Sub Main()
        Messagebox.Show("Goodbye, World!")
    End Sub
End Module

Hello world/Graphical

ActionScript

Ada

AppleScript

AutoHotkey

BASIC

C

C#

C++

Clean

Common Lisp

D

E

eC

F#

Icon

J

Java

JavaScript

MAXScript

Objective-C

Modula-3

OCaml

Perl

PHP

PostScript

Python

RapidQ

R

Ruby

Smalltalk

Tcl

Vedit macro language

Visual Basic .NET