Auto merge of #7 - Eijebong:winapi, r=emilio

Bump winapi to 0.3

I had to drop all those `#[derive(Debug)]` because winapi types don't
implement Debug anymore.

Author: bors-servo

Cargo.toml

@@ -12,8 +12,6 @@ name = "dwrote"
 [dependencies]
 libc = "0.2"
 lazy_static = "1"
-winapi = "0.2"
-kernel32-sys = "0.2"
-gdi32-sys = "0.2"
+winapi = { version = "0.3", features = ["dwrite", "winnt", "unknwnbase", "libloaderapi", "winnls"] }
 serde = "1.0"
 serde_derive = "1.0"

src/bitmap_render_target.rs

@@ -7,23 +7,26 @@ use std::cell::UnsafeCell;
 use std::mem::{zeroed, size_of};
 
 use comptr::ComPtr;
-use winapi;
-use gdi32;
+use winapi::um::dwrite::{DWRITE_GLYPH_RUN, DWRITE_GLYPH_OFFSET};
+use winapi::um::dwrite::IDWriteBitmapRenderTarget;
+use winapi::um::dcommon::{DWRITE_MEASURING_MODE};
+use winapi::um::wingdi::{BITMAP, OBJ_BITMAP, RGB, GetObjectW, GetCurrentObject};
+use winapi::shared::windef::{RECT, HDC};
+use winapi::ctypes::c_void;
 use super::{FontFace, RenderingParams};
 
