diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
new file mode 100644
index 0000000..0065213
--- /dev/null
+++ b/.github/workflows/go.yml
@@ -0,0 +1,28 @@
+# This workflow will build a golang project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
+
+name: Go
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.20'
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./...
diff --git a/README.md b/README.md
index 339f686..db389b9 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,15 @@
 # Xlib Binding
 
-[![GoDoc](https://godoc.org/github.com/vbsw/xlib?status.svg)](https://godoc.org/github.com/vbsw/xlib)
+[![GoDoc](https://godoc.org/github.com/vbsw/xlib?status.svg)](https://godoc.org/github.com/daviseidel/xlib)
 
 ## About
 Xlib Binding is a binding of Xlib (version 11, release 6.7) for the programming language Go.
 
-Xlib Binding is published at <https://github.com/vbsw/xlib>.
+This is a more complete fork of the one by vbsw: <https://github.com/vbsw/xlib>.
 
 ## Copyright
+Copyright 2023 Davi Seidel (daviseidel.brandao@gmail.com)
+
 Copyright 2016 Vitali Baumtrok (vbsw@mailbox.org)
 
 Xlib Binding is distributed under the terms of the Boost Software License, version 1.0.
diff --git a/events.go b/events.go
index 0a568da..d3fd19e 100644
--- a/events.go
+++ b/events.go
@@ -1,23 +1,16 @@
-
 //          Copyright 2016 Vitali Baumtrok
 // Distributed under the Boost Software License, Version 1.0.
 //      (See accompanying file LICENSE or copy at
 //        http://www.boost.org/LICENSE_1_0.txt)
 
-
 // Binding of Xlib (version 11, release 6.7).
 package xlib
 
-
 // #cgo LDFLAGS: -lX11
 // #include <stdlib.h>
 // #include <X11/Xlib.h>
 // #include "xlib.h"
 import "C"
-import (
-	//"unsafe"
-)
-
 
 const (
 	Expose     = int(C.Expose)
@@ -26,6 +19,7 @@ const (
 )
 
 const (
+	// All Event masks.
 	NoEventMask              = int64(C.NoEventMask)
 	KeyPressMask             = int64(C.KeyPressMask)
 	KeyReleaseMask           = int64(C.KeyReleaseMask)
@@ -52,6 +46,39 @@ const (
 	PropertyChangeMask       = int64(C.PropertyChangeMask)
 	ColormapChangeMask       = int64(C.ColormapChangeMask)
 	OwnerGrabButtonMask      = int64(C.OwnerGrabButtonMask)
+	GrabModeSync             = int(C.GrabModeSync)
+	GrabModeAsync            = int(C.GrabModeAsync)
+	Mod1Mask                 = int(C.Mod1Mask)
+	Mod2Mask                 = int(C.Mod2Mask)
+	Mod3Mask                 = int(C.Mod3Mask)
+	Mod4Mask                 = int(C.Mod4Mask)
+	Mod5Mask                 = int(C.Mod5Mask)
+	ShiftMask                = int(C.ShiftMask)
+	LockMask                 = int(C.LockMask)
+	ControlMask              = int(C.ControlMask)
+	AnyModifier              = int(C.AnyModifier)
+	Button1Mask              = int(C.Button1Mask)
+	Button2Mask              = int(C.Button2Mask)
+	Button3Mask              = int(C.Button3Mask)
+	Button4Mask              = int(C.Button4Mask)
+	Button5Mask              = int(C.Button5Mask)
+	ShiftMapIndex            = int(C.ShiftMapIndex)
+	LockMapIndex             = int(C.LockMapIndex)
+	ControlMapIndex          = int(C.ControlMapIndex)
+	Mod1MapIndex             = int(C.Mod1MapIndex)
+	Mod2MapIndex             = int(C.Mod2MapIndex)
+	Mod3MapIndex             = int(C.Mod3MapIndex)
+	Mod4MapIndex             = int(C.Mod4MapIndex)
+	Mod5MapIndex             = int(C.Mod5MapIndex)
+	PointerWindow            = int(C.PointerWindow)
+	InputFocus               = int(C.InputFocus)
+	PointerRoot              = int(C.PointerRoot)
+	AnyPropertyType          = int(C.AnyPropertyType)
+	AnyKey                   = int(C.AnyKey)
+	AnyButton                = int(C.AnyButton)
+	AllTemporary             = int(C.AllTemporary)
+	CurrentTime              = int(C.CurrentTime)
+	NoSymbol                 = int(C.NoSymbol)
 )
 
 type XEvent interface {
@@ -64,53 +91,75 @@ type tEventType struct {
 
 type XKeyEvent struct {
 	tEventType
-	Serial uint64
-	SendEvent bool
-	Display *Display 
-	Window Window
-	Root Window
-	Subwindow Window
-	Time uint64
-	X, Y int
+	Serial       uint64
+	SendEvent    bool
+	Display      *Display
+	Window       Window
+	Root         Window
+	Subwindow    Window
+	Time         uint64
+	X, Y         int
 	XRoot, YRoot int
-	State uint
-	KeyCode uint
-	SameScreen bool
+	State        uint
+	KeyCode      uint
+	SameScreen   bool
 }
 
-func XNextEvent ( display *Display ) XEvent {
+func XNextEvent(display *Display) XEvent {
 	displayC := (*C.Display)(display)
 	var xeventC C.XEvent
 	var xeventTypeC C.int
-	C.XNextEvent(displayC,&xeventC)
-	C.xlib_xevent_type(&xeventC,&xeventTypeC)
+	C.XNextEvent(displayC, &xeventC)
+	C.xlib_xevent_type(&xeventC, &xeventTypeC)
 
 	switch xeventTypeC {
-		case C.KeyPress:
-			return newXKeyEvent(&xeventC,xeventTypeC)
-		case C.KeyRelease:
-			return newXKeyEvent(&xeventC,xeventTypeC)
+	case C.KeyPress:
+		return newXKeyEvent(&xeventC, xeventTypeC)
+	case C.KeyRelease:
+		return newXKeyEvent(&xeventC, xeventTypeC)
 	}
 	return nil
 }
 
-func newXKeyEvent ( xeventC *C.XEvent, xeventTypeC C.int ) *XKeyEvent {
+func newXKeyEvent(xeventC *C.XEvent, xeventTypeC C.int) *XKeyEvent {
 	xKeyEvent := new(XKeyEvent)
-	var serialC C.ulong; var sendEventC C.Bool; var displayC *C.Display; var windowC C.Window
-	var rootC C.Window; var subwindowC C.Window; var timeC C.Time; var xC, yC C.int
-	var xRootC, yRootC C.int; var stateC C.uint; var keyCodeC C.uint; var sameScreenC C.Bool
-	C.xlib_xkeyevent_values(xeventC,&serialC,&sendEventC,&displayC,&windowC,&rootC,&subwindowC,
-	                                &timeC,&xC,&yC,&xRootC,&yRootC,&stateC,&keyCodeC,&sameScreenC)
-	xKeyEvent.typeCode = int(xeventTypeC); xKeyEvent.Serial = uint64(serialC)
-	xKeyEvent.SendEvent = (sendEventC != 0); xKeyEvent.Display = (*Display)(displayC)
-	xKeyEvent.Window = Window(windowC); xKeyEvent.Root = Window(rootC)
-	xKeyEvent.Subwindow = Window(subwindowC); xKeyEvent.Time = uint64(timeC)
-	xKeyEvent.X = int(xC); xKeyEvent.Y = int(yC); xKeyEvent.XRoot = int(xRootC); xKeyEvent.YRoot = int(yRootC)
-	xKeyEvent.State = uint(stateC); xKeyEvent.KeyCode = uint(keyCodeC); xKeyEvent.SameScreen = (sameScreenC != 0)
+	var serialC C.ulong
+	var sendEventC C.Bool
+	var displayC *C.Display
+	var windowC C.Window
+	var rootC C.Window
+	var subwindowC C.Window
+	var timeC C.Time
+	var xC, yC C.int
+	var xRootC, yRootC C.int
+	var stateC C.uint
+	var keyCodeC C.uint
+	var sameScreenC C.Bool
+	C.xlib_xkeyevent_values(xeventC, &serialC, &sendEventC, &displayC, &windowC, &rootC, &subwindowC,
+		&timeC, &xC, &yC, &xRootC, &yRootC, &stateC, &keyCodeC, &sameScreenC)
+	xKeyEvent.typeCode = int(xeventTypeC)
+	xKeyEvent.Serial = uint64(serialC)
+	xKeyEvent.SendEvent = (sendEventC != 0)
+	xKeyEvent.Display = (*Display)(displayC)
+	xKeyEvent.Window = Window(windowC)
+	xKeyEvent.Root = Window(rootC)
+	xKeyEvent.Subwindow = Window(subwindowC)
+	xKeyEvent.Time = uint64(timeC)
+	xKeyEvent.X = int(xC)
+	xKeyEvent.Y = int(yC)
+	xKeyEvent.XRoot = int(xRootC)
+	xKeyEvent.YRoot = int(yRootC)
+	xKeyEvent.State = uint(stateC)
+	xKeyEvent.KeyCode = uint(keyCodeC)
+	xKeyEvent.SameScreen = (sameScreenC != 0)
 	return xKeyEvent
 }
 
-func (this *tEventType) Type ( ) int {
-	return this.typeCode
+func XNextRequest(display *Display) uint64 {
+	displayC := (*C.Display)(display)
+	return uint64(C.XNextRequest(displayC))
 }
 
+func (ev *tEventType) Type() int {
+	return ev.typeCode
+}
diff --git a/go.mod b/go.mod
index 3758285..f0d386f 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
-module github.com/vbsw/xlib
+module github.com/daviseidel/xlib
 
-go 1.13
+go 1.18
diff --git a/xlib.go b/xlib.go
index 8a1aabd..2e787ef 100644
--- a/xlib.go
+++ b/xlib.go
@@ -1,14 +1,11 @@
-
 //          Copyright 2016 Vitali Baumtrok
 // Distributed under the Boost Software License, Version 1.0.
 //      (See accompanying file LICENSE or copy at
 //        http://www.boost.org/LICENSE_1_0.txt)
 
-
 // Binding of Xlib (version 11, release 6.7).
 package xlib
 
-
 // #cgo LDFLAGS: -lX11
 // #include <stdlib.h>
 // #include <X11/Xlib.h>
@@ -21,19 +18,22 @@ import (
 type Display C.Display
 type Screen C.Screen
 type Window C.Window
+type Bool C.Bool
+type WindowAttributes C.XWindowAttributes
+type Cursor C.Cursor
 
-func strConcat ( a []interface{} ) string {
+func strConcat(a []interface{}) string {
 	str := ""
 	for _, strPart := range a {
 		switch s := strPart.(type) {
-			case string:
-				str += s
+		case string:
+			str += s
 		}
 	}
 	return str
 }
 
-func XOpenDisplay ( displayNameParts ...interface{} ) *Display {
+func XOpenDisplay(displayNameParts ...interface{}) *Display {
 	if len(displayNameParts) == 0 {
 		display := C.XOpenDisplay(nil)
 		return (*Display)(display)
@@ -53,12 +53,12 @@ func XOpenDisplay ( displayNameParts ...interface{} ) *Display {
 	}
 }
 
-func XCloseDisplay ( display *Display ) {
+func XCloseDisplay(display *Display) {
 	displayC := (*C.Display)(display)
 	C.XCloseDisplay(displayC)
 }
 
-func XDisplayString ( display *Display ) string {
+func XDisplayString(display *Display) string {
 	displayC := (*C.Display)(display)
 	displayNameC := C.XDisplayString(displayC)
 	displayName := C.GoString(displayNameC)
@@ -66,43 +66,43 @@ func XDisplayString ( display *Display ) string {
 	return displayName
 }
 
-func XScreenCount ( display *Display ) int {
+func XScreenCount(display *Display) int {
 	displayC := (*C.Display)(display)
 	screenCount := C.XScreenCount(displayC)
 	return int(screenCount)
 }
 
-func XScreenOfDisplay ( display *Display, screenNumber int ) *Screen {
+func XScreenOfDisplay(display *Display, screenNumber int) *Screen {
 	displayC := (*C.Display)(display)
 	screen := C.XScreenOfDisplay(displayC, C.int(screenNumber))
 	return (*Screen)(screen)
 }
 
-func XWidthOfScreen ( screen *Screen ) int {
+func XWidthOfScreen(screen *Screen) int {
 	screenC := (*C.Screen)(screen)
 	width := C.XWidthOfScreen(screenC)
 	return int(width)
 }
 
-func XHeightOfScreen ( screen *Screen ) int {
+func XHeightOfScreen(screen *Screen) int {
 	screenC := (*C.Screen)(screen)
 	height := C.XHeightOfScreen(screenC)
 	return int(height)
 }
 
-func XDefaultScreenOfDisplay ( display *Display ) *Screen {
+func XDefaultScreenOfDisplay(display *Display) *Screen {
 	displayC := (*C.Display)(display)
 	defaultScreen := C.XDefaultScreenOfDisplay(displayC)
 	return (*Screen)(defaultScreen)
 }
 
-func XRootWindowOfScreen ( screen *Screen ) Window {
+func XRootWindowOfScreen(screen *Screen) Window {
 	screenC := (*C.Screen)(screen)
 	rootWindow := C.XRootWindowOfScreen(screenC)
 	return Window(rootWindow)
 }
 
-func XCreateSimpleWindow ( display *Display, parent Window, x, y int, width, height, borderWidth uint, border, background uint64) Window {
+func XCreateSimpleWindow(display *Display, parent Window, x, y int, width, height, borderWidth uint, border, background uint64) Window {
 	displayC := (*C.Display)(display)
 	windowC := (C.Window)(parent)
 	xC := C.int(x)
@@ -116,16 +116,309 @@ func XCreateSimpleWindow ( display *Display, parent Window, x, y int, width, hei
 	return Window(window)
 }
 
-func XMapWindow ( display *Display, window Window) {
+func XMapWindow(display *Display, window Window) {
 	displayC := (*C.Display)(display)
 	windowC := (C.Window)(window)
 	C.XMapWindow(displayC, windowC)
 }
 
-func XSelectInput ( display *Display, window Window, eventMask int64) {
+func XSelectInput(display *Display, window Window, eventMask int64) {
 	displayC := (*C.Display)(display)
 	windowC := (C.Window)(window)
 	eventMaskC := (C.long)(eventMask)
-	C.XSelectInput ( displayC, windowC, eventMaskC )
+	C.XSelectInput(displayC, windowC, eventMaskC)
+}
+
+func XGrabKey(display *Display, keycode int, modifiers int, grab_window Window, owner_events Bool, pointer_mode int, keyboard_mode int) int {
+	displayC := (*C.Display)(display)
+	keycodeC := (C.int)(keycode)
+	modifiersC := (C.uint)(modifiers)
+	grab_windowC := (C.Window)(grab_window)
+	owner_eventsC := (C.Bool)(owner_events)
+	pointer_modeC := (C.int)(pointer_mode)
+	keyboard_modeC := (C.int)(keyboard_mode)
+	status := C.XGrabKey(displayC, keycodeC, modifiersC, grab_windowC, owner_eventsC, pointer_modeC, keyboard_modeC)
+	return int(status)
+
+}
+
+func XRaiseWindow(display *Display, window Window) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	C.XRaiseWindow(displayC, windowC)
+}
+
+func XGetWindowAttributes(display *Display, window Window) *C.XWindowAttributes {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	windowAttributes := new(C.XWindowAttributes)
+	C.XGetWindowAttributes(displayC, windowC, windowAttributes)
+	return windowAttributes
+}
+
+func XMoveResizeWindow(display *Display, window Window, x, y int, width, height uint) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	xC := (C.int)(x)
+	yC := (C.int)(y)
+	widthC := (C.uint)(width)
+	heightC := (C.uint)(height)
+	C.XMoveResizeWindow(displayC, windowC, xC, yC, widthC, heightC)
+}
+
+func XKeysymToKeycode(display *Display, keysym uint64) int {
+	displayC := (*C.Display)(display)
+	keysymC := (C.KeySym)(keysym)
+	keycode := C.XKeysymToKeycode(displayC, keysymC)
+	return int(keycode)
+}
+
+func XStringToKeysym(string string) uint64 {
+	stringC := C.CString(string)
+	keysym := C.XStringToKeysym(stringC)
+	C.free(unsafe.Pointer(stringC))
+	return uint64(keysym)
+}
+
+func XGrabButton(display *Display, button int, modifiers int, grab_window Window, owner_events Bool, event_mask int64, pointer_mode int, keyboard_mode int, confine_to Window, cursor Cursor) int {
+	displayC := (*C.Display)(display)
+	buttonC := (C.uint)(button)
+	modifiersC := (C.uint)(modifiers)
+	grab_windowC := (C.Window)(grab_window)
+	owner_eventsC := (C.Bool)(owner_events)
+	event_maskC := (C.uint)(event_mask)
+	pointer_modeC := (C.int)(pointer_mode)
+	keyboard_modeC := (C.int)(keyboard_mode)
+	confine_toC := (C.Window)(confine_to)
+	cursorC := (C.Cursor)(cursor)
+	status := C.XGrabButton(displayC, buttonC, modifiersC, grab_windowC, owner_eventsC, event_maskC, pointer_modeC, keyboard_modeC, confine_toC, cursorC)
+	return int(status)
+}
+
+func XDefaultRootWindow(display *Display) Window {
+	displayC := (*C.Display)(display)
+	rootWindow := C.XDefaultRootWindow(displayC)
+	return Window(rootWindow)
+}
+
+func XUngrabKey(display *Display, keycode int, modifiers int, grab_window Window) {
+	displayC := (*C.Display)(display)
+	keycodeC := (C.int)(keycode)
+	modifiersC := (C.uint)(modifiers)
+	grab_windowC := (C.Window)(grab_window)
+	C.XUngrabKey(displayC, keycodeC, modifiersC, grab_windowC)
+}
+
+func XUngrabButton(display *Display, button int, modifiers int, grab_window Window) {
+	displayC := (*C.Display)(display)
+	buttonC := (C.uint)(button)
+	modifiersC := (C.uint)(modifiers)
+	grab_windowC := (C.Window)(grab_window)
+	C.XUngrabButton(displayC, buttonC, modifiersC, grab_windowC)
+}
+
+func XGrabPointer(display *Display, grab_window Window, owner_events Bool, event_mask int64, pointer_mode int, keyboard_mode int, confine_to Window, cursor Cursor, time uint64) int {
+	displayC := (*C.Display)(display)
+	grab_windowC := (C.Window)(grab_window)
+	owner_eventsC := (C.Bool)(owner_events)
+	event_maskC := (C.uint)(event_mask)
+	pointer_modeC := (C.int)(pointer_mode)
+	keyboard_modeC := (C.int)(keyboard_mode)
+	confine_toC := (C.Window)(confine_to)
+	cursorC := (C.Cursor)(cursor)
+	timeC := (C.Time)(time)
+	status := C.XGrabPointer(displayC, grab_windowC, owner_eventsC, event_maskC, pointer_modeC, keyboard_modeC, confine_toC, cursorC, timeC)
+	return int(status)
+}
+
+func XUngrabPointer(display *Display, time uint64) {
+	displayC := (*C.Display)(display)
+	timeC := (C.Time)(time)
+	C.XUngrabPointer(displayC, timeC)
+}
+
+func XWarpPointer(display *Display, src_window Window, dest_window Window, src_x, src_y int, src_width, src_height uint, dest_x, dest_y int) {
+	displayC := (*C.Display)(display)
+	src_windowC := (C.Window)(src_window)
+	dest_windowC := (C.Window)(dest_window)
+	src_xC := (C.int)(src_x)
+	src_yC := (C.int)(src_y)
+	src_widthC := (C.uint)(src_width)
+	src_heightC := (C.uint)(src_height)
+	dest_xC := (C.int)(dest_x)
+	dest_yC := (C.int)(dest_y)
+	C.XWarpPointer(displayC, src_windowC, dest_windowC, src_xC, src_yC, src_widthC, src_heightC, dest_xC, dest_yC)
+}
+
+func XQueryPointer(display *Display, window Window) (root_return Window, child_return Window, root_x_return, root_y_return, win_x_return, win_y_return int, mask_return uint) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	var root_returnC C.Window
+	var child_returnC C.Window
+	var root_x_returnC C.int
+	var root_y_returnC C.int
+	var win_x_returnC C.int
+	var win_y_returnC C.int
+	var mask_returnC C.uint
+	C.XQueryPointer(displayC, windowC, &root_returnC, &child_returnC, &root_x_returnC, &root_y_returnC, &win_x_returnC, &win_y_returnC, &mask_returnC)
+	root_return = Window(root_returnC)
+	child_return = Window(child_returnC)
+	root_x_return = int(root_x_returnC)
+	root_y_return = int(root_y_returnC)
+	win_x_return = int(win_x_returnC)
+	win_y_return = int(win_y_returnC)
+	mask_return = uint(mask_returnC)
+	return
+}
+
+func XUnmapWindow(display *Display, window Window) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	C.XUnmapWindow(displayC, windowC)
+}
+
+func XDestroyWindow(display *Display, window Window) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	C.XDestroyWindow(displayC, windowC)
+}
+
+func XFree(data unsafe.Pointer) {
+	C.XFree(data)
 }
 
+func XFlush(display *Display) {
+	displayC := (*C.Display)(display)
+	C.XFlush(displayC)
+}
+
+func XStoreName(display *Display, window Window, name string) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	nameC := C.CString(name)
+	C.XStoreName(displayC, windowC, nameC)
+	C.free(unsafe.Pointer(nameC))
+}
+
+func XCreateFontCursor(display *Display, shape uint) Cursor {
+	displayC := (*C.Display)(display)
+	shapeC := (C.uint)(shape)
+	cursor := C.XCreateFontCursor(displayC, shapeC)
+	return Cursor(cursor)
+}
+
+func XDefineCursor(display *Display, window Window, cursor Cursor) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	cursorC := (C.Cursor)(cursor)
+	C.XDefineCursor(displayC, windowC, cursorC)
+}
+
+func XUndefineCursor(display *Display, window Window) {
+	displayC := (*C.Display)(display)
+	windowC := (C.Window)(window)
+	C.XUndefineCursor(displayC, windowC)
+}
+
+func XCreateGC(display *Display, drawable Window, mask uint64, values *C.XGCValues) C.GC {
+	displayC := (*C.Display)(display)
+	drawableC := (C.Drawable)(drawable)
+	gc := C.XCreateGC(displayC, drawableC, C.ulong(mask), values)
+	return gc
+}
+
+func XFreeGC(display *Display, gc C.GC) {
+	displayC := (*C.Display)(display)
+	C.XFreeGC(displayC, gc)
+}
+
+func XSetForeground(display *Display, gc C.GC, foreground uint64) {
+	displayC := (*C.Display)(display)
+	foregroundC := (C.ulong)(foreground)
+	C.XSetForeground(displayC, gc, foregroundC)
+}
+
+func XSetBackground(display *Display, gc C.GC, background uint64) {
+	displayC := (*C.Display)(display)
+	backgroundC := (C.ulong)(background)
+	C.XSetBackground(displayC, gc, backgroundC)
+}
+
+func XSetLineAttributes(display *Display, gc C.GC, line_width uint, line_style int, cap_style int, join_style int) {
+	displayC := (*C.Display)(display)
+	line_widthC := (C.uint)(line_width)
+	line_styleC := (C.int)(line_style)
+	cap_styleC := (C.int)(cap_style)
+	join_styleC := (C.int)(join_style)
+	C.XSetLineAttributes(displayC, gc, line_widthC, line_styleC, cap_styleC, join_styleC)
+}
+
+func XDrawLine(display *Display, drawable Window, gc C.GC, x1, y1, x2, y2 int) {
+	displayC := (*C.Display)(display)
+	drawableC := (C.Drawable)(drawable)
+	x1C := (C.int)(x1)
+	y1C := (C.int)(y1)
+	x2C := (C.int)(x2)
+	y2C := (C.int)(y2)
+	C.XDrawLine(displayC, drawableC, gc, x1C, y1C, x2C, y2C)
+}
+
+func XDrawRectangle(display *Display, drawable Window, gc C.GC, x, y int, width, height uint) {
+	displayC := (*C.Display)(display)
+	drawableC := (C.Drawable)(drawable)
+	xC := (C.int)(x)
+	yC := (C.int)(y)
+	widthC := (C.uint)(width)
+	heightC := (C.uint)(height)
+	C.XDrawRectangle(displayC, drawableC, gc, xC, yC, widthC, heightC)
+}
+
+func XFillRectangle(display *Display, drawable Window, gc C.GC, x, y int, width, height uint) {
+	displayC := (*C.Display)(display)
+	drawableC := (C.Drawable)(drawable)
+	xC := (C.int)(x)
+	yC := (C.int)(y)
+	widthC := (C.uint)(width)
+	heightC := (C.uint)(height)
+	C.XFillRectangle(displayC, drawableC, gc, xC, yC, widthC, heightC)
+}
+
+func XQlength(display *Display) int {
+	displayC := (*C.Display)(display)
+	length := C.XQLength(displayC)
+	return int(length)
+}
+
+func XRootWindow(display *Display, screenNumber int) Window {
+	displayC := (*C.Display)(display)
+	screenNumberC := (C.int)(screenNumber)
+	rootWindow := C.XRootWindow(displayC, screenNumberC)
+	return Window(rootWindow)
+}
+
+func XServerVendor(display *Display) string {
+	displayC := (*C.Display)(display)
+	serverVendorC := C.XServerVendor(displayC)
+	serverVendor := C.GoString(serverVendorC)
+	C.free(unsafe.Pointer(serverVendorC))
+	return serverVendor
+}
+
+func XVendorRelease(display *Display) int {
+	displayC := (*C.Display)(display)
+	vendorRelease := C.XVendorRelease(displayC)
+	return int(vendorRelease)
+}
+
+func XDefaultScreen(display *Display) int {
+	displayC := (*C.Display)(display)
+	screenNumber := C.XDefaultScreen(displayC)
+	return int(screenNumber)
+}
+
+func XDefaultDepth(display *Display, screenNumber int) int {
+	displayC := (*C.Display)(display)
+	screenNumberC := (C.int)(screenNumber)
+	depth := C.XDefaultDepth(displayC, screenNumberC)
+	return int(depth)
+}