extern crate core_graphics;

extern crate x11_dl;

extern crate parking_lot;

extern crate percent_encoding;

use std::rc::Rc;

use std::{mem, ptr};

use std::cell::RefCell;

use std::collections::VecDeque;

use winapi::ctypes::c_int;

use winapi::shared::minwindef::{

winuser::WM_MOUSEMOVE => {

use events::WindowEvent::{CursorEntered, CursorMoved};

let mouse_outside_window = {

if !window.mouse_in_window {

window.mouse_in_window = true;

true

winuser::WM_MOUSELEAVE => {

use events::WindowEvent::CursorLeft;

let mouse_in_window = {

if window.mouse_in_window {

window.mouse_in_window = false;

true

use events::MouseButton::Left;

use events::ElementState::Pressed;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::MouseButton::Left;

use events::ElementState::Released;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::MouseButton::Right;

use events::ElementState::Pressed;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::MouseButton::Right;

use events::ElementState::Released;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::MouseButton::Middle;

use events::ElementState::Pressed;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::MouseButton::Middle;

use events::ElementState::Released;

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::ElementState::Pressed;

let xbutton = winuser::GET_XBUTTON_WPARAM(wparam);

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

use events::ElementState::Released;

let xbutton = winuser::GET_XBUTTON_WPARAM(wparam);

subclass_input.send_event(Event::WindowEvent {

window_id: SuperWindowId(WindowId(window)),

winuser::WM_SETCURSOR => {

let call_def_window_proc = {

if window_state.mouse_in_window {

let cursor = winuser::LoadCursorW(

ptr::null_mut(),

winuser::WM_GETMINMAXINFO => {

let mmi = lparam as *mut winuser::MINMAXINFO;

if window_state.min_size.is_some() || window_state.max_size.is_some() {

let style = winuser::GetWindowLongA(window, winuser::GWL_STYLE) as DWORD;

let new_dpi_factor = dpi_to_scale_factor(new_dpi_x);

let suppress_resize = {

let suppress_resize = window_state.saved_window_info

.as_mut()

.map(|saved_window_info| {

use std::cell::Cell;

use std::ffi::OsStr;

use std::os::windows::ffi::OsStrExt;

use std::sync::mpsc::channel;

use winapi::ctypes::c_int;

use winapi::shared::minwindef::{BOOL, DWORD, FALSE, LPARAM, TRUE, UINT, WORD, WPARAM};

use winapi::shared::windef::{HWND, LPPOINT, POINT, RECT};

use winapi::um::{combaseapi, dwmapi, libloaderapi, winuser, ole2};

use winapi::um::shobjidl_core::{CLSID_TaskbarList, ITaskbarList2};

use winapi::um::wingdi::{CreateRectRgn, DeleteObject};

use winapi::um::oleidl::LPDROPTARGET;

}

pub(crate) fn set_min_dimensions_physical(&self, dimensions: Option<(u32, u32)>) {

// Make windows re-check the window size bounds.

self.get_inner_size_physical()

.map(|(width, height)| self.set_inner_size_physical(width, height));

}

pub fn set_max_dimensions_physical(&self, dimensions: Option<(u32, u32)>) {

// Make windows re-check the window size bounds.

self.get_inner_size_physical()

.map(|(width, height)| self.set_inner_size_physical(width, height));

#[inline]

pub fn set_resizable(&self, resizable: bool) {

if mem::replace(&mut window_state.resizable, resizable) != resizable {

// If we're in fullscreen, update stored configuration but don't apply anything.

if window_state.fullscreen.is_none() {

MouseCursor::Help => winuser::IDC_HELP,

_ => winuser::IDC_ARROW, // use arrow for the missing cases.

});

self.events_loop_proxy.execute_in_thread(move || unsafe {

let cursor = winuser::LoadCursorW(

ptr::null_mut(),

#[inline]

pub fn grab_cursor(&self, grab: bool) -> Result<(), String> {

let currently_grabbed = unsafe { self.cursor_is_grabbed() }?;

if currently_grabbed == grab && grab == window_state_lock.cursor_grabbed {

return Ok(());

}

self.events_loop_proxy.execute_in_thread(move || {

let result = unsafe { Self::grab_cursor_inner(&window, grab) };

if result.is_ok() {

}

let _ = tx.send(result);

});

#[inline]

pub fn hide_cursor(&self, hide: bool) {

// We don't want to increment/decrement the display count more than once!

if hide == window_state_lock.cursor_hidden { return; }

let (tx, rx) = channel();

let window_state = Arc::clone(&self.window_state);

self.events_loop_proxy.execute_in_thread(move || {

unsafe { Self::hide_cursor_inner(hide) };

let _ = tx.send(());

});

drop(window_state_lock);

#[inline]

pub fn get_hidpi_factor(&self) -> f64 {

}

fn set_cursor_position_physical(&self, x: i32, y: i32) -> Result<(), String> {

#[inline]

pub fn set_maximized(&self, maximized: bool) {

if mem::replace(&mut window_state.maximized, maximized) != maximized {

// We only maximize if we're not in fullscreen.

if window_state.fullscreen.is_none() {

(saved_window_info.style, saved_window_info.ex_style)

}

let (rect, mut style, ex_style) = {

// 'saved_window_info' can be None if the window has never been

// in fullscreen mode before this method gets called.

let resizable = window_state_lock.resizable;

let maximized = window_state_lock.maximized;

// We're restoring the window to its size and position from before being fullscreened.

// `ShowWindow` resizes the window, so it must be called from the main thread.

self.events_loop_proxy.execute_in_thread(move || {

mark_fullscreen(window.0, false);

let _ = Self::grab_cursor_inner(&window, window_state_lock.cursor_grabbed);

});

}

#[inline]

pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {

unsafe {

let (x, y): (i32, i32) = inner.get_position().into();

let (width, height): (u32, u32) = inner.get_dimensions().into();

let window = self.window.clone();

let window_state = Arc::clone(&self.window_state);

let (style, ex_style) = self.set_fullscreen_style(&mut window_state_lock);

self.events_loop_proxy.execute_in_thread(move || {

let _ = Self::grab_cursor_inner(&window, false);

mark_fullscreen(window.0, true);

let _ = Self::grab_cursor_inner(&window, window_state_lock.cursor_grabbed);

});

}

}

}

}

#[inline]

pub fn set_decorations(&self, decorations: bool) {

if mem::replace(&mut window_state.decorations, decorations) != decorations {

// if we are in fullscreen mode, we only change the saved window info

if window_state.fullscreen.is_some() {

#[inline]

pub fn set_always_on_top(&self, always_on_top: bool) {

if mem::replace(&mut window_state.always_on_top, always_on_top) != always_on_top {

let window = self.window.clone();

self.events_loop_proxy.execute_in_thread(move || {

} else {

icon::unset_for_window(self.window.0, IconType::Small);

}

}

#[inline]

} else {

icon::unset_for_window(self.window.0, IconType::Big);

}

}

#[inline]

let file_drop_handler = {

use winapi::shared::winerror::{OLE_E_WRONGCOMPOBJ, RPC_E_CHANGED_MODE, S_OK};

let ole_init_result = ole2::OleInitialize(ptr::null_mut());

// It is ok if the initialize result is `S_FALSE` because it might happen that

// multiple windows are created on the same thread.

static COM_INITIALIZED: ComInitialized = {

unsafe {

ComInitialized(ptr::null_mut())

}

};