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

Remove api_transition macro (#279)

Browse source 
* Remove api_transition macro

* Rename Window2 to Window

* Try fix X11 code
This commit is contained in:
tomaka 2017-09-06 17:32:24 +02:00 committed by GitHub
parent 0ada6c15ea
commit 342d5d8587
13 changed files with 97 additions and 247 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
src/api_transition.rs
View file

@ -1,144 +0,0 @@
//! This temporary module generates types that wrap around the old API (winit v5 and below) and
//! expose the new API (winit v6 and above).
//!
//! This is temporary so that existing backends can smoothly transition. After all implementations
//! have finished transitionning, this module should disappear.
#[cfg(any(target_os = "android", target_os = "ios"))]
macro_rules! gen_api_transition {
() => {
pub struct EventsLoop {
windows: ::std::sync::Arc<::std::sync::Mutex<Vec<::std::sync::Arc<Window>>>>,
awakened: ::std::sync::Arc<::std::sync::atomic::AtomicBool>,
}
pub struct EventsLoopProxy {
awakened: ::std::sync::Weak<::std::sync::atomic::AtomicBool>,
}
impl EventsLoop {
pub fn new() -> EventsLoop {
EventsLoop {
windows: ::std::sync::Arc::new(::std::sync::Mutex::new(vec![])),
awakened: ::std::sync::Arc::new(::std::sync::atomic::AtomicBool::new(false)),
}
}
#[inline]
pub fn get_available_monitors(&self) -> ::std::collections::VecDeque<MonitorId> {
get_available_monitors()
}
#[inline]
pub fn get_primary_monitor(&self) -> MonitorId {
get_primary_monitor()
}
pub fn poll_events<F>(&mut self, mut callback: F)
where F: FnMut(::Event)
{
if self.awakened.load(::std::sync::atomic::Ordering::Relaxed) {
self.awakened.store(false, ::std::sync::atomic::Ordering::Relaxed);
callback(::Event::Awakened);
}
let windows = self.windows.lock().unwrap();
for window in windows.iter() {
for event in window.poll_events() {
callback(::Event::WindowEvent {
window_id: ::WindowId(WindowId(&**window as *const Window as usize)),
event: event,
})
}
}
}
pub fn run_forever<F>(&mut self, mut callback: F)
where F: FnMut(::Event) -> ::ControlFlow,
{
self.awakened.store(false, ::std::sync::atomic::Ordering::Relaxed);
// Yeah that's a very bad implementation.
loop {
let mut control_flow = ::ControlFlow::Continue;
self.poll_events(|e| {
if let ::ControlFlow::Break = callback(e) {
control_flow = ::ControlFlow::Break;
}
});
if let ::ControlFlow::Break = control_flow {
break;
}
::std::thread::sleep(::std::time::Duration::from_millis(5));
}
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy {
awakened: ::std::sync::Arc::downgrade(&self.awakened),
}
}
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventsLoopClosed> {
match self.awakened.upgrade() {
None => Err(::EventsLoopClosed),
Some(awakened) => {
awakened.store(true, ::std::sync::atomic::Ordering::Relaxed);
Ok(())
},
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct WindowId(usize);
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DeviceId;
pub struct Window2 {
pub window: ::std::sync::Arc<Window>,
windows: ::std::sync::Weak<::std::sync::Mutex<Vec<::std::sync::Arc<Window>>>>
}
impl ::std::ops::Deref for Window2 {
type Target = Window;
#[inline]
fn deref(&self) -> &Window {
&*self.window
}
}
impl Window2 {
pub fn new(events_loop: &EventsLoop,
window: &::WindowAttributes,
pl_attribs: &PlatformSpecificWindowBuilderAttributes)
-> Result<Window2, CreationError>
{
let win = ::std::sync::Arc::new(try!(Window::new(window, pl_attribs)));
events_loop.windows.lock().unwrap().push(win.clone());
Ok(Window2 {
window: win,
windows: ::std::sync::Arc::downgrade(&events_loop.windows),
})
}
#[inline]
pub fn id(&self) -> WindowId {
WindowId(&*self.window as *const Window as usize)
}
}
impl Drop for Window2 {
fn drop(&mut self) {
if let Some(windows) = self.windows.upgrade() {
let mut windows = windows.lock().unwrap();
windows.retain(|w| &**w as *const Window != &*self.window as *const _);
}
}
}
};
}

5
src/lib.rs
View file

@ -115,9 +115,6 @@ extern crate wayland_client;
pub use events::*;
pub use window::{AvailableMonitorsIter, MonitorId};
#[macro_use]
mod api_transition;
mod platform;
mod events;
mod window;
@ -144,7 +141,7 @@ pub mod os;
/// });
/// ```
pub struct Window {
window: platform::Window2,
window: platform::Window,
}
/// Identifier of a window. Unique for each window.

2
src/os/unix.rs
View file

@ -7,7 +7,7 @@ use EventsLoop;
use MonitorId;
use Window;
use platform::EventsLoop as LinuxEventsLoop;
use platform::Window2 as LinuxWindow;
use platform::Window as LinuxWindow;
use WindowBuilder;
use platform::x11::XConnection;
use platform::x11::ffi::XVisualInfo;

12
src/platform/android/mod.rs
View file

@ -133,7 +133,7 @@ pub struct WindowId;
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DeviceId;
pub struct Window2 {
pub struct Window {
native_window: *const c_void,
}
@ -159,10 +159,10 @@ pub struct PlatformSpecificWindowBuilderAttributes;
#[derive(Clone, Default)]
pub struct PlatformSpecificHeadlessBuilderAttributes;
impl Window2 {
impl Window {
pub fn new(_: &EventsLoop, win_attribs: &WindowAttributes,
_: &PlatformSpecificWindowBuilderAttributes)
-> Result<Window2, CreationError>
-> Result<Window, CreationError>
{
// not implemented
assert!(win_attribs.min_dimensions.is_none());
@ -175,7 +175,7 @@ impl Window2 {
android_glue::set_multitouch(win_attribs.multitouch);
Ok(Window2 {
Ok(Window {
native_window: native_window as *const _,
})
}
@ -269,8 +269,8 @@ impl Window2 {
}
}
unsafe impl Send for Window2 {}
unsafe impl Sync for Window2 {}
unsafe impl Send for Window {}
unsafe impl Sync for Window {}
// Constant device ID, to be removed when this backend is updated to report real device IDs.
const DEVICE_ID: ::DeviceId = ::DeviceId(DeviceId);

8
src/platform/ios/mod.rs
View file

@ -98,7 +98,7 @@ static mut jmpbuf: [c_int;27] = [0;27];
#[derive(Clone)]
pub struct MonitorId;
pub struct Window2 {
pub struct Window {
delegate_state: *mut DelegateState
}
@ -258,11 +258,11 @@ pub struct DeviceId;
#[derive(Clone, Default)]
pub struct PlatformSpecificWindowBuilderAttributes;
impl Window2 {
impl Window {
pub fn new(ev: &EventsLoop, _: &WindowAttributes, _: &PlatformSpecificWindowBuilderAttributes)
-> Result<Window2, CreationError>
-> Result<Window, CreationError>
{
Ok(Window2 {
Ok(Window {
delegate_state: ev.delegate_state,
})
}

78
src/platform/linux/mod.rs
View file

@ -38,8 +38,8 @@ lazy_static!(
};
);
pub enum Window2 {
X(x11::Window2),
pub enum Window {
X(x11::Window),
Wayland(wayland::Window)
}
@ -87,7 +87,7 @@ impl MonitorId {
}
}
impl Window2 {
impl Window {
#[inline]
pub fn new(events_loop: &EventsLoop,
window: &::WindowAttributes,
@ -96,11 +96,11 @@ impl Window2 {
{
match *events_loop {
EventsLoop::Wayland(ref evlp) => {
wayland::Window::new(evlp, window).map(Window2::Wayland)
wayland::Window::new(evlp, window).map(Window::Wayland)
},
EventsLoop::X(ref el) => {
x11::Window2::new(el, window, pl_attribs).map(Window2::X)
x11::Window::new(el, window, pl_attribs).map(Window::X)
},
}
}
@ -108,104 +108,104 @@ impl Window2 {
#[inline]
pub fn id(&self) -> WindowId {
match self {
&Window2::X(ref w) => WindowId::X(w.id()),
&Window2::Wayland(ref w) => WindowId::Wayland(w.id())
&Window::X(ref w) => WindowId::X(w.id()),
&Window::Wayland(ref w) => WindowId::Wayland(w.id())
}
}
#[inline]
pub fn set_title(&self, title: &str) {
match self {
&Window2::X(ref w) => w.set_title(title),
&Window2::Wayland(ref w) => w.set_title(title)
&Window::X(ref w) => w.set_title(title),
&Window::Wayland(ref w) => w.set_title(title)
}
}
#[inline]
pub fn show(&self) {
match self {
&Window2::X(ref w) => w.show(),
&Window2::Wayland(ref w) => w.show()
&Window::X(ref w) => w.show(),
&Window::Wayland(ref w) => w.show()
}
}
#[inline]
pub fn hide(&self) {
match self {
&Window2::X(ref w) => w.hide(),
&Window2::Wayland(ref w) => w.hide()
&Window::X(ref w) => w.hide(),
&Window::Wayland(ref w) => w.hide()
}
}
#[inline]
pub fn get_position(&self) -> Option<(i32, i32)> {
match self {
&Window2::X(ref w) => w.get_position(),
&Window2::Wayland(ref w) => w.get_position()
&Window::X(ref w) => w.get_position(),
&Window::Wayland(ref w) => w.get_position()
}
}
#[inline]
pub fn set_position(&self, x: i32, y: i32) {
match self {
&Window2::X(ref w) => w.set_position(x, y),
&Window2::Wayland(ref w) => w.set_position(x, y)
&Window::X(ref w) => w.set_position(x, y),
&Window::Wayland(ref w) => w.set_position(x, y)
}
}
#[inline]
pub fn get_inner_size(&self) -> Option<(u32, u32)> {
match self {
&Window2::X(ref w) => w.get_inner_size(),
&Window2::Wayland(ref w) => w.get_inner_size()
&Window::X(ref w) => w.get_inner_size(),
&Window::Wayland(ref w) => w.get_inner_size()
}
}
#[inline]
pub fn get_outer_size(&self) -> Option<(u32, u32)> {
match self {
&Window2::X(ref w) => w.get_outer_size(),
&Window2::Wayland(ref w) => w.get_outer_size()
&Window::X(ref w) => w.get_outer_size(),
&Window::Wayland(ref w) => w.get_outer_size()
}
}
#[inline]
pub fn set_inner_size(&self, x: u32, y: u32) {
match self {
&Window2::X(ref w) => w.set_inner_size(x, y),
&Window2::Wayland(ref w) => w.set_inner_size(x, y)
&Window::X(ref w) => w.set_inner_size(x, y),
&Window::Wayland(ref w) => w.set_inner_size(x, y)
}
}
#[inline]
pub fn set_cursor(&self, cursor: MouseCursor) {
match self {
&Window2::X(ref w) => w.set_cursor(cursor),
&Window2::Wayland(ref w) => w.set_cursor(cursor)
&Window::X(ref w) => w.set_cursor(cursor),
&Window::Wayland(ref w) => w.set_cursor(cursor)
}
}
#[inline]
pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
match self {
&Window2::X(ref w) => w.set_cursor_state(state),
&Window2::Wayland(ref w) => w.set_cursor_state(state)
&Window::X(ref w) => w.set_cursor_state(state),
&Window::Wayland(ref w) => w.set_cursor_state(state)
}
}
#[inline]
pub fn hidpi_factor(&self) -> f32 {
match self {
&Window2::X(ref w) => w.hidpi_factor(),
&Window2::Wayland(ref w) => w.hidpi_factor()
&Window::X(ref w) => w.hidpi_factor(),
&Window::Wayland(ref w) => w.hidpi_factor()
}
}
#[inline]
pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
match self {
&Window2::X(ref w) => w.set_cursor_position(x, y),
&Window2::Wayland(ref w) => w.set_cursor_position(x, y)
&Window::X(ref w) => w.set_cursor_position(x, y),
&Window::Wayland(ref w) => w.set_cursor_position(x, y)
}
}
@ -213,8 +213,8 @@ impl Window2 {
pub fn platform_display(&self) -> *mut libc::c_void {
use wayland_client::Proxy;
match self {
&Window2::X(ref w) => w.platform_display(),
&Window2::Wayland(ref w) => w.get_display().ptr() as *mut _
&Window::X(ref w) => w.platform_display(),
&Window::Wayland(ref w) => w.get_display().ptr() as *mut _
}
}
@ -222,24 +222,24 @@ impl Window2 {
pub fn platform_window(&self) -> *mut libc::c_void {
use wayland_client::Proxy;
match self {
&Window2::X(ref w) => w.platform_window(),
&Window2::Wayland(ref w) => w.get_surface().ptr() as *mut _
&Window::X(ref w) => w.platform_window(),
&Window::Wayland(ref w) => w.get_surface().ptr() as *mut _
}
}
#[inline]
pub fn set_maximized(&self, maximized: bool) {
match self {
&Window2::X(ref w) => w.set_maximized(maximized),
&Window2::Wayland(ref _w) => {},
&Window::X(ref w) => w.set_maximized(maximized),
&Window::Wayland(ref _w) => {},
}
}
#[inline]
pub fn set_fullscreen(&self, state: FullScreenState) {
match self {
&Window2::X(ref w) => w.set_fullscreen(state),
&Window2::Wayland(ref _w) => {},
&Window::X(ref w) => w.set_fullscreen(state),
&Window::Wayland(ref _w) => {},
}
}
}

20
src/platform/linux/x11/mod.rs
View file

@ -1,7 +1,7 @@
#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
pub use self::monitor::{MonitorId, get_available_monitors, get_primary_monitor};
pub use self::window::{Window, XWindow};
pub use self::window::{Window2, XWindow};
pub use self::xdisplay::{XConnection, XNotSupported, XError};
pub mod ffi;
@ -655,16 +655,16 @@ pub struct WindowId(ffi::Window);
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DeviceId(c_int);
pub struct Window2 {
pub window: Arc<Window>,
pub struct Window {
pub window: Arc<Window2>,
display: Weak<XConnection>,
windows: Weak<Mutex<HashMap<WindowId, WindowData>>>,
}
impl ::std::ops::Deref for Window2 {
type Target = Window;
impl ::std::ops::Deref for Window {
type Target = Window2;
#[inline]
fn deref(&self) -> &Window {
fn deref(&self) -> &Window2 {
&*self.window
}
}
@ -674,13 +674,13 @@ lazy_static! { // TODO: use a static mutex when that's possible, and put me
static ref GLOBAL_XOPENIM_LOCK: Mutex<()> = Mutex::new(());
}
impl Window2 {
impl Window {
pub fn new(x_events_loop: &EventsLoop,
window: &::WindowAttributes,
pl_attribs: &PlatformSpecificWindowBuilderAttributes)
-> Result<Self, CreationError>
{
let win = ::std::sync::Arc::new(try!(Window::new(&x_events_loop, window, pl_attribs)));
let win = ::std::sync::Arc::new(try!(Window2::new(&x_events_loop, window, pl_attribs)));
// creating IM
let im = unsafe {
@ -716,7 +716,7 @@ impl Window2 {
cursor_pos: None,
});
Ok(Window2 {
Ok(Window {
window: win,
windows: Arc::downgrade(&x_events_loop.windows),
display: Arc::downgrade(&x_events_loop.display),
@ -749,7 +749,7 @@ impl Window2 {
}
}
impl Drop for Window2 {
impl Drop for Window {
fn drop(&mut self) {
if let (Some(windows), Some(display)) = (self.windows.upgrade(), self.display.upgrade()) {
let mut windows = windows.lock().unwrap();

22
src/platform/linux/x11/window.rs
View file

@ -40,8 +40,8 @@ pub struct XWindow {
unsafe impl Send for XWindow {}
unsafe impl Sync for XWindow {}
unsafe impl Send for Window {}
unsafe impl Sync for Window {}
unsafe impl Send for Window2 {}
unsafe impl Sync for Window2 {}
impl XWindow {
fn switch_to_fullscreen_mode(&self, monitor: i32, width: u16, height: u16) {
@ -141,15 +141,15 @@ impl Drop for XWindow {
}
}
pub struct Window {
pub struct Window2 {
pub x: Arc<XWindow>,
cursor_state: Mutex<CursorState>,
}
impl Window {
impl Window2 {
pub fn new(ctx: &EventsLoop, window_attrs: &WindowAttributes,
pl_attribs: &PlatformSpecificWindowBuilderAttributes)
-> Result<Window, CreationError>
-> Result<Window2, CreationError>
{
let display = &ctx.display;
let dimensions = {
@ -306,7 +306,7 @@ impl Window {
};
}
let window = Window {
let window = Window2 {
x: Arc::new(XWindow {
display: display.clone(),
window: window,
@ -402,16 +402,16 @@ impl Window {
match state {
FullScreenState::None => {
self.x.switch_from_fullscreen_mode();
Window::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", false);
Window2::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", false);
},
FullScreenState::Windowed => {
self.x.switch_from_fullscreen_mode();
Window::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", true);
Window2::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", true);
},
FullScreenState::Exclusive(RootMonitorId { inner: PlatformMonitorId::X(X11MonitorId(_, monitor)) }) => {
if let Some(dimensions) = self.get_inner_size() {
self.x.switch_to_fullscreen_mode(monitor as i32, dimensions.0 as u16, dimensions.1 as u16);
Window::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", true);
Window2::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_FULLSCREEN", true);
} else {
eprintln!("[winit] Couldn't get window dimensions to go fullscreen");
}
@ -421,8 +421,8 @@ impl Window {
}
pub fn set_maximized(&self, maximized: bool) {
Window::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_MAXIMIZED_HORZ", maximized);
Window::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_MAXIMIZED_VERT", maximized);
Window2::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_MAXIMIZED_HORZ", maximized);
Window2::set_netwm(&self.x.display, self.x.window, self.x.root, "_NET_WM_STATE_MAXIMIZED_VERT", maximized);
}
pub fn set_title(&self, title: &str) {

4
src/platform/macos/events_loop.rs
View file

@ -4,7 +4,7 @@ use cocoa::appkit::{NSApplication, NSEvent, NSView, NSWindow};
use events::{self, ElementState, Event, MouseButton, TouchPhase, WindowEvent, DeviceEvent, ModifiersState, KeyboardInput};
use std::collections::VecDeque;
use std::sync::{Arc, Mutex, Weak};
use super::window::Window;
use super::window::Window2;
use std;
use super::DeviceId;
@ -16,7 +16,7 @@ pub struct EventsLoop {
// State shared between the `EventsLoop` and its registered windows.
pub struct Shared {
pub windows: Mutex<Vec<Weak<Window>>>,
pub windows: Mutex<Vec<Weak<Window2>>>,
pub pending_events: Mutex<VecDeque<Event>>,
// The user event callback given via either of the `poll_events` or `run_forever` methods.
//

18
src/platform/macos/mod.rs
View file

@ -2,7 +2,7 @@
pub use self::events_loop::{EventsLoop, Proxy as EventsLoopProxy};
pub use self::monitor::MonitorId;
pub use self::window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, Window};
pub use self::window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, Window2};
use std::sync::Arc;
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@ -10,29 +10,29 @@ pub struct DeviceId;
use {CreationError};
pub struct Window2 {
pub window: Arc<Window>,
pub struct Window {
pub window: Arc<Window2>,
}
impl ::std::ops::Deref for Window2 {
type Target = Window;
impl ::std::ops::Deref for Window {
type Target = Window2;
#[inline]
fn deref(&self) -> &Window {
fn deref(&self) -> &Window2 {
&*self.window
}
}
impl Window2 {
impl Window {
pub fn new(events_loop: &EventsLoop,
attributes: &::WindowAttributes,
pl_attribs: &PlatformSpecificWindowBuilderAttributes) -> Result<Self, CreationError>
{
let weak_shared = Arc::downgrade(&events_loop.shared);
let window = Arc::new(try!(Window::new(weak_shared, attributes, pl_attribs)));
let window = Arc::new(try!(Window2::new(weak_shared, attributes, pl_attribs)));
let weak_window = Arc::downgrade(&window);
events_loop.shared.windows.lock().unwrap().push(weak_window);
Ok(Window2 { window: window })
Ok(Window { window: window })
}
}

26
src/platform/macos/window.rs
View file

@ -256,16 +256,16 @@ pub struct PlatformSpecificWindowBuilderAttributes {
pub activation_policy: ActivationPolicy,
}
pub struct Window {
pub struct Window2 {
pub view: IdRef,
pub window: IdRef,
pub delegate: WindowDelegate,
}
unsafe impl Send for Window {}
unsafe impl Sync for Window {}
unsafe impl Send for Window2 {}
unsafe impl Sync for Window2 {}
impl Drop for Window {
impl Drop for Window2 {
fn drop(&mut self) {
// Remove this window from the `EventLoop`s list of windows.
let id = self.id();
@ -283,7 +283,7 @@ impl Drop for Window {
}
}
impl WindowExt for Window {
impl WindowExt for Window2 {
#[inline]
fn get_nswindow(&self) -> *mut c_void {
*self.window as *mut c_void
@ -295,11 +295,11 @@ impl WindowExt for Window {
}
}
impl Window {
impl Window2 {
pub fn new(shared: Weak<Shared>,
win_attribs: &WindowAttributes,
pl_attribs: &PlatformSpecificWindowBuilderAttributes)
-> Result<Window, CreationError>
-> Result<Window2, CreationError>
{
unsafe {
if !msg_send![cocoa::base::class("NSThread"), isMainThread] {
@ -307,17 +307,17 @@ impl Window {
}
}
let app = match Window::create_app(pl_attribs.activation_policy) {
let app = match Window2::create_app(pl_attribs.activation_policy) {
Some(app) => app,
None => { return Err(OsError(format!("Couldn't create NSApplication"))); },
};
let window = match Window::create_window(win_attribs)
let window = match Window2::create_window(win_attribs)
{
Some(window) => window,
None => { return Err(OsError(format!("Couldn't create NSWindow"))); },
};
let view = match Window::create_view(*window) {
let view = match Window2::create_view(*window) {
Some(view) => view,
None => { return Err(OsError(format!("Couldn't create NSView"))); },
};
@ -355,7 +355,7 @@ impl Window {
shared: shared,
};
let window = Window {
let window = Window2 {
view: view,
window: window,
delegate: WindowDelegate::new(ds),
@ -422,11 +422,11 @@ impl Window {
appkit::NSBorderlessWindowMask | appkit::NSResizableWindowMask |
appkit::NSTitledWindowMask
} else if attrs.decorations {
// Window with a titlebar
// Window2 with a titlebar
appkit::NSClosableWindowMask | appkit::NSMiniaturizableWindowMask |
appkit::NSResizableWindowMask | appkit::NSTitledWindowMask
} else {
// Window without a titlebar
// Window2 without a titlebar
appkit::NSClosableWindowMask | appkit::NSMiniaturizableWindowMask |
appkit::NSResizableWindowMask |
appkit::NSFullSizeContentViewWindowMask

3
src/platform/windows/mod.rs
View file

@ -17,9 +17,6 @@ unsafe impl Sync for PlatformSpecificWindowBuilderAttributes {}
// TODO: document what this means
pub type Cursor = *const winapi::wchar_t;
// TODO: remove
pub type Window2 = Window;
// Constant device ID, to be removed when this backend is updated to report real device IDs.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DeviceId;

2
src/window.rs
View file

@ -118,7 +118,7 @@ impl WindowBuilder {
}
// building
let w = try!(platform::Window2::new(&events_loop.events_loop, &self.window, &self.platform_specific));
let w = try!(platform::Window::new(&events_loop.events_loop, &self.window, &self.platform_specific));
Ok(Window { window: w })
}