Add window-relative positioning strategy support

Introduces native_positioning_strategy_relative_to_window to bindings and updates PositioningStrategy to use this function when a window is provided. This enables positioning strategies that are relative to a window's bounds, improving flexibility for menu and UI placement.

Author: lijy91

packages/cnativeapi/lib/src/bindings_generated.dart

@@ -1540,6 +1540,46 @@ class CNativeApiBindings {
             )
           >();
 
+  /// Create a positioning strategy for positioning relative to a window
+  /// @param window Window to position relative to
+  /// @param offset Offset point to apply to the position, or NULL for no offset
+  /// @return Positioning strategy handle, or NULL if window is invalid
+  ///
+  /// This function obtains the window's bounds using native_window_get_bounds()
+  /// and creates a Relative positioning strategy based on those bounds.
+  ///
+  /// @example
+  /// ```c
+  /// native_window_t window = native_window_manager_create(&options);
+  /// native_point_t offset = {0, 10};
+  /// native_positioning_strategy_t strategy = native_positioning_strategy_relative_to_window(window,
+  /// &offset); native_menu_open(menu, strategy); native_positioning_strategy_free(strategy);
+  /// ```
+  native_positioning_strategy_t native_positioning_strategy_relative_to_window(
+    native_window_t window,
+    ffi.Pointer<native_point_t> offset,
+  ) {
+    return _native_positioning_strategy_relative_to_window(window, offset);
+  }
+
+  late final _native_positioning_strategy_relative_to_windowPtr =
+      _lookup<
+        ffi.NativeFunction<
+          native_positioning_strategy_t Function(
+            native_window_t,
+            ffi.Pointer<native_point_t>,
+          )
+        >
+      >('native_positioning_strategy_relative_to_window');
+  late final _native_positioning_strategy_relative_to_window =
+      _native_positioning_strategy_relative_to_windowPtr
+          .asFunction<
+            native_positioning_strategy_t Function(
+              native_window_t,
+              ffi.Pointer<native_point_t>,
+            )
+          >();
+
   /// Free a positioning strategy handle
   /// @param strategy The positioning strategy to free
   void native_positioning_strategy_free(

packages/nativeapi/lib/src/positioning_strategy.dart

@@ -152,7 +152,7 @@ class PositioningStrategy with CNativeApiBindingsMixin {
   /// window's current bounds (obtained dynamically).
   Rect? get relativeRectangle {
     if (_relativeWindow != null) {
-      return _relativeWindow!.bounds;
+      return _relativeWindow.bounds;
     }
     return _relativeRectangle;
   }
@@ -195,7 +195,30 @@ class PositioningStrategy with CNativeApiBindingsMixin {
         return bindings.native_positioning_strategy_cursor_position();
 
       case PositioningStrategyType.relative:
-        final rect = relativeRectangle; // This will get window bounds if needed
+        // If this strategy was created with a Window, use the window-specific native function
+        if (_relativeWindow != null) {
+          final offset = _relativeOffset;
+          final offsetPtr = offset != null
+              ? (ffi.calloc<native_point_t>()
+                  ..ref.x = offset.dx
+                  ..ref.y = offset.dy)
+              : nullptr;
+
+          final strategy = bindings
+              .native_positioning_strategy_relative_to_window(
+                _relativeWindow.nativeHandle,
+                offsetPtr.cast<native_point_t>(),
+              );
+
+          if (offsetPtr != nullptr) {
+            ffi.calloc.free(offsetPtr);
+          }
+
+          return strategy;
+        }
+
+        // Otherwise, use the rectangle-based positioning
+        final rect = relativeRectangle;
         if (rect == null) {
           throw StateError(
             'Relative rectangle is required for relative strategy',