Window creation/X11
You are encouraged to solve this task according to the task description, using any language you may know.
Create a simple X11 application, using an X11 protocol library such as Xlib, that draws a box and "Hello World" in a window. Implementations of this task should avoid using a toolkit as much as possible.
ALGOL 68
Using the X11 & plotutil libraries is not part of any of the original UNESCO/IFIP ALGOL 68 reports. As at December 2008 only ALGOL 68G comes with these built in. <lang algol68>FILE window; draw device (window, "X", "600x400"); open (window, "Hello, World!", stand draw channel);
draw erase (window); draw move (window, 0.25, 0.5); draw colour (window, 1, 0, 0); draw text (window, "c", "c", "hello world"); draw show (window); VOID (read char);
close (window)</lang>
C
Compile with:
- gcc -L/usr/X11R6/lib -lX11 hello-x.c -o hello-x
<lang c>#include <X11/Xlib.h>
- include <stdio.h>
- include <stdlib.h>
- include <string.h>
int main(void) {
Display *d; Window w; XEvent e; char *msg = "Hello, World!"; int s;
d = XOpenDisplay(NULL); if (d == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); }
s = DefaultScreen(d); w = XCreateSimpleWindow(d, RootWindow(d, s), 10, 10, 100, 100, 1, BlackPixel(d, s), WhitePixel(d, s)); XSelectInput(d, w, ExposureMask | KeyPressMask); XMapWindow(d, w);
while (1) { XNextEvent(d, &e); if (e.type == Expose) { XFillRectangle(d, w, DefaultGC(d, s), 20, 20, 10, 10); XDrawString(d, w, DefaultGC(d, s), 10, 50, msg, strlen(msg)); } if (e.type == KeyPress) break; }
XCloseDisplay(d); return 0;
}</lang>
Common Lisp
This example uses CLX, which is the de facto standard X11 library for Common Lisp. CLX is not a binding to Xlib; it is a Lisp library implementing the X11 protocol.
<lang lisp>;;; Single-file/interactive setup; large applications should define an ASDF system instead (cl:require :asdf) (asdf:operate 'asdf:load-op :clx) (cl:defpackage #:rc-xlib-window
(:use #:cl #:xlib))
(cl:in-package #:rc-xlib-window)
(let ((display (open-default-display)))
(unwind-protect (let* ((window (create-window :parent (screen-root (display-default-screen display)) :x 10 :y 10 :width 100 :height 100 :event-mask '(:exposure :key-press))) (gc (create-gcontext :drawable window))) (map-window window) (event-case (display :discard-p t) (exposure () (draw-rectangle window gc 20 20 10 10 t) (draw-glyphs window gc 10 40 "Hello, World!") nil #| continue receiving events |#) (key-press () t #| non-nil result signals event-case to exit |#)))) (close-display display))</lang>
Haskell
Using
from HackageDB
<lang haskell>import Graphics.X11.Xlib import Control.Concurrent (threadDelay)
main = do
display <- openDisplay "" let defScr = defaultScreen display rw <- rootWindow display defScr
xwin <- createSimpleWindow display rw 0 0 400 200 1 (blackPixel display defScr) (whitePixel display defScr)
setTextProperty display xwin "Rosetta Code: X11 simple window" wM_NAME
mapWindow display xwin
sync display False threadDelay (5000000)</lang>
OCaml
execute as a script with:
ocaml -I +Xlib Xlib.cma script.ml
or compile to native code:
ocamlopt -I +Xlib Xlib.cmxa prog.ml -o prog
or to make a standalone script add these lines at the beginning of the file:
#!/usr/bin/env ocaml #directory "+Xlib" #load "Xlib.cma"
<lang ocaml>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 [ExposureMask; KeyPressMask]; xMapWindow d w;
let msg = "Hello, World!" in
let rec main_loop() = match xEventType(xNextEventFun d) with | Expose -> xFillRectangle d w (xDefaultGC d s) 20 20 10 10; xDrawString d w (xDefaultGC d s) 10 50 msg; main_loop() | KeyPress -> () (* exit main loop *) | _ -> main_loop() in main_loop(); xCloseDisplay d;
- </lang>
Python
Download Python X library from http://sourceforge.net/projects/python-xlib/ . python-xlib is a pure python library therefore the example should work anywhere where python does and where there is an X server. Run:
- python xlib_hello_world.py
<lang python>from Xlib import X, display
class Window:
def __init__(self, display, msg): self.display = display self.msg = msg self.screen = self.display.screen() self.window = self.screen.root.create_window( 10, 10, 100, 100, 1, self.screen.root_depth, background_pixel=self.screen.white_pixel, event_mask=X.ExposureMask | X.KeyPressMask, ) self.gc = self.window.create_gc( foreground = self.screen.black_pixel, background = self.screen.white_pixel, )
self.window.map()
def loop(self): while True: e = self.display.next_event() if e.type == X.Expose: self.window.fill_rectangle(self.gc, 20, 20, 10, 10) self.window.draw_text(self.gc, 10, 50, self.msg) elif e.type == X.KeyPress: raise SystemExit
if __name__ == "__main__":
Window(display.Display(), "Hello, World!").loop()</lang>
Tcl
Tcl does not come with a low-level connection to the X protocol, as it has long been distributed with Tk which offers a much higher-level interface (and which is portable to other platforms too). This means that the interface has to be crafted directly. This can be done with either SWIG or critcl. This example shows how to do it the latter way:
Low level interface
<lang tcl>package provide xlib 1 package require critcl
critcl::clibraries -L/usr/X11/lib -lX11 critcl::ccode {
#include <X11/Xlib.h> static Display *d; static GC gc;
}
- Display connection functions
critcl::cproc XOpenDisplay {Tcl_Interp* interp char* name} ok {
d = XOpenDisplay(name[0] ? name : NULL); if (d == NULL) {
Tcl_AppendResult(interp, "cannot open display", NULL); return TCL_ERROR;
} gc = DefaultGC(d, DefaultScreen(d)); return TCL_OK;
} critcl::cproc XCloseDisplay {} void {
XCloseDisplay(d);
}
- Basic window functions
critcl::cproc XCreateSimpleWindow {
int x int y int width int height int events
} int {
int s = DefaultScreen(d); Window w = XCreateSimpleWindow(d, RootWindow(d,s), x, y, width, height, 0,
BlackPixel(d,s), WhitePixel(d,s));
XSelectInput(d, w, ExposureMask | events); return (int) w;
} critcl::cproc XDestroyWindow {int w} void {
XDestroyWindow(d, (Window) w);
} critcl::cproc XMapWindow {int w} void {
XMapWindow(d, (Window) w);
} critcl::cproc XUnmapWindow {int w} void {
XUnmapWindow(d, (Window) w);
}
- Event receiver
critcl::cproc XNextEvent {Tcl_Interp* interp} char* {
XEvent e; XNextEvent(d, &e); switch (e.type) {
case Expose: return "type expose"; case KeyPress: return "type key"; /* etc. This is a cheap hack version. */ default: return "type ?";
}
}
- Painting functions
critcl::cproc XFillRectangle {int w int x int y int width int height} void {
XFillRectangle(d, (Window)w, gc, x, y, width, height);
} critcl::cproc XDrawString {int w int x int y Tcl_Obj* msg} void {
int len; const char *str = Tcl_GetStringFromObj(msg, &len); XDrawString(d, (Window)w, gc, x, y, str, len);
}</lang> Note that this only does enough for this demo. A full adaptation is too long for RosettaCode...
This could then be used like this: <lang tcl>package require xlib
XOpenDisplay {} set w [XCreateSimpleWindow 10 10 100 100 1] XMapWindow $w while {[lindex [XNextEvent] 0] == "expose"} {
XFillRectangle $w 20 20 10 10 XDrawString $w 10 50 "Hello, World!"
} XDestroyWindow $w XCloseDisplay</lang>
Higher level interface
Just because there is a low level package does not mean that it is pleasant to use from Tcl code. Therefore this second package wraps it up inside a higher-level package that provides a more natural way of interacting. <lang tcl>package require Tcl 8.6 package provide x11 1
namespace eval ::x {
namespace export {[a-z]*} namespace ensemble create variable mask array set mask {
KeyPress 1 KeyRelease 2 ButtonPress 4 ButtonRelease 8
}
proc display {script} {
XOpenDisplay {} catch {uplevel 1 $script} msg opts XCloseDisplay return -options $opts $msg
} proc eventloop {var handlers} {
upvar 1 $var v while 1 { set v [XNextEvent] uplevel 1 [list switch [dict get $v type] $handlers] }
}
oo::class create window {
variable w
constructor {x y width height events} {
set m 0 variable ::x::mask foreach e $events {catch {incr m $mask($e)}} set w [XCreateSimpleWindow $x $y $width $height $m] } method map {} { XMapWindow $w } method unmap {} { XUnmapWindow $w } method fill {x y width height} { XFillRectangle $w $x $y $width $height } method text {x y string} { XDrawString $w $x $y $string } destructor { XDestroyWindow $w }
}
}</lang> This script puts the pieces together to carry out the details of the task. <lang tcl>package require x11
- With a display connection open, create and map a window
x display {
set w [x window new 10 10 100 100 KeyPress] $w map
x eventloop ev {
expose { # Paint the window $w fill 20 20 10 10 $w text 10 50 "Hello, World!" } key { # Quit the event loop break }
}
$w destroy
}</lang> Improving this by adding more sophisticated event handling and more window methods is left as an exercise.
- Programming Tasks
- GUI
- ALGOL 68
- AutoHotkey/Omit
- C
- Xlib
- Common Lisp
- Common Lisp examples needing attention
- Examples needing attention
- Field knowledge needed/X11
- Field knowledge needed/X11/Common Lisp
- CLX
- Haskell
- X11
- OCaml
- OCaml-Xlib
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit
- PureBasic/Omit
- Python
- Python examples needing attention
- Field knowledge needed/X11/Python
- Python-xlib
- Tcl
- Critcl
- Batch File/Omit
- M4/Omit
- PowerBASIC/Omit
- SNOBOL4/Omit