-#[derive(Debug)]
 pub struct BitmapRenderTarget {
-    native: UnsafeCell<ComPtr<winapi::IDWriteBitmapRenderTarget>>,
+    native: UnsafeCell<ComPtr<IDWriteBitmapRenderTarget>>,
 }
 
 impl BitmapRenderTarget {
-    pub fn take(native: ComPtr<winapi::IDWriteBitmapRenderTarget>) -> BitmapRenderTarget {
+    pub fn take(native: ComPtr<IDWriteBitmapRenderTarget>) -> BitmapRenderTarget {
         BitmapRenderTarget {
             native: UnsafeCell::new(native),
         }
     }
 
-    pub unsafe fn as_ptr(&self) -> *mut winapi::IDWriteBitmapRenderTarget {
+    pub unsafe fn as_ptr(&self) -> *mut IDWriteBitmapRenderTarget {
         (*self.native.get()).as_ptr()
     }
 
@@ -34,7 +37,7 @@ impl BitmapRenderTarget {
         }
     }
 
-    pub fn get_memory_dc(&self) -> winapi::HDC {
+    pub fn get_memory_dc(&self) -> HDC {
         unsafe {
             (*self.native.get()).GetMemoryDC()
         }
@@ -43,15 +46,15 @@ impl BitmapRenderTarget {
     pub fn draw_glyph_run(&self,
                           baseline_origin_x: f32,
                           baseline_origin_y: f32,
-                          measuring_mode: winapi::DWRITE_MEASURING_MODE,
+                          measuring_mode: DWRITE_MEASURING_MODE,
                           font_face: &FontFace,
                           em_size: f32,
                           glyph_indices: &[u16],
                           glyph_advances: &[f32],
-                          glyph_offsets: &[winapi::DWRITE_GLYPH_OFFSET],
+                          glyph_offsets: &[DWRITE_GLYPH_OFFSET],
                           rendering_params: &RenderingParams,
                           color: &(f32, f32, f32))
-        -> winapi::RECT
+        -> RECT
     {
         unsafe {
             assert!(glyph_indices.len() == glyph_advances.len());
@@ -61,7 +64,7 @@ impl BitmapRenderTarget {
             let g = (color.1 * 255.0) as u8;
             let b = (color.2 * 255.0) as u8;
 
-            let mut glyph_run: winapi::DWRITE_GLYPH_RUN = zeroed();
+            let mut glyph_run: DWRITE_GLYPH_RUN = zeroed();
             glyph_run.fontFace = font_face.as_ptr();
             glyph_run.fontEmSize = em_size;
             glyph_run.glyphCount = glyph_indices.len() as u32;
@@ -71,13 +74,13 @@ impl BitmapRenderTarget {
             glyph_run.isSideways = 0;
             glyph_run.bidiLevel = 0;
 
-            let mut rect: winapi::RECT = zeroed();
+            let mut rect: RECT = zeroed();
             let hr = (*self.native.get()).DrawGlyphRun(baseline_origin_x,
                                                        baseline_origin_y,
                                                        measuring_mode,
                                                        &glyph_run,
                                                        rendering_params.as_ptr(),
-                                                       winapi::RGB(r,g,b),
+                                                       RGB(r,g,b),
                                                        &mut rect);
             assert!(hr == 0);
             rect
@@ -93,11 +96,11 @@ impl BitmapRenderTarget {
         // Now grossness to pull out the pixels
         unsafe {
             let memory_dc = self.get_memory_dc();
-            let mut bitmap: winapi::BITMAP = zeroed();
-            let ret = gdi32::GetObjectW(gdi32::GetCurrentObject(memory_dc, winapi::OBJ_BITMAP),
-                                        size_of::<winapi::BITMAP>() as i32,
-                                        &mut bitmap as *mut _ as *mut winapi::c_void);
-            assert!(ret == size_of::<winapi::BITMAP>() as i32);
+            let mut bitmap: BITMAP = zeroed();
+            let ret = GetObjectW(GetCurrentObject(memory_dc, OBJ_BITMAP),
+                                 size_of::<BITMAP>() as i32,
+                                 &mut bitmap as *mut _ as *mut c_void);
+            assert!(ret == size_of::<BITMAP>() as i32);
             assert!(bitmap.bmBitsPixel == 32);
 
             let width = bitmap.bmWidth as usize;

src/com_helpers.rs

@@ -26,7 +26,7 @@ macro_rules! implement_iunknown {
                     } else if guid_equals!(*riid, UuidOfIUnknown) {
                         mem::transmute(This)
                     } else {
-                        return $crate::winapi::E_NOINTERFACE;
+                        return $crate::winapi::shared::winerror::E_NOINTERFACE;
                     };
 
                     (*This).AddRef();
@@ -67,7 +67,7 @@ macro_rules! implement_iunknown {
                     } else if guid_equals!(*riid, UuidOfIUnknown) {
                         mem::transmute(This)
                     } else {
-                        return $crate::winapi::E_NOINTERFACE;
+                        return $crate::winapi::shared::winerror::E_NOINTERFACE;
                     };
 
                     (*This).AddRef();

src/comptr.rs

@@ -4,7 +4,9 @@
 
 use std::ops::{Deref, DerefMut};
 use std::ptr;
-use winapi::{IUnknown, REFIID, S_OK, E_NOINTERFACE};
+use winapi::um::unknwnbase::IUnknown;
+use winapi::shared::guiddef::REFIID;
+use winapi::shared::winerror::{S_OK, E_NOINTERFACE};
 
 #[derive(Debug)]
 pub struct ComPtr<T> {

src/font.rs

@@ -5,25 +5,25 @@
 use std::cell::UnsafeCell;
 
 use comptr::ComPtr;
-use winapi;
+use winapi::um::dwrite::{IDWriteFontFace, IDWriteLocalizedStrings, IDWriteFont};
+use winapi::um::dwrite::IDWriteFontFamily;
 use std::mem;
 
 use super::*;
 use helpers::*;
 
-#[derive(Debug)]
 pub struct Font {
-    native: UnsafeCell<ComPtr<winapi::IDWriteFont>>,
+    native: UnsafeCell<ComPtr<IDWriteFont>>,
 }
 
 impl Font {
-    pub fn take(native: ComPtr<winapi::IDWriteFont>) -> Font {
+    pub fn take(native: ComPtr<IDWriteFont>) -> Font {
         Font {
             native: UnsafeCell::new(native),
         }
     }
 
-    pub unsafe fn as_ptr(&self) -> *mut winapi::IDWriteFont {
+    pub unsafe fn as_ptr(&self) -> *mut IDWriteFont {
         (*self.native.get()).as_ptr()
     }
 
@@ -38,25 +38,25 @@ impl Font {
 
     pub fn stretch(&self) -> FontStretch {
         unsafe {
-            mem::transmute::<u32, FontStretch>((*self.native.get()).GetStretch().0)
+            mem::transmute::<u32, FontStretch>((*self.native.get()).GetStretch())
         }
     }
 
     pub fn style(&self) -> FontStyle {
         unsafe {
-            mem::transmute::<u32, FontStyle>((*self.native.get()).GetStyle().0)
+            mem::transmute::<u32, FontStyle>((*self.native.get()).GetStyle())
         }
     }
 
     pub fn weight(&self) -> FontWeight {
         unsafe {
-            mem::transmute::<u32, FontWeight>((*self.native.get()).GetWeight().0)
+            mem::transmute::<u32, FontWeight>((*self.native.get()).GetWeight())
         }
     }
 
     pub fn family_name(&self) -> String {
         unsafe {
-            let mut family: ComPtr<winapi::IDWriteFontFamily> = ComPtr::new();
+            let mut family: ComPtr<IDWriteFontFamily> = ComPtr::new();
             let hr = (*self.native.get()).GetFontFamily(family.getter_addrefs());
             assert!(hr == 0);
 
@@ -66,7 +66,7 @@ impl Font {
 
     pub fn face_name(&self) -> String {
         unsafe {
-            let mut names: ComPtr<winapi::IDWriteLocalizedStrings> = ComPtr::new();
+            let mut names: ComPtr<IDWriteLocalizedStrings> = ComPtr::new();
             let hr = (*self.native.get()).GetFaceNames(names.getter_addrefs());
             assert!(hr == 0);
 
@@ -78,7 +78,7 @@ impl Font {
         // FIXME create_font_face should cache the FontFace and return it,
         // there's a 1:1 relationship
         unsafe {
-            let mut face: ComPtr<winapi::IDWriteFontFace> = ComPtr::new();
+            let mut face: ComPtr<IDWriteFontFace> = ComPtr::new();
             let hr = (*self.native.get()).CreateFontFace(face.getter_addrefs());
             assert!(hr == 0);
             FontFace::take(face)

src/font_collection.rs

@@ -3,16 +3,15 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use comptr::ComPtr;
-use winapi;
-use winapi::FALSE;
+use winapi::um::dwrite::{IDWriteFontFamily, IDWriteFont, IDWriteFontCollection};
+use winapi::shared::minwindef::{BOOL, FALSE};
 use std::cell::UnsafeCell;
 
 use super::{DWriteFactory, FontFamily, Font, FontFace, FontDescriptor};
 use helpers::*;
 
-#[derive(Debug)]
 pub struct FontCollectionFamilyIterator {
-    collection: ComPtr<winapi::IDWriteFontCollection>,
+    collection: ComPtr<IDWriteFontCollection>,
     curr: u32,
     count: u32,
 }
@@ -25,7 +24,7 @@ impl Iterator for FontCollectionFamilyIterator {
         }
 
         unsafe {
-            let mut family: ComPtr<winapi::IDWriteFontFamily> = ComPtr::new();
+            let mut family: ComPtr<IDWriteFontFamily> = ComPtr::new();
             let hr = self.collection.GetFontFamily(self.curr, family.getter_addrefs());
             assert!(hr == 0);
             self.curr += 1;
@@ -35,13 +34,13 @@ impl Iterator for FontCollectionFamilyIterator {
 }
 
 pub struct FontCollection {
-    native: UnsafeCell<ComPtr<winapi::IDWriteFontCollection>>,
+    native: UnsafeCell<ComPtr<IDWriteFontCollection>>,
 }
 
 impl FontCollection {
     pub fn system() -> FontCollection {
         unsafe {
-            let mut native: ComPtr<winapi::IDWriteFontCollection> = ComPtr::new();
+            let mut native: ComPtr<IDWriteFontCollection> = ComPtr::new();
             let hr = (*DWriteFactory()).GetSystemFontCollection(native.getter_addrefs(), FALSE);
             assert!(hr == 0);
 
@@ -51,17 +50,16 @@ impl FontCollection {
         }
     }
 
-    pub fn take(native: ComPtr<winapi::IDWriteFontCollection>) -> FontCollection {
+    pub fn take(native: ComPtr<IDWriteFontCollection>) -> FontCollection {
         FontCollection {
             native: UnsafeCell::new(native)
         }
     }
 
-    pub unsafe fn as_ptr(&self) -> *mut winapi::IDWriteFontCollection {
+    pub unsafe fn as_ptr(&self) -> *mut IDWriteFontCollection {
         (*self.native.get()).as_ptr()
     }
 
-    
     pub fn families_iter(&self) -> FontCollectionFamilyIterator {
         unsafe {
             FontCollectionFamilyIterator {
@@ -80,7 +78,7 @@ impl FontCollection {
 
     pub fn get_font_family(&self, index: u32) -> FontFamily {
         unsafe {
-            let mut family: ComPtr<winapi::IDWriteFontFamily> = ComPtr::new();
+            let mut family: ComPtr<IDWriteFontFamily> = ComPtr::new();
             let hr = (*self.native.get()).GetFontFamily(index, family.getter_addrefs());
             assert!(hr == 0);
             FontFamily::take(family)
@@ -106,7 +104,7 @@ impl FontCollection {
 
     pub fn get_font_from_face(&self, face: &FontFace) -> Option<Font> {
         unsafe {
-            let mut font: ComPtr<winapi::IDWriteFont> = ComPtr::new();
+            let mut font: ComPtr<IDWriteFont> = ComPtr::new();
             let hr = (*self.native.get()).GetFontFromFontFace(face.as_ptr(), font.getter_addrefs());
             if hr != 0 {
                 return None;
@@ -118,14 +116,14 @@ impl FontCollection {
     pub fn get_font_family_by_name(&self, family_name: &str) -> Option<FontFamily> {
         unsafe {
             let mut index: u32 = 0;
-            let mut exists: winapi::BOOL = winapi::FALSE;
+            let mut exists: BOOL = FALSE;
             let hr = (*self.native.get()).FindFamilyName(family_name.to_wide_null().as_ptr(), &mut index, &mut exists);
             assert!(hr == 0);
-            if exists == winapi::FALSE {
+            if exists == FALSE {
                 return None;
             }
 
-            let mut family: ComPtr<winapi::IDWriteFontFamily> = ComPtr::new();
+            let mut family: ComPtr<IDWriteFontFamily> = ComPtr::new();
             let hr = (*self.native.get()).GetFontFamily(index, family.getter_addrefs());
             assert!(hr == 0);