Window creation/X11: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program creatFenX1164.s */

.include "../includeARM64.inc"

 

 

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

draw device (window, "X", "600x400");

open (window, "Hello, World!", stand draw channel);

draw show (window);

VOID (read char);

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr @ leave function

iMagicNumber: .int 0xCCCCCCCD

 

 

=={{header|BaCon}}==

 

'--- added a flush to exit cleanly

PRAGMA LDFLAGS `pkg-config --cflags --libs x11`

FLUSH(d)

CLOSE_DISPLAY(d)

 

=={{header|C}}==

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

 

#include <stdio.h>

#include <stdlib.h>

XCloseDisplay(d);

return 0;

 

=== XCB ===

* gcc -o helloxcb helloxcb.c -lxcb

 

#include <stdio.h>

#include <string.h>

 

return 0;

 

=={{header|COBOL}}==

Tested with GnuCOBOL, and only on 64bit architecture, GNU/Linux. Nods to the C XLib version.

 

program-id. x11-hello.

installation. cobc -x x11-hello.cob -lX11

 

goback.

 

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

 

 

(let* ((display (open-default-display))

(close-display display)))

 

=={{header|Forth}}==

warnings off

require xlib.fs

 

0 value X11-root

0 value X11-GC

0 value X11-Black

0 value X11-White

: open-X11 ( -- )

X11-D 0= if 0 XOpendisplay to X11-D

then

X11-D-W $28043 XSelectInput drop

then ;

 

: close-graphics ( -- )

then

then ;

 

: foreground >r X11-D-G r> XSetForeground drop ;

: background >r X11-D-G r> XSetBackground drop ;

 

: ev-loop

case X11-ev @ $ffffffff and

3 of keysym XK_Escape = if exit then endof

endcase

again ;

0 open-X11

ev-loop

bye

 

=={{header|Go}}==

{{trans|C}}

 

// Copyright (c) 2013 Alex Kesling

}

return

Screen capture:

 

groovy WindowCreation.groovy

 

import java.awt.*

import java.awt.event.WindowAdapter

}

}

 

=={{header|GUISS}}==

Graphical User Interface Support Script is really a language for operating a computer, rather than programming one, so we cannot do this via X11 libraries. The example uses leafpad for our open window, and the box symbols to enclose our text:

 

 

=={{header|Haskell}}==

Using {{libheader|X11}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Control.Concurrent (threadDelay)

 

destroyWindow display xwin

closeDisplay display

 

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon provide a portable graphics implementation that does not rely upon a toolkit. The intent is to be platform independent and the same code runs on multiple platforms without change and producing results with only minor variations. Icon and Unicon graphics are implemented in X-Windows as well as MS-Windows and others. There are additional 3D graphics capabilities implemented using opengl.

W1 := open("X-Window","g","size=250,250","bg=black","fg=red") | stop("unable to open window")

FillRectangle(W1,50,50,150,150)

end

 

 

{{libheader|Icon Programming Library}}

run

java WindowExample

import javax.swing.SwingUtilities;

 

frame.setVisible(true);

}

import java.awt.event.*;

import java.awt.geom.*;

f.setVisible(true);

}

 

=={{header|Julia}}==

This was based on https://en.wikipedia.org/wiki/Xlib, and mostly quoted from from the XLib.jl test2() testing code function.

using Xlib

 

 

x11demo()

 

=={{header|Kotlin}}==

{{trans|C}}

{{libheader|Xlib}}

 

import kotlinx.cinterop.*

XCloseDisplay(d)

nativeHeap.free(e)

 

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

Ao for this task we use the M2000 way to make a form and do something on it.

 

\\ M2000 froms (windows) based on a flat, empty with no title bar, vb6 window and a user control.

\\ title bar is a user control in M2000 form

}

SquareAndText2Window

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Note that GUIKit is a high-level wrapper for Swing.

ref = GUIRun[Widget["Panel", {

Widget[

"GIF"]]}],

Widget["Label", { "text" -> "Hello World!"}]}

 

=={{header|Nim}}==

 

const

 

 

 

=={{header|OCaml}}==

#load "Xlib.cma"

 

 

let () =

main_loop();

xCloseDisplay d;

 

=={{header|Pascal}}==

from wiki.freepascal.org/X11#Examples.

Compiled with Freepascal 2.6.4-32

{$mode objfpc}{$H+}

 

ModalShowX11Window('Hello, World!');

end.

 

=={{header|Perl}}==

=== X11::Protocol ===

use strict;

use X11::Protocol;

for (;;) {

$X->handle_input;

 

=={{header|Phix}}==

=={{header|PicoLisp}}==

The following script works in the 32-bit version, using inlined C code

 

(load "@lib/misc.l" "@lib/gcc.l")

 

(simpleWin 300 200 "Hello World")

 

 

=== Xlib ===

{{field attention|Python|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.}}

* python xlib_hello_world.py

 

 

class Window:

if __name__ == "__main__":

 

=== XCB ===

{{libheader|python-xcb}}

 

from xcb.xproto import *

import xcb.render

conn.disconnect()

 

 

=={{header|Racket}}==

Using Racket's GUI which is implemented using gtk. It's not low level, but OTOH it works on Windows and OS X too.

 

 

(define frame (new frame%

(send dc set-text-foreground "blue")

(send dc draw-text "Don't Panic!" 0 0))])

 

=={{header|Raku}}==

There is not yet a X11 library in Raku but we can write the minimal C mappings for this task.

 

 

class Display is repr('CStruct') {

}

}

 

=={{header|Scala}}==

import scala.swing.Swing.pair2Dimension

 

preferredSize = ((200, 150))

}

 

=={{header|Standard ML}}==

Works with PolyML

val dp = XOpenDisplay "" ;

val w = XCreateSimpleWindow (RootWindow dp) origin (Area {x=0,y=0,w=400,h=300}) 3 0 0xffffff ;

XFlush dp ;

XDrawString w (DefaultGC dp) (XPoint {x=10,y=50}) "Hello World!" ;

 

=={{header|Tcl}}==

===Low level interface===

{{libheader|critcl}}

package require critcl

 

const char *str = Tcl_GetStringFromObj(msg, &len);

XDrawString(d, (Window)w, gc, x, y, str, len);

Note that this only does enough for this demo. A full adaptation is too long for RosettaCode...

 

This could then be used like this:

 

XOpenDisplay {}

}

XDestroyWindow $w

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

<br>

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

package provide x11 1

 

}

}

This script puts the pieces together to carry out the details of the task.

 

# With a display connection open, create and map a window

 

$w destroy

Improving this by adding more sophisticated event handling and more window methods is left as an exercise.

 

<br>

As it's not currently possible for Wren-cli to access Xlib directly, we embed a Wren script in a C application to complete this task.

 

var KeyPressMask = 1 << 0

if (e.eventType == KeyPress) break

}

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <stdlib.h>

#include <string.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

 

{{omit from|ACL2}}