Migrate to windows-rs 0.37

Author: str4d

Cargo.lock

@@ -19,11 +19,10 @@ libc = "0.2.112"
 paste = "1.0"
 
 [dependencies.windows]
-version = "0.27.0"
+version = "0.37.0"
 features = [
     "alloc",
-    "build",
-    "std",
+    "implement",
     "Win32_Foundation",
     "Win32_Graphics_Gdi",
     "Win32_System_Com",

platforms/windows/Cargo.toml

@@ -21,20 +21,12 @@ use windows::{
 lazy_static! {
     static ref WIN32_INSTANCE: HINSTANCE = {
         let instance = unsafe { GetModuleHandleW(None) };
-        if instance.0 == 0 {
-            let result: Result<()> = Err(Error::from_win32());
-            result.unwrap();
-        }
-        instance
+        instance.unwrap()
     };
 
     static ref DEFAULT_CURSOR: HCURSOR = {
         let cursor = unsafe { LoadCursorW(None, IDC_ARROW) };
-        if cursor.0 == 0 {
-            let result: Result<()> = Err(Error::from_win32());
-            result.unwrap();
-        }
-        cursor
+        cursor.unwrap()
     };
 
     static ref WINDOW_CLASS_ATOM: u16 = {
@@ -48,7 +40,7 @@ lazy_static! {
         let wc = WNDCLASSW {
             hCursor: *DEFAULT_CURSOR,
             hInstance: *WIN32_INSTANCE,
-            lpszClassName: PWSTR(class_name_wsz.as_ptr() as _),
+            lpszClassName: PCWSTR(class_name_wsz.as_ptr() as _),
             style: CS_HREDRAW | CS_VREDRAW,
             lpfnWndProc: Some(wndproc),
             ..Default::default()
@@ -334,7 +326,7 @@ fn create_window(title: &str, initial_state: TreeUpdate, initial_focus: NodeId)
     let window = unsafe {
         CreateWindowExW(
             Default::default(),
-            PWSTR(*WINDOW_CLASS_ATOM as usize as _),
+            PCWSTR(*WINDOW_CLASS_ATOM as usize as _),
             title,
             WS_OVERLAPPEDWINDOW,
             CW_USEDEFAULT,

platforms/windows/examples/hello_world.rs

@@ -539,9 +539,16 @@ impl PlatformNode {
     {
         self.node
             .map(|node| f(ResolvedPlatformNode::new(node, self.hwnd)))
-            .unwrap_or_else(|| Err(Error::new(HRESULT(UIA_E_ELEMENTNOTAVAILABLE), "".into())))
+            .unwrap_or_else(|| {
+                Err(Error::new(
+                    HRESULT(UIA_E_ELEMENTNOTAVAILABLE as i32),
+                    "".into(),
+                ))
+            })
     }
+}
 
+impl IRawElementProviderSimple_Impl for PlatformNode {
     fn ProviderOptions(&self) -> Result<ProviderOptions> {
         // We don't currently have to resolve the node to implement this.
         // But we might have to in the future. So to avoid leaking
@@ -552,7 +559,7 @@ impl PlatformNode {
         self.resolve(|resolved| Ok(resolved.provider_options()))
     }
 
-    fn GetPatternProvider(&mut self, pattern_id: i32) -> Result<IUnknown> {
+    fn GetPatternProvider(&self, pattern_id: i32) -> Result<IUnknown> {
         let provider = self.resolve(|resolved| Ok(resolved.pattern_provider(pattern_id)))?;
         provider.map_or_else(|| Err(Error::OK), Ok)
     }
@@ -567,7 +574,9 @@ impl PlatformNode {
     fn HostRawElementProvider(&self) -> Result<IRawElementProviderSimple> {
         self.resolve(|resolved| resolved.host_provider())
     }
+}
 
+impl IRawElementProviderFragment_Impl for PlatformNode {
     fn Navigate(&self, direction: NavigateDirection) -> Result<IRawElementProviderFragment> {
         self.resolve(|resolved| match resolved.navigate(direction) {
             Some(result) => Ok(result.downgrade().into()),
@@ -598,14 +607,14 @@ impl PlatformNode {
         })
     }
 
-    fn FragmentRoot(&mut self) -> Result<IRawElementProviderFragmentRoot> {
+    fn FragmentRoot(&self) -> Result<IRawElementProviderFragmentRoot> {
         enum FragmentRootResult {
-            This,
+            This(PlatformNode),
             Other(PlatformNode),
         }
         let result = self.resolve(|resolved| {
             if resolved.node.is_root() {
-                Ok(FragmentRootResult::This)
+                Ok(FragmentRootResult::This(resolved.downgrade()))
             } else {
                 let root = resolved.node.tree_reader.root();
                 Ok(FragmentRootResult::Other(
@@ -614,11 +623,13 @@ impl PlatformNode {
             }
         })?;
         match result {
-            FragmentRootResult::This => Ok(self.into()),
+            FragmentRootResult::This(node) => Ok(node.into()),
             FragmentRootResult::Other(node) => Ok(node.into()),
         }
     }
+}
 
+impl IRawElementProviderFragmentRoot_Impl for PlatformNode {
     fn ElementProviderFromPoint(&self, x: f64, y: f64) -> Result<IRawElementProviderFragment> {
         self.resolve(|resolved| {
             let point = Point::new(x, y);
@@ -707,12 +718,6 @@ macro_rules! patterns {
                 })*
             }
         }
-        $(#[allow(non_snake_case)]
-        impl paste! { [< $base_pattern_id Provider>] } {
-            $(fn $base_property_id(&self) -> Result<$com_type> {
-                self.0.resolve(|resolved| Ok(resolved.$getter().into()))
-            })*
-        })*
     };
 }
 
@@ -764,17 +769,22 @@ patterns! {
 }
 
 #[allow(non_snake_case)]
-impl ToggleProvider {
+impl IToggleProvider_Impl for ToggleProvider {
     fn Toggle(&self) -> Result<()> {
         self.0.resolve(|resolved| {
             resolved.toggle();
             Ok(())
         })
     }
+
+    fn ToggleState(&self) -> Result<ToggleState> {
+        self.0
+            .resolve(|resolved| Ok(resolved.toggle_state().into()))
+    }
 }
 
 #[allow(non_snake_case)]
-impl InvokeProvider {
+impl IInvokeProvider_Impl for InvokeProvider {
     fn Invoke(&self) -> Result<()> {
         self.0.resolve(|resolved| {
             resolved.invoke();
@@ -784,8 +794,8 @@ impl InvokeProvider {
 }
 
 #[allow(non_snake_case)]
-impl ValueProvider {
-    fn SetValue(&self, value: PWSTR) -> Result<()> {
+impl IValueProvider_Impl for ValueProvider {
+    fn SetValue(&self, value: &PCWSTR) -> Result<()> {
         self.0.resolve(|resolved| {
             // Based on BSTR::as_wide in windows-rs
             let value_as_wide = if value.0.is_null() {
@@ -799,20 +809,59 @@ impl ValueProvider {
             Ok(())
         })
     }
+
+    fn Value(&self) -> Result<BSTR> {
+        self.0.resolve(|resolved| Ok(resolved.value().into()))
+    }
+
+    fn IsReadOnly(&self) -> Result<BOOL> {
+        self.0
+            .resolve(|resolved| Ok(resolved.is_read_only().into()))
+    }
 }
 
 #[allow(non_snake_case)]
-impl RangeValueProvider {
+impl IRangeValueProvider_Impl for RangeValueProvider {
     fn SetValue(&self, value: f64) -> Result<()> {
         self.0.resolve(|resolved| {
             resolved.set_numeric_value(value);
             Ok(())
         })
     }
+
+    fn Value(&self) -> Result<f64> {
+        self.0
+            .resolve(|resolved| Ok(resolved.numeric_value().into()))
+    }
+
+    fn IsReadOnly(&self) -> Result<BOOL> {
+        self.0
+            .resolve(|resolved| Ok(resolved.is_read_only().into()))
+    }
+
+    fn Maximum(&self) -> Result<f64> {
+        self.0
+            .resolve(|resolved| Ok(resolved.max_numeric_value().into()))
+    }
+
+    fn Minimum(&self) -> Result<f64> {
+        self.0
+            .resolve(|resolved| Ok(resolved.min_numeric_value().into()))
+    }
+
+    fn LargeChange(&self) -> Result<f64> {
+        self.0
+            .resolve(|resolved| Ok(resolved.numeric_value_jump().into()))
+    }
+
+    fn SmallChange(&self) -> Result<f64> {
+        self.0
+            .resolve(|resolved| Ok(resolved.numeric_value_step().into()))
+    }
 }
 
 #[allow(non_snake_case)]
-impl SelectionItemProvider {
+impl ISelectionItemProvider_Impl for SelectionItemProvider {
     fn Select(&self) -> Result<()> {
         self.0.resolve(|resolved| {
             resolved.select();
@@ -834,6 +883,10 @@ impl SelectionItemProvider {
         })
     }
 
+    fn IsSelected(&self) -> Result<BOOL> {
+        self.0.resolve(|resolved| Ok(resolved.is_selected().into()))
+    }
+
     fn SelectionContainer(&self) -> Result<IRawElementProviderSimple> {
         self.0.resolve(|_resolved| {
             // TODO: implement when we work on list boxes (#23)