Refactoring as of 2019/06/22.

Signed-off-by: Hal Gentz <zegentzy@protonmail.com>

Author: goddessfreya

.circleci/config.yml.old

@@ -0,0 +1,56 @@
+version: 2
+
+jobs:
+
+  android-test:
+    working_directory: ~/glutin
+    docker:
+      - image: gentz/android-rs-glue
+    steps:
+      - run: apt-get -qq update && apt-get install -y git
+      - checkout
+      - restore_cache:
+          key: android-test-cache-{{ checksum "Cargo.toml" }}
+      - run: cd glutin_examples && cargo apk build --example window
+      - save_cache:
+          key: android-test-cache-{{ checksum "Cargo.toml" }}
+          paths:
+            - target
+
+  asmjs-test:
+    working_directory: ~/glutin
+    docker:
+      - image: tomaka/rustc-emscripten
+    steps:
+      - run: apt-get -qq update && apt-get install -y git
+      - checkout
+      - restore_cache:
+          key: asmjs-test-cache-{{ checksum "Cargo.toml" }}
+      - run: cargo build --example window --target asmjs-unknown-emscripten
+      - save_cache:
+          key: asmjs-test-cache-{{ checksum "Cargo.toml" }}
+          paths:
+            - target
+
+  wasm-test:
+    working_directory: ~/glutin
+    docker:
+      - image: tomaka/rustc-emscripten
+    steps:
+      - run: apt-get -qq update && apt-get install -y git
+      - checkout
+      - restore_cache:
+          key: wasm-test-cache-{{ checksum "Cargo.toml" }}
+      - run: cargo build --example window --target wasm32-unknown-emscripten
+      - save_cache:
+          key: wasm-test-cache-{{ checksum "Cargo.toml" }}
+          paths:
+            - target
+  
+workflows:
+  version: 2
+  test-all:
+    jobs:
+      - android-test
+      - asmjs-test
+      - wasm-test

.gitattributes

@@ -20,3 +20,5 @@
 *.PDF	 diff=astextplain
 *.rtf	 diff=astextplain
 *.RTF	 diff=astextplain
+
+/CHANGELOG.md merge=union 

glutin/Cargo.toml

@@ -19,7 +19,8 @@ serde = ["winit/serde"]
 [dependencies]
 lazy_static = "1.3"
 #winit = "^0.19.1"
-winit = { git = "https://github.com/rust-windowing/winit.git", rev = "0eefa3b" }
+winit = { git = "https://github.com/rust-windowing/winit.git", rev = "db794b9" }
+log = "0.4"
 
 [target.'cfg(target_os = "android")'.dependencies]
 android_glue = "0.2"
@@ -62,4 +63,3 @@ glutin_egl_sys = { version = "0.1.3", path = "../glutin_egl_sys" }
 glutin_glx_sys = { version = "0.1.5", path = "../glutin_glx_sys" }
 derivative = "1.0"
 parking_lot = "0.8"
-log = "0.4"

glutin/src/lib.rs

@@ -99,13 +99,6 @@ extern crate lazy_static;
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[macro_use]
 extern crate objc;
-#[cfg(any(
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd",
-))]
 #[macro_use]
 extern crate log;
 #[cfg(any(

glutin/src/platform_impl/unix/mod.rs

@@ -12,7 +12,7 @@ mod x11;
 use self::x11::X11Context;
 use crate::{
     Api, ContextCurrentState, ContextError, CreationError, GlAttributes,
-    NotCurrent, PixelFormat, PixelFormatRequirements,
+    NotCurrent, PixelFormat, PixelFormatRequirements, ContextBuilderWrapper,
 };
 pub use x11::utils as x11_utils;
 
@@ -78,6 +78,36 @@ impl Context {
         }
     }
 
+    #[inline]
+    pub fn new<T>(
+        el: &EventLoop<T>,
+        cb: ContextBuilderWrapper<&'_ Context>,
+        pbuffer_support: bool,
+        window_surface_support: bool,
+        surfaceless_support: bool,
+    ) -> Result<Self, CreationError> {
+        if el.is_wayland() {
+            unimplemented!()
+            /*Context::is_compatible(&gl_attr.sharing, ContextType::Wayland)?;
+
+            let gl_attr = gl_attr.clone().map_sharing(|ctx| match *ctx {
+                Context::Wayland(ref ctx) => ctx,
+                _ => unreachable!(),
+            });
+            wayland::Context::new(wb, el, pf_reqs, &gl_attr, plat_attr)
+                .map(|(win, context)| (win, Context::Wayland(context)))*/
+        } else {
+            Context::is_compatible(&cb.gl_attr.sharing, ContextType::X11)?;
+            let cb = cb.map_sharing(|ctx| match *ctx {
+                Context::X11(ref ctx) => ctx,
+                _ => unreachable!(),
+            });
+            x11::Context::new(el, cb, pbuffer_support, window_surface_support, surfaceless_support)
+                .map(|context| Context::X11(context))
+        }
+    }
+
+    /*
     #[inline]
     pub fn new_windowed<T>(
         wb: WindowBuilder,
@@ -141,7 +171,7 @@ impl Context {
             x11::Context::new_headless(&el, pf_reqs, &gl_attr, plat_attr, size)
                 .map(|ctx| Context::X11(ctx))
         }
-    }
+    }*/
 
     #[inline]
     pub unsafe fn make_current(&self) -> Result<(), ContextError> {
@@ -231,9 +261,29 @@ impl Context {
     }
 }
 
