Window creation
From Rosetta Code
You are encouraged to solve this task according to the task description, using any language you may know.
Display a GUI window. The window need not have any contents, but should respond to requests to be closed.
[edit] Ada
with Gtk.Window; use Gtk.Window;
with Gtk.Widget; use Gtk.Widget;
with Gtk.Handlers;
with Gtk.Main;
procedure Windowed_Application is
Window : Gtk_Window;
package Handlers is new Gtk.Handlers.Callback (Gtk_Widget_Record);
package Return_Handlers is
new Gtk.Handlers.Return_Callback (Gtk_Widget_Record, Boolean);
function Delete_Event (Widget : access Gtk_Widget_Record'Class)
return Boolean is
begin
return False;
end Delete_Event;
procedure Destroy (Widget : access Gtk_Widget_Record'Class) is
begin
Gtk.Main.Main_Quit;
end Destroy;
begin
Gtk.Main.Init;
Gtk.Window.Gtk_New (Window);
Return_Handlers.Connect
( Window,
"delete_event",
Return_Handlers.To_Marshaller (Delete_Event'Access)
);
Handlers.Connect
( Window,
"destroy",
Handlers.To_Marshaller (Destroy'Access)
);
Show (Window);
Gtk.Main.Main;
end Windowed_Application;
[edit] AutoHotkey
Gui, Add, Text,, Hello
Gui, Show
[edit] C
[edit] SDL
Works with: ANSI C version C89
Library: SDL
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.
*/
#include <stdio.h>
#include <stdlib.h>
#include "SDL.h"
int main()
{
SDL_Surface *screen;
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fprintf(stderr, "Unable to initialize SDL: %s\n", SDL_GetError());
return 1;
}
atexit(SDL_Quit);
screen = SDL_SetVideoMode( 800, 600, 16, SDL_SWSURFACE | SDL_HWPALETTE );
return 0;
}
[edit] GTK
Library: GTK
Compile command: gcc `gtk-config --cflags` `gtk-config --libs` -o window window.c
#include <gtk/gtk.h>
int
main(int argc, char *argv[])
{
GtkWidget *window;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_widget_show(window);
gtk_main();
return 0;
}
[edit] GTK2
Library: Gtk2
Compile command: gcc -Wall -pedantic `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -o window window.c
#include <gtk/gtk.h>
int
main(int argc, char *argv[])
{
GtkWidget *window;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show(window);
gtk_main();
return 0;
}
[edit] GLUT
Library: GLUT
Compile command: gcc -I /usr/include/ -lglut -o window window_glut.c
Note that we aren't registering a painting or drawing callback, so the window will be created with nothing drawn in it. This is almost certain to lead to a strange appearance; On many systems, dragging the window around will appear to drag a copy of what was underneath where the window was when it was originally created.
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.
// A C+GLUT implementation of the Creating a Window task at Rosetta Code
// http://rosettacode.org/wiki/Creating_a_Window
#include <stdlib.h>
#include <GL/glut.h>
// This function is not strictly necessary to meet the requirements of the task.
void onKeyPress(unsigned char key, int x, int y)
{
// If you have any cleanup or such, you need to use C's
// onexit routine for registering cleanup callbacks.
exit(0);
}
int main(int argc, char **argv)
{
// Pulls out any command-line arguments that are specific to GLUT,
// And leaves a command-line argument set without any of those arguments
// when it returns.
// (If you want a copy, take a copy first.)
glutInit(&argc, argv);
// Tell GLUT we want to create a window.
// It won't *actually* be created until we call glutMainLoop below.
glutCreateWindow("Goodbye, World!");
// Register a callback to handle key press events (so we can quit on
// when someone hits a key) This part is not necessary to meet the
// requirements of the task.
glutKeyboardFunc(&onKeyPress);
// Put the execution of the app in glut's hands. Most GUI environments
// involve a message loop that communicate window events. GLUT handles
// most of these with defaults, except for any we register callbacks
// for. (Like the onKeyPress above.)
glutMainLoop();
return 0;
}
[edit] C++
Library: Qt
Compiler command: qmake -pro; qmake
#include <QApplication>
#include <QMainWindow>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMainWindow window;
window.show();
return app.exec();
}
Library: GTK
Compiler command: g++ filename.cc -o test `pkg-config --cflags --libs gtkmm-2.4`
#include <iostream>
#include <gtkmm.h>
int
main( int argc, char* argv[] )
{
try
{
Gtk::Main m( argc, argv ) ;
Gtk::Window win ;
m.run( win ) ;
}
catch( std::exception const & exc )
{
std::cout << exc.what() << std::endl ;
exit( -1 ) ;
}
exit( 0 ) ;
}
[edit] C#
Library: Windows Forms
using System;
using System.Windows.Forms;
public class Window {
[STAThread]
static void Main() {
Form form = new Form();
form.Text = "Window";
form.Disposed += delegate { Application.Exit(); };
form.Show();
Application.Run();
}
}
[edit] Clojure
Library: Swing
(import '(javax.swing JFrame))
(let [frame (JFrame. "A Window")]
(doto frame
(.setSize 600 800)
(.setVisible true)))
[edit] Common Lisp
[edit] Library: CAPI
Works with: LispWorks
(capi:display (make-instance 'capi:interface :title "A Window"))
[edit] Library: CLIM
Works with: McCLIM
Setting up the environment:
(require :mcclim)
(cl:defpackage #:rc-window
(:use #:clim-lisp #:clim))
(cl:in-package #:rc-window)
The actual definition and display:
(define-application-frame rc-window ()
()
(: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.
[edit] D
Library: FLTK4d
module Window;
import fltk4d.all;
void main() {
auto window = new Window(300, 300, "A window");
window.show;
FLTK.run;
}
Library: Derelict Library: SDL
import derelict.sdl.sdl;
int main(char[][] args)
{
DerelictSDL.load();
SDL_Event event;
auto done = false;
SDL_Init(SDL_INIT_VIDEO);
scope(exit) SDL_Quit();
SDL_SetVideoMode(1024, 768, 0, SDL_OPENGL);
SDL_WM_SetCaption("My first Window", "SDL test");
while (!done)
{
if (SDL_PollEvent(&event) == 1)
{
switch (event.type)
{
case SDL_QUIT:
done = true;
break;
default:
break;
}
}
}
return 0;
}
Library: QD QD is a simple and easy-to-use wrapper around SDL.
import qd;
void main() {
screen(640, 480);
while (true) events();
}
[edit] E
Swing
Works with: E-on-Java
when (currentVat.morphInto("awt")) -> {
def w := <swing:makeJFrame>("Window")
w.setContentPane(<swing:makeJLabel>("Contents"))
w.pack()
w.show()
}
[edit] Eiffel
Platform independent EiffelVision 2 Library
class
APPLICATION
inherit
EV_APPLICATION
create
make_and_launch
feature {NONE} -- Initialization
make_and_launch
-- Initialize and launch application
do
default_create
create first_window
first_window.show
launch
end
feature {NONE} -- Implementation
first_window: MAIN_WINDOW
-- Main window.
end
class
MAIN_WINDOW
inherit
EV_TITLED_WINDOW
redefine
initialize
end
create
default_create
feature {NONE} -- Initialization
initialize
-- Build the interface for this window.
do
-- Call initialize in parent class EV_TITLED_WINDOW
Precursor {EV_TITLED_WINDOW}
-- Build a container for widgets for this window
build_main_container
-- Add the container to this window
extend (main_container)
-- Add `request_close_window' to the actions taken when the user clicks
-- on the cross in the title bar.
close_request_actions.extend (agent request_close_window)
-- Set the title of the window
set_title ("Rosetta Code")
-- Set the initial size of the window
set_size (400, 400)
end
feature {NONE} -- Implementation, Close event
request_close_window
-- The user wants to close the window
do
-- Destroy this window
destroy;
-- Destroy application
(create {EV_ENVIRONMENT}).application.destroy
end
feature {NONE} -- Implementation
main_container: EV_VERTICAL_BOX
-- Main container contains all widgets displayed in this window.
-- In this case a single text area.
build_main_container
-- Create and populate `main_container'.
require
main_container_not_yet_created: main_container = Void
do
create main_container
main_container.extend (create {EV_TEXT})
ensure
main_container_created: main_container /= Void
end
end
Library: Windows Forms
class
APPLICATION
inherit
WINFORMS_FORM
rename
make as make_form
end
create
make
feature {NONE} -- Initialization
make
-- Run application.
do
-- Set window title
set_text ("Rosetta Code")
-- Launch application
{WINFORMS_APPLICATION}.run_form (Current)
end
end
[edit] Emacs Lisp
(make-frame)
[edit] Factor
USING: ui ui.gadgets.labels ;
"This is a window..." <label> "Really?" open-window
[edit] F#
Everything is provided by the .NET runtime so this is almost identical to C_sharp.
Library: Windows Forms
open System.Windows.Forms
[<System.STAThread>]
do
Form(Text = "F# Window")
|> Application.Run
[edit] Groovy
import groovy.swing.SwingBuilder new SwingBuilder().frame(title:'My Window', size:[200,100]).show()
[edit] Haskell
Using Library: HGL from HackageDB.
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.
import Graphics.HGL
aWindow = runGraphics $
withWindow_ "Rosetta Code task: Creating a window" (300, 200) $ \ w -> do
drawInWindow w $ text (100, 100) "Hello World"
getKey w
[edit] HicEst
WINDOW(WINdowhandle=handle, Width=80, Height=-400, X=1, Y=1/2, TItle="Rosetta Window_creation Example")
! window units: as pixels < 0, as relative window size 0...1, ascurrent character sizes > 1
WRITE(WINdowhandle=handle) '... some output ...'
[edit] IDL
With some example values filled in:
Id = WIDGET_BASE(TITLE='Window Title',xsize=200,ysize=100) WIDGET_CONTROL, /REALIZE, id
[edit] Icon and Unicon
Icon and Unicon windowing is portable between Windows and X-Windows environments.
[edit] Icon
link graphics
procedure main(arglist)
WOpen("size=300, 300", "fg=blue", "bg=light gray")
WDone()
end
Library: Icon Programming Library graphics is required
[edit] Unicon
This Icon solution works in Unicon.
[edit] J
A minimalist modal dialog:
title=: '"Hamlet -- Act 3, Scene 1"'
text=: '"To be, or not to be: that is the question:"'
wd 'mb ',title,text
A free-standing window:
MINWDW=: noun define
pc minwdw;
pas 162 85;pcenter;
rem form end;
)
minwdw_run=: monad define
wd MINWDW
wd 'pshow;'
)
minwdw_close=: monad define
wd'pclose'
)
minwdw_run ''
[edit] Java
Library: Swing
import javax.swing.JFrame;
public class Main {
public static void main(String[] args) throws Exception {
JFrame w = new JFrame("Title");
w.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
w.setSize(800,600);
w.setVisible(true);
}
}
[edit] JavaScript
window.open("webpage.html", "windowname", "width=800,height=600");
[edit] Lua
require"iuplua"
iup.dialog{ iup.label{ title = "example" }; title = "example"}:show()
if (not iup.MainLoopLevel or iup.MainLoopLevel()==0) then
iup.MainLoop()
end
[edit] mIRC Scripting Language
Works with: mIRC
Switches: C = Center Window p = Picture Window d = Desktop Window
alias CreateMyWindow {
.window -Cp +d @WindowName 600 480
}
[edit] Objective-C
Works with: GNUstep
Works with: Cocoa
It opens a 800×600 window, centered on the screen, with title "A Window".
#include <Foundation/Foundation.h>
#include <AppKit/AppKit.h>
@interface Win : NSWindow
{
}
- (void)applicationDidFinishLaunching: (NSNotification *)notification;
- (BOOL)applicationShouldTerminateAfterLastWindowClosed: (NSNotification *)notification;
@end
@implementation Win : NSWindow
-(id) init
{
[self
initWithContentRect: NSMakeRect(0, 0, 800, 600)
styleMask: (NSTitledWindowMask | NSClosableWindowMask)
backing: NSBackingStoreBuffered
defer: NO];
[self setTitle: @"A Window"];
[self center];
return self;
}
-(void) dealloc
{
[super dealloc];
}
- (void)applicationDidFinishLaunching: (NSNotification *)notification
{
[self orderFront: self];
}
- (BOOL)applicationShouldTerminateAfterLastWindowClosed: (NSNotification *)notification
{
return YES;
}
@end
int main()
{
Win *mywin;
NSAutoreleasePool *pool;
pool = [[NSAutoreleasePool alloc] init];
[NSApplication sharedApplication];
mywin = [[Win alloc] init];
[NSApp setDelegate: mywin];
[NSApp runModalForWindow: mywin];
return EXIT_SUCCESS;
}
[edit] OCaml
- with Labltk, the ocaml Tk binding (included with OCaml):
let () =
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 SDL binding ocamlsdl:
let () =
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
- with the Xlib binding OCamlXlib:
open Xlib
let () =
let d = xOpenDisplay "" in
let s = xDefaultScreen d in
let w = xCreateSimpleWindow d (xRootWindow d s) 10 10 100 100 1
(xBlackPixel d s) (xWhitePixel d s) in
xSelectInput d w [KeyPressMask];
xMapWindow d w;
let _ = xNextEventFun d in (* waits any key-press event *)
xCloseDisplay d;
;;
execute with:
ocaml -I +Xlib Xlib.cma sample.ml
- with LablGTK2, the GTK2 OCaml binding:
open GMain
let window = GWindow.window ~border_width:2 ()
let button = GButton.button ~label:"Hello World" ~packing:window#add ()
let () =
window#event#connect#delete ~callback:(fun _ -> true);
window#connect#destroy ~callback:Main.quit;
button#connect#clicked ~callback:window#destroy;
window#show ();
Main.main ()
execute with:
ocaml -I +lablgtk2 lablgtk.cma gtkInit.cmo sample.ml
[edit] Oz
functor
import
Application
QTk at 'x-oz://system/wp/QTk.ozf'
define
proc {OnClose}
{Application.exit 0}
end
%% Descripe the GUI in a declarative style.
GUIDescription = td(label(text:"Hello World!")
action:OnClose %% Exit app when window closes.
)
%% Create a window object from the description and show it.
Window = {QTk.build GUIDescription}
{Window show}
end
[edit] Perl
Works with: Perl version 5.8.8
Library: Tk
use Tk;
MainWindow->new();
MainLoop;
Library: SDL
use SDL::App;
use SDL::Event;
$app = SDL::App->new;
$app->loop({
SDL_QUIT() => sub { exit 0; },
});
Library: GTK
use Gtk '-init';
$window = Gtk::Window->new;
$window->signal_connect(
destroy => sub { Gtk->main_quit; }
);
$window->show_all;
Gtk->main;
Library: Gtk2
use Gtk2 '-init';
$window = Gtk2::Window->new;
$window->signal_connect(
destroy => sub { Gtk2->main_quit; }
);
$window->show_all;
Gtk2->main;
Library: XUL::GuiGui
use XUL::Gui;
display Window;
[edit] PicoLisp
Translation of: C
(load "@lib/openGl.l")
(glutInit)
(glutCreateWindow "Goodbye, World!")
(keyboardFunc '(() (bye)))
(glutMainLoop)
[edit] PowerShell
Library: WPK
New-Window -Show
Library: Windows Forms
$form = New-Object Windows.Forms.Form
$form.Text = "A Window"
$form.Size = New-Object Drawing.Size(150,150)
$form.ShowDialog() | Out-Null
[edit] PureBasic
All that is needed is
OpenWindow(0, 412, 172, 402, 94, "PureBasic")
A working implementation could look like this
Define MyWin, Event
MyWin = OpenWindow(#PB_Any, 412, 172, 402, 94, "PureBasic")
; Event loop
Repeat
Event = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
; Handle any gadget events here
Case #PB_Event_CloseWindow
Break
EndSelect
ForEver
[edit] Python
Works with: Python version 2.4 and 2.5
Library: Tkinter
import Tkinter
w = Tkinter.Tk()
w.mainloop()
Library: wxPython
from wxPython.wx import *
class MyApp(wxApp):
def OnInit(self):
frame = wxFrame(NULL, -1, "Hello from wxPython")
frame.Show(true)
self.SetTopWindow(frame)
return true
app = MyApp(0)
app.MainLoop()
Library: Pythonwin
import win32ui
from pywin.mfc.dialog import Dialog
d = Dialog(win32ui.IDD_SIMPLE_INPUT)
d.CreateWindow()
Library: PyGTK
import gtk
window = gtk.Window()
window.show()
gtk.main()
[edit] 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.
win <- tktoplevel()
Library: gWidgets
The gWidgets packages let you write GUIs in a toolkit independent way. You can create a window with
library(gWidgetstcltk) #or e.g. gWidgetsRGtk2
win <- gwindow()
[edit] RapidQ
create form as qform
center
width=500
height=400
end create
form.showModal
[edit] Ruby
Works with: Ruby version 1.8.5
Library: Ruby/Tk
require 'tk'
window = TkRoot::new()
window::mainloop()
Library: GTK
require 'gtk2'
window = Gtk::Window.new.show
Gtk.main
[edit] Scheme
Library: Scheme/PsTk
#!r6rs
;; PS-TK example: display simple frame
(import (rnrs)
(lib pstk main) ; change this to refer to your installation of PS/Tk
)
(define tk (tk-start))
(tk/wm 'title tk "PS-Tk Example: Frame")
(tk-event-loop tk)
[edit] Scala
Library: sdljava
import javax.swing.JFrame
object ShowWindow{
def main(args: Array[String]){
var jf = new JFrame("Hello!")
jf.setSize(800, 600)
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
jf.setVisible(true)
}
}
Using native Scala libraries (which are wrappers over Java libraries):
import scala.swing._
import scala.swing.Swing._
object SimpleWindow extends SimpleSwingApplication {
def top = new MainFrame {
title = "Hello!"
preferredSize = ((800, 600):Dimension)
}
}
[edit] Tcl
Library: Tk Loading the Tk package is all that is required to get an initial window:
package require Tk
If you need an additional window:
toplevel .top
If you are using the increasingly popular tclkit under MS Windows, all you have to do is associate the tclkit with the extension “.tcl” and then create an empty file with, e.g., with the name nothing.tcl. Double-clicking that will “open a window” (an empty one).
[edit] TI-89 BASIC
Dialog Title "Rosetta Code" Text "" EndDlog
[edit] Toka
Library: SDL
Toka does not inherently know about graphical environments, but can interact with them using external libraries. This example makes use of the SDL library bindings included with Toka.
needs sdl 800 600 sdl_setup
[edit] 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.
Win_Create(A, 2, 5, 20, 80)
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).
[edit] Visual Basic .NET
Dim newForm as new Form
newForm.Text = "It's a new window"
newForm.Show()
