Window creation: Difference between revisions

{{libheader|GtkAda}}

{{uses from|library|GtkAda|component1=Window|component2=Widget|component3=Handlers|component4=Main}}

with Gtk.Widget; use Gtk.Widget;

 

 

Gtk.Main.Main;

 

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

{{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

gtk main

END

=={{header|AutoHotkey}}==

 

=={{header|AutoIt}}==

GUISetState(@SW_SHOW)

 

Exit

EndSwitch

 

 

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

{{works with|BBC BASIC for Windows}}

dlg% = FN_newdialog("GUI Window", 0, 0, 200, 150, 8, 1000)

 

=={{header|C}}==

 

'''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.

return 0;

 

===GTK===

'''Compile command:''' gcc `gtk-config --cflags` `gtk-config --libs` -o window window.c

 

 

int

 

return 0;

 

===GTK2===

'''Compile command:''' gcc -Wall -pedantic `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0` -o window window.c

 

 

int

 

return 0;

 

===GLUT===

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>

}

 

 

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

'''Compiler command:''' qmake -pro; qmake

 

#include <QMainWindow>

 

window.show();

return app.exec();

 

{{libheader|GTK}}

'''Compiler command:''' g++ filename.cc -o test `pkg-config --cflags --libs gtkmm-2.4`

 

#include <gtkmm.h>

 

exit( 0 ) ;

 

=={{header|Clojure}}==

{{uses from|library|Swing|component1=JFrame}}

 

 

(let [frame (JFrame. "A Window")]

(doto frame

(.setSize 600 800)

 

=={{header|Common Lisp}}==

{{works with|LispWorks}}

 

 

==={{libheader|CLIM}}===

Setting up the environment:

 

(cl:defpackage #:rc-window

(:use #:clim-lisp #:clim))

 

The actual definition and display:

 

()

(:layouts (:default)))

 

 

Note: This creates a small, useless window ("frame"). Useful frames will have some ''panes'' defined inside them.

Works with the Armed Bear Common Lisp implementation that targets the JVM.

 

"Creates a window"

(let ((window (jnew (jconstructor "javax.swing.JFrame"))))

window (make-immediate-object t :boolean))))

 

 

=={{header|D}}==

{{libheader|FLTK4d}}

import fltk4d.all;

window.show;

FLTK.run;

 

{{libheader|Derelict}}

{{libheader|SDL}}

int main(char[][] args)

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}}==

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.

 

 

// The project file (Project1.dpr)

end

 

 

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.

 

program Project3;

 

 

end.

 

=={{header|E}}==

Platform independent EiffelVision 2 Library

 

APPLICATION

inherit

first_window: MAIN_WINDOW

-- Main window.

 

MAIN_WINDOW

inherit

main_container_created: main_container /= Void

end

 

 

{{libheader|Windows Forms}}

APPLICATION

inherit

{WINFORMS_APPLICATION}.run_form (Current)

end

 

=={{header|Emacs Lisp}}==

 

=={{header|Euphoria}}==

===ARWEN===

{{libheader|ARWEN}}

 

constant win = create(Window, "ARWEN window", 0, 0,100,100,640,480,{0,0})

 

WinMain(win, SW_NORMAL)

 

===EuGTK===

{{libheader|EuGTK}}

 

 

show_all(win)

 

===EuWinGUI===

{{libheader|EuWinGUI}}

 

Window("EuWinGUI window",100,100,640,480)

end while

 

 

===Win32Lib===

{{libheader|Win32Lib}}

 

constant win = createEx( Window, "Win32Lib", 0, Default, Default, 640, 480, 0, 0 )

 

 

===wxEuphoria===

{{libheader|wxEuphoria}}

 

constant win = create( wxFrame, {0, -1, "wxEuphoria window", -1, -1, 640, 480} )

 

 

=={{header|Factor}}==

 

 

=={{header|Fantom}}==

using fwt

 

}

}

 

=={{header|Forth}}==

'''gtk-server command:''' gtk-server -fifo=ffl-fifo &

 

 

\ Open the connection to the gtk-server and load the Gtk2 definitions

 

gsv+close drop

 

=={{header|Frink}}==

g=(new graphics).show[]

 

 

=={{header|Go}}==

===GTK===

{{libheader|go-gtk}}

 

 

func main() {

gtk.Init(nil)

window.Show()

gtk.Main()

===SDL===

{{libheader|Go-SDL}}

 

import (

)

 

func main() {

}

}

 

===X11===

 

import (

}

}

 

=={{header|Groovy}}==

We will open notepad as a window here.

 

To close the window:

 

 

=={{header|Haskell}}==

 

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"

 

=={{header|HicEst}}==

! window units: as pixels < 0, as relative window size 0...1, ascurrent character sizes > 1

 

 

=={{header|IDL}}==

Icon and Unicon windowing is portable between Windows and X-Windows environments.

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

 

procedure main(arglist)

WOpen("size=300, 300", "fg=blue", "bg=light gray")

WDone()

 

{{libheader|Icon Programming Library}}

The Icon solution works in Unicon. An Unicon-only version is as follows:

 

import gui

$include "guih.icn"

w.show_modal ()

end

 

=={{header|J}}==

A minimalist modal dialog:

A free-standing window:

pc minwdw;

pas 162 85;pcenter;

)

 

)

 

=={{header|Java}}==

{{libheader|Swing}}

 

public class Main {

w.setVisible(true);

}

 

=={{header|JavaScript}}==

window.open("webpage.html", "windowname", "width=800,height=600");

 

=={{header|Kotlin}}==

{{trans|Java}}

 

 

fun main(args : Array<String>) {

 

=={{header|Lua}}==

{{libheader|IUPLua}}

 

iup.dialog{

 

iup.MainLoop()

 

 

 

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

.window -Cp +d @WindowName 600 480

}

 

=={{header|NetRexx}}==

{{libheader|Swing}}

options replace format comments java crossref symbols binary

 

method isFalse() public static returns boolean

return \(1 == 1)

 

=={{header|Nim}}==

=== gtk2 ===

This is example 9 from the Araq/Nim github repository (modified to include a quit button)

 

const

 

 

nim_init()

 

 

 

 

=== SDL ===

sdl, sdl_image, colors

 

greeting.freeSurface()

screen.freeSurface()

 

=== X11 ===

 

const

WINDOW_WIDTH = 400

WINDOW_HEIGHT = 300

 

 

if display == nil:

 

var rootwin = XRootWindow(display, screen)

discard XMapWindow(display, win)

 

 

of KeyPress:

if key.int != 0:

if key.int == 65307: # <Esc>

of ButtonPressMask, PointerMotionMask:

 

 

while true:

 

=== glut ===

 

var win: int = 0

win = glutCreateWindow("Goodbye, World!")

glutKeyboardFunc(TGlut1Char2IntCallback(myOnKeyPress))

 

=== win ===

 

import

# {stdcall, import: "MessageBox", header: "<windows.h>"}

 

 

=== IUP ===

 

# assumes you have the iup .dll or .so installed

 

# now use a Dialog box to show a message

setAttribute(lbl,"PADDING","10x10")

 

#SetAttribute(contents, "MARGIN", "5x5")

 

#SetAttribute(dlg, "SIZE", "100x50")

 

 

discard mainloop()

 

=={{header|Objeck}}==

use Gtk2;

}

}

 

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

It opens a 800&times;600 window, centered on the screen, with title "A Window".

 

#include <AppKit/AppKit.h>

 

}

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

execute with:

ocaml graphics.cma tmp.ml

 

{{libheader|LablGTK2}}

 

let window = GWindow.window ~border_width:2 ()

button#connect#clicked ~callback:window#destroy;

window#show ();

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;

execute with:

ocaml bigarray.cma -I +sdl sdl.cma sample.ml

 

{{libheader|ocaml-sfml}}

let app = SFRenderWindow.make (640, 480) "OCaml-SFML Windowing" in

let continue =

| Some SFEvent.Closed -> false

| _ -> true

SFRenderWindow.clear app SFColor.black;

SFRenderWindow.display app;

in

execute with:

 

{{libheader|OCaml-Xlib}}

let () =

let _ = xNextEventFun d in (* waits any key-press event *)

xCloseDisplay d;

execute with:

ocaml -I +Xlib Xlib.cma sample.ml

 

 

=={{header|OpenEdge ABL/Progress 4GL}}==

 

 

DEFINE VAR C-Win AS WIDGET-HANDLE NO-UNDO.

WAIT-FOR CLOSE OF THIS-PROCEDURE.

 

=={{header|Oz}}==

import

Application

Window = {QTk.build GUIDescription}

{Window show}

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

{{libheader|SysUtils}}{{libheader|SDL}}

 

{$linklib SDL}

sleep(2000);

SDL_Quit;

 

=={{header|Perl}}==

 

==={{libheader|Perl/Tk}}===

MainWindow->new();

 

==={{libheader|Perl/SDL}}===

use SDL::Event;

$app->loop({

SDL_QUIT() => sub { exit 0; },

 

$window->signal_connect(

);

$window->show_all;

 

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

use warnings;

use QtGui4;

my $window = Qt::MainWindow;

$window->show;

 

==={{libheader|Perl/Wx}}===

$window = Wx::Frame->new(undef, -1, 'title');

$window->Show;

 

 

=={{header|PicoLisp}}==

{{trans|C}}

 

(glutInit)

(glutCreateWindow "Goodbye, World!")

(keyboardFunc '(() (bye)))

 

=={{header|PowerShell}}==

{{libheader|WPK}}

{{libheader|Windows Forms}}

$form.Text = "A Window"

$form.Size = New-Object Drawing.Size(150,150)

 

=={{header|Prolog}}==

Works with SWI-Prolog which has a graphic interface XPCE.

=={{header|PureBasic}}==

 

Case #PB_Event_Gadget

Case #PB_Event_CloseWindow

 

=={{header|Python}}==

{{works with|Python|2.4 and 2.5}}

 

w = Tkinter.Tk()

 

class MyApp(wxApp):

app = MyApp(0)

 

from pywin.mfc.dialog import Dialog

d = Dialog(win32ui.IDD_SIMPLE_INPUT)

 

window = gtk.Window()

window.show()

 

 

app = QApplication([])

win.show()

 

 

=={{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.

win <- tktoplevel()

 

{{libheader|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()

 

=={{header|Racket}}==

 

#lang racket/gui

(send (new frame%

[width 100] [height 100])

show #t)

 

=={{header|RapidQ}}==

=={{header|REBOL}}==

 

view layout [size 100x100]

 

'size' needed to show the close-window button.

 

=={{header|Ruby}}==

 

{{libheader|Ruby/Tk}}

window = TkRoot::new()

 

{{libheader|GTK}}

window = Gtk::Window.new.show

 

{{libheader|Shoes}}

 

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

Show a empty browser with a button to "Close Me"

button #c, "Close Me", [doExit]

wait

history.go(-a);

</script>"

 

 

 

 

 

=={{header|Scala}}==

{{libheader|sdljava}}

 

object ShowWindow{

jf.setVisible(true)

}

 

Using native Scala libraries (which are wrappers over Java libraries):

 

import scala.swing.Swing._

 

preferredSize = ((800, 600):Dimension)

}

 

=={{header|Seed7}}==

The program waits until a key is pressed and exits.

 

include "draw.s7i";

include "keybd.s7i";

KEYBOARD := GRAPH_KEYBOARD;

ignore(getc(KEYBOARD));

 

=={{header|Sidef}}==

===Tk===

%s'MainWindow'.new;

 

===Gtk2===

var window = %s'Gtk2::Window'.new;

window.show_all;

 

=={{header|Smalltalk}}==

{{works with|Pharo}}

{{works with|Squeak}}

 

{{works with|Smalltalk/X}}

top := TopView new.

top add: (Label label: 'Hello World') in:(0.0@0.0 corner:1.0@1.0).

 

=={{header|Tcl}}==

{{libheader|Tk}}

Loading the [[Tk]] package is all that is required to get an initial window:

If you need an additional window:

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}}==

=={{header|TorqueScript}}==

 

new GuiControl(GuiName)

{

 

canvas.pushDialog(GuiName);

 

=={{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"

 

 

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

{{libheader|GTK}}<br>

{{works with|NASM}}

;GTK imports and defines etc.

%define GTK_WINDOW_TOPLEVEL 0

exit_sig_msg db "-> Rage quitting..",10,0

<br>

{{works with|MASM}}

.586

.model flat, stdcall

WndProc endp

end start

 

{{omit from|Logtalk}}

{{omit from|Maxima}}

{{omit from|PARI/GP}}

{{omit from|PostScript}}

{{omit from|Retro}}