Window creation: Difference between revisions
→{{header|PureBasic}}: expanding the task
(→{{header|Python}}: python 3) |
(→{{header|PureBasic}}: expanding the task) |
||
(29 intermediate revisions by 17 users not shown) | |||
Line 6:
{{libheader|GtkAda}}
{{uses from|library|GtkAda|component1=Window|component2=Widget|component3=Handlers|component4=Main}}
<
with Gtk.Widget; use Gtk.Widget;
Line 46:
Gtk.Main.Main;
end Windowed_Application;</
=={{header|ALGOL 68}}==
Line 52:
{{works with|ELLA ALGOL 68|[https://sourceforge.net/projects/algol68/files/algol68toc/algol68toc_1.14 algol68toc_1.14]}}
'''Compile command:''' ca -l gtk-3 -l gdk-3 -l atk-1.0 -l gio-2.0 -l pangocairo-1.0 -l gdk_pixbuf-2.0 -l cairo-gobject -l pango-1.0 -l cairo -l gobject-2.0 -l glib-2.0 firstgtk.a68
<
USE standard
BEGIN
Line 90:
gtk main
END
FINISH</
=={{header|AmigaBASIC}}==
<syntaxhighlight lang="amigabasic">WINDOW 2,"New Window"</syntaxhighlight>
=={{header|AurelBasic}}==
<
=={{header|AutoHotkey}}==
<
Gui, Show</
=={{header|AutoIt}}==
<
GUISetState(@SW_SHOW)
Line 121 ⟶ 114:
Exit
EndSwitch
Until False</
=={{header|BaCon}}==
BaCon includes a Highlevel Universal GUI abstraction layer (HUG). The implementation is based on GTK.
<
INCLUDE "hug.bac"
Line 132 ⟶ 125:
REM start gtk event loop...
DISPLAY</
=={{header|BASIC256}}==
BASIC256 it has a built-in graphics mode.
<syntaxhighlight lang="basic256">clg
text (50,50, "I write in the graphics area")</syntaxhighlight>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
dlg% = FN_newdialog("GUI Window", 0, 0, 200, 150, 8, 1000)
PROC_showdialog(dlg%)</
=={{header|C}}==
Line 149 ⟶ 148:
'''Compile Command:''' gcc `sdl-config --cflags` `sdl-config --libs` SDL_Window.c -o window
<
* Opens an 800x600 16bit color window.
* Done here with ANSI C.
Line 170 ⟶ 169:
return 0;
}</
===GTK===
Line 178 ⟶ 177:
'''Compile command:''' gcc `gtk-config --cflags` `gtk-config --libs` -o window window.c
<
int
Line 193 ⟶ 192:
return 0;
}</
===GTK2===
Line 200 ⟶ 199:
'''Compile command:''' gcc -Wall -pedantic `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -o window window.c
<
int
Line 214 ⟶ 213:
return 0;
}</
===GLUT===
Line 226 ⟶ 225:
We ''are'' registering a keypress callback, which isn't strictly necessary; It simply allows us to use a keypress to close the program rather than depending on the windowing system the program is run under.
<
// http://rosettacode.org/wiki/Creating_a_Window
#include <stdlib.h>
Line 267 ⟶ 266:
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
Line 273 ⟶ 272:
{{libheader|Windows Forms}}
{{uses from|library|.NET Framework|component1=System.Windows.Forms|component2=System.Windows.Forms.Window|component3=System.Windows.Forms.Form|component4=System.Windows.Forms.Application}}
<
using System.Windows.Forms;
Line 287 ⟶ 286:
Application.Run();
}
}</
=={{header|C++}}==
Line 294 ⟶ 293:
'''Compiler command:''' qmake -pro; qmake
<
#include <QMainWindow>
Line 303 ⟶ 302:
window.show();
return app.exec();
}</
{{libheader|GTK}}
Line 309 ⟶ 308:
'''Compiler command:''' g++ filename.cc -o test `pkg-config --cflags --libs gtkmm-2.4`
<
#include <gtkmm.h>
Line 329 ⟶ 328:
exit( 0 ) ;
}</
=={{header|Clojure}}==
Line 335 ⟶ 334:
{{uses from|library|Swing|component1=JFrame}}
<
(let [frame (JFrame. "A Window")]
(doto frame
(.setSize 600 800)
(.setVisible true)))</
=={{header|Common Lisp}}==
Line 348 ⟶ 347:
{{works with|LispWorks}}
<
==={{libheader|CLIM}}===
Line 356 ⟶ 355:
Setting up the environment:
<
(cl:defpackage #:rc-window
(:use #:clim-lisp #:clim))
(cl:in-package #:rc-window)</
The actual definition and display:
<
()
(:layouts (:default)))
(run-frame-top-level (make-application-frame 'rc-window))</
Note: This creates a small, useless window ("frame"). Useful frames will have some ''panes'' defined inside them.
Line 375 ⟶ 374:
Works with the Armed Bear Common Lisp implementation that targets the JVM.
<
"Creates a window"
(let ((window (jnew (jconstructor "javax.swing.JFrame"))))
Line 381 ⟶ 380:
window (make-immediate-object t :boolean))))
(create-window)</
=={{header|D}}==
{{libheader|FLTK4d}}
<
import fltk4d.all;
Line 393 ⟶ 392:
window.show;
FLTK.run;
}</
{{libheader|Derelict}}
{{libheader|SDL}}
<
int main(char[][] args)
Line 428 ⟶ 427:
return 0;
}</
{{libheader|QD}}
QD is a simple and easy-to-use wrapper around SDL.
<
void main() {
screen(640, 480);
while (true) events();
}</
=={{header|Delphi}}==
Line 443 ⟶ 442:
This first example is a minimalist approach using Delphi's standard Window (form) creation procedure. In Delphi 7, this will create a single Window executable of 362KB.
<syntaxhighlight lang="delphi">
// The project file (Project1.dpr)
Line 502 ⟶ 501:
end
</syntaxhighlight>
This second example demonstrates a 'pure' Windows API approach (i.e. NOT using the Delphi Visual Component Library). In Delphi 7, this will create a single Window executable of 15KB.
<syntaxhighlight lang="delphi">
program Project3;
Line 570 ⟶ 569:
end.
</syntaxhighlight>
=={{header|Dragon}}==
{{libheader|GUI}}
<
window = newWindow("Window")
Line 580 ⟶ 579:
window.setVisible()
</syntaxhighlight>
=={{header|E}}==
Line 599 ⟶ 598:
Platform independent EiffelVision 2 Library
<
APPLICATION
inherit
Line 617 ⟶ 616:
first_window: MAIN_WINDOW
-- Main window.
end</
<
MAIN_WINDOW
inherit
Line 669 ⟶ 668:
main_container_created: main_container /= Void
end
end</
{{libheader|Windows Forms}}
<
APPLICATION
inherit
Line 691 ⟶ 690:
{WINFORMS_APPLICATION}.run_form (Current)
end
end</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(make-frame)</syntaxhighlight>
=={{header|Euphoria}}==
===ARWEN===
{{libheader|ARWEN}}
<
constant win = create(Window, "ARWEN window", 0, 0,100,100,640,480,{0,0})
WinMain(win, SW_NORMAL)
</syntaxhighlight>
===EuGTK===
{{libheader|EuGTK}}
<
constant win = create(GtkWindow,"title=EuGTK Window;size=640x480;border=10;$destroy=Quit")
show_all(win)
main()</
===EuWinGUI===
{{libheader|EuWinGUI}}
<
Window("EuWinGUI window",100,100,640,480)
Line 732 ⟶ 725:
end while
CloseApp(0)</
===Win32Lib===
{{libheader|Win32Lib}}
<
constant win = createEx( Window, "Win32Lib", 0, Default, Default, 640, 480, 0, 0 )
WinMain( win, Normal )</
===wxEuphoria===
{{libheader|wxEuphoria}}
<
constant win = create( wxFrame, {0, -1, "wxEuphoria window", -1, -1, 640, 480} )
wxMain( win )</
=={{header|F_Sharp|F#}}==
Line 754 ⟶ 747:
{{libheader|Windows Forms}}
<
[<System.STAThread>]
do
Form(Text = "F# Window")
|> Application.Run</
=={{header|Factor}}==
<
"This is a window..." <label> "Really?" open-window</
=={{header|Fantom}}==
<
using fwt
Line 777 ⟶ 770:
}
}
</syntaxhighlight>
=={{header|Forth}}==
Line 784 ⟶ 777:
'''gtk-server command:''' gtk-server -fifo=ffl-fifo &
<
\ Open the connection to the gtk-server and load the Gtk2 definitions
Line 816 ⟶ 809:
gsv+close drop
[THEN]</
===iMops===
{{works with|iMops on MacOS}}
<syntaxhighlight lang="iMops">
Window+ w \ create a window
View v \ create a view
300 30 430 230 put: frameRect \ size a rectangle for the view
frameRect " Test" docWindow v new: w \ activate the view and window
show: w \ display the window
</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
#Include "windows.bi"
Line 836 ⟶ 841:
End
</syntaxhighlight>
=={{header|Frink}}==
<
g=(new graphics).show[]
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">window 1</syntaxhighlight>
=={{header|Gambas}}==
<
End</
=={{header|Go}}==
===GTK===
{{libheader|go-gtk}}
<
import (
Line 865 ⟶ 873:
window.Show()
gtk.Main()
}</
===SDL===
{{libheader|Go-SDL}}
<
import (
Line 890 ⟶ 898:
}
window.Destroy()
}</
===X11===
<
import (
Line 914 ⟶ 922:
}
}
}</
=={{header|Groovy}}==
Line 927 ⟶ 935:
We will open notepad as a window here.
<syntaxhighlight lang
To close the window:
<syntaxhighlight lang
=={{header|Haskell}}==
Line 937 ⟶ 945:
A simple graphics library, designed to give the programmer access to most interesting parts of the Win32 Graphics Device Interface and X11 library without exposing the programmer to the pain and anguish usually associated with using these interfaces.
<
aWindow = runGraphics $
withWindow_ "Rosetta Code task: Creating a window" (300, 200) $ \ w -> do
drawInWindow w $ text (100, 100) "Hello World"
getKey w</
=={{header|HicEst}}==
<
! window units: as pixels < 0, as relative window size 0...1, ascurrent character sizes > 1
WRITE(WINdowhandle=handle) '... some output ...'</
=={{header|IDL}}==
Line 959 ⟶ 967:
Icon and Unicon windowing is portable between Windows and X-Windows environments.
==={{header|Icon}}===
<
procedure main(arglist)
Line 965 ⟶ 973:
WOpen("size=300, 300", "fg=blue", "bg=light gray")
WDone()
end</
{{libheader|Icon Programming Library}}
Line 973 ⟶ 981:
The Icon solution works in Unicon. An Unicon-only version is as follows:
<
import gui
$include "guih.icn"
Line 991 ⟶ 999:
w.show_modal ()
end
</syntaxhighlight>
=={{header|J}}==
A minimalist modal dialog:
<
A free-standing window:
<
pc minwdw;
pas 162 85;pcenter;
Line 1,012 ⟶ 1,020:
)
minwdw_run ''</
=={{header|Java}}==
{{libheader|Swing}}
<
public class Main {
Line 1,025 ⟶ 1,033:
w.setVisible(true);
}
}</
=={{header|JavaScript}}==
Line 1,031 ⟶ 1,039:
=={{header|Julia}}==
<
using Tk
w = Toplevel("Example")</
=={{header|Kotlin}}==
{{trans|Java}}
<
fun main(args : Array<String>) {
Line 1,048 ⟶ 1,056:
isVisible = true
}
}</
=={{header|Liberty BASIC}}==
Minimum code required to fulfill the task.
<
open "GUI Window" for window as #1
wait
</
As it would properly be used in a real program.
<
open "GUI Window" for window as #1
#1 "trapclose Quit"
Line 1,065 ⟶ 1,073:
end
end sub
</
=={{header|Lingo}}==
<
w = 320
h = 240
Line 1,079 ⟶ 1,087:
-- it can be re-used for multiple windows.
win.filename = _movie.path & "empty.dir"
win.open()</
=={{header|Lua}}==
{{libheader|IUPLua}}
<
iup.dialog{
Line 1,094 ⟶ 1,102:
iup.MainLoop()
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
Line 1,109 ⟶ 1,117:
<syntaxhighlight lang="m2000 interpreter">
Module DisplayWindow {
Declare MyForm Form
Line 1,115 ⟶ 1,123:
}
DisplayWindow
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">CreateDocument[]</syntaxhighlight>
=={{header|mIRC Scripting Language}}==
Line 1,136 ⟶ 1,142:
=={{header|Nanoquery}}==
This program creates and displays a 300x300 window with no contents and the title Nanoquery.
<
=={{header|NetRexx}}==
{{libheader|Swing}}
<
options replace format comments java crossref symbols binary
Line 1,194 ⟶ 1,200:
method isFalse() public static returns boolean
return \(1 == 1)
</syntaxhighlight>
=={{header|Nim}}==
=== gtk3 / gintro ===
{{libheader|gintro}}
<syntaxhighlight lang="nim">import gintro/[glib, gobject, gtk, gio]
proc activate(app: Application) =
## Activate the application.
let window = newApplicationWindow(app)
window.setTitle("Window for Rosetta")
window.setSizeRequest(640, 480)
window.showAll()
let app = newApplication(Application, "Rosetta.Window")
discard app.connect("activate", activate)
discard app.run()</syntaxhighlight>
=== gtk2 ===
This is example 9 from the Araq/Nim github repository (modified to include a quit button)
<
const
Inside
OutSide
# Context transmitted to callback.
type Context = object
label: PLabel
overButton: bool
proc changeLabel(p: PWidget; event: gdk2.PEventCrossing; context: var Context) {.cdecl.} =
context.label.set_text(if context.overButton: OutSide else: Inside)
context.overButton = not context.overButton
proc thisDestroy(widget: PWidget, data: Pgpointer) {.cdecl.} =
main_quit()
var context: Context
nim_init()
let window = window_new(gtk2.WINDOW_TOPLEVEL)
let stackbox = vbox_new(true, 10)
let button1 = button_new("Move mouse over button")
let buttonstyle = copy(button1.get_style())
buttonstyle.bg[STATE_PRELIGHT] = TColor(pixel: 0, red: 255, green: 0, blue: 0)
button1.set_style(buttonstyle)
let button2 = button_new()
context = Context(label: label_new(Outside), overButton: false)
let button3 = button_new("Quit")
button2.add(context.label)
stackbox.pack_start(button1, true, true, 0)
stackbox.pack_start(button2, true, true, 0)
stackbox.pack_start(button3, true, true, 0)
window.set_border_width(5)
window.add(stackbox)
discard window.signal_connect("destroy", SIGNAL_FUNC(thisDestroy), nil)
discard button1.signal_connect("enter_notify_event", SIGNAL_FUNC(changeLabel), addr(context))
discard button1.signal_connect("leave_notify_event", SIGNAL_FUNC(changeLabel), addr(context))
discard button3.signal_connect("clicked", SIGNAL_FUNC(thisDestroy), nil)
window.show_all()
main()</syntaxhighlight>
=== SDL ===
<
sdl, sdl_image, colors
Line 1,300 ⟶ 1,317:
greeting.freeSurface()
screen.freeSurface()
sdl.Quit()</
=== X11 ===
<syntaxhighlight lang
const
WINDOW_WIDTH = 400
WINDOW_HEIGHT = 300
type WindowData = tuple[display: PDisplay; window: Window]
proc createWindow: WindowData =
let width: cuint = WINDOW_WIDTH
let height: cuint = WINDOW_HEIGHT
var sizeHints: XSizeHints
let display = XOpenDisplay(nil)
if display == nil:
echo
quit
let screen = XDefaultScreen(display)
var rootwin = XRootWindow(display, screen)
let win = XCreateSimpleWindow(display, rootwin, 100, 10, width, height, 5,
sizeHints.flags = PSize or PMinSize or PMaxSize
sizeHints.min_width = width.cint
sizeHints.max_width = width.cint
discard XSetStandardProperties(
display, win, "Simple Window", "window", 0, nil, 0, addr(sizeHints))
discard
discard XMapWindow(display, win)
result = (display, win)
proc closeWindow(data: WindowData) =
discard XDestroyWindow(data.display,
discard XCloseDisplay(data.display)
proc processEvent(xev: var XEvent) =
var key:
case
of KeyPress:
key = XLookupKeysym(cast[ptr
if key.int != 0:
echo
if key.int == 65307: # <Esc>
quit
of ButtonPressMask, PointerMotionMask:
else:
discard
proc eventloop(data: WindowData) =
var xev: XEvent
var numEvents = XPending(data.display).int
while numEvents != 0:
dec numEvents
discard XNextEvent(data.display, addr(xev))
processEvent(xev)
let windata = createWindow()
while true:
eventloop(windata)
windata.closeWindow()</syntaxhighlight>
=== glut ===
<
var win: int = 0
Line 1,391 ⟶ 1,398:
win = glutCreateWindow("Goodbye, World!")
glutKeyboardFunc(TGlut1Char2IntCallback(myOnKeyPress))
glutMainLoop()</
=== win ===
<
import
Line 1,402 ⟶ 1,409:
# {stdcall, import: "MessageBox", header: "<windows.h>"}
discard MessageBox(0, "Hello World!", "Nim GUI Application", 0)</
=== IUP ===
<
# assumes you have the iup .dll or .so installed
Line 1,428 ⟶ 1,435:
discard mainloop()
iup.close()</
=== wxWidgets ===
This example works on MacOS but should be cross platform and native
<
{.experimental.}
Line 1,449 ⟶ 1,456:
window.show(true)
run_main_loop()</
=={{header|Objeck}}==
<
use Gtk2;
Line 1,467 ⟶ 1,474:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
Line 1,476 ⟶ 1,483:
It opens a 800×600 window, centered on the screen, with title "A Window".
<
#include <AppKit/AppKit.h>
Line 1,524 ⟶ 1,531:
}
return EXIT_SUCCESS;
}</
=={{header|OCaml}}==
{{libheader|LablTk}}
<
let top = Tk.openTk() in
Wm.title_set top "An Empty Window";
Wm.geometry_set top "240x180";
Tk.mainLoop ();
;;</
execute with:
ocaml -I +labltk labltk.cma sample.ml
with the [http://caml.inria.fr/pub/docs/manual-ocaml/manual039.html Graphics] module:
<
let () =
open_graph " 800x600";
let _ = read_line() in
close_graph ()</
execute with:
ocaml graphics.cma tmp.ml
{{libheader|LablGTK2}}
<
let window = GWindow.window ~border_width:2 ()
Line 1,559 ⟶ 1,566:
button#connect#clicked ~callback:window#destroy;
window#show ();
Main.main ()</
execute with:
ocaml -I +lablgtk2 lablgtk.cma gtkInit.cmo sample.ml
{{libheader|OCamlSDL}}
<
Sdl.init [`VIDEO];
let _ = Sdlvideo.set_video_mode 200 200 [] in
Sdltimer.delay 2000;
Sdl.quit ()</
execute with:
ocaml bigarray.cma -I +sdl sdl.cma sample.ml
{{libheader|OCamlSDL2}}
<
let () =
Line 1,588 ⟶ 1,595:
Render.render_present renderer;
Timer.delay 3000;
Sdl.quit ()</
execute with:
ocaml -I +sdl2 sdl2.cma sample.ml
{{libheader|ocaml-sfml}}
<
let app = SFRenderWindow.make (640, 480) "OCaml-SFML Windowing" in
Line 1,606 ⟶ 1,613:
if continue then loop ()
in
loop ()</
execute with:
ocaml -I /tmp/ocaml-sfml/src sfml_system.cma sfml_window.cma sfml_graphics.cma win.ml
{{libheader|OCaml-Xlib}}
<
let () =
Line 1,622 ⟶ 1,629:
let _ = xNextEventFun d in (* waits any key-press event *)
xCloseDisplay d;
;;</
execute with:
ocaml -I +Xlib Xlib.cma sample.ml
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "vendor:sdl2"
main :: proc() {
using sdl2
window: ^Window = ---
renderer: ^Renderer = ---
event: Event = ---
Init(INIT_VIDEO)
CreateWindowAndRenderer(
640, 480,
WINDOW_SHOWN,
&window, &renderer
)
SetWindowTitle(window, "Empty window")
RenderPresent(renderer)
for event.type != .QUIT {
Delay(10)
PollEvent(&event)
}
DestroyRenderer(renderer)
DestroyWindow(window)
Quit()
}</syntaxhighlight>
=={{header|OpenEdge ABL/Progress 4GL}}==
<syntaxhighlight lang="openedgeabl">
DEFINE VAR C-Win AS WIDGET-HANDLE NO-UNDO.
Line 1,662 ⟶ 1,701:
WAIT-FOR CLOSE OF THIS-PROCEDURE.
</syntaxhighlight>
=={{header|Oz}}==
<
import
Application
Line 1,682 ⟶ 1,721:
Window = {QTk.build GUIDescription}
{Window show}
end</
=={{header|Pascal}}==
{{works with|Free_Pascal}}
{{libheader|SysUtils}}{{libheader|SDL}}
<
{$linklib SDL}
Line 1,703 ⟶ 1,742:
sleep(2000);
SDL_Quit;
end.</
=={{header|Perl}}==
Line 1,709 ⟶ 1,748:
==={{libheader|Perl/Tk}}===
<
MainWindow->new();
MainLoop;</
==={{libheader|Perl/SDL}}===
<
use SDL::Event;
Line 1,721 ⟶ 1,760:
$app->loop({
SDL_QUIT() => sub { exit 0; },
});</
==={{libheader|Perl/Gtk3}}===
<
$window = Gtk3::Window->new;
Line 1,731 ⟶ 1,770:
);
$window->show_all;
Gtk3->main;</
==={{libheader|Perl/Qt}}===
<
use warnings;
use QtGui4;
Line 1,741 ⟶ 1,780:
my $window = Qt::MainWindow;
$window->show;
exit $app->exec;</
==={{libheader|Perl/Wx}}===
<
$window = Wx::Frame->new(undef, -1, 'title');
$window->Show;
Wx::SimpleApp->new->MainLoop;</
=={{header|Phix}}==
{{libheader|Phix/
{{libheader|Phix/pGUI}}
Works on Windows/Linux, 32/64-bit, and you can run this online [http://phix.x10.mx/p2js/Window_creation.htm here].
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\Window_creation.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<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;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">IupVbox</span><span style="color: #0000FF;">({</span><span style="color: #7060A8;">IupLabel</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"hello"</span><span style="color: #0000FF;">)},</span><span style="color: #008000;">"MARGIN=200x200"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"TITLE=Hello"</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
{{trans|C}}
<
(glutInit)
(glutCreateWindow "Goodbye, World!")
(keyboardFunc '(() (bye)))
(glutMainLoop)</
=={{header|PowerShell}}==
{{libheader|WPK}}
<syntaxhighlight lang
{{libheader|Windows Forms}}
<
$form.Text = "A Window"
$form.Size = New-Object Drawing.Size(150,150)
$form.ShowDialog() | Out-Null</
=={{header|Processing}}==
<syntaxhighlight lang="java">
size(1000,1000);
</syntaxhighlight>
=={{header|Prolog}}==
Works with SWI-Prolog which has a graphic interface XPCE.
<syntaxhighlight lang
=={{header|PureBasic}}==
<
x = 400
y = 300
If OpenWindow(0, 0, 0, x, y, "I am a window - PureBasic", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
If CreateImage(0, x, y) And StartDrawing(ImageOutput(0))
DrawingMode(#PB_2DDrawing_Transparent)
Box(0, 0, x, y, #White)
For i = 1 To 10
DrawText(x/3, y/2, "Hello World!", #Black)
;DrawText(Random(200), Random(200), "Hello World!", RGB(Random(255), Random(255), Random(255)))
Next i
StopDrawing()
ImageGadget(0, 0, 0, x, y, ImageID(0))
EndIf
Repeat
Event = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Case #PB_Event_CloseWindow
EndSelect
ForEver
EndIf</syntaxhighlight>
=={{header|Python}}==
Line 1,805 ⟶ 1,864:
==={{libheader|Tkinter}}===
<
w = Tkinter.Tk()
w.mainloop()</
{{works with|Python|3.7}}
<!-- see also https://stackoverflow.com/questions/673174/which-tkinter-modules-were-renamed-in-python-3 -->
<
w = tkinter.Tk()
w.mainloop()</
==={{libheader|wxPython}}===
<
class MyApp(wxApp):
Line 1,828 ⟶ 1,887:
app = MyApp(0)
app.MainLoop()</
==={{libheader|Pythonwin}}===
<
from pywin.mfc.dialog import Dialog
d = Dialog(win32ui.IDD_SIMPLE_INPUT)
d.CreateWindow()</
==={{libheader|PyGTK}}===
<
window = gtk.Window()
window.show()
gtk.main()</
==={{libheader|PyQT}}===
<
app = QApplication([])
Line 1,851 ⟶ 1,910:
win.show()
app.exec_()</
=={{header|R}}==
Although R cannot create windows itself, it has wrappers for several GUI toolkits. tcl/tk is shipped with R by default, and you can create windows with that.
<syntaxhighlight lang="r">
win <- tktoplevel()
</syntaxhighlight>
{{libheader|gWidgets}}
The gWidgets packages let you write GUIs in a toolkit independent way. You can create a window with
<syntaxhighlight lang="r">
library(gWidgetstcltk) #or e.g. gWidgetsRGtk2
win <- gwindow()
</syntaxhighlight>
=={{header|Racket}}==
<
#lang racket/gui
(send (new frame%
Line 1,875 ⟶ 1,934:
[width 100] [height 100])
show #t)
</syntaxhighlight>
=={{header|Raku}}==
Line 1,882 ⟶ 1,941:
Exit either by clicking the button or the close window control in the upper corner.
<syntaxhighlight lang="raku"
use GTK::Simple::App;
Line 1,899 ⟶ 1,958:
$button.clicked.tap: { $app.exit }
$app.run;</
=={{header|RapidQ}}==
Line 1,911 ⟶ 1,970:
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
view layout [size 100x100]
</syntaxhighlight>
'size' needed to show the close-window button.
Line 1,919 ⟶ 1,978:
=={{header|Red}}==
Empty Window with close [X] button
<
</syntaxhighlight>
=={{header|Ring}}==
<
Load "guilib.ring"
Line 1,932 ⟶ 1,991:
show()}
exec()}
</syntaxhighlight>
=={{header|Ruby}}==
Line 1,938 ⟶ 1,997:
{{libheader|Ruby/Tk}}
<
window = TkRoot::new()
window::mainloop()</
{{libheader|GTK}}
<
window = Gtk::Window.new.show
Gtk.main</
{{libheader|Shoes}}
<syntaxhighlight lang
=={{header|Run BASIC}}==
Show a empty browser with a button to "Close Me"
<
button #c, "Close Me", [doExit]
wait
Line 1,970 ⟶ 2,029:
history.go(-a);
</script>"
wait</
=={{header|Rust}}==
{{libheader|winit}}
<syntaxhighlight lang="rust">use winit::event::{Event, WindowEvent}; // winit 0.24
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
fn main() {
let event_loop = EventLoop::new();
let _win = WindowBuilder::new()
.with_title("Window")
.build(&event_loop).unwrap();
event_loop.run(move |ev, _, flow| {
match ev {
Event::WindowEvent {
event: WindowEvent::CloseRequested, ..
} => {
*flow = ControlFlow::Exit;
}
_ => {}
}
});
}</syntaxhighlight>
=={{header|Scala}}==
{{libheader|sdljava}}
{{libheader|Scala Java Swing interoperability}}
<
object ShowWindow{
Line 1,985 ⟶ 2,069:
jf.setVisible(true)
}
}</
Using native Scala libraries (which are wrappers over Java libraries):
<
import scala.swing.Swing._
Line 1,997 ⟶ 2,081:
preferredSize = ((800, 600):Dimension)
}
}</
=={{header|Scheme}}==
{{libheader|Scheme/PsTk}}
<
#!r6rs
Line 2,015 ⟶ 2,099:
(tk-event-loop tk)
</syntaxhighlight>
=={{header|Seed7}}==
Line 2,024 ⟶ 2,108:
The program waits until a key is pressed and exits.
<
include "draw.s7i";
include "keybd.s7i";
Line 2,033 ⟶ 2,117:
KEYBOARD := GRAPH_KEYBOARD;
ignore(getc(KEYBOARD));
end func;</
=={{header|Sidef}}==
===Tk===
<
%s'MainWindow'.new;
tk.MainLoop;</
===Gtk2===
<
var window = %s'Gtk2::Window'.new;
window.signal_connect(destroy => func(*_) { gtk2.main_quit });
window.show_all;
gtk2.main;</
=={{header|Smalltalk}}==
{{works with|Pharo}}
{{works with|Squeak}}
<syntaxhighlight lang
{{works with|Smalltalk/X}}
<
top := TopView new.
top add: (Label label: 'Hello World') in:(0.0@0.0 corner:1.0@1.0).
top open</
=={{header|Standard ML}}==
Works with PolyML (XWindows/Motif module)
<syntaxhighlight lang="standard ml">
open XWindows ;
open Motif ;
Line 2,082 ⟶ 2,166:
end;
</syntaxhighlight>
call
<syntaxhighlight lang="standard ml">
showWindow ()
</syntaxhighlight>
=={{header|Tcl}}==
{{libheader|Tk}}
Loading the [[Tk]] package is all that is required to get an initial window:
<syntaxhighlight lang
If you need an additional window:
<syntaxhighlight lang
If you are using the increasingly popular [http://www.equi4.com/tclkit.html tclkit] under MS Windows, all you have to do is associate the tclkit with the extension “<tt>.tcl</tt>” and then create an <i>empty</i> file with, e.g., with the name <tt>nothing.tcl</tt>. Double-clicking that will “open a window” (an empty one).
=={{header|TI-89 BASIC}}==
<
=={{header|Toka}}==
Line 2,110 ⟶ 2,194:
=={{header|TorqueScript}}==
<syntaxhighlight lang="torquescript">
new GuiControl(GuiName)
{
Line 2,149 ⟶ 2,233:
canvas.pushDialog(GuiName);
</syntaxhighlight>
=={{header|TXR}}==
Line 2,169 ⟶ 2,253:
Here, we exploit TXR's capability to define enumerations of specific types: we make the event enumeration based on <code>uint8</code>, giving it a <code>typedef</code> name, and then use that <code>typedef</code> in the <code>SD_Event</code> union.
<
(defvarl SDL_SWSURFACE #x00000000)
(defvarl SDL_HWPALETTE #x20000000)
Line 2,202 ⟶ 2,286:
(until* (memql (union-get e 'type) '(SDL_KEYUP SDL_QUIT))
(SDL_WaitEvent e))))
(SDL_Quit))</
===X11===
Line 2,212 ⟶ 2,296:
Also, this uses an enumeration for the events, so when the event type is decoded from the <code>XEvent</code> union, it comes out as a Lisp symbol.
<
(typedef Window XID)
Line 2,277 ⟶ 2,361:
(KeyPress (return)))))
(XCloseDisplay d)))</
===GTK2===
Line 2,283 ⟶ 2,367:
{{trans|C}}
<
(typedef GtkWidget* (cptr GtkWidget))
Line 2,313 ⟶ 2,397:
(gtk_signal_connect (GTK_OBJECT window) "destroy" gtk_main_quit nil)
(gtk_widget_show window)
(gtk_main))</
===Win32/Win64===
Line 2,321 ⟶ 2,405:
Note that the <code>CW_USEDEFAULT</code> constant in the Windows header files is defined as <code>0x80000000</code>. This is out of range of the signed <code>int</code> arguments of <code>CreateWindowEx</code> with which it is used. Microsoft is relying on an implementation-defined C conversion to turn this value into the most negative <code>int</code>. When the original constant was used in the TXR translation, TXR's FFI '''uncovered this little problem''' by throwing an exception arising from the out-of-range conversion attempt. The fix is to specify the correct value directly as <code>#x-80000000</code>.
<
(typedef LPARAM int-ptr-t)
(typedef WPARAM uint-ptr-t)
Line 2,450 ⟶ 2,534:
(while (GetMessage msg NULL 0 0)
(TranslateMessage msg)
(DispatchMessage msg))))))</
=={{header|VBA}}==
Line 2,459 ⟶ 2,543:
And :
Programmatic Access to Visual Basic Project must be trusted. See it in Macro's security!</pre>
<syntaxhighlight lang="vb">
Option Explicit
Line 2,467 ⟶ 2,551:
strname = myForm.Name
VBA.UserForms.Add(strname).Show
End Sub</
=={{header|Vedit macro language}}==
Creates an empty window with ID 'A' near the upper left corner of document area, with height of 20 text lines and width of 80 characters.
<
Note: if you run this command while in Visual Mode, you should adjust your active window smaller so that the created window will not be hidden behind it (since the active window is always on top).
=={{header|Visual Basic .NET}}==
<
newForm.Text = "It's a new window"
newForm.Show()</
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Zig">
import gg
import gx
fn main() {
mut app := gg.new_context(
bg_color: gx.white
resizable: true
create_window: true
width: 600
height: 600
frame_fn: frame
window_title: "Empty Window"
)
app.run()
}
fn frame(mut ctx gg.Context) {
ctx.begin()
ctx.end()
}
</syntaxhighlight>
=={{header|Wren}}==
{{libheader|DOME}}
<syntaxhighlight lang="wren">import "dome" for Window
class EmptyWindow {
construct new(width, height) {
Window.title = "Empty window"
Window.resize(width, height)
}
init() {}
update() {}
draw(alpha) {}
}
var Game = EmptyWindow.new(600, 600)</syntaxhighlight>
=={{header|X86 Assembly}}==
{{libheader|GTK}}<br>
{{works with|NASM}}
<
;GTK imports and defines etc.
%define GTK_WINDOW_TOPLEVEL 0
Line 2,542 ⟶ 2,669:
exit_sig_msg db "-> Rage quitting..",10,0
</syntaxhighlight>
<br>
{{works with|MASM}}
<
.586
.model flat, stdcall
Line 2,621 ⟶ 2,748:
WndProc endp
end start
</syntaxhighlight>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">open window 400,200 //minimum line required to accomplish the indicated task
clear screen
text 200,100,"I am a window - close me!","cc"
end</syntaxhighlight>
{{omit from|Batch File|No access to GUI functions.}}
{{omit from|EasyLang}}
{{omit from|Logtalk}}
{{omit from|Maxima}}
|