Hello world/Graphical: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program disMessGraph64.s */

.include "../includeARM64.inc"

 

 

=={{header|ActionScript}}==

var textField:TextField = new TextField();

stage.addChild(textField);

textField.text = "Goodbye, World!"

 

=={{header|Ada}}==

{{libheader|GTK|GtkAda}}

{{libheader|GtkAda}}

with Gtk.Label; use Gtk.Label;

with Gtk.Window; use Gtk.Window;

 

Gtk.Main.Main;

 

=={{header|ALGOL 68}}==

The code below is a gentle re-write (including a bug fix) of that in

the Algol 68 Genie documentation.

BEGIN

FILE window;

close (window)

END

[[Category:ALGOL 68#ALGOL 68]]

 

set Screen1.Title to "Goodbye World!"<br>

[https://lh6.googleusercontent.com/-0MGq3ZZTgT8/UuwF5KBd7-I/AAAAAAAAJ-c/HirntN5II9g/s1600/blocks.PNG VIEW THE BLOCKS AND ANDROID APP SCREEN]

 

=={{header|AppleScript}}==

 

=={{header|Applesoft BASIC}}==

2 LET R = 5:GX = 3:GY = 2:O = 3:XC = R + GX:YC = R * 2 + GY

3 TEXT : HOME : TEXT : HGR : HCOLOR= 7: HPLOT 0,0: CALL 62454: HCOLOR= 6

108 HPLOT XC - R,YC - R * 2 TO XC - R,YC + R: GOTO 9: REM L

114 HPLOT XC - R,YC - R TO XC - R,YC + R:O = 2: GOTO 10: REM R

 

=={{header|Arendelle}}==

 

// done</pre>

 

=={{header|ATS}}==

#include

"share/atspre_define.hats"

val ((*void*)) = gtk_main ()

//

 

=={{header|AutoHotkey}}==

 

Gui, Add, Edit, xp+90 yp-3, Goodbye, World!

Gui, Add, Button, xp+98 yp-1, OK

Gui, Show, w226 h22 , Rosetta Code

 

=={{header|AutoIt}}==

 

$hGUI = GUICreate("Hello World") ; Create the main GUI

EndSwitch

WEnd

 

 

 

=={{header|AWK}}==

and [[Hello_world/Graphical#UNIX_Shell|UNIX_Shell]].

 

BEGIN { system("msg * Goodbye, Msgbox !") }

 

=={{header|Axe}}==

This example is almost identical to the [[#TI-83_BASIC|TI-83 BASIC version]].

Text(0,0,"Goodbye, world!")

 

=={{header|BaCon}}==

Using Xaw backend:

 

gui = GUIDEFINE("{ type=window name=window XtNtitle=\"Graphical\" } \

{ type=labelWidgetClass name=label parent=window XtNlabel=\"Goodbye, World!\" } ")

 

 

Using GTK3 backend:

PRAGMA GUI gtk3

 

{ type=LABEL name=label parent=window margin=5 label=\"Goodbye, World!\" } ")

 

 

=={{header|BASIC}}==

{{works with|FreeBASIC}}

 

#include once "windows.bi"

MessageBox(NULL, "Goodbye World", "Goodbye World", MB_ICONINFORMATION)

function = 0

 

 

#INCLUDE "gtk/gtk.bi"

gtk_main()

 

 

=={{header|BASIC256}}==

font "times new roman", 20,100

color orange

rect 10,10, 140,30

color red

 

=={{header|batari Basic}}==

................................

................................

drawscreen

goto mainloop

 

=={{header|Batch File}}==

From Window 7 and later, pure Batch File does not completely provide GUI. However, <code>MSHTA.EXE</code> provides command-line JavaScript/VBScript access.

 

::Output to message box [Does not work in Window 7 and later]

@mshta javascript:alert("Goodbye, World!");code(close());

@mshta vbscript:Execute("msgbox(""Goodbye, World!""):code close")

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

 

=={{header|Beads}}==

Beads specializes in graphical design and can use draw_str for html in the browser or alerts for popup boxes.

calc main_init

alert('Goodbye, World!')

draw main_draw

 

=={{header|BML}}==

 

=={{header|C}}==

=== GTK ===

{{libheader|GTK}}

 

int main (int argc, char **argv) {

gtk_main();

return 0;

 

=== Win32 ===

To compile with Visual C++: <code>cl /nologo hello.c user32.lib</code>, or with Open Watcom: <code>wcl386 /q hello.c user32.lib</code>.

 

 

int main(void) {

MessageBox(NULL, TEXT("Goodbye, World!"), TEXT("Rosetta Code"), MB_OK | MB_ICONINFORMATION);

return 0;

 

=== OS/2 Presentation Manager ===

wlink system os2v2_pm name hello file hello.obj</pre>

 

 

int main(void) {

WinTerminate(hab);

return 0;

 

=== Turbo C for DOS ===

Using the graphics library included with Turbo C. The BGI driver and the font must be in the same directory as the program (<code>EGAVGA.BGI</code> and <code>SANS.CHR</code>). Compile with <code>tcc hellobgi.c graphics.lib</code>.

 

#include <graphics.h>

 

closegraph();

return 0;

 

=={{header|C sharp|C#}}==

{{libheader|Windows Forms}}

 

using System.Windows.Forms;

 

MessageBox.Show("Goodbye, World!");

}

 

{{libheader|GTK}}

 

using GtkSharp;

 

Application.Run();

}

 

=={{header|C++}}==

 

{{libheader|GTK}}<!-- c++ bindings -->

int main(int argc, char *argv[])

{

Gtk::MessageDialog msg("Goodbye, World!");

msg.run();

{{libheader|Win32}}

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

{{libheader|MFC}}

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

void ShowGoodbyeWorld(CWnd* pWnd)

{

pWnd->SetWindowText(_T("Goodbye, World!"));

 

{{libheader|FLTK}}

 

#include <FL/Fl.H>

#include <FL/Fl_Window.H>

return Fl::run();

}

 

=={{header|C++/CLI}}==

using namespace System::Windows::Forms;

 

return 0;

}

 

=={{header|Casio BASIC}}==

To configure the "Graphical screen"

AxesOff

CoordOff

GridOff

ViewWindow parameters depend on the calculator resolution (These are the most common). <br>

To print text on the "Graphical screen" of the calculator:

 

=={{header|Clean}}==

{{libheader|Object I/O}}

 

Start :: *World -> *World

where

hello = Dialog "" (TextControl "Goodbye, World!" [])

 

=={{header|Clojure}}==

(:import (javax.swing JOptionPane JFrame JTextArea JButton)

(java.awt FlowLayout)))

(.pack)

(.setDefaultCloseOperation (JFrame/EXIT_ON_CLOSE))

 

=== With cljfx ===

{{libheader|cljfx}}

(:require [cljfx.api :as fx]))

 

:alignment :center

:children [{:fx/type :label

 

=={{header|COBOL}}==

{{libheader|Windows Forms}}

{{trans|C#}}

METHOD-ID Main STATIC.

PROCEDURE DIVISION.

INVOKE TYPE MessageBox::Show("Goodbye, World!")

END METHOD.

 

{{libheader|Windows Presentation Foundation}}

gui.xaml.cbl:

INHERITS TYPE System.Windows.Window.

METHOD-ID NEW.

INVOKE self::InitializeComponent()

END METHOD.

 

gui.xaml:

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Hello world/Graphical">

<TextBox>Goodbye, World!</TextBox>

 

===GTK===

{{works with|GnuCOBOL|2.0}}

{{libheader|cobweb-gtk}}

*> cobweb-gui-hello, using gtk-label

*> Tectonics:

 

goback.

 

===TUI===

The program gets the lines and columns of the screen and positions the text in the middle. Program waits for a return key.

 

data division.

working-storage section.

end-display

accept var end-accept

 

=={{header|Cobra}}==

Requires {{libheader|GTK#}} GUI library.

 

@args -pkg:gtk-sharp-2.0

 

dialog.run

dialog.destroy

 

=={{header|CoffeeScript}}==

 

=={{header|Commodore BASIC}}==

The POKE statements encapsulating the text drawing routine (lines 410-415 and 450-455) are necessary to make the Character ROM visible to BASIC without crashing the operating system. As such, keyboard scanning must be suspended during this time, preventing the routine from any user interruption until it is finished.

 

1 rem hello world on graphics screen

2 rem commodore 64 version

530 poke mem,peek(mem) or 2^px

540 return

 

 

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

{{libheader|Tk}}

 

(defun show-message (text)

(mainloop))))

 

 

This can also be done using the ''CLIM 2.0'' specification. The following code runs on both SBCL and the LispWorks

IDE:

{{libheader|CLIM}}

(in-package :clim-user)

 

(run-frame-top-level

(make-application-frame 'hello-world

 

=={{header|Creative Basic}}==

DEF Win:WINDOW

DEF Close:CHAR

 

RETURN

 

=={{header|D}}==

{{libheader|gtkD}}

 

class GoodbyeWorld : MainWindow {

new GoodbyeWorld();

Main.run();

 

=={{header|Dart}}==

 

Simplest (and ugliest) solution

 

main() => runApp( MaterialApp( home: Text( "Goodbye, World!" ) ) );

 

A still bare bones but much better looking example that displays a white screen with the text centered

 

void main() {

);

}

 

 

===Web/Javascript===

{{libheader|dart:html}}

 

main() => document.body.innerHtml = '<p>Goodbye, World!</p>';

 

{{trans|JavaScript}}

 

main() => window.alert("Goodbye, World!");

 

=={{header|Delphi}}==

 

uses

begin

ShowMessage('Goodbye, World!');

 

=={{header|Dylan}}==

(This works entered into the interactive shell):

 

=={{header|E}}==

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

 

def SWT := <swt:makeSWT>

 

frame.open()

 

 

=={{header|EasyLang}}==

 

 

 

=={{header|eC}}==

MessageBox:

 

 

Label:

 

 

Titled Form + Surface Output:

 

 

class GoodByeForm : Window

}

 

 

=={{header|EchoLisp}}==

(alert "Goodbye, World!")

 

=={{header|EGL}}==

{{works with|EDT}}

Allows entry of any name into a text field (using "World" as the default entry). Then, when the "Say Goodbye" button is pressed, sets a text label to the value "Goodbye, <name>!".

import org.eclipse.edt.rui.widgets.*;

import dojo.widgets.*;

 

end

 

=={{header|Elena}}==

public class MainWindow : SDIDialog

constructor new()

{

self.Caption := "ELENA";

closeButton.onClick := (args){ forward program.stop() };

}

=== Alternative version using xforms script ===

 

 

const layout = "

dispatch() => Form;

 

=={{header|Euphoria}}==

===Message box===

 

integer response

 

=={{header|F_Sharp|F#}}==

Just display the text in a message box.

open System

open System.Windows.Forms

let main _ =

MessageBox.Show("Hello World!") |> ignore

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

using fwt

 

}

}

 

=={{header|Forth}}==

{{works with|SwiftForth}}

 

 

Alternative:

{{works with|Win32Forth|6.15.03}}

 

=={{header|Fortran}}==

 

{{works with|Absoft Pro Fortran}}

use windows

integer :: res

res = MessageBoxA(0, LOC("Hello, World"), LOC("Window Title"), MB_OK)

 

Compile with <code>af90 hello.f90 user32.lib</code> or for a 64-bit executable <code>af90 -i8 -m64 hello.f90 user32.lib</code>.

 

{{works with|Intel Fortran}}

use user32

integer :: res

res = MessageBox(0, "Hello, World", "Window Title", MB_OK)

 

Compile with <code>ifort hello.f90</code>.

Using [https://github.com/jerryd/gtk-fortran gtk-fortran] library

{{works with|GNU Fortran}}

module handlers_m

use iso_c_binding

end program test

Compile with

<code>gfortran gtk2_mini.f90 -o gtk2_mini.x `pkg-config --cflags --libs gtk-2-fortran`</code>

 

=={{header|FreeBASIC}}==

 

'''Graphics Mode'''

{{works with|QBasic}}

locate 12,15

? "Goodbye, World!"

 

'''Windows API'''

 

=={{header|Frege}}==

 

 

import Java.Swing

cp.add label

frame.pack

 

=={{header|Frink}}==

The graphics are infinitely-scalable and can be rendered at full quality to any resolution. This program "shows off" by rotating the text by 10 degrees, and also rendering it to a printer (which can include tiling across multiple pages) and rendering to a graphics file. (Frink can automatically render the same graphics object to many image formats, including PNG, JPG, SVG, HTML5 canvas, animated GIF, bitmapped image in memory, and more.)

 

g = new graphics

g.font["SansSerif", 10]

g.print[] // Optional: render to printer

g.write["GoodbyeWorld.png", 400, 300] // Optional: write to graphics file

 

=={{header|FunL}}==

native java.awt.Font

 

f.setVisible( true )

 

 

=={{header|Gambas}}==

 

 

=={{header|Genie}}==

/*

Genie GTK+ hello

window.show_all()

window.destroy.connect(Gtk.main_quit)

 

=={{header|GlovePIE}}==

The text is rendered using Braille text characters.

 

=={{header|GML}}==

 

=={{header|Go}}==

{{libheader|go-gtk}}

 

import "github.com/mattn/go-gtk/gtk"

win.ShowAll()

gtk.Main()

 

=={{header|Groovy}}==

{{trans|Java}}

import javax.swing.JFrame

 

}

}

 

=={{header|GUISS}}==

Here we display the message on the system notepad:

 

 

=={{header|Harbour}}==

RETURN wapi_MessageBox(,"Goodbye, World!","")

 

=={{header|Haskell}}==

Using {{libheader|gtk}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Control.Monad

 

dialog `onDestroy` mainQuit

Run in GHCi interpreter:

 

=={{header|HicEst}}==

 

=={{header|HolyC}}==

 

== Icon and Unicon ==

 

==={{header|Icon}}===

procedure main()

WOpen("size=100,20") | stop("No window")

WWrites("Goodbye, World!")

WDone()

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/gprocs/graphics.icn graphics is required ]

==={{header|Unicon}}===

 

import gui

$include "guih.icn"

w.show_modal ()

end

 

=={{header|HPPPL}}==

With an alert box:

By drawing directly to the screen:

TEXTOUT_P("Goodbye, World!", GROBW_P(G0)/4, GROBH_P(G0)/4, 7);

 

=={{header|i}}==

display("Goodbye, World!")

 

=={{header|Integer BASIC}}==

40&times;40 isn't great resolution, but it's enough!

 

10 REM FONT DERIVED FROM 04B-09 BY YUJI OSHIMOTO

20 GR

660 VLIN 32,33 AT 33 : VLIN 32,33 AT 34

670 END

 

=={{header|Ioke}}==

{{trans|Java}}

:javax:swing, :JOptionPane, :JFrame, :JTextArea, :JButton

)

setDefaultCloseOperation(JFrame field:EXIT_ON_CLOSE)

visible = true

 

=={{header|IWBASIC}}==

DEF Win:WINDOW

DEF Close:CHAR

RETURN

ENDSUB

 

=={{header|J}}==

 

=={{header|Java}}==

{{libheader|Swing}}

import java.awt.*;

 

});

}

 

Using Java 8 lambdas syntax:

 

import java.awt.*;

 

});

}

 

=={{header|JavaScript}}==

 

=={{header|jq}}==

 

'''Part 1: Generic SVG-related functions'''

# e.g: "font-size: 40px; text-align: center;" (without the quotation marks)

def to_s:

| "<text x='\(x//0)' y='\(y//0)' style='\($style)'>

\(.)",

'''Part 2: "Goodbye, World!"'''

svg(null;null), # use the defaults

linearGradient("gradient"; "rgb(255,255,0)"; "rgb(255,0,0)"), # define "gradient"

"</svg>";

 

{{out}}

jq -n -r -f Hello_word_Graphical.jq > Hello_word_Graphical.svg

 

=={{header|JSE}}==

 

=={{header|Jsish}}==

That is based on JSI CData, a blend of typed Javascript and C, interwoven via a preprocessor.

 

/*

Alert popup, via libAgar and Jsish CData

return rc;

}

 

Build rules are ''jsish -c'' preprocessor, query ''jsish'' for C compile time flags, compile the C, load the module into jsish via ''require''.

{{libheader|Tk}}

 

 

window = Toplevel("Hello World", 200, 100, false)

set_visible(window, true)

 

 

=={{header|Just Basic}}==

print "Goodbye, World!"

'Prints in the upper left corner of the default text window: mainwin, a window with scroll bars.

 

=={{header|KonsolScript}}==

Popping a dialog-box.

Konsol:Message("Goodbye, World!", "")

 

Displaying it in a Window.

Screen:PrintString("Goodbye, World!")

while (B1 == false) {

Screen:Render()

}

 

=={{header|Kotlin}}==

{{trans|Java}}

{{libheader|Swing}}

import javax.swing.*

 

isVisible = true

}

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Hello_world_Graphical.png}}

 

=={{header|Lasso}}==

On OS X machines:

 

=={{header|Liberty BASIC}}==

 

=={{header|Lingo}}==

 

Display in alert box:

 

Display in main window ("stage"):

m = new(#field)

m.rect = rect(0,0,320,240)

 

-- force immediate update

 

A dialog box can be modified as appropriate for the context by setting a "iconType", button text and title

 

=={{header|Lobster}}==

gl_setfontname("data/fonts/Droid_Sans/DroidSans.ttf")

gl_setfontsize(30)

while gl_frame():

gl_clear([ 0.0, 0.0, 0.0, 1.0 ])

 

=={{header|Logo}}==

 

Among the turtle commands are some commands for drawing text in the graphical area. Details and capabilities differ among Logo implementations.

SETLABELHEIGHT 2 * last LABELSIZE

 

=={{header|Lua}}==

==={{libheader|IUPLua}}===

 

dlg = iup.dialog{iup.label{title="Goodbye, World!"}; title="test"}

if (not iup.MainLoopLevel or iup.MainLoopLevel()==0) then

iup.MainLoop()

 

==={{libheader|LÖVE}}===

or a shortcut to love.exe.

 

function love.draw()

love.graphics.print("Goodbye, World!", 400, 300)

end

 

=={{header|M2000 Interpreter}}==

A window with a click event to open a message box, and print returned number to window form, scrolling at the lower part of form's layer.

Module CheckIt {

Declare Simple Form

}

CheckIt

 

A simple Window only

Module CheckIt {

Declare Simple Form

}

CheckIt

 

=={{header|Maple}}==

Maplets:-Display( Maplets:-Elements:-Maplet( [ "Goodbye, World!" ] ) );

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

Add text to a graphical plot.

 

=={{header|MAXScript}}==

 

 

=={{header|mIRC Scripting Language}}==

dialog -m Goodbye Goodbye

}

option dbu

text "Goodbye, World!", 1, 20 6 41 7

 

=={{header|Modula-3}}==

{{libheader|Trestle}}

 

IMPORT TextVBT, Trestle;

Trestle.Install(v);

Trestle.AwaitDelete(v);

This code requires an m3makefile.

<pre>

{{works with|All implementations of TROFF}}

 

 

=={{header|Neko}}==

The NekoVM uses a C FFI that requires marshaling of C types to Neko ''value'' types.

{{libheader|Agar}}

Tectonics:

gcc -shared -fPIC -o nekoagar.ndll nekoagar.c `agar-config --cflags --libs`

return alloc_int(rc);

}

 

The C file above is used to create a Neko friendly Dynamic Shared Object file, nekoagar.ndll.

The Neko program follows:

 

<doc><pre>

Hello world, graphical, in Neko, via Agar label

 

/* Run the event loop */

 

{{out}}

=={{header|Nemerle}}==

Compile with:<pre>ncc -reference:System.Windows.Forms goodbye.n</pre>

using System.Windows.Forms;

 

 

=={{header|NetRexx}}==

Using [[Java|Java's]] [http://download.oracle.com/javase/6/docs/technotes/guides/swing/index.html Swing Foundation Classes].

{{libheader|Swing}}

options replace format comments java crossref symbols binary

 

msgText = 'Goodbye, World!'

JOptionPane.showMessageDialog(null, msgText)

 

An alternative version using other Swing classes.

{{libheader|Swing}}

options replace format comments java crossref symbols binary

 

method isFalse() public static returns boolean

return \isTrue

 

An example using [[Java|Java's]] [http://download.oracle.com/javase/6/docs/technotes/guides/awt/index.html Abstract Window Toolkit (AWT)]

{{libheader|AWT}}

 

options replace format comments java crossref symbols binary

 

method isFalse() public static returns boolean

return \isTrue

 

=={{header|newLISP}}==

NewLISP uses a lightweight Java GUI server that it communicates with over a pipe, similar how some languages use Tcl/Tk. This takes advantage of Java's cross platform GUI capability.

 

; oofoe 2012-01-18

 

 

(exit) ; NewLisp normally goes to listener after running script.

 

 

> (! "dialog --msgbox GoodbyeWorld! 5 20")

 

=={{header|Nim}}==

==={{libheader|GTK2}}===

gtk2.nim_init()

 

==={{libheader|IUP}}===

 

discard iup.open(nil, nil)

message("Hello", "Hello World")

 

=={{header|NS-HUBASIC}}==

 

=={{header|Nyquist}}==

===Audacity plug-in (Lisp syntax)===

;version 4

;type tool

;name "Goodbye World"

 

 

===Audacity plug-in (SAL syntax)===

;version 4

;type tool

;name "Goodbye World"

 

 

=={{header|Objeck}}==

{{libheader|Qt}}

use Qt;

 

}

}

 

=={{header|Objective-C}}==

To show a modal alert (Mac):

[alert setMessageText:@"Goodbye, World!"];

 

To show a modal alert (iOS):

 

=={{header|OCaml}}==

{{libheader|GTK}}

 

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

;;

 

 

{{libheader|OCaml-Xlib}}

 

Just output as a label in a window:

let main_widget = Tk.openTk () in

let lbl = Label.create ~text:"Goodbye, World" main_widget in

Tk.pack [lbl];

 

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

let action () = exit 0 in

let main_widget = Tk.openTk () in

Button.create main_widget ~text:"Goodbye, World" ~command:action in

Tk.pack [bouton_press];

 

=={{header|Ol}}==

{{libheader|Win32}}

(import (lib winapi))

(MessageBox #f (c-string "Hello, World!") (c-string "Rosettacode") #x40)

 

=={{header|OpenEdge/Progress}}==

 

=={{header|OxygenBasic}}==

<br clear=both>

Requires a Glade GUI description file. 'ere be one I produced earlier:

<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->

<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.24.dtd">

 

</glade-interface>

And finally the Oxygene:

// Display a Message in a GUI Window

//

 

end.

===.NET===

[[File:OxygeneNEThw.jpg|left|HelloWorld]]

<br clear=both>

namespace HelloWorldNET;

 

end.

 

=={{header|Oz}}==

[QTk] = {Module.link ['x-oz://system/wp/QTk.ozf']}

Window = {QTk.build td(label(text:"Goodbye, World!"))}

in

 

=={{header|Panoramic}}==

'Prints in the upper left corner of the window.

 

=={{header|PARI/GP}}==

plotstring(1, "Goodbye, World!");

 

=={{header|Pascal}}==

{{libheader|Gtk2}}

Variant of the C example:

 

uses

gtk_main();

 

=={{header|Perl}}==

{{works with|Perl|5.8.8}}

Just output as a label in a window:

 

use strict;

use warnings;

my $main = MainWindow->new;

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

 

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

 

use warnings;

use Tk;

-command => \&exit,

)->pack;

 

==={{libheader|Perl/Gtk2}}===

use warnings;

use Gtk2 '-init';

 

$window->show_all;

 

==={{libheader|Perl/Qt}}===

use warnings;

use QtGui4;

my $label = Qt::Label('Goodbye, World');

$label->show;

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

{{libheader|Phix/pGUI}}

<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">IupMessage</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Bye"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Goodbye, World!"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

 

=={{header|PHP}}==

{{libheader|PHP-GTK}}

{

die("Please load the php-gtk2 module in your php.ini\r\n");

$wnd->show_all();

 

=={{header|PicoLisp}}==

 

=={{header|Plain English}}==

Start up.

Clear the screen.

Refresh the screen.

Wait for the escape key.

 

=={{header|PostScript}}==

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

 

% render in Helvetica, 12pt:

/Helvetica findfont 12 scalefont setfont

(Goodbye, World!) show

% wrap up page display:

 

=={{header|PowerBASIC}}==

{{works with|PB/Win}}

 

MSGBOX "Goodbye, World!"

 

=={{header|PowerShell}}==

{{libheader|WPK}}<br/>

{{works with|PowerShell|2}}

{{libheader|Windows Forms}}

$label = New-Object System.Windows.Forms.Label

 

$form.Controls.Add($label)

 

Alternatively, simply as a message box:

 

{{libheader|Windows Forms}}

 

=={{header|Processing}}==

Uses default Processing methods and variables.

 

=={{header|Prolog}}==

Works with SWI-Prolog and XPCE. <br><br>

A simple message box :

A more sophisticated window :

new(D, window('Goodbye')),

send(D, size, size(250, 100)),

send(D, display, T, point(XT, YT)),

send(D, open).

 

=={{header|Pure Data}}==

 

=={{header|PureBasic}}==

Using the Windows API:

 

=={{header|Python}}==

{{works with|Python|2.x}}

==={{libheader|Tkinter}}===

 

 

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

{{works with|Python|3.x}}

{{libheader|Tkinter}}

 

 

 

==={{libheader|PyQt}}===

app = PyQt4.QtGui.QApplication([])

pb = PyQt4.QtGui.QPushButton('Hello World')

pb.connect(pb,PyQt4.QtCore.SIGNAL("clicked()"),pb.close)

pb.show()

 

==={{libheader|PyGTK}}===

pygtk.require('2.0')

import gtk

window.connect('delete-event', gtk.main_quit)

window.show_all()

 

==={{libheader|VPython}}===

{{works with|Python|2.7.5}}

# HelloWorld for VPython - HaJo Gurt - 2014-09-20

from visual import *

S.rotate( angle=rot, axis=(0,1,0) )

 

 

==={{libheader|WxPython}}===

 

app = wx.App(False)

frame = wx.Frame(None, wx.ID_ANY, "Hello, World")

frame.Show(True)

 

 

==={{libheader|Kivy}}===

from kivy.app import App

from kivy.uix.floatlayout import FloatLayout

 

GoodByeApp().run()

 

 

==={{libheader|Kivy}}===

With kv language

 

from kivy.app import App

 

GoodByeApp().run()

 

=={{header|R}}==

{{libheader|GTK}}

Rather minimalist, but working...

w <- gtkWindowNew()

l <- gtkLabelNew("Goodbye, World!")

 

=={{header|Racket}}==

 

(require racket/gui/base)

 

; Show the frame by calling its show method

 

=={{header|Raku}}==

 

{{libheader|GTK}}

use GTK::Simple::App;

 

$app.border-width = 20;

$app.set-content( GTK::Simple::Label.new(text => "Goodbye, World!") );

 

=={{header|RapidQ}}==

 

=={{header|Rascal}}==

import vis::Figure;

import vis::Render;

public void GoodbyeWorld() =

render(box(text("Goodbye World")));

Output:

[[File:Goodbyeworld.png]]

 

=={{header|REALbasic}}==

MsgBox("Goodbye, World!")

 

=={{header|REBOL}}==

 

=={{header|Red}}==

 

=={{header|REXX}}==

:::* &nbsp; PC/REXX

:::* &nbsp; Personal REXX

if fcnPkg('rxWindow') ¬== 1 then do

say 'RXWINDOW function package not loaded.'

call w_put window#, 2, 2, center("Goodbye, World!", 80-2)

 

'''output'''

<pre>

<br>and it creates two windows, the first (main) window contains the &nbsp; '''Goodbye, World!''' &nbsp; text,

<br>the other "help" window contains a message about how to close the windows.

parse upper version !ver .; !pcrexx= !ver=='REXX/PERSONAL' | !ver=='REXX/PC'

if ¬!pcrexx then call ser "This isn't PC/REXX" /*this isn't PC/REXX ? */

parse var curPos row col

call cursor row, col

 

=={{header|Ring}}==

Load "guilib.ring"

New qApp {

exec()

}

 

=={{header|Robotic}}==

Since visuals are already built in, [[Hello world/Newbie#Robotic|this link]] does the same thing.

 

=={{header|Ruby}}==

{{libheader|GTK}}

 

window = Gtk::Window.new

window.show_all

 

 

{{libheader|Ruby/Tk}}

root = TkRoot.new("title" => "User Output")

TkLabel.new(root, "text"=>"CHUNKY BACON!").pack("side"=>'top')

 

{{libheader|Shoes}}

 

Shoes.app do

para "CHUNKY BACON!", :size => 72

 

{{libheader|Gosu}}

require 'gosu'

 

end

 

 

{{libheader|Green shoes}}

#_Note: this code must not be executed through a GUI

require 'green_shoes'

para "Hello world"

end

 

{{libheader|Win32ole}}

require 'win32ole'

WIN32OLE.new('WScript.Shell').popup("Hello world")

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

==={{libheader|GTK}}===

extern crate gtk;

use gtk::traits::*;

window.show_all();

gtk::main();

 

=={{header|Scala}}==

===Ad hoc REPL solution===

Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] script:

===JVM Application===

Longer example, as an application:

 

object GoodbyeWorld extends SimpleSwingApplication {

}

}

===.Net Framework===

object HelloDotNetWorld {

("Goodbye, World!")

}

 

=={{header|Scheme}}==

{{libheader|Scheme/PsTk}}

 

#!r6rs

 

 

(tk-event-loop tk)

 

=={{header|Scilab}}==

 

=={{header|Scratch}}==

 

=={{header|ScratchScript}}==

This example waits until the mouse is clicked for the program to end. This can be useful if the program executes too fast for "Hello world!" to be visible on the screen long enough for it to be comfortable.

print "Goodbye, World!"

 

=={{header|Seed7}}==

the area is currently covered or off screen.

 

include "draw.s7i";

include "keybd.s7i";

write(screen, "Goodbye, World");

ignore(getc(KEYBOARD));

 

=={{header|SenseTalk}}==

 

=={{header|Sidef}}==

{{libheader|Tk}}

main.Button(

'-text' => 'Goodbye, World!',

'-command' => 'exit',

 

{{libheader|Gtk2}}

 

 

 

 

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

{{works with|Pharo}}

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

 

=={{header|SmileBASIC}}==

 

=={{header|SSEM}}==

Ok, I know this is cheating. But it isn't <i>completely</i> cheating: the SSEM uses Williams tube storage, so the memory is basically a CRT device; and this is an executable program, up to a point, because the first line includes a <tt>111 Stop</tt> instruction (disguised as a little flourish joining the tops of the <b>d</b> and the <b>b</b>).

10000000000001010000000000000000

10011101110111011101010111000000

00100100101010100010010100000000

00100100101110100011011100100000

Once you've keyed it in, the first eighteen words of storage will look a bit like this:

<pre> oo ooo

=={{header|Standard ML}}==

Works with PolyML

open Motif ;

end;

call

helloWindow ();

 

=={{header|Stata}}==

 

=={{header|Supernova}}==

 

=={{header|Swift}}==

{{trans|Objective-C}}

 

let alert = NSAlert()

alert.messageText = "Goodbye, World!"

 

=={{header|Tcl}}==

{{libheader|Tk}}

Just output as a label in a window:

 

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

''Note:'' If you name this program "button.tcl", you might get strange errors. <br>

Don't use the name of any internal tcl/tk-command as a filename for a tcl-script.

 

This shows our text in a message box:

 

=={{header|TI-83 BASIC}}==

 

=={{header|TI-89 BASIC}}==

 

Text "Goodbye, World!"

 

=={{header|Tosh}}==

say "Goodbye, World!"

 

=={{header|TXR}}==

==== Microsoft Windows ====

 

(deffi messagebox "MessageBoxW" int (cptr wstr wstr uint)))

 

 

=={{header|UNIX Shell}}==

===In a virtual terminal===

Using whiptail or dialog

whiptail --title 'Farewell' --msgbox 'Goodbye, World!' 7 20

dialog --title 'Farewell' --msgbox 'Goodbye, World!' 7 20

===In a graphical environment===

Using the simple dialog command xmessage, which uses the X11 Athena Widget library

xmessage 'Goodbye, World!'

Using the zenity modal dialogue command (wraps GTK library) available with many distributions of [[Linux]]

zenity --info --text='Goodbye, World!'

Using yad (a fork of zenity with many more advanced options)

yad --title='Farewell' --text='Goodbye, World!'

 

 

The following code is altered from the TheIDE example page. It displays a blank GUI with a menu. Click on about from the menu and the goodbye world prompt appears.

 

#include <CtrlLib/CtrlLib.h>

// submitted by Aykayayciti (Earl Lamont Montgomery)

GoodbyeWorld().Run();

}

 

 

 

=={{header|Vala}}==

using Gtk;

 

 

Gtk.main();

 

=={{header|VBA}}==

{{trans|Visual Basic}}

MsgBox "Goodbye, World!"

 

=={{header|VBScript}}==

 

MsgBox("Goodbye, World!")

 

=={{header|Vedit macro language}}==

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

 

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

 

=={{header|Visual Basic}}==

MsgBox "Goodbye, World!"

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic|2005}}

 

Module GoodbyeWorld

Messagebox.Show("Goodbye, World!")

End Sub

 

=={{header|Visual FoxPro}}==

MESSAGEBOX("Goodbye, World!")

* Version 2:

 

=={{header|Web 68}}==

Define the structure of the program.

 

macro fl finish;

 

 

=={{header|Wee Basic}}==

 

=={{header|Wren}}==

{{libheader|DOME}}

 

class Game {

 

static draw(alpha) {}

 

=={{header|X86 Assembly}}==

function parameters onto the stack and the stack has been fixed up

when the callee returns.

;;;

;;; nasm -fwin32 hellowin.asm

title:

db 'RosettaCode sample',0

{{works with|FASM on Windows}}

 

;use win32ax for 32 bit

;use win64ax for 64 bit

invoke ExitProcess,0

.end start

 

=={{header|X86-64 Assembly}}==

Not sure if ncurses counts as 'graphical', but whatver..

===={{libheader|ncurses}}====

option casemap:none

 

 

.code

 

end

 

=={{header|XPL0}}==

This sets up a 320x200x8 (VGA) graphics screen and writes text on it.

 

=={{header|XSLT}}==

The output is an SVG document. The idea is that it's straightforward to use XSLT to turn an existing SVG into an instantiable template.

 

<xsl:output method="xml"/>

<xsl:template match="/*">

</svg>

</xsl:template>

 

Sample input:

 

 

Sample output (with formatting non-destructively adjusted):

 

<rect x="0" y="0" width="400" height="200" fill="cyan"/>

<circle cx="200" cy="100" r="50" fill="yellow"/>

text-anchor: middle;

fill: black;">Goodbye, World!</text>

 

=={{header|Yabasic}}==

text 10, 20, "Hello world"

 

=={{header|zkl}}==

zkl doesn't have a decent GUI ffi but, on my Linux box, the following work:

System.cmd(0'|notify-send "Goodbye, World!"|); // desktop notification

The quote quote syntax is 0'<char>text<char> or you can use \ (eg "\"Goodbye, World!\"")