+#[derive(Debug, Clone)]
+pub enum BackingApi {
+    GlxThenEgl,
+    EglThenGlx,
+    Egl,
+    Glx,
+}
+
+impl Default for BackingApi {
+    fn default() -> Self {
+        BackingApi::GlxThenEgl
+    }
+}
+
 #[derive(Default, Debug, Clone)]
 pub struct PlatformAttributes {
     /// X11 only: set internally to insure a certain visual xid is used when
     /// choosing the fbconfig.
     pub(crate) x11_visual_xid: Option<std::os::raw::c_ulong>,
+
+    /// GLX only: Whether the context will have transparency support.
+    pub glx_transparency: Option<bool>,
+
+    /// Ignored by surfaceless.
+    pub backing_api: BackingApi,
 }

glutin/src/platform_impl/unix/x11.rs

@@ -10,7 +10,7 @@ use crate::platform::unix::{
 use crate::platform_impl::{x11_utils, PlatformAttributes};
 use crate::{
     Api, ContextError, CreationError, GlAttributes, GlRequest, PixelFormat,
-    PixelFormatRequirements,
+    PixelFormatRequirements, ContextBuilderWrapper
 };
 
 use glutin_glx_sys as ffi;
@@ -98,7 +98,7 @@ unsafe impl Sync for Context {}
 pub fn select_config<T, F>(
     xconn: &Arc<XConnection>,
     transparent: Option<bool>,
-    plat_attr: &PlatformAttributes,
+    cb: &ContextBuilderWrapper<&'_ Context>,
     config_ids: Vec<T>,
     mut convert_to_xvisualinfo: F,
 ) -> Result<(T, ffi::XVisualInfo), ()>
@@ -119,7 +119,7 @@ where
             &xconn,
             visual_infos,
             transparent == Some(true),
-            plat_attr.x11_visual_xid,
+            cb.plat_attr.x11_visual_xid,
         );
 
         let pict_format = unsafe {
@@ -184,6 +184,7 @@ impl Context {
         }
     }
 
+    /*
     #[inline]
     pub fn new_headless<T>(
         el: &EventLoop<T>,
@@ -310,24 +311,22 @@ impl Context {
 
             Ok(context)
         }
-    }
+    }*/
 
     #[inline]
     fn new_first_stage<'a>(
         xconn: &Arc<XConnection>,
-        pf_reqs: &PixelFormatRequirements,
-        gl_attr: &'a GlAttributes<&'a Context>,
-        plat_attr: &'a PlatformAttributes,
+        cb: &ContextBuilderWrapper<&'_ Context>,
         screen_id: raw::c_int,
