Implement inner methods in outer struct for NodePath

Add desktop.ini to gitignore (for icons).

Author: sylbeth

.gitignore

@@ -26,3 +26,6 @@ exp.rs
 
 # Mac specific
 .DS_Store
+
+# Windows specific
+desktop.ini

godot-codegen/src/special_cases/special_cases.rs

@@ -395,6 +395,11 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("StringName", "to_wchar_buffer")
 
         // NodePath
+        | ("NodePath", "is_absolute")
+        | ("NodePath", "is_empty")
+        | ("NodePath", "get_concatenated_names")
+        | ("NodePath", "get_concatenated_subnames")
+        //| ("NodePath", "get_as_property_path")
 
         // Callable
         | ("Callable", "call")

godot-core/src/builtin/string/node_path.rs

@@ -5,7 +5,13 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::fmt;
+use std::{
+    fmt,
+    ops::{
+        Bound::{Excluded, Included, Unbounded},
+        RangeBounds,
+    },
+};
 
 use godot_ffi as sys;
 use godot_ffi::{ffi_methods, GodotFfi};
@@ -41,8 +47,33 @@ impl NodePath {
         Self { opaque }
     }
 
-    pub fn is_empty(&self) -> bool {
-        self.as_inner().is_empty()
+    /// Returns the number of node names in the path. Property subnames are not included.
+    pub fn get_name_count(&self) -> u32 {
+        self.as_inner()
+            .get_name_count()
+            .try_into()
+            .expect("Godot name counts are non negative int")
+    }
+
+    /// Returns the node name indicated by `idx`, starting from 0. If `idx` is out of bounds, [`None`] is returned.
+    /// See also [`NodePath::get_subname_count`] and [`NodePath::get_name_count`].
+    pub fn get_name(&self, idx: u32) -> Option<StringName> {
+        let inner = self.as_inner();
+        let idx = idx as i64;
+        // This check checks both data being empty (get_name_count returns 0) and index out of bounds.
+        if idx >= inner.get_name_count() {
+            None
+        } else {
+            Some(inner.get_name(idx))
+        }
+    }
+
+    /// Returns the number of property names ("subnames") in the path. Each subname in the node path is listed after a colon character (`:`).
+    pub fn get_subname_count(&self) -> u32 {
+        self.as_inner()
+            .get_subname_count()
+            .try_into()
+            .expect("Godot subname counts are non negative int")
     }
 
     /// Returns a 32-bit integer hash value representing the string.
@@ -53,6 +84,50 @@ impl NodePath {
             .expect("Godot hashes are uint32_t")
     }
 
+    /// Returns the property name indicated by `idx`, starting from 0. If `idx` is out of bounds, [`None`] is returned.
+    /// See also [`NodePath::get_subname_count`].
+    pub fn get_subname(&self, idx: u32) -> Option<StringName> {
+        let inner = self.as_inner();
+        let idx = idx as i64;
+        // This check checks both data being empty (get_subname_count returns 0) and index out of bounds.
+        if idx >= inner.get_subname_count() {
+            None
+        } else {
+            Some(inner.get_subname(idx))
+        }
+    }
+
+    /// Returns the slice of the [`NodePath`] as a new [`NodePath`]
+    pub fn slice(&self, range: impl RangeBounds<i64>) -> NodePath {
+        self.as_inner().slice(
+            match range.start_bound() {
+                Excluded(&start) => {
+                    if start == -1 {
+                        // Default end from godot, since the start is excluded.
+                        i32::MAX as i64
+                    } else {
+                        start + 1
+                    }
+                }
+                Included(&start) => start,
+                Unbounded => 0,
+            },
+            match range.end_bound() {
+                Excluded(&end) => end,
+                Included(&end) => {
+                    if end == -1 {
+                        // Default end from godot, since the end is excluded.
+                        i32::MAX as i64
+                    } else {
+                        end + 1
+                    }
+                }
+                // Default end from godot.
+                Unbounded => i32::MAX as i64,
+            },
+        )
+    }
+
     crate::meta::declare_arg_method! {
         /// Use as argument for an [`impl AsArg<GString|StringName>`][crate::meta::AsArg] parameter.
         ///