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

 

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

 

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

===GTK===

{{libheader|go-gtk}}

 

 

func main() {

gtk.Init(nil)

window.Show()

gtk.Main()

===SDL===

{{libheader|Go-SDL}}

 

import (

)

 

func main() {

}

 

}

 

}

 

=={{header|Groovy}}==

new SwingBuilder().frame(title:'My Window', size:[200,100]).show()

</pre>

 

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

 

==={{header|Unicon}}===

 

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

 

 

 

 

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

.window -Cp +d @WindowName 600 480

}

 

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

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

 

#include <AppKit/AppKit.h>

 

 

@implementation Win : NSWindow

{

initWithContentRect: NSMakeRect(0, 0, 800, 600)

styleMask: (NSTitledWindowMask | NSClosableWindowMask)

backing: NSBackingStoreBuffered

 

return self;

}

 

int main()

{

 

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

import

Application

Window = {QTk.build GUIDescription}

{Window show}

 

=={{header|Perl}}==

{{works with|Perl|5.8.8}}

 

MainWindow->new();

 

use SDL::Event;

$app->loop({

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

 

$window->signal_connect(

);

$window->show_all;

 

 

 

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

 

 

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

end create

form.showModal

 

=={{header|Ruby}}==

 

{{libheader|Ruby/Tk}}

window = TkRoot::new()

 

{{libheader|GTK}}

window = Gtk::Window.new.show

 

 

 

 

 

 

 

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

{{works with|Pharo}}

{{works with|Squeak}}

 

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

needs sdl

800 600 sdl_setup

 

=={{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|PARI/GP}}