[NUI] Add SystemInterceptKeyEvent for framework-level key event interception

Add SystemInterceptKeyEvent to provide system-level key event interception
with higher priority than user-level InterceptKeyEvent.

Features:
- System-level event that executes before InterceptKeyEvent
- Highest priority for intercepting key events in the framework
- When consumed, prevents event dispatch to both InterceptKeyEvent and child views
- Supports multiple handlers with OR'd return values
- Marked as internal for framework use only

Author: JoogabYun

src/Tizen.NUI/src/public/Window/WindowEvent.cs

@@ -713,6 +713,7 @@ public bool DispatchHoverMotion
         private ReturnTypeEventHandler<object, WheelEventArgs, bool> interceptWheelHandler;
         private event EventHandler<KeyEventArgs> stageKeyHandler;
         private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
+        private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageSystemInterceptKeyHandler;
         private event EventHandler stageEventProcessingFinishedEventHandler;
         private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
@@ -826,6 +827,37 @@ internal event EventHandler SceneCreated
             }
         }
 
+        /// <summary>
+        /// System-level key event interception that occurs before the user-level InterceptKeyEvent.<br />
+        /// This event is intended for internal framework use and provides the highest priority for intercepting key events.<br />
+        /// When this event returns true (consumed), it prevents the key event from being dispatched to both InterceptKeyEvent and child views.<br />
+        /// Multiple handlers can be registered, and their return values are OR'd together.<br />
+        /// This event is marked as internal and should not be used by application code.
+        /// </summary>
+        internal event ReturnTypeEventHandler<object, KeyEventArgs, bool> SystemInterceptKeyEvent
+        {
+            add
+            {
+                if (stageInterceptKeyHandler == null)
+                {
+                    CreateSafeCallback(OnStageInterceptKey, out stageInterceptKeyCallbackDelegate);
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
+                }
+                stageSystemInterceptKeyHandler += value;
+            }
+            remove
+            {
+                stageSystemInterceptKeyHandler -= value;
+                if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
+                {
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
+                    ReleaseSafeCallback(ref stageInterceptKeyCallbackDelegate);
+                }
+            }
+        }
+
         internal System.IntPtr GetNativeWindowHandler()
         {
             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
@@ -1177,6 +1209,26 @@ private bool OnStageInterceptKey(IntPtr data)
                 return false;
             }
 
+            bool systemConsumed = false;
+            if (stageSystemInterceptKeyHandler != null)
+            {
+                KeyEventArgs e = new KeyEventArgs();
+                e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
+
+                Delegate[] delegateList = stageSystemInterceptKeyHandler.GetInvocationList();
+                // Oring the result of each callback.
+                foreach (ReturnTypeEventHandler<object, KeyEventArgs, bool> del in delegateList)
+                {
+                    systemConsumed |= del(this, e);
+                }
+            }
+
+            // If SystemInterceptKeyEvent consumes, it also blocks interceptKeyEvent.
+            if (systemConsumed)
+            {
+                return true;
+            }
+
             bool consumed = false;
             if (stageInterceptKeyHandler != null)
             {