-        builder_glx_u: &'a mut Option<GlAttributes<&'a GlxContext>>,
-        builder_egl_u: &'a mut Option<GlAttributes<&'a EglContext>>,
+        builder_glx_u: &'_ mut Option<ContextBuilderWrapper<&'_ GlxContext>>,
+        builder_egl_u: &'_ mut Option<ContextBuilderWrapper<&'_ EglContext>>,
         surface_type: EglSurfaceType,
         prefer_egl: bool,
         force_prefer_unless_only: bool,
         transparent: Option<bool>,
     ) -> Result<Prototype<'a>, CreationError> {
         let select_config = |cs, display| {
-            select_config(&xconn, transparent, plat_attr, cs, |config_id| {
+            select_config(&xconn, transparent, cb, cs, |config_id| {
                 let xid = egl::get_native_visual_id(display, *config_id)
                     as ffi::VisualID;
                 if xid == 0 {
@@ -337,7 +336,7 @@ impl Context {
             })
             .map(|(c, _)| c)
         };
-        Ok(match gl_attr.version {
+        Ok(match cb.gl_attr.version {
             GlRequest::Latest
             | GlRequest::Specific(Api::OpenGl, _)
             | GlRequest::GlThenGles { .. } => {
@@ -347,25 +346,23 @@ impl Context {
                 // However, with surfaceless, GLX isn't really there, so we
                 // should prefer EGL.
                 let glx = |builder_u: &'a mut Option<_>| {
-                    let builder = gl_attr.clone();
+                    let builder = cb.clone();
                     *builder_u =
                         Some(builder.map_sharing(|c| match c.context {
                             X11Context::Glx(ref c) => c,
                             _ => panic!(),
                         }));
                     Ok(Prototype::Glx(GlxContext::new(
                         Arc::clone(&xconn),
-                        pf_reqs,
                         builder_u.as_ref().unwrap(),
-                        plat_attr,
                         screen_id,
                         surface_type,
                         transparent,
                     )?))
                 };
 
                 let egl = |builder_u: &'a mut Option<_>| {
-                    let builder = gl_attr.clone();
+                    let builder = cb.clone();
                     *builder_u =
                         Some(builder.map_sharing(|c| match c.context {
                             X11Context::Egl(ref c) => c,
@@ -374,9 +371,7 @@ impl Context {
                     let native_display =
                         NativeDisplay::X11(Some(xconn.display as *const _));
                     Ok(Prototype::Egl(EglContext::new(
-                        pf_reqs,
                         builder_u.as_ref().unwrap(),
-                        plat_attr,
                         native_display,
                         surface_type,
                         select_config,
@@ -428,16 +423,14 @@ impl Context {
             }
             GlRequest::Specific(Api::OpenGlEs, _) => {
                 if let Some(_) = *EGL {
-                    let builder = gl_attr.clone();
+                    let builder = cb.clone();
                     *builder_egl_u =
                         Some(builder.map_sharing(|c| match c.context {
                             X11Context::Egl(ref c) => c,
                             _ => panic!(),
                         }));
                     Prototype::Egl(EglContext::new(
-                        pf_reqs,
                         builder_egl_u.as_ref().unwrap(),
-                        plat_attr,
                         NativeDisplay::X11(Some(xconn.display as *const _)),
                         surface_type,
                         select_config,
@@ -458,25 +451,25 @@ impl Context {
 
     #[inline]
     pub fn new<T>(
-        wb: WindowBuilder,
         el: &EventLoop<T>,
-        pf_reqs: &PixelFormatRequirements,
-        gl_attr: &GlAttributes<&Context>,
-        plat_attr: &PlatformAttributes,
-    ) -> Result<(Window, Self), CreationError> {
+        cb: ContextBuilderWrapper<&'_ Context>,
+        pbuffer_support: bool,
+        window_surface_support: bool,
+        surfaceless_support: bool,
+    ) -> Result<Self, CreationError> {
         Self::try_then_fallback(|fallback| {
-            Self::new_impl(wb.clone(), el, pf_reqs, gl_attr, plat_attr, fallback)
+            Self::new_impl(el, &cb, pbuffer_support, window_surface_support, surfaceless_support, fallback)
         })
     }
 
     fn new_impl<T>(
-        wb: WindowBuilder,
         el: &EventLoop<T>,
-        pf_reqs: &PixelFormatRequirements,
-        gl_attr: &GlAttributes<&Context>,
-        plat_attr: &PlatformAttributes,
+        cb: &ContextBuilderWrapper<&'_ Context>,
+        pbuffer_support: bool,
+        window_surface_support: bool,
+        surfaceless_support: bool,
         fallback: bool,
-    ) -> Result<(Window, Self), CreationError> {
+    ) -> Result<Self, CreationError> {
         let xconn = match el.xlib_xconnection() {
             Some(xconn) => xconn,
             None => {
@@ -495,9 +488,7 @@ impl Context {
         // start the context building process
         let context = Self::new_first_stage(
             &xconn,
-            pf_reqs,
-            gl_attr,
-            plat_attr,
+            cb,
             screen_id,
             &mut builder_glx_u,
             &mut builder_egl_u,
@@ -537,6 +528,7 @@ impl Context {
         Ok((win, context))
     }
 
+    /*
     #[inline]
     pub fn new_raw_context(
         xconn: Arc<XConnection>,
@@ -624,6 +616,7 @@ impl Context {
 
         Ok(context)
     }
+    */
 
     #[inline]
     pub unsafe fn make_current(&self) -> Result<(), ContextError> {

glutin/src/surface.rs

@@ -87,3 +87,19 @@ impl PBuffer {
 }
 
 impl IsPBuffer for PBuffer {}
+
+impl Drop for PBuffer {
+    fn drop(&mut self) {
+        if self.is_current() {
+            warn!("User dropped PBuffer that is still current. Future operations that modify and/or depend on the pbuffer will cause UB.");
+        }
+    }
+}
+
+impl<T> Drop for WindowSurfaceWrapper<T> {
+    fn drop(&mut self) {
+        if self.is_current() {
+            warn!("User dropped WindowSurfaceWrapper that is still current. Future operations that modify and/or depend on the surface will cause UB.");
+        }
+    }
+}