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

BaCon includes a Highlevel Universal GUI abstraction layer (HUG). The implementation is based on GTK.

 

INCLUDE "hug.bac"

 

 

REM start gtk event loop...

 

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

#Include "windows.bi"

 

 

End

 

=={{header|Frink}}==

g=(new graphics).show[]

 

 

=={{header|Gambas}}==

 

 

=={{header|Go}}==

===GTK===

{{libheader|go-gtk}}

 

import (

window.Show()

gtk.Main()

 

===SDL===

{{libheader|Go-SDL}}

 

import (

}

window.Destroy()

 

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

 

=={{header|Julia}}==

 

using Tk

 

 

=={{header|Kotlin}}==

{{trans|Java}}

 

 

fun main(args : Array<String>) {

isVisible = true

}

 

=={{header|Lingo}}==

w = 320

h = 240

-- it can be re-used for multiple windows.

win.filename = _movie.path & "empty.dir"

 

=={{header|Lua}}==

{{libheader|IUPLua}}

 

iup.dialog{

 

iup.MainLoop()

 

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

Window has title by default the name of variable, here MyForm

 

Here we open MyForm as modal window (with 1 as first parameter, after "Show")

 

 

Module DisplayWindow {

Declare MyForm Form

}

DisplayWindow

 

 

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

 

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

 

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

Empty Window with close [X] button

=={{header|Ring}}==

Load "guilib.ring"

 

show()}

exec()}

 

=={{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.signal_connect(destroy => func(*_) { gtk2.main_quit });

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

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)

(until* (memql (union-get e 'type) '(SDL_KEYUP SDL_QUIT))

(SDL_WaitEvent e))))

 

===X11===

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)

(KeyPress (return)))))

 

 

===GTK2===

{{trans|C}}

 

(typedef GtkWidget* (cptr GtkWidget))

 

(gtk_signal_connect (GTK_OBJECT window) "destroy" gtk_main_quit nil)

(gtk_widget_show window)

 

===Win32/Win64===

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)

(while (GetMessage msg NULL 0 0)

(TranslateMessage msg)

 

=={{header|VBA}}==

<pre>!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

And :

Programmatic Access to Visual Basic Project must be trusted. See it in Macro's security!</pre>

Option Explicit

 

strname = myForm.Name

VBA.UserForms.Add(strname).Show

 

=={{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|Batch File|No access to GUI functions.}}

{{omit from|Logtalk}}

{{omit from|Maxima}}