From 9327dcf204ee4782430beec215afa9d12d223c81 Mon Sep 17 00:00:00 2001
From: snuk182 <snuk188@gmail.com>
Date: Wed, 29 Nov 2017 23:31:57 +0100
Subject: [PATCH] Initial commit

---
 Cargo.toml             |  22 +++
 build.rs               |   5 +
 plygui.manifest        |  33 ++++
 plygui.rc              |   2 +
 rustfmt.toml           |   1 +
 src/application.rs     |  65 ++++++
 src/button.rs          | 267 +++++++++++++++++++++++++
 src/common.rs          | 408 ++++++++++++++++++++++++++++++++++++++
 src/layout_linear.rs   | 435 +++++++++++++++++++++++++++++++++++++++++
 src/layout_relative.rs |   5 +
 src/lib.rs             |  31 +++
 src/window.rs          | 282 ++++++++++++++++++++++++++
 12 files changed, 1556 insertions(+)
 create mode 100644 Cargo.toml
 create mode 100644 build.rs
 create mode 100644 plygui.manifest
 create mode 100644 plygui.rc
 create mode 100644 rustfmt.toml
 create mode 100644 src/application.rs
 create mode 100644 src/button.rs
 create mode 100644 src/common.rs
 create mode 100644 src/layout_linear.rs
 create mode 100644 src/layout_relative.rs
 create mode 100644 src/lib.rs
 create mode 100644 src/window.rs

diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..7bd9433
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "plygui-win32"
+version = "0.0.1"
+authors = ["Serhii Plyhun <snuk188@gmail.com>"]
+
+[lib]
+name = "plygui_win32"
+path = "src/lib.rs"
+
+[dependencies]
+plygui = {version = "0.0.1", path = "../plygui"}
+user32-sys = "~0.2"
+gdi32-sys = "~0.2"
+kernel32-sys = "~0.2"
+comctl32-sys = "~0.2"
+comdlg32-sys = "~0.2"
+winapi = "~0.2"
+lazy_static = "~0.2"
+derive_builder = "~0.5"
+
+[build-dependencies]
+embed-resource = "~1.1"
\ No newline at end of file
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..9674400
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,5 @@
+extern crate embed_resource;
+
+fn main() {
+    embed_resource::compile("plygui.rc");
+}
\ No newline at end of file
diff --git a/plygui.manifest b/plygui.manifest
new file mode 100644
index 0000000..b0ee38f
--- /dev/null
+++ b/plygui.manifest
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
+	manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+	<assemblyIdentity version="1.0.0.0"
+		processorArchitecture="*" name="plygui.Plygui" type="win32" />
+	<description>Plygui</description>
+	<dependency>
+		<dependentAssembly>
+			<assemblyIdentity type="win32"
+				name="Microsoft.Windows.Common-Controls" version="6.0.0.0"
+				processorArchitecture="*" publicKeyToken="6595b64144ccf1df"
+				language="*" />
+		</dependentAssembly>
+	</dependency>
+
+	<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+		<application>
+			<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" /> <!-- Windows Vista -->
+			<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" /> <!-- Windows 7 -->
+			<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" /> <!-- Windows 8 -->
+			<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" /> <!-- Windows 8.1 -->
+			<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> <!-- Windows 10 -->
+		</application>
+	</compatibility>
+
+	<asmv3:application>
+		<asmv3:windowsSettings
+			xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+			<dpiAware>true</dpiAware>
+		</asmv3:windowsSettings>
+	</asmv3:application>
+</assembly>
+
diff --git a/plygui.rc b/plygui.rc
new file mode 100644
index 0000000..19b4adc
--- /dev/null
+++ b/plygui.rc
@@ -0,0 +1,2 @@
+#define RT_MANIFEST 24
+1 RT_MANIFEST "plygui.manifest"
\ No newline at end of file
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 0000000..61d8e96
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+max_width = 250
diff --git a/src/application.rs b/src/application.rs
new file mode 100644
index 0000000..1b21cbd
--- /dev/null
+++ b/src/application.rs
@@ -0,0 +1,65 @@
+use super::*;
+use super::common::WindowsContainer;
+
+use std::{mem, thread};
+
+use plygui::{Id, UiApplication, UiWindow};
+
+pub struct Application {
+    name: String,
+    windows: Vec<winapi::HWND>,
+}
+
+impl UiApplication for Application {
+    fn new_window(&mut self, title: &str, width: u16, height: u16, has_menu: bool) -> Box<UiWindow> {
+        let w = Window::new(title, width, height, has_menu);
+        unsafe {
+            self.windows.push(w.hwnd());
+        }
+        w
+    }
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+    fn start(&mut self) {
+        for i in (0..self.windows.len()).rev() {
+            if i > 0 {
+                thread::spawn(move || {});
+            } else {
+                start_window(self.windows[i]);
+            }
+        }
+    }
+}
+
+impl Application {
+    pub fn with_name(name: &str) -> Box<Application> {
+    	init_comctl();
+    	Id::next();
+	    Box::new(Application {
+                     name: name.into(),
+                     windows: Vec::with_capacity(1),
+                 })
+    }
+}
+
+fn start_window(hwnd: winapi::HWND) {
+	let w: &mut Window = unsafe { mem::transmute(user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA)) };
+    w.start();
+}
+
+fn init_comctl() {
+	unsafe {
+    	let mut icc: winapi::INITCOMMONCONTROLSEX = mem::zeroed();
+    	icc.dwSize = mem::size_of::<winapi::INITCOMMONCONTROLSEX>() as u32;
+		icc.dwICC = winapi::ICC_STANDARD_CLASSES 
+			| winapi::ICC_LISTVIEW_CLASSES
+			| winapi::ICC_TAB_CLASSES
+			| winapi::ICC_PROGRESS_CLASS
+			| winapi::ICC_UPDOWN_CLASS
+			| winapi::ICC_BAR_CLASSES;
+		if comctl32::InitCommonControlsEx(&icc) == 0 {
+			common::log_error();
+		}
+	}        
+}
\ No newline at end of file
diff --git a/src/button.rs b/src/button.rs
new file mode 100644
index 0000000..317684c
--- /dev/null
+++ b/src/button.rs
@@ -0,0 +1,267 @@
+use super::*;
+
+use plygui::{layout, Id, UiRole, UiRoleMut, Visibility, UiControl, UiButton, UiMember, UiContainer};
+
+use std::{ptr, mem, str};
+use std::os::raw::c_void;
+use std::os::windows::ffi::OsStrExt;
+use std::ffi::OsStr;
+
+pub const CLASS_ID: &str = "Button";
+
+lazy_static! {
+	pub static ref WINDOW_CLASS: Vec<u16> = OsStr::new(CLASS_ID)
+        .encode_wide()
+        .chain(Some(0).into_iter())
+        .collect::<Vec<_>>();
+}
+
+#[repr(C)]
+pub struct Button {
+    base: common::WindowsControlBase,
+    label: String,
+    h_left_clicked: Option<Box<FnMut(&mut UiButton)>>,
+}
+
+impl Button {
+    pub fn new(label: &str) -> Box<Button> {
+        let b = Box::new(Button {
+                             base: Default::default(),
+                             h_left_clicked: None,
+                             label: label.to_owned(),
+                         });
+
+        b
+    }
+}
+
+impl UiButton for Button {
+    fn on_left_click(&mut self, handle: Option<Box<FnMut(&mut UiButton)>>) {
+        self.h_left_clicked = handle;
+    }
+    fn label(&self) -> &str {
+        self.label.as_ref()
+    }
+}
+
+impl UiControl for Button {
+    fn layout_width(&self) -> layout::Size {
+    	self.base.layout_width()
+    }
+	fn layout_height(&self) -> layout::Size {
+		self.base.layout_height()
+	}
+	fn layout_gravity(&self) -> layout::Gravity {
+		self.base.layout_gravity()
+	}
+	fn layout_orientation(&self) -> layout::Orientation {
+		self.base.layout_orientation()
+	}
+	fn layout_alignment(&self) -> layout::Alignment {
+		self.base.layout_alignment()
+	}
+	
+	fn set_layout_width(&mut self, width: layout::Size) {
+		self.base.set_layout_width(width);
+	}
+	fn set_layout_height(&mut self, height: layout::Size) {
+		self.base.set_layout_height(height);
+	}
+	fn set_layout_gravity(&mut self, gravity: layout::Gravity) {
+		self.base.set_layout_gravity(gravity);
+	}
+	fn set_layout_orientation(&mut self, orientation: layout::Orientation) {
+		self.base.set_layout_orientation(orientation);
+	}
+	fn set_layout_alignment(&mut self, alignment: layout::Alignment) {
+		self.base.set_layout_alignment(alignment);
+	}
+    fn draw(&mut self, coords: Option<(i32, i32)>) {
+    	if coords.is_some() {
+    		self.base.coords = coords;
+    	}
+        if let Some((x, y)) = self.base.coords {
+        	unsafe {
+	            user32::SetWindowPos(self.base.hwnd,
+	                                 ptr::null_mut(),
+	                                 x as i32,
+	                                 y as i32,
+	                                 self.base.measured_size.0 as i32,
+	                                 self.base.measured_size.1 as i32,
+	                                 0);
+	        }
+        }
+    }
+    fn measure(&mut self, parent_width: u16, parent_height: u16) -> (u16, u16, bool) {
+    	let old_size = self.base.measured_size;
+    	
+    	self.base.measured_size = match self.base.visibility() {
+    		Visibility::Gone => (0, 0),
+    		_ => {
+    			unsafe {
+		            let mut label_size: winapi::SIZE = mem::zeroed();
+		            let w = match self.base.layout_width() {
+		                layout::Size::MatchParent => parent_width,
+		                layout::Size::Exact(w) => w,
+		                layout::Size::WrapContent => {
+		                    if label_size.cx < 1 {
+		                        let label = OsStr::new(self.label.as_str())
+		                            .encode_wide()
+		                            .chain(Some(0).into_iter())
+		                            .collect::<Vec<_>>();
+		                        gdi32::GetTextExtentPointW(user32::GetDC(self.base.hwnd),
+		                                                   label.as_ptr(),
+		                                                   self.label.len() as i32,
+		                                                   &mut label_size);
+		                    }
+		                    label_size.cx as u16
+		                } 
+		            };
+		            let h = match self.base.layout_height() {
+		                layout::Size::MatchParent => parent_height,
+		                layout::Size::Exact(h) => h,
+		                layout::Size::WrapContent => {
+		                    if label_size.cy < 1 {
+		                        let label = OsStr::new(self.label.as_str())
+		                            .encode_wide()
+		                            .chain(Some(0).into_iter())
+		                            .collect::<Vec<_>>();
+		                        gdi32::GetTextExtentPointW(user32::GetDC(self.base.hwnd),
+		                                                   label.as_ptr(),
+		                                                   self.label.len() as i32,
+		                                                   &mut label_size);
+		                    }
+		                    label_size.cy as u16
+		                } 
+		            };
+		            (w, h)
+		        }
+    		}
+    	};
+        (self.base.measured_size.0, self.base.measured_size.1, self.base.measured_size != old_size)
+    }
+    fn is_container_mut(&mut self) -> Option<&mut UiContainer> {
+        None
+    }
+    fn is_container(&self) -> Option<&UiContainer> {
+        None
+    }
+
+    fn parent(&self) -> Option<&UiContainer> {
+        self.base.parent()
+    }
+    fn parent_mut(&mut self) -> Option<&mut UiContainer> {
+        self.base.parent_mut()
+    }
+    fn root(&self) -> Option<&UiContainer> {
+        self.base.root()
+    }
+    fn root_mut(&mut self) -> Option<&mut UiContainer> {
+        self.base.root_mut()
+    }
+}
+
+impl UiMember for Button {
+    fn size(&self) -> (u16, u16) {
+        let rect = unsafe { common::window_rect(self.base.hwnd) };
+        ((rect.right - rect.left) as u16, (rect.bottom - rect.top) as u16)
+    }
+
+    fn on_resize(&mut self, handler: Option<Box<FnMut(&mut UiMember, u16, u16)>>) {
+        self.base.h_resize = handler;
+    }
+
+    fn set_visibility(&mut self, visibility: Visibility) {
+        self.base.set_visibility(visibility);
+    }
+    fn visibility(&self) -> Visibility {
+        self.base.visibility()
+    }
+
+    fn role<'a>(&'a self) -> UiRole<'a> {
+        UiRole::Button(self)
+    }
+    fn role_mut<'a>(&'a mut self) -> UiRoleMut<'a> {
+        UiRoleMut::Button(self)
+    }
+    /*fn native_id(&self) -> NativeId {
+        self.base.hwnd
+    }*/
+    fn id(&self) -> Id {
+    	self.base.id()
+    }
+    fn is_control(&self) -> Option<&UiControl> {
+    	Some(self)
+    }
+    fn is_control_mut(&mut self) -> Option<&mut UiControl> {
+    	Some(self)
+    }     
+}
+
+impl Drop for Button {
+    fn drop(&mut self) {
+        self.set_visibility(Visibility::Gone);
+        common::destroy_hwnd(self.base.hwnd, 0, None);
+    }
+}
+
+unsafe impl common::WindowsControl for Button {
+    unsafe fn on_added_to_container(&mut self, parent: &common::WindowsContainer, px: u16, py: u16) {
+        let selfptr = self as *mut _ as *mut c_void;
+        let (pw, ph) = parent.size();
+        self.base.hwnd = parent.hwnd(); // required for measure, as we don't have own hwnd yet
+        let (w, h, _) = self.measure(pw, ph);
+        let (hwnd, id) = common::create_control_hwnd(px as i32,
+                                                     py as i32,
+                                                     w as i32,
+                                                     h as i32,
+                                                     parent.hwnd(),
+                                                     0,
+                                                     WINDOW_CLASS.as_ptr(),
+                                                     self.label.as_str(),
+                                                     winapi::BS_PUSHBUTTON | winapi::WS_TABSTOP,
+                                                     selfptr,
+                                                     Some(handler));
+        self.base.hwnd = hwnd;
+        self.base.subclass_id = id;
+    }
+    unsafe fn on_removed_from_container(&mut self, _: &common::WindowsContainer) {
+        common::destroy_hwnd(self.base.hwnd, self.base.subclass_id, Some(handler));
+        self.base.hwnd = 0 as winapi::HWND;
+        self.base.subclass_id = 0;
+    }
+    fn as_base(&self) -> &common::WindowsControlBase {
+    	&self.base
+    }
+    fn as_base_mut(&mut self) -> &mut common::WindowsControlBase {
+    	&mut self.base
+    }
+}
+
+unsafe extern "system" fn handler(hwnd: winapi::HWND, msg: winapi::UINT, wparam: winapi::WPARAM, lparam: winapi::LPARAM, _: u64, param: u64) -> i64 {
+    let mut button: &mut Button = mem::transmute(param);
+    let ww = user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA);
+    if ww == 0 {
+        user32::SetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA, param as i64);
+    }
+    match msg {
+        winapi::WM_LBUTTONDOWN => {
+            if let Some(ref mut cb) = button.h_left_clicked {
+                let mut button2: &mut Button = mem::transmute(param);
+                (cb)(button2);
+            }
+        }
+        winapi::WM_SIZE => {
+            let width = lparam as u16;
+            let height = (lparam >> 16) as u16;
+
+            if let Some(ref mut cb) = button.base.h_resize {
+                let mut button2: &mut Button = mem::transmute(param);
+                (cb)(button2, width, height);
+            }
+        }
+        _ => {}
+    }
+
+    comctl32::DefSubclassProc(hwnd, msg, wparam, lparam)
+}
diff --git a/src/common.rs b/src/common.rs
new file mode 100644
index 0000000..c8affd2
--- /dev/null
+++ b/src/common.rs
@@ -0,0 +1,408 @@
+use super::*;
+
+use std::{ptr, mem, str};
+use std::os::raw::c_void;
+use std::os::windows::ffi::OsStrExt;
+use std::ffi::OsStr;
+
+use plygui::{development, layout, Id, UiContainer, UiMember, UiControl, UiRoleMut, Visibility};
+
+pub static mut INSTANCE: winapi::HINSTANCE = 0 as winapi::HINSTANCE;
+
+#[repr(C)]
+pub struct WindowsControlBase {
+	id: Id,
+    layout: development::layout::LayoutBase,
+    visibility: Visibility,
+    
+    pub hwnd: winapi::HWND,
+    pub subclass_id: u64,
+    pub coords: Option<(i32, i32)>,
+    pub measured_size: (u16, u16),
+
+    pub h_resize: Option<Box<FnMut(&mut UiMember, u16, u16)>>,
+}
+
+impl Default for WindowsControlBase {
+    fn default() -> WindowsControlBase {
+        WindowsControlBase {
+        	id: Id::next(),
+            hwnd: 0 as winapi::HWND,
+            h_resize: None,
+            subclass_id: 0,
+            layout: development::layout::LayoutBase {
+	            width: layout::Size::MatchParent,
+				height: layout::Size::WrapContent,
+				gravity: layout::gravity::CENTER_HORIZONTAL | layout::gravity::TOP,
+				orientation: layout::Orientation::Vertical,
+				alignment: layout::Alignment::None,
+            },
+            measured_size: (0, 0),
+            coords: None,
+            visibility: Visibility::Visible,
+        }
+    }
+}
+impl WindowsControlBase {
+	fn invalidate(&mut self) {
+		unsafe {
+			let self_hwnd = self.hwnd;
+			let parent_hwnd = self.parent_hwnd();	
+			if let Some(parent) = self.parent_mut() {
+				let parent_hwnd = parent_hwnd.unwrap();
+				if let Some(real_self) = cast_hwnd_to_uimember(self_hwnd) {
+					if let Some(control_self) = real_self.is_control_mut() {
+						let (pw, ph) = parent.size();
+						let wparent = common::cast_hwnd_to_windows(parent_hwnd);
+						/*let (_,_,changed) = */control_self.measure(pw, ph);
+						control_self.draw(None);
+							
+						//if changed {
+							if let Some(wparent) = wparent {
+								wparent.as_base_mut().invalidate();
+							} 
+						//} 
+					}
+				}
+				if parent_hwnd != 0 as winapi::HWND {
+	        		user32::InvalidateRect(parent_hwnd, ptr::null_mut(), winapi::TRUE);
+	        	}
+	        }
+		}
+	}
+	pub fn layout_width(&self) -> layout::Size {
+    	self.layout.width
+    }
+	pub fn layout_height(&self) -> layout::Size {
+		self.layout.height
+	}
+	pub fn layout_gravity(&self) -> layout::Gravity {
+		self.layout.gravity
+	}
+	pub fn layout_orientation(&self) -> layout::Orientation {
+		self.layout.orientation
+	}
+	pub fn layout_alignment(&self) -> layout::Alignment {
+		self.layout.alignment
+	}
+	
+	pub fn set_layout_width(&mut self, width: layout::Size) {
+		self.layout.width = width;
+		self.invalidate();
+	}
+	pub fn set_layout_height(&mut self, height: layout::Size) {
+		self.layout.height = height;
+		self.invalidate();
+	}
+	pub fn set_layout_gravity(&mut self, gravity: layout::Gravity) {
+		self.layout.gravity = gravity;
+		self.invalidate();
+	}
+	pub fn set_layout_orientation(&mut self, orientation: layout::Orientation) {
+		self.layout.orientation = orientation;
+		self.invalidate();
+	}
+	pub fn set_layout_alignment(&mut self, alignment: layout::Alignment) {
+		self.layout.alignment = alignment;
+		self.invalidate();
+	}
+    
+    pub fn set_visibility(&mut self, visibility: Visibility) {
+        self.visibility = visibility;
+        unsafe {
+            user32::ShowWindow(self.hwnd,
+                               if self.visibility == Visibility::Invisible {
+                                   winapi::SW_HIDE
+                               } else {
+                                   winapi::SW_SHOW
+                               });
+            self.invalidate();
+        }
+    }
+    pub fn id(&self) -> Id {
+    	self.id
+    }
+    pub fn visibility(&self) -> Visibility {
+        self.visibility
+    }
+    pub fn parent_hwnd(&self) -> Option<winapi::HWND> {
+    	unsafe {
+    		let parent_hwnd = user32::GetParent(self.hwnd);
+            if parent_hwnd == self.hwnd {
+                None
+            } else {
+            	Some(parent_hwnd)
+            }
+    	}
+    }
+    pub fn parent(&self) -> Option<&UiContainer> {
+        unsafe {
+            let parent_hwnd = user32::GetParent(self.hwnd);
+            if parent_hwnd == self.hwnd {
+                return None;
+            }
+
+            let parent_ptr = user32::GetWindowLongPtrW(parent_hwnd, winapi::GWLP_USERDATA);
+            let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(parent_hwnd).as_ref());
+            match parent_class.as_str() {
+                development::CLASS_ID_LAYOUT_LINEAR => {
+                    let ll: &layout_linear::LinearLayout = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(ll);
+                }
+                development::CLASS_ID_WINDOW => {
+                    let w: &window::Window = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(w);
+                }
+                _ => None,
+            }
+        }
+    }
+    pub fn parent_mut(&mut self) -> Option<&mut UiContainer> {
+        unsafe {
+            let parent_hwnd = user32::GetParent(self.hwnd);
+            if parent_hwnd == self.hwnd {
+                return None;
+            }
+
+            let parent_ptr = user32::GetWindowLongPtrW(parent_hwnd, winapi::GWLP_USERDATA);
+            let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(parent_hwnd).as_ref());
+            match parent_class.as_str() {
+                development::CLASS_ID_LAYOUT_LINEAR => {
+                    let ll: &mut layout_linear::LinearLayout = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(ll);
+                }
+                development::CLASS_ID_WINDOW => {
+                    let w: &mut window::Window = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(w);
+                }
+                _ => None,
+            }
+        }
+    }
+    pub fn root(&self) -> Option<&UiContainer> {
+        unsafe {
+            let parent_hwnd = user32::GetAncestor(self.hwnd, 2); //GA_ROOT
+            if parent_hwnd == self.hwnd {
+                return None;
+            }
+
+            let parent_ptr = user32::GetWindowLongPtrW(parent_hwnd, winapi::GWLP_USERDATA);
+            let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(parent_hwnd).as_ref());
+            match parent_class.as_str() {
+                development::CLASS_ID_LAYOUT_LINEAR => {
+                    let ll: &layout_linear::LinearLayout = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(ll);
+                }
+                development::CLASS_ID_WINDOW => {
+                    let w: &window::Window = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(w);
+                }
+                _ => {
+                    println!("unknown {}", parent_class);
+                    None
+                }
+            }
+        }
+    }
+    pub fn root_mut(&mut self) -> Option<&mut UiContainer> {
+        unsafe {
+            let parent_hwnd = user32::GetAncestor(self.hwnd, 2); //GA_ROOT
+            if parent_hwnd == self.hwnd {
+                return None;
+            }
+
+            let parent_ptr = user32::GetWindowLongPtrW(parent_hwnd, winapi::GWLP_USERDATA);
+            let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(parent_hwnd).as_ref());
+            match parent_class.as_str() {
+                development::CLASS_ID_LAYOUT_LINEAR => {
+                    let ll: &mut layout_linear::LinearLayout = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(ll);
+                }
+                development::CLASS_ID_WINDOW => {
+                    let w: &mut window::Window = mem::transmute(parent_ptr as *mut c_void);
+                    return Some(w);
+                }
+                _ => {
+                    println!("unknown {}", parent_class);
+                    None
+                }
+            }
+        }
+    }
+}
+
+pub unsafe trait WindowsControl: UiMember {
+    unsafe fn on_added_to_container(&mut self, &WindowsContainer, x: u16, y: u16);
+    unsafe fn on_removed_from_container(&mut self, &WindowsContainer);
+    fn as_base(&self) -> &WindowsControlBase;
+    fn as_base_mut(&mut self) -> &mut WindowsControlBase;
+}
+
+pub unsafe trait WindowsContainer: UiContainer + UiMember {
+    unsafe fn hwnd(&self) -> winapi::HWND;
+}
+
+pub unsafe fn get_class_name_by_hwnd(hwnd: winapi::HWND) -> Vec<u16> {
+    let mut max_id = 256;
+    let mut name = vec![0u16; max_id];
+    max_id = user32::GetClassNameW(hwnd, name.as_mut_slice().as_ptr(), max_id as i32) as usize;
+    name.truncate(max_id);
+    name
+}
+
+pub unsafe fn create_control_hwnd(x: i32,
+                                  y: i32,
+                                  w: i32,
+                                  h: i32,
+                                  parent: winapi::HWND,
+                                  ex_style: winapi::DWORD,
+                                  class_name: winapi::LPCWSTR,
+                                  control_name: &str,
+                                  style: winapi::DWORD,
+                                  param: winapi::LPVOID,
+                                  handler: Option<unsafe extern "system" fn(winapi::HWND,
+                                                                            msg: winapi::UINT,
+                                                                            winapi::WPARAM,
+                                                                            winapi::LPARAM,
+                                                                            u64,
+                                                                            u64)
+                                                                            -> i64>)
+                                  -> (winapi::HWND, u64) {
+    let mut style = style;
+    if (style & winapi::WS_TABSTOP) != 0 {
+        style |= winapi::WS_GROUP;
+    }
+	#[allow(deprecated)]
+    let subclass_id = {
+        use std::hash::{Hasher, SipHasher};
+
+        let mut hasher = SipHasher::new();
+        hasher.write_usize(class_name as usize);
+        hasher.finish()
+    };
+    let control_name = OsStr::new(control_name)
+        .encode_wide()
+        .chain(Some(0).into_iter())
+        .collect::<Vec<_>>();
+    let hwnd = user32::CreateWindowExW(ex_style,
+                                       class_name,
+                                       control_name.as_ptr(),
+                                       style | winapi::WS_CHILD | winapi::WS_VISIBLE,
+                                       x,
+                                       y,
+                                       w,
+                                       h,
+                                       parent,
+                                       ptr::null_mut(),
+                                       INSTANCE,
+                                       param);
+    log_error();
+    comctl32::SetWindowSubclass(hwnd, handler, subclass_id, param as u64);
+    log_error();
+    (hwnd, subclass_id)
+}
+
+pub fn destroy_hwnd(hwnd: winapi::HWND,
+                    subclass_id: u64,
+                    handler: Option<unsafe extern "system" fn(winapi::HWND,
+                                                              msg: winapi::UINT,
+                                                              winapi::WPARAM,
+                                                              winapi::LPARAM,
+                                                              u64,
+                                                              u64)
+                                                              -> i64>) {
+    unsafe {
+        if subclass_id != 0 {
+            comctl32::RemoveWindowSubclass(hwnd, handler, subclass_id);
+        }
+        if user32::DestroyWindow(hwnd) == 0 {
+            //panic!("Cannot destroy window!");
+        }
+    }
+}
+
+pub unsafe fn window_rect(hwnd: winapi::HWND) -> winapi::RECT {
+    let mut rect: winapi::RECT = mem::zeroed();
+    user32::GetWindowRect(hwnd, &mut rect);
+    rect
+}
+
+pub unsafe fn cast_uicontrol_to_windows(input: &mut Box<UiControl>) -> &mut WindowsControl {
+    use std::ops::DerefMut;
+    match input.role_mut() {
+        UiRoleMut::Button(_) => {
+            let a: &mut Box<button::Button> = mem::transmute(input);
+            a.deref_mut()
+        }
+        UiRoleMut::LinearLayout(_) => {
+            let a: &mut Box<layout_linear::LinearLayout> = mem::transmute(input);
+            a.deref_mut()
+        }
+        UiRoleMut::Window(_) => {
+            panic!("Window as a container child is impossible!");
+        }
+    }
+}
+
+pub unsafe fn cast_hwnd_to_windows<'a>(hwnd: winapi::HWND) -> Option<&'a mut WindowsControl> {
+	let hwnd_ptr = user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA);
+    let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(hwnd).as_ref());
+    match parent_class.as_str() {
+        development::CLASS_ID_LAYOUT_LINEAR => {
+            let ll: &mut layout_linear::LinearLayout = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(ll);
+        },
+        /*development::CLASS_ID_WINDOW => {
+            let w: &mut window::Window = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(w);
+        },*/
+        button::CLASS_ID => {
+            let b: &mut button::Button = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(b);
+        },
+        _ => None,
+    }
+}
+
+pub unsafe fn cast_hwnd_to_uimember<'a>(hwnd: winapi::HWND) -> Option<&'a mut UiMember> {// TODO merge with above using T: Sized
+	let hwnd_ptr = user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA);
+    let parent_class = String::from_utf16_lossy(get_class_name_by_hwnd(hwnd).as_ref());
+    match parent_class.as_str() {
+        development::CLASS_ID_LAYOUT_LINEAR => {
+            let ll: &mut layout_linear::LinearLayout = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(ll);
+        },
+        development::CLASS_ID_WINDOW => {
+            let w: &mut window::Window = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(w);
+        },
+        button::CLASS_ID => {
+            let b: &mut button::Button = mem::transmute(hwnd_ptr as *mut c_void);
+            return Some(b);
+        },
+        _ => {
+        	println!("Unsupported {}", parent_class);
+	        None
+        },
+    }
+}
+
+pub unsafe fn log_error() {
+    let error = kernel32::GetLastError();
+    if error == 0 {
+        return;
+    }
+
+    let mut string = vec![0u16; 127];
+    kernel32::FormatMessageW(winapi::FORMAT_MESSAGE_FROM_SYSTEM | winapi::FORMAT_MESSAGE_IGNORE_INSERTS,
+                             ptr::null_mut(),
+                             error,
+                             winapi::LANG_SYSTEM_DEFAULT as u32,
+                             string.as_mut_ptr(),
+                             string.len() as u32,
+                             ptr::null_mut());
+
+    println!("Last error #{}: {}",
+             error,
+             String::from_utf16_lossy(&string));
+}
diff --git a/src/layout_linear.rs b/src/layout_linear.rs
new file mode 100644
index 0000000..1301c87
--- /dev/null
+++ b/src/layout_linear.rs
@@ -0,0 +1,435 @@
+use super::*;
+use super::common::*;
+
+use plygui::{development, layout, Id, UiRole, UiRoleMut, UiControl, UiMember, UiContainer, UiMultiContainer, UiLinearLayout, Visibility};
+
+use std::{ptr, mem};
+use std::os::raw::c_void;
+use std::os::windows::ffi::OsStrExt;
+use std::ffi::OsStr;
+
+lazy_static! {
+	pub static ref WINDOW_CLASS: Vec<u16> = unsafe { register_window_class() };
+	//pub static ref INSTANCE: winapi::HINSTANCE = unsafe { kernel32::GetModuleHandleW(ptr::null()) };
+}
+
+#[repr(C)]
+pub struct LinearLayout {
+    base: WindowsControlBase,
+    orientation: layout::Orientation,
+    children: Vec<Box<UiControl>>,
+}
+
+impl LinearLayout {
+    pub fn new(orientation: layout::Orientation) -> Box<LinearLayout> {
+        Box::new(LinearLayout {
+                     base: Default::default(),
+                     orientation: orientation,
+                     children: Vec::new(),
+                 })
+    }
+}
+
+impl UiMember for LinearLayout {
+    fn set_visibility(&mut self, visibility: Visibility) {
+        self.base.set_visibility(visibility);
+    }
+    fn visibility(&self) -> Visibility {
+        self.base.visibility()
+    }
+
+    /*fn native_id(&self) -> NativeId {
+        self.base.hwnd
+    }*/
+    fn id(&self) -> Id {
+    	self.base.id()
+    }
+    fn size(&self) -> (u16, u16) {
+        let rect = unsafe { window_rect(self.base.hwnd) };
+        ((rect.right - rect.left) as u16, (rect.bottom - rect.top) as u16)
+    }
+
+    fn on_resize(&mut self, handler: Option<Box<FnMut(&mut UiMember, u16, u16)>>) {
+        self.base.h_resize = handler;
+    }
+
+    fn role<'a>(&'a self) -> UiRole<'a> {
+        UiRole::LinearLayout(self)
+    }
+    fn role_mut<'a>(&'a mut self) -> UiRoleMut<'a> {
+        UiRoleMut::LinearLayout(self)
+    }
+    fn is_control(&self) -> Option<&UiControl> {
+    	Some(self)
+    }
+    fn is_control_mut(&mut self) -> Option<&mut UiControl> {
+    	Some(self)
+    }     
+}
+
+impl UiControl for LinearLayout {
+    fn layout_width(&self) -> layout::Size {
+    	self.base.layout_width()
+    }
+	fn layout_height(&self) -> layout::Size {
+		self.base.layout_height()
+	}
+	fn layout_gravity(&self) -> layout::Gravity {
+		self.base.layout_gravity()
+	}
+	fn layout_orientation(&self) -> layout::Orientation {
+		self.base.layout_orientation()
+	}
+	fn layout_alignment(&self) -> layout::Alignment {
+		self.base.layout_alignment()
+	}
+	
+	fn set_layout_width(&mut self, width: layout::Size) {
+		self.base.set_layout_width(width);
+	}
+	fn set_layout_height(&mut self, height: layout::Size) {
+		self.base.set_layout_height(height);
+	}
+	fn set_layout_gravity(&mut self, gravity: layout::Gravity) {
+		self.base.set_layout_gravity(gravity);
+	}
+	fn set_layout_orientation(&mut self, orientation: layout::Orientation) {
+		self.base.set_layout_orientation(orientation);
+	}
+	fn set_layout_alignment(&mut self, alignment: layout::Alignment) {
+		self.base.set_layout_alignment(alignment);
+	}
+    fn draw(&mut self, coords: Option<(i32, i32)>) {
+    	if coords.is_some() {
+    		self.base.coords = coords;
+    	}
+        if let Some((x, y)) = self.base.coords {
+        	unsafe {
+	            user32::SetWindowPos(self.base.hwnd,
+	                                 ptr::null_mut(),
+	                                 x as i32,
+	                                 y as i32,
+	                                 self.base.measured_size.0 as i32,
+	                                 self.base.measured_size.1 as i32,
+	                                 0);
+	        }
+        	let mut x = 0;
+	        let mut y = 0;
+	        for ref mut child in self.children.as_mut_slice() {
+	            child.draw(Some((x, y)));
+	            let (xx, yy) = child.size();
+	            match self.orientation {
+	                layout::Orientation::Horizontal => x += xx as i32,
+	                layout::Orientation::Vertical => y += yy as i32,
+	            }
+	        }
+        }
+    }
+    fn measure(&mut self, parent_width: u16, parent_height: u16) -> (u16, u16, bool) {
+    	let old_size = self.base.measured_size;
+        self.base.measured_size = match self.visibility() {
+        	Visibility::Gone => (0,0),
+        	_ => {
+        		let mut w = parent_width;
+		        let mut h = parent_height;
+		
+		        if let layout::Size::Exact(ew) = self.base.layout_width() {
+		            w = ew;
+		        }
+		        if let layout::Size::Exact(eh) = self.base.layout_height() {
+		            w = eh;
+		        }
+		        match self.orientation {
+		            layout::Orientation::Vertical => {
+		                if let layout::Size::WrapContent = self.base.layout_height() {
+		                    let mut hh = 0;
+		                    for ref mut child in self.children.as_mut_slice() {
+		                        let (_, ch, _) = child.measure(w, h);
+		                        hh += ch;
+		                    }
+		                    h = hh;
+		                }
+		            }
+		            layout::Orientation::Horizontal => {
+		                if let layout::Size::WrapContent = self.base.layout_width() {
+		                    let mut ww = 0;
+		                    for ref mut child in self.children.as_mut_slice() {
+		                        let (cw, _, _) = child.measure(w, h);
+		                        ww += cw;
+		                    }
+		                    w = ww;
+		                }
+		            }
+		        }
+		        (w, h)
+        	}
+        };
+        (self.base.measured_size.0, self.base.measured_size.1, self.base.measured_size != old_size)
+    }
+    fn is_container_mut(&mut self) -> Option<&mut UiContainer> {
+        Some(self)
+    }
+    fn is_container(&self) -> Option<&UiContainer> {
+        Some(self)
+    }
+
+    fn parent(&self) -> Option<&UiContainer> {
+        self.base.parent()
+    }
+    fn parent_mut(&mut self) -> Option<&mut UiContainer> {
+        self.base.parent_mut()
+    }
+    fn root(&self) -> Option<&UiContainer> {
+        self.base.root()
+    }
+    fn root_mut(&mut self) -> Option<&mut UiContainer> {
+        self.base.root_mut()
+    }
+}
+
+impl UiContainer for LinearLayout {
+    fn set_child(&mut self, child: Option<Box<UiControl>>) -> Option<Box<UiControl>> {
+        let old = self.children.pop();
+        self.children.clear();
+
+        if let Some(child) = child {
+            self.set_child_to(0, child);
+        }
+
+        old
+    }
+    fn child(&self) -> Option<&UiControl> {
+        self.children.get(0).map(|c| c.as_ref())
+    }
+    fn child_mut(&mut self) -> Option<&mut UiControl> {
+        //self.children.get_mut(0).map(|c|c.as_mut()) // WTF??
+        if self.children.len() > 0 {
+            Some(self.children[0].as_mut())
+        } else {
+            None
+        }
+    }
+    fn find_control_by_id_mut(&mut self, id_: Id) -> Option<&mut UiControl> {
+        if self.id() == id_ {
+            return Some(self);
+        }
+        for child in self.children.as_mut_slice() {
+            if child.id() == id_ {
+                return Some(child.as_mut());
+            } else if let Some(c) = child.is_container_mut() {
+                let ret = c.find_control_by_id_mut(id_);
+                if ret.is_none() {
+                    continue;
+                }
+                return ret;
+            }
+        }
+        None
+    }
+    fn find_control_by_id(&self, id_: Id) -> Option<&UiControl> {
+        if self.id() == id_ {
+            return Some(self);
+        }
+        for child in self.children.as_slice() {
+            if child.id() == id_ {
+                return Some(child.as_ref());
+            } else if let Some(c) = child.is_container() {
+                let ret = c.find_control_by_id(id_);
+                if ret.is_none() {
+                    continue;
+                }
+                return ret;
+            }
+        }
+        None
+    }
+    fn is_multi_mut(&mut self) -> Option<&mut UiMultiContainer> {
+        Some(self)
+    }
+    fn is_multi(&self) -> Option<&UiMultiContainer> {
+        Some(self)
+    }
+}
+
+impl UiMultiContainer for LinearLayout {
+    fn len(&self) -> usize {
+        self.children.len()
+    }
+    fn set_child_to(&mut self, index: usize, child: Box<UiControl>) -> Option<Box<UiControl>> {
+        //TODO yes this is ineffective, need a way to swap old item with new
+        self.children.insert(index, child);
+        if (index + 1) >= self.children.len() {
+            return None;
+        }
+        Some(self.children.remove(index + 1))
+    }
+    fn remove_child_from(&mut self, index: usize) -> Option<Box<UiControl>> {
+        if index < self.children.len() {
+            Some(self.children.remove(index))
+        } else {
+            None
+        }
+    }
+    fn child_at(&self, index: usize) -> Option<&Box<UiControl>> {
+        self.children.get(index)
+    }
+    fn child_at_mut(&mut self, index: usize) -> Option<&mut Box<UiControl>> {
+        self.children.get_mut(index)
+    }
+}
+
+impl UiLinearLayout for LinearLayout {
+    fn orientation(&self) -> layout::Orientation {
+        self.orientation
+    }
+    fn set_orientation(&mut self, orientation: layout::Orientation) {
+        self.orientation = orientation;
+    }
+}
+
+unsafe impl WindowsContainer for LinearLayout {
+    unsafe fn hwnd(&self) -> winapi::HWND {
+        self.base.hwnd
+    }
+}
+
+unsafe impl WindowsControl for LinearLayout {
+    unsafe fn on_added_to_container(&mut self, parent: &WindowsContainer, px: u16, py: u16) {
+        let selfptr = self as *mut _ as *mut c_void;
+        let (pw, ph) = parent.size();
+        self.base.hwnd = parent.hwnd(); // required for measure, as we don't have own hwnd yet
+        let (width, height, _) = self.measure(pw, ph);
+        let (hwnd, id) = common::create_control_hwnd(px as i32,
+                                                     py as i32,
+                                                     width as i32,
+                                                     height as i32,
+                                                     parent.hwnd(),
+                                                     winapi::WS_EX_CONTROLPARENT,
+                                                     WINDOW_CLASS.as_ptr(),
+                                                     "",
+                                                     0,
+                                                     selfptr,
+                                                     None);
+        self.base.hwnd = hwnd;
+        self.base.subclass_id = id;
+        self.base.coords = Some((px as i32, py as i32));
+        let mut x = 0;
+        let mut y = 0;
+        for ref mut child in self.children.as_mut_slice() {
+            let mut wc = common::cast_uicontrol_to_windows(child);
+            let self2: &mut LinearLayout = mem::transmute(selfptr);
+            wc.on_added_to_container(self2, x, y);
+            let (xx, yy) = wc.size();
+            match self.orientation {
+                layout::Orientation::Horizontal => x += xx,
+                layout::Orientation::Vertical => y += yy,
+            }
+        }
+    }
+    unsafe fn on_removed_from_container(&mut self, _: &WindowsContainer) {
+        let selfptr = self as *mut _ as *mut c_void;
+        for ref mut child in self.children.as_mut_slice() {
+            let mut wc = common::cast_uicontrol_to_windows(child);
+            let self2: &mut LinearLayout = mem::transmute(selfptr);
+            wc.on_removed_from_container(self2);
+        }
+        destroy_hwnd(self.base.hwnd, self.base.subclass_id, None);
+        self.base.hwnd = 0 as winapi::HWND;
+        self.base.subclass_id = 0;
+    }
+    fn as_base(&self) -> &WindowsControlBase {
+    	&self.base
+    }
+    fn as_base_mut(&mut self) -> &mut WindowsControlBase {
+    	&mut self.base
+    }    
+}
+
+unsafe fn register_window_class() -> Vec<u16> {
+    let class_name = OsStr::new(development::CLASS_ID_LAYOUT_LINEAR)
+        .encode_wide()
+        .chain(Some(0).into_iter())
+        .collect::<Vec<_>>();
+    let class = winapi::WNDCLASSEXW {
+        cbSize: mem::size_of::<winapi::WNDCLASSEXW>() as winapi::UINT,
+        style: winapi::CS_DBLCLKS,
+        lpfnWndProc: Some(whandler),
+        cbClsExtra: 0,
+        cbWndExtra: 0,
+        hInstance: kernel32::GetModuleHandleW(ptr::null()),
+        hIcon: user32::LoadIconW(ptr::null_mut(), winapi::IDI_APPLICATION),
+        hCursor: user32::LoadCursorW(ptr::null_mut(), winapi::IDC_ARROW),
+        hbrBackground: ptr::null_mut(),
+        lpszMenuName: ptr::null(),
+        lpszClassName: class_name.as_ptr(),
+        hIconSm: ptr::null_mut(),
+    };
+    user32::RegisterClassExW(&class);
+    class_name
+}
+
+unsafe extern "system" fn whandler(hwnd: winapi::HWND, msg: winapi::UINT, wparam: winapi::WPARAM, lparam: winapi::LPARAM) -> winapi::LRESULT {
+    let ww = user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA);
+    if ww == 0 {
+        if winapi::WM_CREATE == msg {
+            let cs: &mut winapi::CREATESTRUCTW = mem::transmute(lparam);
+            user32::SetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA, cs.lpCreateParams as i64);
+        }
+        return user32::DefWindowProcW(hwnd, msg, wparam, lparam);
+    }
+
+    match msg {
+        winapi::WM_SIZE => {
+            let mut width = lparam as u16;
+            let mut height = (lparam >> 16) as u16;
+            let mut ll: &mut LinearLayout = mem::transmute(ww);
+            let o = ll.orientation;
+
+            let mut x = 0;
+            let mut y = 0;
+            for ref mut child in ll.children.as_mut_slice() {
+                let (cw, ch, _) = child.measure(width, height);
+                child.draw(Some((x, y))); //TODO padding
+                match o {
+                    layout::Orientation::Horizontal if width >= cw => {
+                        x += cw as i32;
+                        width -= cw;
+                    }
+                    layout::Orientation::Vertical if height >= ch => {
+                        y += ch as i32;
+                        height -= ch;
+                    }
+                    _ => {}
+                }
+            }
+
+            if let Some(ref mut cb) = ll.base.h_resize {
+                let mut ll2: &mut LinearLayout = mem::transmute(ww);
+                (cb)(ll2, width, height);
+            }
+        }
+        winapi::WM_DESTROY => {
+            user32::PostQuitMessage(0);
+            return 0;
+        }
+        /*winapi::WM_NOTIFY => {
+        	let hdr: winapi::LPNMHDR = mem::transmute(lparam);
+        	println!("notify for {:?}", hdr);
+        },
+        winapi::WM_COMMAND => {
+        	let hdr: winapi::LPNMHDR = mem::transmute(lparam);
+        	
+        	println!("command for {:?}", hdr);
+        }*/
+        _ => {}
+    }
+
+    user32::DefWindowProcW(hwnd, msg, wparam, lparam)
+}
+
+impl Drop for LinearLayout {
+    fn drop(&mut self) {
+        self.set_visibility(Visibility::Gone);
+        common::destroy_hwnd(self.base.hwnd, 0, None);
+    }
+}
\ No newline at end of file
diff --git a/src/layout_relative.rs b/src/layout_relative.rs
new file mode 100644
index 0000000..887ef97
--- /dev/null
+++ b/src/layout_relative.rs
@@ -0,0 +1,5 @@
+
+
+pub struct RelativeLayout {
+	
+}
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..561fcee
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,31 @@
+#![cfg(target_os="windows")]
+
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate derive_builder;
+
+extern crate plygui;
+
+extern crate winapi;
+extern crate gdi32;
+extern crate kernel32;
+extern crate user32;
+extern crate comctl32;
+extern crate comdlg32;
+
+pub mod common;
+
+mod application;
+mod window;
+mod button;
+mod layout_linear;
+mod layout_relative;
+
+pub type NativeId = winapi::HWND;
+
+pub use self::application::Application;
+pub use self::window::Window;
+pub use self::button::Button;
+pub use self::layout_linear::LinearLayout;
+pub use self::layout_relative::RelativeLayout;
\ No newline at end of file
diff --git a/src/window.rs b/src/window.rs
new file mode 100644
index 0000000..86aaa2f
--- /dev/null
+++ b/src/window.rs
@@ -0,0 +1,282 @@
+use super::*;
+use super::common::*;
+
+use plygui::{development, Id, UiRole, UiRoleMut, UiWindow, UiControl, UiMember, UiContainer, UiMultiContainer, Visibility};
+
+use std::{ptr, mem, str};
+use std::os::raw::c_void;
+use std::os::windows::ffi::OsStrExt;
+use std::ffi::OsStr;
+
+lazy_static! {
+	pub static ref WINDOW_CLASS: Vec<u16> = unsafe { register_window_class() };
+	//pub static ref INSTANCE: winapi::HINSTANCE = unsafe { kernel32::GetModuleHandleW(ptr::null()) };
+}
+
+#[repr(C)]
+pub struct Window {
+	id: Id,
+    hwnd: winapi::HWND,
+    visibility: Visibility,
+    child: Option<Box<UiControl>>,
+    h_resize: Option<Box<FnMut(&mut UiMember, u16, u16)>>,
+}
+
+impl Window {
+    pub(crate) fn new(
+                      title: &str,
+                      width: u16,
+                      height: u16,
+                      has_menu: bool)
+                      -> Box<Window> {
+        unsafe {
+            let mut rect = winapi::RECT {
+                left: 0,
+                top: 0,
+                right: width as i32,
+                bottom: height as i32,
+            };
+            let style = winapi::WS_OVERLAPPEDWINDOW;
+            let exstyle = winapi::WS_EX_APPWINDOW;
+
+            user32::AdjustWindowRectEx(&mut rect, style, winapi::FALSE, exstyle);
+            let window_name = OsStr::new(title)
+                .encode_wide()
+                .chain(Some(0).into_iter())
+                .collect::<Vec<_>>();
+
+            let mut w = Box::new(Window {
+				            		id: Id::next(),
+                                     hwnd: 0 as winapi::HWND,
+                                     child: None,
+                                     h_resize: None,
+                                     visibility: Visibility::Visible,
+                                 });
+
+            if INSTANCE as usize == 0 {
+                INSTANCE = kernel32::GetModuleHandleW(ptr::null());
+            }
+
+            let hwnd = user32::CreateWindowExW(exstyle,
+                                               WINDOW_CLASS.as_ptr(),
+                                               window_name.as_ptr() as winapi::LPCWSTR,
+                                               style | winapi::WS_VISIBLE,
+                                               winapi::CW_USEDEFAULT,
+                                               winapi::CW_USEDEFAULT,
+                                               rect.right - rect.left,
+                                               rect.bottom - rect.top,
+                                               ptr::null_mut(),
+                                               ptr::null_mut(),
+                                               INSTANCE,
+                                               w.as_mut() as *mut _ as *mut c_void);
+
+            w.hwnd = hwnd;
+            w
+        }
+    }
+    pub(crate) fn start(&mut self) {
+        loop {
+            unsafe {
+                let mut msg: winapi::MSG = mem::zeroed();
+                if user32::GetMessageW(&mut msg, ptr::null_mut(), 0, 0) <= 0 {
+                    break;
+                } else {
+                    user32::TranslateMessage(&mut msg);
+                    user32::DispatchMessageW(&mut msg);
+                }
+            }
+        }
+    }
+}
+
+impl UiWindow for Window {}
+
+impl UiContainer for Window {
+    fn set_child(&mut self, mut child: Option<Box<UiControl>>) -> Option<Box<UiControl>> {
+        unsafe {
+            let mut old = self.child.take();
+            if let Some(old) = old.as_mut() {
+                let mut wc = common::cast_uicontrol_to_windows(old);
+                wc.on_removed_from_container(self);
+            }
+            if let Some(new) = child.as_mut() {
+                let mut wc = common::cast_uicontrol_to_windows(new);
+                wc.on_added_to_container(self, 0, 0); //TODO padding
+
+            }
+            self.child = child;
+
+            old
+        }
+    }
+    fn child(&self) -> Option<&UiControl> {
+        self.child.as_ref().map(|c| c.as_ref())
+    }
+    fn child_mut(&mut self) -> Option<&mut UiControl> {
+        //self.child.as_mut().map(|c|c.as_mut()) // WTF ??
+        if let Some(child) = self.child.as_mut() {
+            Some(child.as_mut())
+        } else {
+            None
+        }
+    }
+    fn find_control_by_id_mut(&mut self, id_: Id) -> Option<&mut UiControl> {
+        /*if self.id() == id_ {
+			return Some(self);
+		} else*/
+        if let Some(child) = self.child.as_mut() {
+            if let Some(c) = child.is_container_mut() {
+                return c.find_control_by_id_mut(id_);
+            }
+        }
+        None
+    }
+    fn find_control_by_id(&self, id_: Id) -> Option<&UiControl> {
+        /*if self.id() == id_ {
+			return Some(self);
+		} else*/
+        if let Some(child) = self.child.as_ref() {
+            if let Some(c) = child.is_container() {
+                return c.find_control_by_id(id_);
+            }
+        }
+        None
+    }
+    fn is_multi_mut(&mut self) -> Option<&mut UiMultiContainer> {
+        None
+    }
+    fn is_multi(&self) -> Option<&UiMultiContainer> {
+        None
+    } 
+}
+
+impl UiMember for Window {
+    fn size(&self) -> (u16, u16) {
+        let rect = unsafe { window_rect(self.hwnd) };
+        ((rect.right - rect.left) as u16, (rect.bottom - rect.top) as u16)
+    }
+
+    fn on_resize(&mut self, handler: Option<Box<FnMut(&mut UiMember, u16, u16)>>) {
+        self.h_resize = handler;
+    }
+
+    fn role<'a>(&'a self) -> UiRole<'a> {
+        UiRole::Window(self)
+    }
+    fn set_visibility(&mut self, visibility: Visibility) {
+        self.visibility = visibility;
+        unsafe {
+            user32::ShowWindow(self.hwnd,
+                               if self.visibility == Visibility::Visible {
+                                   winapi::SW_SHOW
+                               } else {
+                                   winapi::SW_HIDE
+                               });
+        }
+    }
+    fn visibility(&self) -> Visibility {
+        self.visibility
+    }
+    fn role_mut<'a>(&'a mut self) -> UiRoleMut<'a> {
+        UiRoleMut::Window(self)
+    }
+    /*fn native_id(&self) -> NativeId {
+        self.hwnd
+    }*/
+    fn id(&self) -> Id {
+    	self.id
+    }
+    fn is_control(&self) -> Option<&UiControl> {
+    	None
+    }
+    fn is_control_mut(&mut self) -> Option<&mut UiControl> {
+    	None
+    } 
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        self.set_child(None);
+        self.set_visibility(Visibility::Gone);
+        destroy_hwnd(self.hwnd, 0, None);
+    }
+}
+
+unsafe impl WindowsContainer for Window {
+    unsafe fn hwnd(&self) -> winapi::HWND {
+        self.hwnd
+    }
+}
+
+unsafe fn register_window_class() -> Vec<u16> {
+    let class_name = OsStr::new(development::CLASS_ID_WINDOW)
+        .encode_wide()
+        .chain(Some(0).into_iter())
+        .collect::<Vec<_>>();
+
+    let class = winapi::WNDCLASSEXW {
+        cbSize: mem::size_of::<winapi::WNDCLASSEXW>() as winapi::UINT,
+        style: winapi::CS_DBLCLKS,
+        lpfnWndProc: Some(handler),
+        cbClsExtra: 0,
+        cbWndExtra: 0,
+        hInstance: kernel32::GetModuleHandleW(ptr::null()),
+        hIcon: user32::LoadIconW(ptr::null_mut(), winapi::IDI_APPLICATION),
+        hCursor: user32::LoadCursorW(ptr::null_mut(), winapi::IDC_ARROW),
+        hbrBackground: (winapi::COLOR_BTNFACE + 1) as winapi::HBRUSH,
+        lpszMenuName: ptr::null(),
+        lpszClassName: class_name.as_ptr(),
+        hIconSm: ptr::null_mut(),
+    };
+    user32::RegisterClassExW(&class);
+    class_name
+}
+
+unsafe extern "system" fn handler(hwnd: winapi::HWND, msg: winapi::UINT, wparam: winapi::WPARAM, lparam: winapi::LPARAM) -> winapi::LRESULT {
+    let ww = user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA);
+    if ww == 0 {
+        if winapi::WM_CREATE == msg {
+            let cs: &mut winapi::CREATESTRUCTW = mem::transmute(lparam);
+            user32::SetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA, cs.lpCreateParams as i64);
+        }
+        return user32::DefWindowProcW(hwnd, msg, wparam, lparam);
+    }
+
+    match msg {
+        winapi::WM_SIZE => {
+            let width = lparam as u16;
+            let height = (lparam >> 16) as u16;
+            let mut w: &mut window::Window = mem::transmute(ww);
+
+            if let Some(ref mut child) = w.child {
+                child.measure(width, height);
+                child.draw(Some((0, 0))); //TODO padding
+            }
+
+            if let Some(ref mut cb) = w.h_resize {
+                let w2: &mut Window = mem::transmute(user32::GetWindowLongPtrW(hwnd, winapi::GWLP_USERDATA));
+                (cb)(w2, width, height);
+            }
+        }
+        winapi::WM_DESTROY => {
+            user32::PostQuitMessage(0);
+            return 0;
+        },
+        /*winapi::WM_PRINTCLIENT => {
+        	user32::SendMessageW(hwnd, winapi::WM_ERASEBKGND, wparam, lparam);
+	        return 0;
+        },*/
+        /*winapi::WM_NOTIFY => {
+        	let hdr: winapi::LPNMHDR = mem::transmute(lparam);
+        	println!("notify for {:?}", hdr);
+        },
+        winapi::WM_COMMAND => {
+        	let hdr: winapi::LPNMHDR = mem::transmute(lparam);
+        	
+        	println!("command for {:?}", hdr);
+        }*/
+        _ => {}
+    }
+
+    user32::DefWindowProcW(hwnd, msg, wparam, lparam)
+}