Window creation/X11

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

ALGOL 68

Works with: ALGOL 68G version tested with release mk15-0.8b.fc9.i386

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.

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)

C

Library: Xlib

Compile with:

• gcc -L/usr/X11R6/lib -lX11 hello-x.c -o hello-x

<lang c>#include <X11/Xlib.h>

1. include <stdio.h>
2. include <stdlib.h>
3. 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 needs review by someone who knows about: X11 This example was written in near-total ignorance of X11 by consulting the CLX manual to find equivalents for the parts of the C example. It was also only tested with Mac OS X X11, which is not exactly normal. If you know X11, please review this example and, as necessary, improve it or describe what should be done for someone who knows the language.

Translation of: C

Library: CLX

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>

OCaml

Library: OCaml-Xlib

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

This example needs review by someone who knows about: X11 Note (stolen from CLX example): This example was written in near-total ignorance of X11 by consulting the python-xlib's examples (included in its distribution) to find equivalents for the parts of the C example. If you know X11, please review this example and, as necessary, improve it or describe what should be done for someone who knows the language.

Translation of: C

Library: python-Xlib

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