alex/winit-sonoma-fix
1
0
Fork 0
mirror of https://github.com/italicsjenga/winit-sonoma-fix.git synced 2024-10-17 23:41:33 +11:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #44 from tomaka/headless-rendering

Browse source 
Implement headless rendering
This commit is contained in:
tomaka 2014-10-09 20:04:02 +02:00
parent cfb0cb7001 e565bfeb13
commit 093c188b11
17 changed files with 791 additions and 518 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.travis.yml
View file

@ -1,7 +1,11 @@
language: rust
install:
- sudo apt-get install libXxf86vm-dev
- sudo apt-get install libXxf86vm-dev libosmesa6-dev
script:
- cargo build --verbose
- cargo test --verbose --features "headless" --no-default-features
os:
- linux

4
Cargo.toml
View file

@ -5,7 +5,9 @@ version = "0.0.1"
authors = ["tomaka <pierre.krieger1708@gmail.com>"]
[features]
default = ["cocoa"]
default = ["cocoa", "window"]
window = []
headless = []
[dependencies.compile_msg]
git = "https://github.com/huonw/compile_msg"

4
examples/fullscreen.rs
View file

@ -14,6 +14,10 @@ mod support;
#[cfg(target_os = "android")]
android_start!(main)
#[cfg(not(feature = "window"))]
fn main() { println!("This example requires glutin to be compiled with the `window` feature"); }
#[cfg(feature = "window")]
fn main() {
// enumerating monitors
let monitor = {

5
examples/multiwindow.rs
View file

@ -12,6 +12,10 @@ mod support;
#[cfg(target_os = "android")]
android_start!(main)
#[cfg(not(feature = "window"))]
fn main() { println!("This example requires glutin to be compiled with the `window` feature"); }
#[cfg(feature = "window")]
fn main() {
let window1 = glutin::Window::new().unwrap();
let window2 = glutin::Window::new().unwrap();
@ -30,6 +34,7 @@ fn main() {
});
}
#[cfg(feature = "window")]
fn run(window: glutin::Window, color: (f32, f32, f32, f32)) {
unsafe { window.make_current() };

2
examples/support/mod.rs
View file

@ -1,3 +1,5 @@
#![cfg(feature = "window")]
#[phase(plugin)]
extern crate gl_generator;

4
examples/window.rs
View file

@ -12,6 +12,10 @@ mod support;
#[cfg(target_os = "android")]
android_start!(main)
#[cfg(not(feature = "window"))]
fn main() { println!("This example requires glutin to be compiled with the `window` feature"); }
#[cfg(feature = "window")]
fn main() {
let window = glutin::Window::new().unwrap();

82
src/lib.rs
View file

@ -1,3 +1,4 @@
#![feature(tuple_indexing)]
#![feature(unsafe_destructor)]
#![feature(globs)]
#![feature(phase)]
@ -17,6 +18,16 @@
//!
//! The second way allows you to customize the way your window and GL context
//! will look and behave.
//!
//! # Features
//!
//! This crate has two Cargo features: `window` and `headless`.
//!
//! - `window` allows you to create regular windows and enables the `WindowBuilder` object.
//! - `headless` allows you to do headless rendering, and enables
//! the `HeadlessRendererBuilder` object.
//!
//! By default only `window` is enabled.
#[phase(plugin)] extern crate compile_msg;
#[phase(plugin)] extern crate gl_generator;
@ -55,9 +66,11 @@ mod events;
compile_error!("Only the `windows`, `linux` and `macos` platforms are supported")
/// Identifier for a monitor.
#[cfg(feature = "window")]
pub struct MonitorID(winimpl::MonitorID);
/// Object that allows you to build windows.
#[cfg(feature = "window")]
pub struct WindowBuilder {
dimensions: Option<(uint, uint)>,
title: String,
@ -65,6 +78,7 @@ pub struct WindowBuilder {
gl_version: Option<(uint, uint)>,
}
#[cfg(feature = "window")]
impl WindowBuilder {
/// Initializes a new `WindowBuilder` with default values.
pub fn new() -> WindowBuilder {
@ -128,6 +142,41 @@ impl WindowBuilder {
}
}
/// Object that allows you to build headless contexts.
#[cfg(feature = "headless")]
pub struct HeadlessRendererBuilder {
dimensions: (uint, uint),
gl_version: Option<(uint, uint)>,
}
#[cfg(feature = "headless")]
impl HeadlessRendererBuilder {
/// Initializes a new `HeadlessRendererBuilder` with default values.
pub fn new(width: uint, height: uint) -> HeadlessRendererBuilder {
HeadlessRendererBuilder {
dimensions: (width, height),
gl_version: None,
}
}
/// Requests to use a specific OpenGL version.
///
/// Version is a (major, minor) pair. For example to request OpenGL 3.3
/// you would pass `(3, 3)`.
pub fn with_gl_version(mut self, version: (uint, uint)) -> HeadlessRendererBuilder {
self.gl_version = Some(version);
self
}
/// Builds the headless context.
///
/// Error should be very rare and only occur in case of permission denied, incompatible system,
/// out of memory, etc.
pub fn build(self) -> Result<HeadlessContext, String> {
winimpl::HeadlessContext::new(self).map(|w| HeadlessContext { context: w })
}
}
/// Represents an OpenGL context and the Window or environment around it.
///
/// # Example
@ -150,16 +199,19 @@ impl WindowBuilder {
/// std::io::timer::sleep(17);
/// }
/// ```
#[cfg(feature = "window")]
pub struct Window {
window: winimpl::Window,
}
#[cfg(feature = "window")]
impl Default for Window {
fn default() -> Window {
Window::new().unwrap()
}
}
#[cfg(feature = "window")]
impl Window {
/// Creates a new OpenGL context, and a Window for platforms where this is appropriate.
///
@ -168,6 +220,7 @@ impl Window {
/// Error should be very rare and only occur in case of permission denied, incompatible system,
/// out of memory, etc.
#[inline]
#[cfg(feature = "window")]
pub fn new() -> Result<Window, String> {
let builder = WindowBuilder::new();
builder.build()
@ -295,6 +348,30 @@ impl Window {
}
}
/// Represents a headless OpenGL context.
#[cfg(feature = "headless")]
pub struct HeadlessContext {
context: winimpl::HeadlessContext,
}
#[cfg(feature = "headless")]
impl HeadlessContext {
/// Creates a new OpenGL context
/// Sets the context as the current context.
#[inline]
pub unsafe fn make_current(&self) {
self.context.make_current()
}
/// Returns the address of an OpenGL function.
///
/// Contrary to `wglGetProcAddress`, all available OpenGL functions return an address.
#[inline]
pub fn get_proc_address(&self, addr: &str) -> *const libc::c_void {
self.context.get_proc_address(addr) as *const libc::c_void
}
}
/// An iterator for the `poll_events` function.
// Implementation note: we retreive the list once, then serve each element by one by one.
// This may change in the future.
@ -324,10 +401,12 @@ impl<'a> Iterator<Event> for WaitEventsIterator<'a> {
/// An iterator for the list of available monitors.
// Implementation note: we retreive the list once, then serve each element by one by one.
// This may change in the future.
#[cfg(feature = "window")]
pub struct AvailableMonitorsIter {
data: Vec<winimpl::MonitorID>,
}
#[cfg(feature = "window")]
impl Iterator<MonitorID> for AvailableMonitorsIter {
fn next(&mut self) -> Option<MonitorID> {
self.data.remove(0).map(|id| MonitorID(id))
@ -335,16 +414,19 @@ impl Iterator<MonitorID> for AvailableMonitorsIter {
}
/// Returns the list of all available monitors.
#[cfg(feature = "window")]
pub fn get_available_monitors() -> AvailableMonitorsIter {
let data = winimpl::get_available_monitors();
AvailableMonitorsIter{ data: data }
}
/// Returns the primary monitor of the system.
#[cfg(feature = "window")]
pub fn get_primary_monitor() -> MonitorID {
MonitorID(winimpl::get_primary_monitor())
}
#[cfg(feature = "window")]
impl MonitorID {
/// Returns a human-readable name of the monitor.
pub fn get_name(&self) -> Option<String> {

34
src/osx/mod.rs
View file

@ -1,4 +1,10 @@
use {Event, WindowBuilder};
use Event;
#[cfg(feature = "window")]
use WindowBuilder;
#[cfg(feature = "headless")]
use HeadlessRendererBuilder;
use cocoa::base::{id, NSUInteger, nil};
use cocoa::appkit::*;
@ -11,6 +17,14 @@ pub struct Window {
context: id,
}
pub struct HeadlessContext(Window);
impl Deref<Window> for HeadlessContext {
fn deref(&self) -> &Window {
&self.0
}
}
pub struct MonitorID;
pub fn get_available_monitors() -> Vec<MonitorID> {
@ -31,14 +45,28 @@ impl MonitorID {
}
}
#[cfg(feature = "window")]
impl Window {
pub fn new(_builder: WindowBuilder) -> Result<Window, String> {
pub fn new(builder: WindowBuilder) -> Result<Window, String> {
Window::new_impl(builder.dimensions, builder.title.as_slice(), true)
}
}
#[cfg(feature = "headless")]
impl HeadlessContext {
pub fn new(builder: HeadlessRendererBuilder) -> Result<HeadlessContext, String> {
Window::new_impl(Some(builder.dimensions), "", false)
.map(|w| HeadlessContext(w))
}
}
impl Window {
fn new_impl(dimensions: Option<(uint, uint)>, title: &str, visible: bool) -> Result<Window, String> {
let app = match Window::create_app() {
Some(app) => app,
None => { return Err(format!("Couldn't create NSApplication")); },
};
let window = match Window::create_window(_builder.dimensions.unwrap_or((800, 600)), _builder.title.as_slice()) {
let window = match Window::create_window(dimensions.unwrap_or((800, 600)), title) {
Some(window) => window,
None => { return Err(format!("Couldn't create NSWindow")); },
};

40
src/win32/init.rs
View file

@ -6,7 +6,7 @@ use std::sync::atomics::AtomicBool;
use std::ptr;
use super::{event, ffi};
use super::Window;
use {Event, WindowBuilder};
use Event;
/// Stores the current window and its events dispatcher.
///
@ -14,12 +14,16 @@ use {Event, WindowBuilder};
/// receive an event for another window.
local_data_key!(WINDOW: (ffi::HWND, Sender<Event>))
pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
pub fn new_window(builder_dimensions: Option<(uint, uint)>, builder_title: String,
builder_monitor: Option<super::MonitorID>,
builder_gl_version: Option<(uint, uint)>,
builder_headless: bool) -> Result<Window, String>
{
use std::mem;
use std::os;
// initializing variables to be sent to the task
let title = builder.title.as_slice().utf16_units()
let title = builder_title.as_slice().utf16_units()
.collect::<Vec<u16>>().append_one(0); // title to utf16
//let hints = hints.clone();
let (tx, rx) = channel();
@ -59,15 +63,15 @@ pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
// building a RECT object with coordinates
let mut rect = ffi::RECT {
left: 0, right: builder.dimensions.unwrap_or((1024, 768)).val0() as ffi::LONG,
top: 0, bottom: builder.dimensions.unwrap_or((1024, 768)).val1() as ffi::LONG,
left: 0, right: builder_dimensions.unwrap_or((1024, 768)).val0() as ffi::LONG,
top: 0, bottom: builder_dimensions.unwrap_or((1024, 768)).val1() as ffi::LONG,
};
// switching to fullscreen if necessary
// this means adjusting the window's position so that it overlaps the right monitor,
// and change the monitor's resolution if necessary
if builder.monitor.is_some() {
let monitor = builder.monitor.as_ref().unwrap();
if builder_monitor.is_some() {
let monitor = builder_monitor.as_ref().unwrap();
// adjusting the rect
{
@ -96,7 +100,7 @@ pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
}
// computing the style and extended style of the window
let (ex_style, style) = if builder.monitor.is_some() {
let (ex_style, style) = if builder_monitor.is_some() {
(ffi::WS_EX_APPWINDOW, ffi::WS_POPUP | ffi::WS_CLIPSIBLINGS | ffi::WS_CLIPCHILDREN)
} else {
(ffi::WS_EX_APPWINDOW | ffi::WS_EX_WINDOWEDGE,
@ -227,17 +231,23 @@ pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
// creating the real window this time
let real_window = unsafe {
let (width, height) = if builder.monitor.is_some() || builder.dimensions.is_some() {
let (width, height) = if builder_monitor.is_some() || builder_dimensions.is_some() {
(Some(rect.right - rect.left), Some(rect.bottom - rect.top))
} else {
(None, None)
};
let style = if builder_headless {
style
} else {
style | ffi::WS_VISIBLE
};
let handle = ffi::CreateWindowExW(ex_style, class_name.as_ptr(),
title.as_ptr() as ffi::LPCWSTR,
style | ffi::WS_VISIBLE | ffi::WS_CLIPSIBLINGS | ffi::WS_CLIPCHILDREN,
if builder.monitor.is_some() { 0 } else { ffi::CW_USEDEFAULT },
if builder.monitor.is_some() { 0 } else { ffi::CW_USEDEFAULT },
style | ffi::WS_CLIPSIBLINGS | ffi::WS_CLIPCHILDREN,
if builder_monitor.is_some() { 0 } else { ffi::CW_USEDEFAULT },
if builder_monitor.is_some() { 0 } else { ffi::CW_USEDEFAULT },
width.unwrap_or(ffi::CW_USEDEFAULT), height.unwrap_or(ffi::CW_USEDEFAULT),
ptr::null(), ptr::null(), ffi::GetModuleHandleW(ptr::null()),
ptr::null_mut());
@ -280,8 +290,8 @@ pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
let mut attributes = Vec::new();
if builder.gl_version.is_some() {
let version = builder.gl_version.as_ref().unwrap();
if builder_gl_version.is_some() {
let version = builder_gl_version.as_ref().unwrap();
attributes.push(ffi::wgl_extra::CONTEXT_MAJOR_VERSION_ARB as libc::c_int);
attributes.push(version.val0() as libc::c_int);
attributes.push(ffi::wgl_extra::CONTEXT_MINOR_VERSION_ARB as libc::c_int);
@ -310,7 +320,7 @@ pub fn new_window(builder: WindowBuilder) -> Result<Window, String> {
};
// calling SetForegroundWindow if fullscreen
if builder.monitor.is_some() {
if builder_monitor.is_some() {
unsafe { ffi::SetForegroundWindow(real_window) };
}

39
src/win32/mod.rs
View file

@ -1,6 +1,12 @@
use std::sync::atomics::AtomicBool;
use std::ptr;
use {Event, WindowBuilder};
use Event;
#[cfg(feature = "window")]
use WindowBuilder;
#[cfg(feature = "headless")]
use HeadlessRendererBuilder;
pub use self::monitor::{MonitorID, get_available_monitors, get_primary_monitor};
@ -9,6 +15,30 @@ mod ffi;
mod init;
mod monitor;
///
#[cfg(feature = "headless")]
pub struct HeadlessContext(Window);
#[cfg(feature = "headless")]
impl HeadlessContext {
/// See the docs in the crate root file.
pub fn new(builder: HeadlessRendererBuilder) -> Result<HeadlessContext, String> {
let HeadlessRendererBuilder { dimensions, gl_version } = builder;
init::new_window(Some(dimensions), "".to_string(), None, gl_version, true)
.map(|w| HeadlessContext(w))
}
/// See the docs in the crate root file.
pub unsafe fn make_current(&self) {
self.0.make_current()
}
/// See the docs in the crate root file.
pub fn get_proc_address(&self, addr: &str) -> *const () {
self.0.get_proc_address(addr)
}
}
/// The Win32 implementation of the main `Window` object.
pub struct Window {
/// Main handle for the window.
@ -33,12 +63,16 @@ pub struct Window {
is_closed: AtomicBool,
}
#[cfg(feature = "window")]
impl Window {
/// See the docs in the crate root file.
pub fn new(builder: WindowBuilder) -> Result<Window, String> {
init::new_window(builder)
let WindowBuilder { dimensions, title, monitor, gl_version } = builder;
init::new_window(dimensions, title, monitor, gl_version, false)
}
}
impl Window {
/// See the docs in the crate root file.
pub fn is_closed(&self) -> bool {
use std::sync::atomics::Relaxed;
@ -200,6 +234,7 @@ impl Window {
}
}
#[cfg(feature = "window")]
#[unsafe_destructor]
impl Drop for Window {
fn drop(&mut self) {

24
src/x11/ffi.rs
View file

@ -20,6 +20,7 @@ pub type GLXPixmap = XID;
pub type GLXWindow = XID;
pub type KeyCode = libc::c_ulong;
pub type KeySym = XID;
pub type OSMesaContext = *const ();
pub type Pixmap = XID;
pub type Status = libc::c_int; // TODO: not sure
pub type Time = libc::c_ulong;
@ -1356,6 +1357,29 @@ pub struct XF86VidModeModeInfo {
private: libc::c_long,
}
#[cfg(feature = "headless")]
#[link(name = "OSMesa")]
extern "C" {
pub fn OSMesaCreateContext(format: libc::c_uint, sharelist: OSMesaContext) -> OSMesaContext;
pub fn OSMesaCreateContextExt(format: libc::c_uint, depthBits: libc::c_int,
stencilBits: libc::c_int, accumBits: libc::c_int, sharelist: OSMesaContext)
-> OSMesaContext;
pub fn OSMesaDestroyContext(ctx: OSMesaContext);
pub fn OSMesaMakeCurrent(ctx: OSMesaContext, buffer: *mut libc::c_void, type_: libc::c_uint,
width: libc::c_int, height: libc::c_int) -> libc::c_uchar;
pub fn OSMesaGetCurrentContext() -> OSMesaContext;
pub fn OSMesaPixelStore(pname: libc::c_int, value: libc::c_int);
pub fn OSMesaGetIntegerv(pname: libc::c_int, value: *mut libc::c_int);
pub fn OSMesaGetDepthBuffer(c: OSMesaContext, width: *mut libc::c_int,
height: *mut libc::c_int, bytesPerValue: *mut libc::c_int,
buffer: *mut *mut libc::c_void);
pub fn OSMesaGetColorBuffer(c: OSMesaContext, width: *mut libc::c_int,
height: *mut libc::c_int, format: *mut libc::c_int, buffer: *mut *mut libc::c_void);
pub fn OSMesaGetProcAddress(funcName: *const libc::c_char) -> *const libc::c_void;
pub fn OSMesaColorClamp(enable: libc::c_uchar);
}
#[cfg(feature = "window")]
#[link(name = "GL")]
#[link(name = "X11")]
#[link(name = "Xxf86vm")]

47
src/x11/headless.rs Normal file
View file

@ -0,0 +1,47 @@
use HeadlessRendererBuilder;
use libc;
use std::{mem, ptr};
use super::ffi;
pub struct HeadlessContext {
context: ffi::OSMesaContext,
buffer: Vec<u32>,
width: uint,
height: uint,
}
impl HeadlessContext {
pub fn new(builder: HeadlessRendererBuilder) -> Result<HeadlessContext, String> {
Ok(HeadlessContext {
width: builder.dimensions.0,
height: builder.dimensions.1,
buffer: Vec::from_elem(builder.dimensions.0 * builder.dimensions.1, unsafe { mem::uninitialized() }),
context: unsafe {
// TODO: check errors
ffi::OSMesaCreateContext(0x1908, ptr::null())
}
})
}
pub unsafe fn make_current(&self) {
ffi::OSMesaMakeCurrent(self.context,
self.buffer.as_ptr() as *mut libc::c_void,
0x1401, self.width as libc::c_int, self.height as libc::c_int);
}
pub fn get_proc_address(&self, addr: &str) -> *const () {
use std::c_str::ToCStr;
unsafe {
addr.with_c_str(|s| {
ffi::OSMesaGetProcAddress(mem::transmute(s)) as *const ()
})
}
}
}
impl Drop for HeadlessContext {
fn drop(&mut self) {
unsafe { ffi::OSMesaDestroyContext(self.context) }
}
}

502
src/x11/mod.rs
View file

@ -1,499 +1,13 @@
use {Event, WindowBuilder};
use libc;
use std::{mem, ptr};
use std::sync::atomics::AtomicBool;
#[cfg(feature = "headless")]
pub use self::headless::HeadlessContext;
pub use self::monitor::{MonitorID, get_available_monitors, get_primary_monitor};
#[cfg(feature = "window")]
pub use self::window::{Window, MonitorID, get_available_monitors, get_primary_monitor};
mod events;
mod ffi;
mod monitor;
pub struct Window {
display: *mut ffi::Display,
window: ffi::Window,
im: ffi::XIM,
ic: ffi::XIC,
context: ffi::GLXContext,
is_closed: AtomicBool,
wm_delete_window: ffi::Atom,
xf86_desk_mode: *mut ffi::XF86VidModeModeInfo,
screen_id: libc::c_int,
is_fullscreen: bool,
}
#[cfg(feature = "headless")]
mod headless;
impl Window {
pub fn new(builder: WindowBuilder) -> Result<Window, String> {
let dimensions = builder.dimensions.unwrap_or((800, 600));
// calling XOpenDisplay
let display = unsafe {
let display = ffi::XOpenDisplay(ptr::null());
if display.is_null() {
return Err(format!("XOpenDisplay failed"));
}
display
};
let screen_id = match builder.monitor {
Some(MonitorID(monitor)) => monitor as i32,
None => unsafe { ffi::XDefaultScreen(display) },
};
// getting the FBConfig
let fb_config = unsafe {
static VISUAL_ATTRIBUTES: [libc::c_int, ..23] = [
ffi::GLX_X_RENDERABLE, 1,
ffi::GLX_DRAWABLE_TYPE, ffi::GLX_WINDOW_BIT,
ffi::GLX_RENDER_TYPE, ffi::GLX_RGBA_BIT,
ffi::GLX_X_VISUAL_TYPE, ffi::GLX_TRUE_COLOR,
ffi::GLX_RED_SIZE, 8,
ffi::GLX_GREEN_SIZE, 8,
ffi::GLX_BLUE_SIZE, 8,
ffi::GLX_ALPHA_SIZE, 8,
ffi::GLX_DEPTH_SIZE, 24,
ffi::GLX_STENCIL_SIZE, 8,
ffi::GLX_DOUBLEBUFFER, 1,
0
];
let mut num_fb: libc::c_int = mem::uninitialized();
let fb = ffi::glXChooseFBConfig(display, ffi::XDefaultScreen(display),
VISUAL_ATTRIBUTES.as_ptr(), &mut num_fb);
if fb.is_null() {
return Err(format!("glXChooseFBConfig failed"));
}
let preferred_fb = *fb; // TODO: choose more wisely
ffi::XFree(fb as *const libc::c_void);
preferred_fb
};
let mut best_mode = -1;
let modes = unsafe {
let mut mode_num: libc::c_int = mem::uninitialized();
let mut modes: *mut *mut ffi::XF86VidModeModeInfo = mem::uninitialized();
if ffi::XF86VidModeGetAllModeLines(display, screen_id, &mut mode_num, &mut modes) == 0 {
return Err(format!("Could not query the video modes"));
}
for i in range(0, mode_num) {
let mode: ffi::XF86VidModeModeInfo = **modes.offset(i as int);
if mode.hdisplay == dimensions.val0() as u16 && mode.vdisplay == dimensions.val1() as u16 {
best_mode = i;
}
};
if best_mode == -1 {
return Err(format!("Could not find a suitable graphics mode"));
}
modes
};
let xf86_desk_mode = unsafe {
*modes.offset(0)
};
// getting the visual infos
let visual_infos = unsafe {
let vi = ffi::glXGetVisualFromFBConfig(display, fb_config);
if vi.is_null() {
return Err(format!("glXChooseVisual failed"));
}
let vi_copy = *vi;
ffi::XFree(vi as *const libc::c_void);
vi_copy
};
// getting the root window
let root = unsafe { ffi::XDefaultRootWindow(display) };
// creating the color map
let cmap = unsafe {
let cmap = ffi::XCreateColormap(display, root,
visual_infos.visual, ffi::AllocNone);
// TODO: error checking?
cmap
};
// creating
let mut set_win_attr = {
let mut swa: ffi::XSetWindowAttributes = unsafe { mem::zeroed() };
swa.colormap = cmap;
swa.event_mask = ffi::ExposureMask | ffi::ResizeRedirectMask |
ffi::VisibilityChangeMask | ffi::KeyPressMask | ffi::PointerMotionMask |
ffi::KeyReleaseMask | ffi::ButtonPressMask |
ffi::ButtonReleaseMask | ffi::KeymapStateMask;
swa.border_pixel = 0;
swa.override_redirect = 0;
swa
};
let mut window_attributes = ffi::CWBorderPixel | ffi::CWColormap | ffi:: CWEventMask;
if builder.monitor.is_some() {
window_attributes |= ffi::CWOverrideRedirect;
unsafe {
ffi::XF86VidModeSwitchToMode(display, screen_id, *modes.offset(best_mode as int));
ffi::XF86VidModeSetViewPort(display, screen_id, 0, 0);
set_win_attr.override_redirect = 1;
}
}
// finally creating the window
let window = unsafe {
let win = ffi::XCreateWindow(display, root, 0, 0, dimensions.val0() as libc::c_uint,
dimensions.val1() as libc::c_uint, 0, visual_infos.depth, ffi::InputOutput,
visual_infos.visual, window_attributes,
&mut set_win_attr);
win
};
// creating window, step 2
let wm_delete_window = unsafe {
use std::c_str::ToCStr;
ffi::XMapWindow(display, window);
let mut wm_delete_window = ffi::XInternAtom(display,
"WM_DELETE_WINDOW".to_c_str().as_ptr() as *const libc::c_char, 0);
ffi::XSetWMProtocols(display, window, &mut wm_delete_window, 1);
ffi::XStoreName(display, window, mem::transmute(builder.title.as_slice().as_ptr()));
ffi::XFlush(display);
wm_delete_window
};
// getting the pointer to glXCreateContextAttribs
let create_context_attribs = unsafe {
let mut addr = ffi::glXGetProcAddress(b"glXCreateContextAttribs".as_ptr()
as *const u8) as *const ();
if addr.is_null() {
addr = ffi::glXGetProcAddress(b"glXCreateContextAttribsARB".as_ptr()
as *const u8) as *const ();
}
addr.as_ref().map(|addr| {
let addr: extern "system" fn(*mut ffi::Display, ffi::GLXFBConfig, ffi::GLXContext,
ffi::Bool, *const libc::c_int) -> ffi::GLXContext = mem::transmute(addr);
addr
})
};
// creating IM
let im = unsafe {
let im = ffi::XOpenIM(display, ptr::null(), ptr::null_mut(), ptr::null_mut());
if im.is_null() {
return Err(format!("XOpenIM failed"));
}
im
};
// creating input context
let ic = unsafe {
use std::c_str::ToCStr;
let ic = ffi::XCreateIC(im, "inputStyle".to_c_str().as_ptr(),
ffi::XIMPreeditNothing | ffi::XIMStatusNothing, "clientWindow".to_c_str().as_ptr(),
window, ptr::null());
if ic.is_null() {
return Err(format!("XCreateIC failed"));
}
ffi::XSetICFocus(ic);
ic
};
// Attempt to make keyboard input repeat detectable
unsafe {
let mut supported_ptr = false;
ffi::XkbSetDetectableAutoRepeat(display, true, &mut supported_ptr);
if !supported_ptr {
return Err(format!("XkbSetDetectableAutoRepeat failed"));
}
}
// creating GL context
let context = unsafe {
let mut attributes = Vec::new();
if builder.gl_version.is_some() {
let version = builder.gl_version.as_ref().unwrap();
attributes.push(ffi::GLX_CONTEXT_MAJOR_VERSION);
attributes.push(version.val0() as libc::c_int);
attributes.push(ffi::GLX_CONTEXT_MINOR_VERSION);
attributes.push(version.val1() as libc::c_int);
}
attributes.push(0);
let context = if create_context_attribs.is_some() {
let create_context_attribs = create_context_attribs.unwrap();
create_context_attribs(display, fb_config, ptr::null(), 1,
attributes.as_ptr())
} else {
ffi::glXCreateContext(display, &visual_infos, ptr::null(), 1)
};
if context.is_null() {
return Err(format!("GL context creation failed"));
}
context
};
// creating the window object
let window = Window {
display: display,
window: window,
im: im,
ic: ic,
context: context,
is_closed: AtomicBool::new(false),
wm_delete_window: wm_delete_window,
xf86_desk_mode: xf86_desk_mode,
screen_id: screen_id,
is_fullscreen: builder.monitor.is_some(),
};
// calling glViewport
unsafe {
let ptr = window.get_proc_address("glViewport");
assert!(!ptr.is_null());
let ptr: extern "system" fn(libc::c_int, libc::c_int, libc::c_int, libc::c_int) =
mem::transmute(ptr);
let dimensions = window.get_inner_size().unwrap();
ptr(0, 0, dimensions.val0() as libc::c_int, dimensions.val1() as libc::c_int);
}
// returning
Ok(window)
}
pub fn is_closed(&self) -> bool {
use std::sync::atomics::Relaxed;
self.is_closed.load(Relaxed)
}
pub fn set_title(&self, title: &str) {
unsafe {
ffi::XStoreName(self.display, self.window,
mem::transmute(title.as_slice().as_ptr()));
}
}
fn get_geometry(&self) -> Option<(int, int, uint, uint)> {
unsafe {
use std::mem;
let mut root: ffi::Window = mem::uninitialized();
let mut x: libc::c_int = mem::uninitialized();
let mut y: libc::c_int = mem::uninitialized();
let mut width: libc::c_uint = mem::uninitialized();
let mut height: libc::c_uint = mem::uninitialized();
let mut border: libc::c_uint = mem::uninitialized();
let mut depth: libc::c_uint = mem::uninitialized();
if ffi::XGetGeometry(self.display, self.window,
&mut root, &mut x, &mut y, &mut width, &mut height,
&mut border, &mut depth) == 0
{
return None;
}
Some((x as int, y as int, width as uint, height as uint))
}
}
pub fn get_position(&self) -> Option<(int, int)> {
self.get_geometry().map(|(x, y, _, _)| (x, y))
}
pub fn set_position(&self, x: int, y: int) {
unsafe { ffi::XMoveWindow(self.display, self.window, x as libc::c_int, y as libc::c_int) }
}
pub fn get_inner_size(&self) -> Option<(uint, uint)> {
self.get_geometry().map(|(_, _, w, h)| (w, h))
}
pub fn get_outer_size(&self) -> Option<(uint, uint)> {
unimplemented!()
}
pub fn set_inner_size(&self, _x: uint, _y: uint) {
unimplemented!()
}
pub fn poll_events(&self) -> Vec<Event> {
use std::mem;
let mut events = Vec::new();
loop {
use std::num::Bounded;
let mut xev = unsafe { mem::uninitialized() };
let res = unsafe { ffi::XCheckMaskEvent(self.display, Bounded::max_value(), &mut xev) };
if res == 0 {
let res = unsafe { ffi::XCheckTypedEvent(self.display, ffi::ClientMessage, &mut xev) };
if res == 0 {
break
}
}
match xev.type_ {
ffi::KeymapNotify => {
unsafe { ffi::XRefreshKeyboardMapping(&xev) }
},
ffi::ClientMessage => {
use Closed;
use std::sync::atomics::Relaxed;
let client_msg: &ffi::XClientMessageEvent = unsafe { mem::transmute(&xev) };
if client_msg.l[0] == self.wm_delete_window as libc::c_long {
self.is_closed.store(true, Relaxed);
events.push(Closed);
}
},
ffi::ResizeRequest => {
use Resized;
let rs_event: &ffi::XResizeRequestEvent = unsafe { mem::transmute(&xev) };
events.push(Resized(rs_event.width as uint, rs_event.height as uint));
},
ffi::MotionNotify => {
use MouseMoved;
let event: &ffi::XMotionEvent = unsafe { mem::transmute(&xev) };
events.push(MouseMoved((event.x as int, event.y as int)));
},
ffi::KeyPress | ffi::KeyRelease => {
use {KeyboardInput, Pressed, Released, ReceivedCharacter, KeyModifiers};
let event: &mut ffi::XKeyEvent = unsafe { mem::transmute(&xev) };
if event.type_ == ffi::KeyPress {
let raw_ev: *mut ffi::XKeyEvent = event;
unsafe { ffi::XFilterEvent(mem::transmute(raw_ev), self.window) };
}
let state = if xev.type_ == ffi::KeyPress { Pressed } else { Released };
let written = unsafe {
use std::str;
let mut buffer: [u8, ..16] = [mem::uninitialized(), ..16];
let raw_ev: *mut ffi::XKeyEvent = event;
let count = ffi::Xutf8LookupString(self.ic, mem::transmute(raw_ev),
mem::transmute(buffer.as_mut_ptr()),
buffer.len() as libc::c_int, ptr::null_mut(), ptr::null_mut());
str::from_utf8(buffer.as_slice().slice_to(count as uint))
.unwrap_or("").to_string()
};
for chr in written.as_slice().chars() {
events.push(ReceivedCharacter(chr));
}
let keysym = unsafe {
ffi::XKeycodeToKeysym(self.display, event.keycode as ffi::KeyCode, 0)
};
let vkey = events::keycode_to_element(keysym as libc::c_uint);
events.push(KeyboardInput(state, event.keycode as u8,
vkey, KeyModifiers::empty()));
//
},
ffi::ButtonPress | ffi::ButtonRelease => {
use {MouseInput, Pressed, Released};
use {LeftMouseButton, RightMouseButton, MiddleMouseButton, OtherMouseButton};
let event: &ffi::XButtonEvent = unsafe { mem::transmute(&xev) };
let state = if xev.type_ == ffi::ButtonPress { Pressed } else { Released };
let button = match event.button {
ffi::Button1 => Some(LeftMouseButton),
ffi::Button2 => Some(MiddleMouseButton),
ffi::Button3 => Some(RightMouseButton),
ffi::Button4 => Some(OtherMouseButton(4)),
ffi::Button5 => Some(OtherMouseButton(5)),
_ => None
};
match button {
Some(button) =>
events.push(MouseInput(state, button)),
None => ()
};
},
_ => ()
}
}
events
}
pub fn wait_events(&self) -> Vec<Event> {
use std::mem;
loop {
// this will block until an event arrives, but doesn't remove
// it from the queue
let mut xev = unsafe { mem::uninitialized() };
unsafe { ffi::XPeekEvent(self.display, &mut xev) };
// calling poll_events()
let ev = self.poll_events();
if ev.len() >= 1 {
return ev;
}
}
}
pub unsafe fn make_current(&self) {
let res = ffi::glXMakeCurrent(self.display, self.window, self.context);
if res == 0 {
fail!("glXMakeCurrent failed");
}
}
pub fn get_proc_address(&self, addr: &str) -> *const () {
use std::c_str::ToCStr;
use std::mem;
unsafe {
addr.with_c_str(|s| {
ffi::glXGetProcAddress(mem::transmute(s)) as *const ()
})
}
}
pub fn swap_buffers(&self) {
unsafe { ffi::glXSwapBuffers(self.display, self.window) }
}
}
impl Drop for Window {
fn drop(&mut self) {
unsafe { ffi::glXMakeCurrent(self.display, 0, ptr::null()); }
unsafe { ffi::glXDestroyContext(self.display, self.context); }
if self.is_fullscreen {
unsafe { ffi::XF86VidModeSwitchToMode(self.display, self.screen_id, self.xf86_desk_mode); }
unsafe { ffi::XF86VidModeSetViewPort(self.display, self.screen_id, 0, 0); }
}
unsafe { ffi::XDestroyIC(self.ic); }
unsafe { ffi::XCloseIM(self.im); }
unsafe { ffi::XDestroyWindow(self.display, self.window); }
unsafe { ffi::XCloseDisplay(self.display); }
}
}
#[cfg(feature = "window")]
mod window;

2
src/x11/events.rs → src/x11/window/events.rs
View file

@ -1,5 +1,5 @@
use {events, libc};
use super::ffi;
use super::super::ffi;
use VirtualKeyCode;
pub fn keycode_to_element(scancode: libc::c_uint) -> Option<VirtualKeyCode> {

499
src/x11/window/mod.rs Normal file
View file

@ -0,0 +1,499 @@
use {Event, WindowBuilder};
use libc;
use std::{mem, ptr};
use std::sync::atomics::AtomicBool;
use super::ffi;
pub use self::monitor::{MonitorID, get_available_monitors, get_primary_monitor};
mod events;
mod monitor;
pub struct Window {
display: *mut ffi::Display,
window: ffi::Window,
im: ffi::XIM,
ic: ffi::XIC,
context: ffi::GLXContext,
is_closed: AtomicBool,
wm_delete_window: ffi::Atom,
xf86_desk_mode: *mut ffi::XF86VidModeModeInfo,
screen_id: libc::c_int,
is_fullscreen: bool,
}
impl Window {
pub fn new(builder: WindowBuilder) -> Result<Window, String> {
let dimensions = builder.dimensions.unwrap_or((800, 600));
// calling XOpenDisplay
let display = unsafe {
let display = ffi::XOpenDisplay(ptr::null());
if display.is_null() {
return Err(format!("XOpenDisplay failed"));
}
display
};
let screen_id = match builder.monitor {
Some(MonitorID(monitor)) => monitor as i32,
None => unsafe { ffi::XDefaultScreen(display) },
};
// getting the FBConfig
let fb_config = unsafe {
static VISUAL_ATTRIBUTES: [libc::c_int, ..23] = [
ffi::GLX_X_RENDERABLE, 1,
ffi::GLX_DRAWABLE_TYPE, ffi::GLX_WINDOW_BIT,
ffi::GLX_RENDER_TYPE, ffi::GLX_RGBA_BIT,
ffi::GLX_X_VISUAL_TYPE, ffi::GLX_TRUE_COLOR,
ffi::GLX_RED_SIZE, 8,
ffi::GLX_GREEN_SIZE, 8,
ffi::GLX_BLUE_SIZE, 8,
ffi::GLX_ALPHA_SIZE, 8,
ffi::GLX_DEPTH_SIZE, 24,
ffi::GLX_STENCIL_SIZE, 8,
ffi::GLX_DOUBLEBUFFER, 1,
0
];
let mut num_fb: libc::c_int = mem::uninitialized();
let fb = ffi::glXChooseFBConfig(display, ffi::XDefaultScreen(display),
VISUAL_ATTRIBUTES.as_ptr(), &mut num_fb);
if fb.is_null() {
return Err(format!("glXChooseFBConfig failed"));
}
let preferred_fb = *fb; // TODO: choose more wisely
ffi::XFree(fb as *const libc::c_void);
preferred_fb
};
let mut best_mode = -1;
let modes = unsafe {
let mut mode_num: libc::c_int = mem::uninitialized();
let mut modes: *mut *mut ffi::XF86VidModeModeInfo = mem::uninitialized();
if ffi::XF86VidModeGetAllModeLines(display, screen_id, &mut mode_num, &mut modes) == 0 {
return Err(format!("Could not query the video modes"));
}
for i in range(0, mode_num) {
let mode: ffi::XF86VidModeModeInfo = **modes.offset(i as int);
if mode.hdisplay == dimensions.val0() as u16 && mode.vdisplay == dimensions.val1() as u16 {
best_mode = i;
}
};
if best_mode == -1 {
return Err(format!("Could not find a suitable graphics mode"));
}
modes
};
let xf86_desk_mode = unsafe {
*modes.offset(0)
};
// getting the visual infos
let visual_infos = unsafe {
let vi = ffi::glXGetVisualFromFBConfig(display, fb_config);
if vi.is_null() {
return Err(format!("glXChooseVisual failed"));
}
let vi_copy = *vi;
ffi::XFree(vi as *const libc::c_void);
vi_copy
};
// getting the root window
let root = unsafe { ffi::XDefaultRootWindow(display) };
// creating the color map
let cmap = unsafe {
let cmap = ffi::XCreateColormap(display, root,
visual_infos.visual, ffi::AllocNone);
// TODO: error checking?
cmap
};
// creating
let mut set_win_attr = {
let mut swa: ffi::XSetWindowAttributes = unsafe { mem::zeroed() };
swa.colormap = cmap;
swa.event_mask = ffi::ExposureMask | ffi::ResizeRedirectMask |
ffi::VisibilityChangeMask | ffi::KeyPressMask | ffi::PointerMotionMask |
ffi::KeyReleaseMask | ffi::ButtonPressMask |
ffi::ButtonReleaseMask | ffi::KeymapStateMask;
swa.border_pixel = 0;
swa.override_redirect = 0;
swa
};
let mut window_attributes = ffi::CWBorderPixel | ffi::CWColormap | ffi:: CWEventMask;
if builder.monitor.is_some() {
window_attributes |= ffi::CWOverrideRedirect;
unsafe {
ffi::XF86VidModeSwitchToMode(display, screen_id, *modes.offset(best_mode as int));
ffi::XF86VidModeSetViewPort(display, screen_id, 0, 0);
set_win_attr.override_redirect = 1;
}
}
// finally creating the window
let window = unsafe {
let win = ffi::XCreateWindow(display, root, 0, 0, dimensions.val0() as libc::c_uint,
dimensions.val1() as libc::c_uint, 0, visual_infos.depth, ffi::InputOutput,
visual_infos.visual, window_attributes,
&mut set_win_attr);
win
};
// creating window, step 2
let wm_delete_window = unsafe {
use std::c_str::ToCStr;
ffi::XMapWindow(display, window);
let mut wm_delete_window = ffi::XInternAtom(display,
"WM_DELETE_WINDOW".to_c_str().as_ptr() as *const libc::c_char, 0);
ffi::XSetWMProtocols(display, window, &mut wm_delete_window, 1);
ffi::XStoreName(display, window, mem::transmute(builder.title.as_slice().as_ptr()));
ffi::XFlush(display);
wm_delete_window
};
// getting the pointer to glXCreateContextAttribs
let create_context_attribs = unsafe {
let mut addr = ffi::glXGetProcAddress(b"glXCreateContextAttribs".as_ptr()
as *const u8) as *const ();
if addr.is_null() {
addr = ffi::glXGetProcAddress(b"glXCreateContextAttribsARB".as_ptr()
as *const u8) as *const ();
}
addr.as_ref().map(|addr| {
let addr: extern "system" fn(*mut ffi::Display, ffi::GLXFBConfig, ffi::GLXContext,
ffi::Bool, *const libc::c_int) -> ffi::GLXContext = mem::transmute(addr);
addr
})
};
// creating IM
let im = unsafe {
let im = ffi::XOpenIM(display, ptr::null(), ptr::null_mut(), ptr::null_mut());
if im.is_null() {
return Err(format!("XOpenIM failed"));
}
im
};
// creating input context
let ic = unsafe {
use std::c_str::ToCStr;
let ic = ffi::XCreateIC(im, "inputStyle".to_c_str().as_ptr(),
ffi::XIMPreeditNothing | ffi::XIMStatusNothing, "clientWindow".to_c_str().as_ptr(),
window, ptr::null());
if ic.is_null() {
return Err(format!("XCreateIC failed"));
}
ffi::XSetICFocus(ic);
ic
};
// Attempt to make keyboard input repeat detectable
unsafe {
let mut supported_ptr = false;
ffi::XkbSetDetectableAutoRepeat(display, true, &mut supported_ptr);
if !supported_ptr {
return Err(format!("XkbSetDetectableAutoRepeat failed"));
}
}
// creating GL context
let context = unsafe {
let mut attributes = Vec::new();
if builder.gl_version.is_some() {
let version = builder.gl_version.as_ref().unwrap();
attributes.push(ffi::GLX_CONTEXT_MAJOR_VERSION);
attributes.push(version.val0() as libc::c_int);
attributes.push(ffi::GLX_CONTEXT_MINOR_VERSION);
attributes.push(version.val1() as libc::c_int);
}
attributes.push(0);
let context = if create_context_attribs.is_some() {
let create_context_attribs = create_context_attribs.unwrap();
create_context_attribs(display, fb_config, ptr::null(), 1,
attributes.as_ptr())
} else {
ffi::glXCreateContext(display, &visual_infos, ptr::null(), 1)
};
if context.is_null() {
return Err(format!("GL context creation failed"));
}
context
};
// creating the window object
let window = Window {
display: display,
window: window,
im: im,
ic: ic,
context: context,
is_closed: AtomicBool::new(false),
wm_delete_window: wm_delete_window,
xf86_desk_mode: xf86_desk_mode,
screen_id: screen_id,
is_fullscreen: builder.monitor.is_some(),
};
// calling glViewport
unsafe {
let ptr = window.get_proc_address("glViewport");
assert!(!ptr.is_null());
let ptr: extern "system" fn(libc::c_int, libc::c_int, libc::c_int, libc::c_int) =
mem::transmute(ptr);
let dimensions = window.get_inner_size().unwrap();
ptr(0, 0, dimensions.val0() as libc::c_int, dimensions.val1() as libc::c_int);
}
// returning
Ok(window)
}
pub fn is_closed(&self) -> bool {
use std::sync::atomics::Relaxed;
self.is_closed.load(Relaxed)
}
pub fn set_title(&self, title: &str) {
unsafe {
ffi::XStoreName(self.display, self.window,
mem::transmute(title.as_slice().as_ptr()));
}
}
fn get_geometry(&self) -> Option<(int, int, uint, uint)> {
unsafe {
use std::mem;
let mut root: ffi::Window = mem::uninitialized();
let mut x: libc::c_int = mem::uninitialized();
let mut y: libc::c_int = mem::uninitialized();
let mut width: libc::c_uint = mem::uninitialized();
let mut height: libc::c_uint = mem::uninitialized();
let mut border: libc::c_uint = mem::uninitialized();
let mut depth: libc::c_uint = mem::uninitialized();
if ffi::XGetGeometry(self.display, self.window,
&mut root, &mut x, &mut y, &mut width, &mut height,
&mut border, &mut depth) == 0
{
return None;
}
Some((x as int, y as int, width as uint, height as uint))
}
}
pub fn get_position(&self) -> Option<(int, int)> {
self.get_geometry().map(|(x, y, _, _)| (x, y))
}
pub fn set_position(&self, x: int, y: int) {
unsafe { ffi::XMoveWindow(self.display, self.window, x as libc::c_int, y as libc::c_int) }
}
pub fn get_inner_size(&self) -> Option<(uint, uint)> {
self.get_geometry().map(|(_, _, w, h)| (w, h))
}
pub fn get_outer_size(&self) -> Option<(uint, uint)> {
unimplemented!()
}
pub fn set_inner_size(&self, _x: uint, _y: uint) {
unimplemented!()
}
pub fn poll_events(&self) -> Vec<Event> {
use std::mem;
let mut events = Vec::new();
loop {
use std::num::Bounded;
let mut xev = unsafe { mem::uninitialized() };
let res = unsafe { ffi::XCheckMaskEvent(self.display, Bounded::max_value(), &mut xev) };
if res == 0 {
let res = unsafe { ffi::XCheckTypedEvent(self.display, ffi::ClientMessage, &mut xev) };
if res == 0 {
break
}
}
match xev.type_ {
ffi::KeymapNotify => {
unsafe { ffi::XRefreshKeyboardMapping(&xev) }
},
ffi::ClientMessage => {
use Closed;
use std::sync::atomics::Relaxed;
let client_msg: &ffi::XClientMessageEvent = unsafe { mem::transmute(&xev) };
if client_msg.l[0] == self.wm_delete_window as libc::c_long {
self.is_closed.store(true, Relaxed);
events.push(Closed);
}
},
ffi::ResizeRequest => {
use Resized;
let rs_event: &ffi::XResizeRequestEvent = unsafe { mem::transmute(&xev) };
events.push(Resized(rs_event.width as uint, rs_event.height as uint));
},
ffi::MotionNotify => {
use MouseMoved;
let event: &ffi::XMotionEvent = unsafe { mem::transmute(&xev) };
events.push(MouseMoved((event.x as int, event.y as int)));
},
ffi::KeyPress | ffi::KeyRelease => {
use {KeyboardInput, Pressed, Released, ReceivedCharacter, KeyModifiers};
let event: &mut ffi::XKeyEvent = unsafe { mem::transmute(&xev) };
if event.type_ == ffi::KeyPress {
let raw_ev: *mut ffi::XKeyEvent = event;
unsafe { ffi::XFilterEvent(mem::transmute(raw_ev), self.window) };
}
let state = if xev.type_ == ffi::KeyPress { Pressed } else { Released };
let written = unsafe {
use std::str;
let mut buffer: [u8, ..16] = [mem::uninitialized(), ..16];
let raw_ev: *mut ffi::XKeyEvent = event;
let count = ffi::Xutf8LookupString(self.ic, mem::transmute(raw_ev),
mem::transmute(buffer.as_mut_ptr()),
buffer.len() as libc::c_int, ptr::null_mut(), ptr::null_mut());
str::from_utf8(buffer.as_slice().slice_to(count as uint))
.unwrap_or("").to_string()
};
for chr in written.as_slice().chars() {
events.push(ReceivedCharacter(chr));
}
let keysym = unsafe {
ffi::XKeycodeToKeysym(self.display, event.keycode as ffi::KeyCode, 0)
};
let vkey = events::keycode_to_element(keysym as libc::c_uint);
events.push(KeyboardInput(state, event.keycode as u8,
vkey, KeyModifiers::empty()));
//
},
ffi::ButtonPress | ffi::ButtonRelease => {
use {MouseInput, Pressed, Released};
use {LeftMouseButton, RightMouseButton, MiddleMouseButton, OtherMouseButton};
let event: &ffi::XButtonEvent = unsafe { mem::transmute(&xev) };
let state = if xev.type_ == ffi::ButtonPress { Pressed } else { Released };
let button = match event.button {
ffi::Button1 => Some(LeftMouseButton),
ffi::Button2 => Some(MiddleMouseButton),
ffi::Button3 => Some(RightMouseButton),
ffi::Button4 => Some(OtherMouseButton(4)),
ffi::Button5 => Some(OtherMouseButton(5)),
_ => None
};
match button {
Some(button) =>
events.push(MouseInput(state, button)),
None => ()
};
},
_ => ()
}
}
events
}
pub fn wait_events(&self) -> Vec<Event> {
use std::mem;
loop {
// this will block until an event arrives, but doesn't remove
// it from the queue
let mut xev = unsafe { mem::uninitialized() };
unsafe { ffi::XPeekEvent(self.display, &mut xev) };
// calling poll_events()
let ev = self.poll_events();
if ev.len() >= 1 {
return ev;
}
}
}
pub unsafe fn make_current(&self) {
let res = ffi::glXMakeCurrent(self.display, self.window, self.context);
if res == 0 {
fail!("glXMakeCurrent failed");
}
}
pub fn get_proc_address(&self, addr: &str) -> *const () {
use std::c_str::ToCStr;
use std::mem;
unsafe {
addr.with_c_str(|s| {
ffi::glXGetProcAddress(mem::transmute(s)) as *const ()
})
}
}
pub fn swap_buffers(&self) {
unsafe { ffi::glXSwapBuffers(self.display, self.window) }
}
}
impl Drop for Window {
fn drop(&mut self) {
unsafe { ffi::glXMakeCurrent(self.display, 0, ptr::null()); }
unsafe { ffi::glXDestroyContext(self.display, self.context); }
if self.is_fullscreen {
unsafe { ffi::XF86VidModeSwitchToMode(self.display, self.screen_id, self.xf86_desk_mode); }
unsafe { ffi::XF86VidModeSetViewPort(self.display, self.screen_id, 0, 0); }
}
unsafe { ffi::XDestroyIC(self.ic); }
unsafe { ffi::XCloseIM(self.im); }
unsafe { ffi::XDestroyWindow(self.display, self.window); }
unsafe { ffi::XCloseDisplay(self.display); }
}
}

2
src/x11/monitor.rs → src/x11/window/monitor.rs
View file

@ -1,5 +1,5 @@
use std::{ptr};
use super::ffi;
use super::super::ffi;
pub struct MonitorID(pub uint);

13
tests/headless.rs Normal file
View file

@ -0,0 +1,13 @@
#![feature(phase)]
#![feature(tuple_indexing)]
extern crate glutin;
#[cfg(feature = "headless")]
#[test]
fn main() {
let window = glutin::HeadlessRendererBuilder::new(1024, 768).build().unwrap();
unsafe { window.make_current() };
}