Window creation

Window creation
You are encouraged to solve this task according to the task description, using any language you may know.

Ada

Library: GTK+

Library: GtkAda

<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; </Ada>

C

Works with: ANSI C version C89

Works with: gcc version 4.0.3

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

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

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

C++

Library: Qt

4

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 ) ;
}

C#

Works with: Visual C# version 2003

Library: System.Windows.Forms

 using System;
 using System.Windows.Forms;
 
 public class Window
 {
   [STAThread]
   static void Main()
   {
     Form newForm = new Form();
     newForm.Text = "It's a new Window!";
     newForm.Show();
   }
 }

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();
}

E

Java AWT/Swing

Works with: E-on-Java

when (currentVat.morphInto("awt")) -> {
    def w := <swing:makeJFrame>("Window")
    w.setContentPane(<swing:makeJLabel>("Contents"))
    w.pack()
    w.show()
}

Groovy

 import groovy.swing.SwingBuilder

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

IDL

With some example values filled in:

Id = WIDGET_BASE(TITLE='Window Title',xsize=200,ysize=100)
WIDGET_CONTROL, /REALIZE, id

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=: 0 : 0
pc minwdw;
pas 162 85;pcenter;
rem form end;
)

minwdw_run=: 3 : 0
wd MINWDW
wd 'pshow;'
)

minwdw_close=: 3 : 0
wd'pclose'
)

minwdw_run ''

Java

Library: Swing

<java>import javax.swing.JFrame;

public class Main {

    public static void main(String[] args) throws Exception {
        JFrame w = new JFrame("Title");
        w.setDefaultCloseOperation(w.EXIT_ON_CLOSE);
        w.setSize(800,600);
        w.setVisible(true);
    }

}</java>

JavaScript

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

mIRC Scripting Language

Works with: mIRC

Switches: C = Center Window p = Picture Window d = Desktop Window

alias CreateMyWindow {
 .window -Cp +d @WindowName 600 480
}

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;

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

RapidQ

  create form as qform
     center
     width=500
     height=400
  end create
  form.showModal

Ruby

Works with: Ruby version 1.8.5

Library: Tk

require 'tk'

window = TkRoot::new()
window::mainloop()

Library: GTK+

require 'gtk2'

window = Gtk::Window.new.show
Gtk.main

Tcl

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 tcklkit with the extension ".tcl" and then create an empty file with the name (e.g.) nothing.tcl. Douple-clicking that will "open a window" (an empty one).

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

Visual Basic .NET

   Dim newForm as new Form
   newForm.Text = "It's a new window"
  
       newForm.Show()