Added X11 support

src/lib.rs

@@ -0,0 +1,62 @@
+mod x11;
+
+use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
+use crate::x11::X11Impl;
+
+pub struct GraphicsContext<W: HasRawWindowHandle>{
+    window: W,
+    graphics_context_impl: Box<dyn GraphicsContextImpl>
+}
+
+impl<W: HasRawWindowHandle> GraphicsContext<W> {
+
+    pub unsafe fn new(window: W) -> Self{
+        let raw_handle = window.raw_window_handle();
+        let imple = match raw_handle{
+            RawWindowHandle::Xlib(xlib_handle) => Box::new(X11Impl::new(xlib_handle)),
+            unimplemented_handle_type => unimplemented!("Unsupported window handle type: {}.", window_handle_type_name(&unimplemented_handle_type))
+        };
+
+        Self{
+            window,
+            graphics_context_impl: imple
+        }
+    }
+
+    #[inline]
+    pub fn window(&self) -> &W{
+        &self.window
+    }
+
+    #[inline]
+    pub fn window_mut(&mut self) -> &mut W{
+        &mut self.window
+    }
+
+    #[inline]
+    pub fn set_buffer(&mut self, buffer: &[u32], width: u16, height: u16){
+        unsafe {
+            self.graphics_context_impl.set_buffer(buffer, width, height);
+        }
+    }
+
+}
+
+trait GraphicsContextImpl{
+    unsafe fn set_buffer(&mut self, buffer: &[u32], width: u16, height: u16);
+}
+
+fn window_handle_type_name(handle: &RawWindowHandle) -> &'static str{
+    match handle{
+        RawWindowHandle::Xlib(_) => "Xlib",
+        RawWindowHandle::Win32(_) => "Win32",
+        RawWindowHandle::WinRt(_) => "WinRt",
+        RawWindowHandle::Web(_) => "Web",
+        RawWindowHandle::Wayland(_) => "Wayland",
+        RawWindowHandle::AndroidNdk(_) => "AndroidNdk",
+        RawWindowHandle::AppKit(_) => "AppKit",
+        RawWindowHandle::Orbital(_) => "Orbital",
+        RawWindowHandle::UiKit(_) => "UiKit",
+        _ => "Unknown Name" //don't completely fail to compile if there is a new raw window handle type that's added at some point
+    }
+}

src/x11.rs

@@ -0,0 +1,75 @@
+use std::os::raw::{c_char, c_uint};
+use raw_window_handle::XlibHandle;
+use x11_dl::xlib::{Display, GC, Visual, Xlib, ZPixmap};
+use crate::GraphicsContextImpl;
+
+pub struct X11Impl{
+    handle: XlibHandle,
+    lib: Xlib,
+    gc: GC,
+    visual: *mut Visual,
+    depth: i32
+}
+
+impl X11Impl {
+
+    pub unsafe fn new(handle: XlibHandle) -> Self{
+        let lib = Xlib::open().unwrap();
+        let screen = (lib.XDefaultScreen)(handle.display as *mut Display);
+        let gc = (lib.XDefaultGC)(handle.display as *mut Display, screen);
+        let visual = (lib.XDefaultVisual)(handle.display as *mut Display, screen);
+        let depth = (lib.XDefaultDepth)(handle.display as *mut Display, screen);
+
+        Self{
+            handle,
+            lib,
+            gc,
+            visual,
+            depth
+        }
+    }
+
+}
+
+impl GraphicsContextImpl for X11Impl {
+
+    unsafe fn set_buffer(&mut self, buffer: &[u32], width: u16, height: u16) {
+        let mut owned_buffer = vec![0; (width as usize)*(height as usize)];
+        owned_buffer.copy_from_slice(buffer);
+
+        //create image
+        let image = (self.lib.XCreateImage)(
+            self.handle.display as *mut Display,
+            self.visual,
+            self.depth as u32,
+            ZPixmap,
+            0,
+            Box::leak(owned_buffer.into_boxed_slice()).as_mut_ptr() as *mut c_char,
+            width as u32,
+            height as u32,
+            32,
+            (width*4) as i32
+        );
+
+        if image.is_null(){
+            panic!("Image is null!");
+        }
+
+        //push image to window
+        (self.lib.XPutImage)(
+            self.handle.display as *mut Display,
+            self.handle.window,
+            self.gc,
+            image,
+            0,
+            0,
+            0,
+            0,
+            width as c_uint,
+            height as c_uint
+        );
+
+        (self.lib.XDestroyImage)(image);
+    }
+
+}