Merge most impl Device blocks

It was very difficult to know where any particular `Device` method was
implemented. This will make it easier to eliminate `macros.rs, necessary
to implement the new version of the API.

Signed-off-by: Martin Robinson <mrobinson@abandonedwig.info>

Author: mrobinson

src/angle/context.rs

@@ -54,371 +54,3 @@ impl Drop for Context {
         }
     }
 }
-
-impl Device {
-    /// Creates a context descriptor with the given attributes.
-    ///
-    /// Context descriptors are local to this device.
-    #[inline]
-    pub fn create_context_descriptor(
-        &self,
-        attributes: &ContextAttributes,
-    ) -> Result<ContextDescriptor, Error> {
-        unsafe {
-            ContextDescriptor::new(
-                self.egl_display,
-                attributes,
-                &[
-                    egl::BIND_TO_TEXTURE_RGBA as EGLint,
-                    1 as EGLint,
-                    egl::SURFACE_TYPE as EGLint,
-                    egl::PBUFFER_BIT as EGLint,
-                    egl::RENDERABLE_TYPE as EGLint,
-                    egl::OPENGL_ES2_BIT as EGLint,
-                ],
-            )
-        }
-    }
-
-    /// Creates a new OpenGL context.
-    ///
-    /// The context initially has no surface attached. Until a surface is bound to it, rendering
-    /// commands will fail or have no effect.
-    pub fn create_context(
-        &self,
-        descriptor: &ContextDescriptor,
-        share_with: Option<&Context>,
-    ) -> Result<Context, Error> {
-        let (egl_context, id) = {
-            let mut next_context_id_lock = CREATE_CONTEXT_MUTEX.lock().unwrap();
-            let egl_context = unsafe {
-                context::create_context(
-                    self.egl_display,
-                    descriptor,
-                    share_with.map_or(egl::NO_CONTEXT, |ctx| ctx.egl_context),
-                    self.gl_api(),
-                )?
-            };
-            next_context_id_lock.0 += 1;
-            (egl_context, *next_context_id_lock)
-        };
-
-        unsafe {
-            EGL_FUNCTIONS.with(|egl| {
-                let result = egl.MakeCurrent(
-                    self.egl_display,
-                    egl::NO_SURFACE,
-                    egl::NO_SURFACE,
-                    egl_context,
-                );
-                if result == egl::FALSE {
-                    return Err(Error::MakeCurrentFailed(
-                        egl.GetError().to_windowing_api_error(),
-                    ));
-                }
-                Ok(())
-            })?;
-        }
-
-        let context = Context {
-            egl_context,
-            id,
-            framebuffer: Framebuffer::None,
-            context_is_owned: true,
-            gl: unsafe { Gl::from_loader_function(context::get_proc_address) },
-        };
-        Ok(context)
-    }
-
-    /// Wraps a native `EGLContext` in a context object.
-    ///
-    /// The underlying `EGLContext` is not retained, as there is no way to do this in the EGL API.
-    /// Therefore, it is the caller's responsibility to keep it alive as long as this `Context`
-    /// remains alive.
-    pub unsafe fn create_context_from_native_context(
-        &self,
-        native_context: NativeContext,
-    ) -> Result<Context, Error> {
-        let mut next_context_id = CREATE_CONTEXT_MUTEX.lock().unwrap();
-
-        // Create the context.
-        let context = Context {
-            egl_context: native_context.egl_context,
-            id: *next_context_id,
-            framebuffer: Framebuffer::External(ExternalEGLSurfaces {
-                draw: native_context.egl_draw_surface,
-                read: native_context.egl_read_surface,
-            }),
-            context_is_owned: false,
-            gl: Gl::from_loader_function(context::get_proc_address),
-        };
-        next_context_id.0 += 1;
-
-        Ok(context)
-    }
-
-    /// Destroys a context.
-    ///
-    /// The context must have been created on this device.
-    pub fn destroy_context(&self, context: &mut Context) -> Result<(), Error> {
-        if context.egl_context == egl::NO_CONTEXT {
-            return Ok(());
-        }
-
-        if let Ok(Some(mut surface)) = self.unbind_surface_from_context(context) {
-            self.destroy_surface(context, &mut surface)?;
-        }
-
-        EGL_FUNCTIONS.with(|egl| unsafe {
-            egl.MakeCurrent(
-                self.egl_display,
-                egl::NO_SURFACE,
-                egl::NO_SURFACE,
-                egl::NO_CONTEXT,
-            );
-
-            if context.context_is_owned {
-                let result = egl.DestroyContext(self.egl_display, context.egl_context);
-                assert_ne!(result, egl::FALSE);
-            }
-
-            context.egl_context = egl::NO_CONTEXT;
-        });
-
-        Ok(())
-    }
-
-    /// Returns the descriptor that this context was created with.
-    pub fn context_descriptor(&self, context: &Context) -> ContextDescriptor {
-        unsafe {
-            ContextDescriptor::from_egl_context(&context.gl, self.egl_display, context.egl_context)
-        }
-    }
-
-    /// Makes the context the current OpenGL context for this thread.
-    ///
-    /// After calling this function, it is valid to use OpenGL rendering commands.
-    pub fn make_context_current(&self, context: &Context) -> Result<(), Error> {
-        unsafe {
-            let (egl_draw_surface, egl_read_surface) = match context.framebuffer {
-                Framebuffer::Surface(ref surface) => (surface.egl_surface, surface.egl_surface),
-                Framebuffer::None => (egl::NO_SURFACE, egl::NO_SURFACE),
-                Framebuffer::External(ref surfaces) => (surfaces.draw, surfaces.read),
-            };
-
-            EGL_FUNCTIONS.with(|egl| {
-                let result = egl.MakeCurrent(
-                    self.egl_display,
-                    egl_draw_surface,
-                    egl_read_surface,
-                    context.egl_context,
-                );
-                if result == egl::FALSE {
-                    let err = egl.GetError().to_windowing_api_error();
-                    return Err(Error::MakeCurrentFailed(err));
-                }
-                Ok(())
-            })
-        }
-    }
-
-    /// Removes the current OpenGL context from this thread.
-    ///
-    /// After calling this function, OpenGL rendering commands will fail until a new context is
-    /// made current.
-    pub fn make_no_context_current(&self) -> Result<(), Error> {
-        unsafe { context::make_no_context_current(self.egl_display) }
-    }
-
-    pub(crate) fn temporarily_make_context_current(
-        &self,
-        context: &Context,
-    ) -> Result<CurrentContextGuard, Error> {
-        let guard = CurrentContextGuard::new();
-        self.make_context_current(context)?;
-        Ok(guard)
-    }
-
-    pub(crate) fn context_is_current(&self, context: &Context) -> bool {
-        EGL_FUNCTIONS.with(|egl| unsafe { egl.GetCurrentContext() == context.egl_context })
-    }
-
-    /// Returns the attributes that the context descriptor was created with.
-    #[inline]
-    pub fn context_descriptor_attributes(
-        &self,
-        context_descriptor: &ContextDescriptor,
-    ) -> ContextAttributes {
-        unsafe { context_descriptor.attributes(self.egl_display) }
-    }
-
-    /// Fetches the address of an OpenGL function associated with this context.
-    ///
-    /// OpenGL functions are local to a context. You should not use OpenGL functions on one context
-    /// with any other context.
-    ///
-    /// This method is typically used with a function like `gl::load_with()` from the `gl` crate to
-    /// load OpenGL function pointers.
-    #[inline]
-    pub fn get_proc_address(&self, _: &Context, symbol_name: &str) -> *const c_void {
-        context::get_proc_address(symbol_name)
-    }
-
-    #[inline]
-    pub(crate) fn context_descriptor_to_egl_config(
-        &self,
-        context_descriptor: &ContextDescriptor,
-    ) -> EGLConfig {
-        unsafe { context::egl_config_from_id(self.egl_display, context_descriptor.egl_config_id) }
-    }
-
-    /// Attaches a surface to a context for rendering.
-    ///
-    /// This function takes ownership of the surface. The surface must have been created with this
-    /// context, or an `IncompatibleSurface` error is returned.
-    ///
-    /// If this function is called with a surface already bound, a `SurfaceAlreadyBound` error is
-    /// returned. To avoid this error, first unbind the existing surface with
-    /// `unbind_surface_from_context`.
-    ///
-    /// If an error is returned, the surface is returned alongside it.
-    pub fn bind_surface_to_context(
-        &self,
-        context: &mut Context,
-        surface: Surface,
-    ) -> Result<(), (Error, Surface)> {
-        if context.id != surface.context_id {
-            return Err((Error::IncompatibleSurface, surface));
-        }
-
-        match context.framebuffer {
-            Framebuffer::None => {}
-            Framebuffer::External(_) => return Err((Error::ExternalRenderTarget, surface)),
-            Framebuffer::Surface(_) => return Err((Error::SurfaceAlreadyBound, surface)),
-        }
-
-        // If the surface is synchronized with GLFinish, then finish.
-        // FIXME(pcwalton): Is this necessary and sufficient?
-        if surface.uses_gl_finish() {
-            if let Ok(_guard) = self.temporarily_make_context_current(context) {
-                unsafe {
-                    context.gl.finish();
-                }
-            }
-        }
-
-        let is_current = self.context_is_current(context);
-
-        match surface.win32_objects {
-            Win32Objects::Pbuffer {
-                synchronization: Synchronization::KeyedMutex(ref keyed_mutex),
-                ..
-            } => unsafe {
-                let result = keyed_mutex.AcquireSync(0, INFINITE);
-                assert_eq!(result, S_OK);
-            },
-            _ => {}
-        }
-
-        context.framebuffer = Framebuffer::Surface(surface);
-
-        if is_current {
-            // We need to make ourselves current again, because the surface changed.
-            drop(self.make_context_current(context));
-        }
-
-        Ok(())
-    }
-
-    /// Removes and returns any attached surface from this context.
-    ///
-    /// Any pending OpenGL commands targeting this surface will be automatically flushed, so the
-    /// surface is safe to read from immediately when this function returns.
-    pub fn unbind_surface_from_context(
-        &self,
-        context: &mut Context,
-    ) -> Result<Option<Surface>, Error> {
-        match context.framebuffer {
-            Framebuffer::None => return Ok(None),
-            Framebuffer::External(_) => return Err(Error::ExternalRenderTarget),
-            Framebuffer::Surface(_) => {}
-        }
-
-        let surface = match mem::replace(&mut context.framebuffer, Framebuffer::None) {
-            Framebuffer::Surface(surface) => surface,
-            Framebuffer::None | Framebuffer::External(_) => unreachable!(),
-        };
-
-        match surface.win32_objects {
-            Win32Objects::Pbuffer {
-                synchronization: Synchronization::KeyedMutex(ref keyed_mutex),
-                ..
-            } => unsafe {
-                let result = keyed_mutex.ReleaseSync(0);
-                assert_eq!(result, S_OK);
-            },
-            _ => {}
-        }
-
-        Ok(Some(surface))
-    }
-
-    /// Displays the contents of the currently bound surface to the screen, if
-    /// it is a widget surface.
-    ///
-    /// Widget surfaces are internally double-buffered, so changes to them don't
-    /// show up in their associated widgets until this method is called.
-    pub fn present_bound_surface(&self, context: &mut Context) -> Result<(), Error> {
-        match &context.framebuffer {
-            Framebuffer::Surface(surface) => surface.present(self),
-            _ => Ok(()),
-        }
-    }
-
-    /// If the currently bound surface is a widget surface, resize it,
-    pub fn resize_bound_surface(
-        &self,
-        context: &mut Context,
-        size: Size2D<i32>,
-    ) -> Result<(), Error> {
-        if let Framebuffer::Surface(surface) = &mut context.framebuffer {
-            surface.resize(size);
-        }
-        Ok(())
-    }
-
-    /// Returns a unique ID representing a context.
-    ///
-    /// This ID is unique to all currently-allocated contexts. If you destroy a context and create
-    /// a new one, the new context might have the same ID as the destroyed one.
-    #[inline]
-    pub fn context_id(&self, context: &Context) -> ContextID {
-        context.id
-    }
-
-    /// Returns various information about the surface attached to a context.
-    ///
-    /// This includes, most notably, the OpenGL framebuffer object needed to render to the surface.
-    pub fn context_surface_info(&self, context: &Context) -> Result<Option<SurfaceInfo>, Error> {
-        match context.framebuffer {
-            Framebuffer::None => Ok(None),
-            Framebuffer::External(_) => Err(Error::ExternalRenderTarget),
-            Framebuffer::Surface(ref surface) => Ok(Some(self.surface_info(surface))),
-        }
-    }
-
-    /// Given a context, returns its underlying EGL context and attached surfaces.
-    pub fn native_context(&self, context: &Context) -> NativeContext {
-        let (egl_draw_surface, egl_read_surface) = match context.framebuffer {
-            Framebuffer::Surface(Surface { egl_surface, .. }) => (egl_surface, egl_surface),
-            Framebuffer::External(ExternalEGLSurfaces { draw, read }) => (draw, read),
-            Framebuffer::None => (egl::NO_SURFACE, egl::NO_SURFACE),
-        };
-
-        NativeContext {
-            egl_context: context.egl_context,
-            egl_draw_surface,
-            egl_read_surface,
-        }
-    }
-}