Window creation: Difference between revisions
→{{header|PureBasic}}: expanding the task
(Window creation in Yabasic) |
(→{{header|PureBasic}}: expanding the task) |
||
(8 intermediate revisions by 8 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}}==
<
=={{header|AurelBasic}}==
<
=={{header|AutoHotkey}}==
<
Gui, Show</
=={{header|AutoIt}}==
<
GUISetState(@SW_SHOW)
Line 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 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")</
=={{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 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 169:
return 0;
}</
===GTK===
Line 177:
'''Compile command:''' gcc `gtk-config --cflags` `gtk-config --libs` -o window window.c
<
int
Line 192:
return 0;
}</
===GTK2===
Line 199:
'''Compile command:''' gcc -Wall -pedantic `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -o window window.c
<
int
Line 213:
return 0;
}</
===GLUT===
Line 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 266:
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
Line 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 286:
Application.Run();
}
}</
=={{header|C++}}==
Line 293:
'''Compiler command:''' qmake -pro; qmake
<
#include <QMainWindow>
Line 302:
window.show();
return app.exec();
}</
{{libheader|GTK}}
Line 308:
'''Compiler command:''' g++ filename.cc -o test `pkg-config --cflags --libs gtkmm-2.4`
<
#include <gtkmm.h>
Line 328:
exit( 0 ) ;
}</
=={{header|Clojure}}==
Line 334:
{{uses from|library|Swing|component1=JFrame}}
<
(let [frame (JFrame. "A Window")]
(doto frame
(.setSize 600 800)
(.setVisible true)))</
=={{header|Common Lisp}}==
Line 347:
{{works with|LispWorks}}
<
==={{libheader|CLIM}}===
Line 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 374:
Works with the Armed Bear Common Lisp implementation that targets the JVM.
<
"Creates a window"
(let ((window (jnew (jconstructor "javax.swing.JFrame"))))
Line 380:
window (make-immediate-object t :boolean))))
(create-window)</
=={{header|D}}==
{{libheader|FLTK4d}}
<
import fltk4d.all;
Line 392:
window.show;
FLTK.run;
}</
{{libheader|Derelict}}
{{libheader|SDL}}
<
int main(char[][] args)
Line 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 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 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 569:
end.
</syntaxhighlight>
=={{header|Dragon}}==
{{libheader|GUI}}
<
window = newWindow("Window")
Line 579:
window.setVisible()
</syntaxhighlight>
=={{header|E}}==
Line 598:
Platform independent EiffelVision 2 Library
<
APPLICATION
inherit
Line 616:
first_window: MAIN_WINDOW
-- Main window.
end</
<
MAIN_WINDOW
inherit
Line 668:
main_container_created: main_container /= Void
end
end</
{{libheader|Windows Forms}}
<
APPLICATION
inherit
Line 690:
{WINFORMS_APPLICATION}.run_form (Current)
end
end</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang
=={{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 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 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 770:
}
}
</syntaxhighlight>
=={{header|Forth}}==
Line 777:
'''gtk-server command:''' gtk-server -fifo=ffl-fifo &
<
\ Open the connection to the gtk-server and load the Gtk2 definitions
Line 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 829 ⟶ 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 858 ⟶ 873:
window.Show()
gtk.Main()
}</
===SDL===
{{libheader|Go-SDL}}
<
import (
Line 883 ⟶ 898:
}
window.Destroy()
}</
===X11===
<
import (
Line 907 ⟶ 922:
}
}
}</
=={{header|Groovy}}==
Line 920 ⟶ 935:
We will open notepad as a window here.
<syntaxhighlight lang
To close the window:
<syntaxhighlight lang
=={{header|Haskell}}==
Line 930 ⟶ 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 952 ⟶ 967:
Icon and Unicon windowing is portable between Windows and X-Windows environments.
==={{header|Icon}}===
<
procedure main(arglist)
Line 958 ⟶ 973:
WOpen("size=300, 300", "fg=blue", "bg=light gray")
WDone()
end</
{{libheader|Icon Programming Library}}
Line 966 ⟶ 981:
The Icon solution works in Unicon. An Unicon-only version is as follows:
<
import gui
$include "guih.icn"
Line 984 ⟶ 999:
w.show_modal ()
end
</syntaxhighlight>
=={{header|J}}==
A minimalist modal dialog:
<
A free-standing window:
<
pc minwdw;
pas 162 85;pcenter;
Line 1,005 ⟶ 1,020:
)
minwdw_run ''</
=={{header|Java}}==
{{libheader|Swing}}
<
public class Main {
Line 1,018 ⟶ 1,033:
w.setVisible(true);
}
}</
=={{header|JavaScript}}==
Line 1,024 ⟶ 1,039:
=={{header|Julia}}==
<
using Tk
w = Toplevel("Example")</
=={{header|Kotlin}}==
{{trans|Java}}
<
fun main(args : Array<String>) {
Line 1,041 ⟶ 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,058 ⟶ 1,073:
end
end sub
</
=={{header|Lingo}}==
<
w = 320
h = 240
Line 1,072 ⟶ 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,087 ⟶ 1,102:
iup.MainLoop()
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
Line 1,102 ⟶ 1,117:
<syntaxhighlight lang="m2000 interpreter">
Module DisplayWindow {
Declare MyForm Form
Line 1,108 ⟶ 1,123:
}
DisplayWindow
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang
=={{header|mIRC Scripting Language}}==
Line 1,127 ⟶ 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,185 ⟶ 1,200:
method isFalse() public static returns boolean
return \(1 == 1)
</syntaxhighlight>
=={{header|Nim}}==
Line 1,191 ⟶ 1,206:
{{libheader|gintro}}
<
proc activate(app: Application) =
Line 1,202 ⟶ 1,217:
let app = newApplication(Application, "Rosetta.Window")
discard app.connect("activate", activate)
discard app.run()</
=== gtk2 ===
This is example 9 from the Araq/Nim github repository (modified to include a quit button)
<
const
Line 1,252 ⟶ 1,267:
window.show_all()
main()</
=== SDL ===
<
sdl, sdl_image, colors
Line 1,302 ⟶ 1,317:
greeting.freeSurface()
screen.freeSurface()
sdl.Quit()</
=== X11 ===
<
const
Line 1,368 ⟶ 1,383:
while true:
eventloop(windata)
windata.closeWindow()</
=== glut ===
<
var win: int = 0
Line 1,383 ⟶ 1,398:
win = glutCreateWindow("Goodbye, World!")
glutKeyboardFunc(TGlut1Char2IntCallback(myOnKeyPress))
glutMainLoop()</
=== win ===
<
import
Line 1,394 ⟶ 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,420 ⟶ 1,435:
discard mainloop()
iup.close()</
=== wxWidgets ===
This example works on MacOS but should be cross platform and native
<
{.experimental.}
Line 1,441 ⟶ 1,456:
window.show(true)
run_main_loop()</
=={{header|Objeck}}==
<
use Gtk2;
Line 1,459 ⟶ 1,474:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
Line 1,468 ⟶ 1,483:
It opens a 800×600 window, centered on the screen, with title "A Window".
<
#include <AppKit/AppKit.h>
Line 1,516 ⟶ 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,551 ⟶ 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,580 ⟶ 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,598 ⟶ 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,614 ⟶ 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,654 ⟶ 1,701:
WAIT-FOR CLOSE OF THIS-PROCEDURE.
</syntaxhighlight>
=={{header|Oz}}==
<
import
Application
Line 1,674 ⟶ 1,721:
Window = {QTk.build GUIDescription}
{Window show}
end</
=={{header|Pascal}}==
{{works with|Free_Pascal}}
{{libheader|SysUtils}}{{libheader|SDL}}
<
{$linklib SDL}
Line 1,695 ⟶ 1,742:
sleep(2000);
SDL_Quit;
end.</
=={{header|Perl}}==
Line 1,701 ⟶ 1,748:
==={{libheader|Perl/Tk}}===
<
MainWindow->new();
MainLoop;</
==={{libheader|Perl/SDL}}===
<
use SDL::Event;
Line 1,713 ⟶ 1,760:
$app->loop({
SDL_QUIT() => sub { exit 0; },
});</
==={{libheader|Perl/Gtk3}}===
<
$window = Gtk3::Window->new;
Line 1,723 ⟶ 1,770:
);
$window->show_all;
Gtk3->main;</
==={{libheader|Perl/Qt}}===
<
use warnings;
use QtGui4;
Line 1,733 ⟶ 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}}==
Line 1,746 ⟶ 1,793:
{{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].
<!--<
<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>
Line 1,756 ⟶ 1,803:
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</
=={{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 CreateImage(0, x, y) And StartDrawing(ImageOutput(0))
DrawingMode(#PB_2DDrawing_Transparent)
Box(0, 0, x, y, #White)
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,800 ⟶ 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,823 ⟶ 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,846 ⟶ 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,870 ⟶ 1,934:
[width 100] [height 100])
show #t)
</syntaxhighlight>
=={{header|Raku}}==
Line 1,877 ⟶ 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,894 ⟶ 1,958:
$button.clicked.tap: { $app.exit }
$app.run;</
=={{header|RapidQ}}==
Line 1,906 ⟶ 1,970:
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
view layout [size 100x100]
</syntaxhighlight>
'size' needed to show the close-window button.
Line 1,914 ⟶ 1,978:
=={{header|Red}}==
Empty Window with close [X] button
<
</syntaxhighlight>
=={{header|Ring}}==
<
Load "guilib.ring"
Line 1,927 ⟶ 1,991:
show()}
exec()}
</syntaxhighlight>
=={{header|Ruby}}==
Line 1,933 ⟶ 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,965 ⟶ 2,029:
history.go(-a);
</script>"
wait</
=={{header|Rust}}==
{{libheader|winit}}
<
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
Line 1,989 ⟶ 2,053:
}
});
}</
Line 1,995 ⟶ 2,059:
{{libheader|sdljava}}
{{libheader|Scala Java Swing interoperability}}
<
object ShowWindow{
Line 2,005 ⟶ 2,069:
jf.setVisible(true)
}
}</
Using native Scala libraries (which are wrappers over Java libraries):
<
import scala.swing.Swing._
Line 2,017 ⟶ 2,081:
preferredSize = ((800, 600):Dimension)
}
}</
=={{header|Scheme}}==
{{libheader|Scheme/PsTk}}
<
#!r6rs
Line 2,035 ⟶ 2,099:
(tk-event-loop tk)
</syntaxhighlight>
=={{header|Seed7}}==
Line 2,044 ⟶ 2,108:
The program waits until a key is pressed and exits.
<
include "draw.s7i";
include "keybd.s7i";
Line 2,053 ⟶ 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,102 ⟶ 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,130 ⟶ 2,194:
=={{header|TorqueScript}}==
<syntaxhighlight lang="torquescript">
new GuiControl(GuiName)
{
Line 2,169 ⟶ 2,233:
canvas.pushDialog(GuiName);
</syntaxhighlight>
=={{header|TXR}}==
Line 2,189 ⟶ 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,222 ⟶ 2,286:
(until* (memql (union-get e 'type) '(SDL_KEYUP SDL_QUIT))
(SDL_WaitEvent e))))
(SDL_Quit))</
===X11===
Line 2,232 ⟶ 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,297 ⟶ 2,361:
(KeyPress (return)))))
(XCloseDisplay d)))</
===GTK2===
Line 2,303 ⟶ 2,367:
{{trans|C}}
<
(typedef GtkWidget* (cptr GtkWidget))
Line 2,333 ⟶ 2,397:
(gtk_signal_connect (GTK_OBJECT window) "destroy" gtk_main_quit nil)
(gtk_widget_show window)
(gtk_main))</
===Win32/Win64===
Line 2,341 ⟶ 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,470 ⟶ 2,534:
(while (GetMessage msg NULL 0 0)
(TranslateMessage msg)
(DispatchMessage msg))))))</
=={{header|VBA}}==
Line 2,479 ⟶ 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,487 ⟶ 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}}
<
class EmptyWindow {
Line 2,518 ⟶ 2,606:
}
var Game = EmptyWindow.new(600, 600)</
=={{header|X86 Assembly}}==
{{libheader|GTK}}<br>
{{works with|NASM}}
<
;GTK imports and defines etc.
%define GTK_WINDOW_TOPLEVEL 0
Line 2,581 ⟶ 2,669:
exit_sig_msg db "-> Rage quitting..",10,0
</syntaxhighlight>
<br>
{{works with|MASM}}
<
.586
.model flat, stdcall
Line 2,660 ⟶ 2,748:
WndProc endp
end start
</syntaxhighlight>
=={{header|Yabasic}}==
<
clear screen
text 200,100,"I am a window - close me!","cc"
end</
{{omit from|Batch File|No access to GUI functions.}}
{{omit from|EasyLang}}
{{omit from|Logtalk}}
{{omit from|Maxima}}
|