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

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21 using Tizen.NUI.BaseComponents;
  22 using System.Collections.Generic;
  23
  24 namespace Tizen.NUI
  25 {
  26     /// <summary>
  27     /// The window class is used internally for drawing.<br />
  28     /// The window has an orientation and indicator properties.<br />
  29     /// </summary>
  30     /// <since_tizen> 3 </since_tizen>
  31     public partial class Window
  32     {
  33         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback;
  34         private RootLayerTouchDataCallbackType rootLayerTouchDataCallback;
  35         private WheelEventCallbackType wheelEventCallback;
  36         private EventCallbackDelegateType1 stageKeyCallbackDelegate;
  37         private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
  38         private EventHandler stageContextLostEventHandler;
  39         private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
  40         private EventHandler stageContextRegainedEventHandler;
  41         private EventCallbackDelegateType0 stageContextRegainedEventCallbackDelegate;
  42         private EventHandler stageSceneCreatedEventHandler;
  43         private EventCallbackDelegateType0 stageSceneCreatedEventCallbackDelegate;
  44         private WindowResizeEventCallbackType windowResizeEventCallback;
  45         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback2;
  46         private TransitionEffectEventCallbackType transitionEffectEventCallback;
  47         private WindowTransitionEffectSignal transitionEffectSignal;
  48         private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
  49         private KeyboardRepeatSettingsChangedSignal keyboardRepeatSettingsChangedSignal;
  50         private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
  51
  52         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  53         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
  54         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  55         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  58         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  59         private delegate void WindowResizeEventCallbackType(IntPtr window, IntPtr windowSize);
  60         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  61         private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
  62         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  63         private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
  64         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  65         private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
  66         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  67         private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
  68
  69         /// <summary>
  70         /// FocusChanged event.
  71         /// </summary>
  72         /// <since_tizen> 3 </since_tizen>
  73         public event EventHandler<FocusChangedEventArgs> FocusChanged
  74         {
  75             add
  76             {
  77                 if (windowFocusChangedEventHandler == null)
  78                 {
  79                     windowFocusChangedEventCallback = OnWindowFocusedChanged;
  80                     using WindowFocusSignalType windowFocusChangedSignal = WindowFocusChangedSignal();
  81                     windowFocusChangedSignal?.Connect(windowFocusChangedEventCallback);
  82                 }
  83
  84                 windowFocusChangedEventHandler += value;
  85             }
  86             remove
  87             {
  88                 windowFocusChangedEventHandler -= value;
  89
  90                 using WindowFocusSignalType windowFocusChangedSignal = WindowFocusChangedSignal();
  91                 if (windowFocusChangedEventHandler == null && windowFocusChangedSignal?.Empty() == false && windowFocusChangedEventCallback != null)
  92                 {
  93                     windowFocusChangedSignal?.Disconnect(windowFocusChangedEventCallback);
  94                     if(windowFocusChangedSignal?.Empty() == true)
  95                     {
  96                         windowFocusChangedEventCallback = null;
  97                     }
  98                 }
  99             }
 100         }
 101
 102         /// <summary>
 103         /// Emits the event when the screen is touched and when the touch ends.<br />
 104         /// If there are multiple touch points then it is emitted when the first touch occurs and
 105         /// when the last finger is lifted too.<br />
 106         /// Even though incoming events are interrupted, the event occurs.<br />
 107         /// </summary>
 108         /// <since_tizen> 3 </since_tizen>
 109         public event EventHandler<TouchEventArgs> TouchEvent
 110         {
 111             add
 112             {
 113                 if (rootLayerTouchDataEventHandler == null)
 114                 {
 115                     rootLayerTouchDataCallback = OnWindowTouch;
 116                     using TouchDataSignal touchDataSignal = this.TouchDataSignal();
 117                     touchDataSignal?.Connect(rootLayerTouchDataCallback);
 118                 }
 119                 rootLayerTouchDataEventHandler += value;
 120             }
 121             remove
 122             {
 123                 rootLayerTouchDataEventHandler -= value;
 124                 using TouchDataSignal touchDataSignal = this.TouchDataSignal();
 125                 if (rootLayerTouchDataEventHandler == null && touchDataSignal?.Empty() == false && rootLayerTouchDataCallback != null)
 126                 {
 127                     touchDataSignal?.Disconnect(rootLayerTouchDataCallback);
 128                     if(touchDataSignal?.Empty() == true)
 129                     {
 130                         rootLayerTouchDataCallback = null;
 131                     }
 132                 }
 133             }
 134         }
 135
 136         /// <summary>
 137         /// Emits the event when the wheel event is received.
 138         /// </summary>
 139         /// <since_tizen> 3 </since_tizen>
 140         public event EventHandler<WheelEventArgs> WheelEvent
 141         {
 142             add
 143             {
 144                 if (stageWheelHandler == null)
 145                 {
 146                     wheelEventCallback = OnStageWheel;
 147                     using WheelSignal wheelSignal = WheelEventSignal();
 148                     wheelSignal?.Connect(wheelEventCallback);
 149                 }
 150                 stageWheelHandler += value;
 151
 152                 if (DetentEventHandler == null)
 153                 {
 154                     DetentEventCallback = OnDetentEvent;
 155                     using StageWheelSignal stageWheelSignal = StageWheelEventSignal();
 156                     stageWheelSignal?.Connect(DetentEventCallback);
 157                 }
 158                 DetentEventHandler += value;
 159             }
 160             remove
 161             {
 162                 stageWheelHandler -= value;
 163                 using WheelSignal wheelSignal = WheelEventSignal();
 164                 if (stageWheelHandler == null && wheelSignal?.Empty() == false)
 165                 {
 166                     wheelSignal?.Disconnect(wheelEventCallback);
 167                     if(wheelSignal?.Empty() == true)
 168                     {
 169                         wheelEventCallback = null;
 170                     }
 171                 }
 172
 173                 DetentEventHandler -= value;
 174                 using StageWheelSignal stageWheelSignal = StageWheelEventSignal();
 175                 if (DetentEventHandler == null && stageWheelSignal?.Empty() == false)
 176                 {
 177                     stageWheelSignal?.Disconnect(DetentEventCallback);
 178                     if(stageWheelSignal?.Empty() == true)
 179                     {
 180                         DetentEventCallback = null;
 181                     }
 182                 }
 183             }
 184         }
 185
 186         /// <summary>
 187         /// Emits the event when the key event is received.
 188         /// </summary>
 189         /// <since_tizen> 3 </since_tizen>
 190         public event EventHandler<KeyEventArgs> KeyEvent
 191         {
 192             add
 193             {
 194                 if (stageKeyHandler == null)
 195                 {
 196                     stageKeyCallbackDelegate = OnStageKey;
 197                     using KeyEventSignal keyEventSignal = KeyEventSignal();
 198                     keyEventSignal?.Connect(stageKeyCallbackDelegate);
 199                 }
 200                 stageKeyHandler += value;
 201             }
 202             remove
 203             {
 204                 stageKeyHandler -= value;
 205                 using KeyEventSignal keyEventSignal = KeyEventSignal();
 206                 if (stageKeyHandler == null && keyEventSignal?.Empty() == false)
 207                 {
 208                     keyEventSignal?.Disconnect(stageKeyCallbackDelegate);
 209                     if(keyEventSignal?.Empty() == true)
 210                     {
 211                         stageKeyCallbackDelegate = null;
 212                     }
 213                 }
 214             }
 215         }
 216
 217         /// <summary>
 218         /// Emits the event when the window resized.
 219         /// </summary>
 220         /// <since_tizen> 3 </since_tizen>
 221         public event EventHandler<ResizedEventArgs> Resized
 222         {
 223             add
 224             {
 225                 if (windowResizeEventHandler == null)
 226                 {
 227                     windowResizeEventCallback = OnResized;
 228                     using ResizeSignal resizeSignal = ResizeSignal();
 229                     resizeSignal?.Connect(windowResizeEventCallback);
 230                 }
 231
 232                 windowResizeEventHandler += value;
 233             }
 234             remove
 235             {
 236                 windowResizeEventHandler -= value;
 237
 238                 using ResizeSignal resizeSignal = ResizeSignal();
 239                 if (windowResizeEventHandler == null && resizeSignal?.Empty() == false && windowResizeEventCallback != null)
 240                 {
 241                     resizeSignal?.Disconnect(windowResizeEventCallback);
 242                     if(resizeSignal?.Empty() == true)
 243                     {
 244                         windowResizeEventCallback = null;
 245                     }
 246                 }
 247             }
 248         }
 249
 250         /// <summary>
 251         /// Please do not use! this will be deprecated. Please use 'FocusChanged' event instead.
 252         /// </summary>
 253         /// <since_tizen> 3 </since_tizen>
 254         /// Please do not use! this will be deprecated!
 255         /// Instead please use FocusChanged.
 256         [Obsolete("Please do not use! This will be deprecated! Please use FocusChanged instead! " +
 257             "Like: " +
 258             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 259             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 260         [EditorBrowsable(EditorBrowsableState.Never)]
 261         public event EventHandler<FocusChangedEventArgs> WindowFocusChanged
 262         {
 263             add
 264             {
 265                 if (windowFocusChangedEventHandler2 == null)
 266                 {
 267                     windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
 268                     using WindowFocusSignalType windowFocusChangedSignal2 = WindowFocusChangedSignal();
 269                     windowFocusChangedSignal2?.Connect(windowFocusChangedEventCallback2);
 270                 }
 271
 272                 windowFocusChangedEventHandler2 += value;
 273             }
 274             remove
 275             {
 276                 windowFocusChangedEventHandler2 -= value;
 277
 278                 using WindowFocusSignalType windowFocusChangedSignal2 = WindowFocusChangedSignal();
 279                 if (windowFocusChangedEventHandler2 == null && windowFocusChangedSignal2?.Empty() == false && windowFocusChangedEventCallback2 != null)
 280                 {
 281                     windowFocusChangedSignal2?.Disconnect(windowFocusChangedEventCallback2);
 282                     if(windowFocusChangedSignal2?.Empty() == true)
 283                     {
 284                         windowFocusChangedEventCallback2 = null;
 285                     }
 286                 }
 287             }
 288         }
 289
 290         /// <summary>
 291         /// EffectStart
 292         /// </summary>
 293         [EditorBrowsable(EditorBrowsableState.Never)]
 294         public event EventHandler<TransitionEffectEventArgs> TransitionEffect
 295         {
 296             add
 297             {
 298                 if (transitionEffectHandler == null)
 299                 {
 300                     transitionEffectEventCallback = OnTransitionEffect;
 301                     TransitionEffectEventSignal().Connect(transitionEffectEventCallback);
 302                 }
 303                 transitionEffectHandler += value;
 304             }
 305             remove
 306             {
 307                 transitionEffectHandler -= value;
 308                 if (transitionEffectHandler == null && TransitionEffectEventSignal().Empty() == false)
 309                 {
 310                     TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
 311                     if(TransitionEffectEventSignal().Empty() == true)
 312                     {
 313                         transitionEffectEventCallback = null;
 314                     }
 315                 }
 316             }
 317         }
 318
 319         /// <summary>
 320         /// Keyboard Repeat Settings Changed
 321         /// </summary>
 322         [EditorBrowsable(EditorBrowsableState.Never)]
 323         public event EventHandler KeyboardRepeatSettingsChanged
 324         {
 325             add
 326             {
 327                 if (keyboardRepeatSettingsChangedHandler == null)
 328                 {
 329                     keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
 330                     KeyboardRepeatSettingsChangedEventSignal().Connect(keyboardRepeatSettingsChangedEventCallback);
 331                 }
 332                 keyboardRepeatSettingsChangedHandler += value;
 333             }
 334             remove
 335             {
 336                 keyboardRepeatSettingsChangedHandler -= value;
 337                 if (keyboardRepeatSettingsChangedHandler == null && KeyboardRepeatSettingsChangedEventSignal().Empty() == false)
 338                 {
 339                     KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback);
 340                     if(KeyboardRepeatSettingsChangedEventSignal().Empty() == true)
 341                     {
 342                         keyboardRepeatSettingsChangedEventCallback = null;
 343                     }
 344                 }
 345             }
 346         }
 347
 348         /// <summary>
 349         /// ViewAdded will be triggered when the view added on Window
 350         /// </summary>
 351         /// <since_tizen> 6 </since_tizen>
 352         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 353         [EditorBrowsable(EditorBrowsableState.Never)]
 354         public event EventHandler ViewAdded;
 355         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
 356         private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
 357         private event EventHandler<WheelEventArgs> stageWheelHandler;
 358         private event EventHandler<KeyEventArgs> stageKeyHandler;
 359         private event EventHandler stageEventProcessingFinishedEventHandler;
 360         private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
 361         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
 362         private event EventHandler<TransitionEffectEventArgs> transitionEffectHandler;
 363         private event EventHandler keyboardRepeatSettingsChangedHandler;
 364         private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
 365
 366         internal void SendViewAdded(View view)
 367         {
 368             ViewAdded?.Invoke(view, EventArgs.Empty);
 369         }
 370
 371         internal event EventHandler EventProcessingFinished
 372         {
 373             add
 374             {
 375                 if (stageEventProcessingFinishedEventHandler == null)
 376                 {
 377                     stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 378                     using VoidSignal eventProcessingFinishedSignal = EventProcessingFinishedSignal();
 379                     eventProcessingFinishedSignal?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
 380                 }
 381                 stageEventProcessingFinishedEventHandler += value;
 382
 383             }
 384             remove
 385             {
 386                 stageEventProcessingFinishedEventHandler -= value;
 387
 388                 using VoidSignal eventProcessingFinishedSignal = EventProcessingFinishedSignal();
 389                 if (stageEventProcessingFinishedEventHandler == null && eventProcessingFinishedSignal?.Empty() == false)
 390                 {
 391                     eventProcessingFinishedSignal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 392                     if(eventProcessingFinishedSignal?.Empty() == true)
 393                     {
 394                         stageEventProcessingFinishedEventCallbackDelegate = null;
 395                     }
 396                 }
 397             }
 398         }
 399
 400         internal event EventHandler ContextLost
 401         {
 402             add
 403             {
 404                 if (stageContextLostEventHandler == null)
 405                 {
 406                     stageContextLostEventCallbackDelegate = OnContextLost;
 407                     using VoidSignal contextLostSignal = ContextLostSignal();
 408                     contextLostSignal?.Connect(stageContextLostEventCallbackDelegate);
 409                 }
 410                 stageContextLostEventHandler += value;
 411             }
 412             remove
 413             {
 414                 stageContextLostEventHandler -= value;
 415
 416                 using VoidSignal contextLostSignal = ContextLostSignal();
 417                 if (stageContextLostEventHandler == null && contextLostSignal?.Empty() == false)
 418                 {
 419                     contextLostSignal?.Disconnect(stageContextLostEventCallbackDelegate);
 420                     if(contextLostSignal?.Empty() == true)
 421                     {
 422                         stageContextLostEventCallbackDelegate = null;
 423                     }
 424                 }
 425             }
 426         }
 427
 428         internal event EventHandler ContextRegained
 429         {
 430             add
 431             {
 432                 if (stageContextRegainedEventHandler == null)
 433                 {
 434                     stageContextRegainedEventCallbackDelegate = OnContextRegained;
 435                     using VoidSignal contextRegainedSignal = ContextRegainedSignal();
 436                     contextRegainedSignal?.Connect(stageContextRegainedEventCallbackDelegate);
 437                 }
 438                 stageContextRegainedEventHandler += value;
 439             }
 440             remove
 441             {
 442                 stageContextRegainedEventHandler -= value;
 443
 444                 using VoidSignal contextRegainedSignal = ContextRegainedSignal();
 445                 if (stageContextRegainedEventHandler == null && contextRegainedSignal?.Empty() == false)
 446                 {
 447                     contextRegainedSignal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 448                     if(contextRegainedSignal?.Empty() == true)
 449                     {
 450                         stageContextRegainedEventCallbackDelegate = null;
 451                     }
 452                 }
 453             }
 454         }
 455
 456         internal event EventHandler SceneCreated
 457         {
 458             add
 459             {
 460                 if (stageSceneCreatedEventHandler == null)
 461                 {
 462                     stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 463                     using VoidSignal sceneCreatedSignal = SceneCreatedSignal();
 464                     sceneCreatedSignal?.Connect(stageSceneCreatedEventCallbackDelegate);
 465                 }
 466                 stageSceneCreatedEventHandler += value;
 467             }
 468             remove
 469             {
 470                 stageSceneCreatedEventHandler -= value;
 471
 472                 using VoidSignal sceneCreatedSignal = SceneCreatedSignal();
 473                 if (stageSceneCreatedEventHandler == null && sceneCreatedSignal?.Empty() == false)
 474                 {
 475                     sceneCreatedSignal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 476                     if(sceneCreatedSignal?.Empty() == true)
 477                     {
 478                         stageSceneCreatedEventCallbackDelegate = null;
 479                     }
 480                 }
 481             }
 482         }
 483
 484         internal WindowFocusSignalType WindowFocusChangedSignal()
 485         {
 486             WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 487             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 488             return ret;
 489         }
 490
 491         internal WindowFocusSignalType FocusChangedSignal()
 492         {
 493             WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 494             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 495             return ret;
 496         }
 497
 498         internal KeyEventSignal KeyEventSignal()
 499         {
 500             KeyEventSignal ret = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 501             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 502             return ret;
 503         }
 504
 505         internal VoidSignal EventProcessingFinishedSignal()
 506         {
 507             VoidSignal ret = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 508             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 509             return ret;
 510         }
 511
 512         internal TouchSignal TouchSignal()
 513         {
 514             TouchSignal ret = new TouchSignal(Interop.Window.TouchSignal(SwigCPtr), false);
 515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 516             return ret;
 517         }
 518
 519         internal TouchDataSignal TouchDataSignal()
 520         {
 521             TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
 522             if (NDalicPINVOKE.SWIGPendingException.Pending)
 523                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 524             return ret;
 525         }
 526
 527         internal VoidSignal ContextLostSignal()
 528         {
 529             VoidSignal ret = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 530             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 531             return ret;
 532         }
 533
 534         internal VoidSignal ContextRegainedSignal()
 535         {
 536             VoidSignal ret = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 537             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 538             return ret;
 539         }
 540
 541         internal VoidSignal SceneCreatedSignal()
 542         {
 543             VoidSignal ret = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 544             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 545             return ret;
 546         }
 547
 548         internal ResizeSignal ResizeSignal()
 549         {
 550             ResizeSignal ret = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 551             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 552             return ret;
 553         }
 554
 555         internal System.IntPtr GetNativeWindowHandler()
 556         {
 557             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
 558             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 559             return ret;
 560         }
 561
 562         /// <summary>
 563         /// Disconnect all native signals
 564         /// </summary>
 565         /// <since_tizen> 5 </since_tizen>
 566         internal void DisconnectNativeSignals()
 567         {
 568             if (windowFocusChangedEventCallback != null)
 569             {
 570                 using WindowFocusSignalType windowFocusChangedSignal = WindowFocusChangedSignal();
 571                 if( windowFocusChangedSignal?.Empty() == false )
 572                 {
 573                     windowFocusChangedSignal?.Disconnect(windowFocusChangedEventCallback);
 574                     windowFocusChangedEventCallback = null;
 575                 }
 576             }
 577
 578             if (rootLayerTouchDataCallback != null)
 579             {
 580                 using TouchDataSignal touchDataSignal = TouchDataSignal();
 581                 if( touchDataSignal?.Empty() == false )
 582                 {
 583                     touchDataSignal?.Disconnect(rootLayerTouchDataCallback);
 584                     rootLayerTouchDataCallback = null;
 585                 }
 586             }
 587
 588             if (wheelEventCallback != null)
 589             {
 590                 using WheelSignal wheelSignal = WheelEventSignal();
 591                 if( wheelSignal?.Empty() == false )
 592                 {
 593                     wheelSignal?.Disconnect(wheelEventCallback);
 594                     wheelEventCallback = null;
 595                 }
 596             }
 597
 598             if (DetentEventCallback != null)
 599             {
 600                 using StageWheelSignal stageWheelSignal = StageWheelEventSignal();
 601                 if( stageWheelSignal?.Empty() == false )
 602                 {
 603                     stageWheelSignal?.Disconnect(DetentEventCallback);
 604                     DetentEventCallback = null;
 605                 }
 606             }
 607
 608             if (stageKeyCallbackDelegate != null)
 609             {
 610                 using KeyEventSignal keyEventSignal = KeyEventSignal();
 611                 if( keyEventSignal?.Empty() == false )
 612                 {
 613                     keyEventSignal?.Disconnect(stageKeyCallbackDelegate);
 614                     stageKeyCallbackDelegate = null;
 615                 }
 616             }
 617
 618             if (stageEventProcessingFinishedEventCallbackDelegate != null)
 619             {
 620                 using VoidSignal eventProcessingFinishedSignal = EventProcessingFinishedSignal();
 621                 if( eventProcessingFinishedSignal?.Empty() == false )
 622                 {
 623                     eventProcessingFinishedSignal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 624                     stageEventProcessingFinishedEventCallbackDelegate = null;
 625                 }
 626             }
 627
 628             if (stageContextLostEventCallbackDelegate != null)
 629             {
 630                 using VoidSignal contextLostSignal = ContextLostSignal();
 631                 if( contextLostSignal?.Empty() == false )
 632                 {
 633                     contextLostSignal?.Disconnect(stageContextLostEventCallbackDelegate);
 634                     stageContextLostEventCallbackDelegate= null;
 635                 }
 636             }
 637
 638             if (stageContextRegainedEventCallbackDelegate != null)
 639             {
 640                 using VoidSignal contextRegainedSignal = ContextRegainedSignal();
 641                 if( contextRegainedSignal?.Empty() == false )
 642                 {
 643                     contextRegainedSignal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 644                     stageContextRegainedEventCallbackDelegate = null;
 645                 }
 646             }
 647
 648             if (stageSceneCreatedEventCallbackDelegate != null)
 649             {
 650                 using VoidSignal sceneCreatedSignal = SceneCreatedSignal();
 651                 if( sceneCreatedSignal?.Empty() == false )
 652                 {
 653                     sceneCreatedSignal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 654                     stageSceneCreatedEventCallbackDelegate = null;
 655                 }
 656             }
 657
 658             if (windowResizeEventCallback != null)
 659             {
 660                 using ResizeSignal resizeSignal = ResizeSignal();
 661                 if( resizeSignal?.Empty() == false )
 662                 {
 663                     resizeSignal?.Disconnect(windowResizeEventCallback);
 664                     windowResizeEventCallback = null;
 665                 }
 666             }
 667
 668             if (windowFocusChangedEventCallback2 != null)
 669             {
 670                 using WindowFocusSignalType windowFocusChangedSignal2 = WindowFocusChangedSignal();
 671                 if( windowFocusChangedSignal2?.Empty() == false )
 672                 {
 673                     windowFocusChangedSignal2?.Disconnect(windowFocusChangedEventCallback2);
 674                     windowFocusChangedEventCallback2 = null;
 675                 }
 676             }
 677
 678             if (transitionEffectSignal != null)
 679             {
 680                 TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
 681                 transitionEffectEventCallback = null;
 682             }
 683
 684             if (keyboardRepeatSettingsChangedSignal != null)
 685             {
 686                 KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback);
 687                 keyboardRepeatSettingsChangedEventCallback = null;
 688             }
 689
 690             if (auxiliaryMessageEventCallback != null)
 691             {
 692                 using var signal = new WindowAuxiliaryMessageSignal(this);
 693                 signal.Disconnect(auxiliaryMessageEventCallback);
 694                 auxiliaryMessageEventHandler = null;
 695                 auxiliaryMessageEventCallback = null;
 696             }
 697         }
 698
 699         private StageWheelSignal StageWheelEventSignal()
 700         {
 701             StageWheelSignal ret = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 702             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 703             return ret;
 704         }
 705
 706         private WheelSignal WheelEventSignal()
 707         {
 708             WheelSignal ret = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 709             if (NDalicPINVOKE.SWIGPendingException.Pending)
 710                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 711             return ret;
 712         }
 713
 714         private WindowTransitionEffectSignal TransitionEffectEventSignal()
 715         {
 716             if (transitionEffectSignal == null)
 717             {
 718                 transitionEffectSignal = new WindowTransitionEffectSignal(this);
 719                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 720                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 721             }
 722             return transitionEffectSignal;
 723         }
 724
 725         private KeyboardRepeatSettingsChangedSignal KeyboardRepeatSettingsChangedEventSignal()
 726         {
 727             if (keyboardRepeatSettingsChangedSignal == null)
 728             {
 729                 keyboardRepeatSettingsChangedSignal = new KeyboardRepeatSettingsChangedSignal(this);
 730                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 731                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 732             }
 733             return keyboardRepeatSettingsChangedSignal;
 734         }
 735
 736         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
 737         {
 738             if (window == IntPtr.Zero)
 739             {
 740                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 741                 return;
 742             }
 743
 744             if (windowFocusChangedEventHandler != null)
 745             {
 746                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 747                 e.FocusGained = focusGained;
 748                 windowFocusChangedEventHandler(this, e);
 749             }
 750         }
 751
 752         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
 753         {
 754             if (touchData == global::System.IntPtr.Zero)
 755             {
 756                 NUILog.Error("touchData should not be null!");
 757                 return false;
 758             }
 759
 760             if (rootLayerTouchDataEventHandler != null)
 761             {
 762                 TouchEventArgs e = new TouchEventArgs();
 763                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 764                 rootLayerTouchDataEventHandler(this, e);
 765             }
 766             return false;
 767         }
 768
 769         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
 770         {
 771             if (wheelEvent == global::System.IntPtr.Zero)
 772             {
 773                 NUILog.Error("wheelEvent should not be null!");
 774                 return true;
 775             }
 776
 777             if (stageWheelHandler != null)
 778             {
 779                 WheelEventArgs e = new WheelEventArgs();
 780                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 781                 stageWheelHandler(this, e);
 782             }
 783             return true;
 784         }
 785
 786         // Callback for Stage KeyEventsignal
 787         private void OnStageKey(IntPtr data)
 788         {
 789             if (stageKeyHandler != null)
 790             {
 791                 KeyEventArgs e = new KeyEventArgs();
 792                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 793                 //here we send all data to user event handlers
 794                 stageKeyHandler(this, e);
 795             }
 796         }
 797
 798         // Callback for Stage EventProcessingFinishedSignal
 799         private void OnEventProcessingFinished()
 800         {
 801             stageEventProcessingFinishedEventHandler?.Invoke(this, null);
 802         }
 803
 804         // Callback for Stage ContextLostSignal
 805         private void OnContextLost()
 806         {
 807             stageContextLostEventHandler?.Invoke(this, null);
 808         }
 809
 810         // Callback for Stage ContextRegainedSignal
 811         private void OnContextRegained()
 812         {
 813             stageContextRegainedEventHandler?.Invoke(this, null);
 814         }
 815
 816         // Callback for Stage SceneCreatedSignal
 817         private void OnSceneCreated()
 818         {
 819             stageSceneCreatedEventHandler?.Invoke(this, null);
 820         }
 821
 822         private void OnResized(IntPtr window, IntPtr windowSize)
 823         {
 824             if (window == IntPtr.Zero)
 825             {
 826                 NUILog.Error("OnResized() Window is null! Do nothing!");
 827                 return;
 828             }
 829
 830             if (windowResizeEventHandler != null)
 831             {
 832                 ResizedEventArgs e = new ResizedEventArgs();
 833                 // var val = new Uint16Pair(windowSize, false);
 834                 // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
 835                 // val.Dispose();
 836
 837                 // Workaround : windowSize should be valid pointer from dali,
 838                 // but currently it is fixed and is not Uint16Pair class.
 839                 // will be fixed later.
 840                 e.WindowSize = this.WindowSize;
 841                 windowResizeEventHandler(this, e);
 842             }
 843         }
 844
 845         private void OnWindowFocusedChanged2(IntPtr window, bool focusGained)
 846         {
 847             if (window == IntPtr.Zero)
 848             {
 849                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 850                 return;
 851             }
 852
 853             if (windowFocusChangedEventHandler2 != null)
 854             {
 855                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 856                 e.FocusGained = focusGained;
 857                 windowFocusChangedEventHandler2(this, e);
 858             }
 859         }
 860
 861         private void OnTransitionEffect(IntPtr window, int state, int type)
 862         {
 863             if (window == global::System.IntPtr.Zero)
 864             {
 865                 return;
 866             }
 867
 868             if (transitionEffectHandler != null)
 869             {
 870                 TransitionEffectEventArgs e = new TransitionEffectEventArgs();
 871                 e.State = (EffectState)state;
 872                 e.Type = (EffectType)type;
 873                 transitionEffectHandler(this, e);
 874             }
 875             return;
 876         }
 877
 878         private void OnKeyboardRepeatSettingsChanged()
 879         {
 880             keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
 881             return;
 882         }
 883
 884         /// <summary>
 885         /// The focus changed event argument.
 886         /// </summary>
 887         /// <since_tizen> 3 </since_tizen>
 888         public class FocusChangedEventArgs : EventArgs
 889         {
 890             /// <summary>
 891             /// FocusGained flag.
 892             /// </summary>
 893             /// <since_tizen> 3 </since_tizen>
 894             public bool FocusGained
 895             {
 896                 get;
 897                 set;
 898             }
 899         }
 900
 901         /// <summary>
 902         /// The touch event argument.
 903         /// </summary>
 904         /// <since_tizen> 3 </since_tizen>
 905         public class TouchEventArgs : EventArgs
 906         {
 907             private Touch touch;
 908
 909             /// <summary>
 910             /// Touch.
 911             /// </summary>
 912             /// <since_tizen> 3 </since_tizen>
 913             public Touch Touch
 914             {
 915                 get
 916                 {
 917                     return touch;
 918                 }
 919                 set
 920                 {
 921                     touch = value;
 922                 }
 923             }
 924         }
 925
 926         /// <summary>
 927         /// Wheel event arguments.
 928         /// </summary>
 929         /// <since_tizen> 3 </since_tizen>
 930         public class WheelEventArgs : EventArgs
 931         {
 932             private Wheel wheel;
 933
 934             /// <summary>
 935             /// Wheel.
 936             /// </summary>
 937             /// <since_tizen> 3 </since_tizen>
 938             public Wheel Wheel
 939             {
 940                 get
 941                 {
 942                     return wheel;
 943                 }
 944                 set
 945                 {
 946                     wheel = value;
 947                 }
 948             }
 949         }
 950
 951         /// <summary>
 952         /// Key event arguments.
 953         /// </summary>
 954         /// <since_tizen> 3 </since_tizen>
 955         public class KeyEventArgs : EventArgs
 956         {
 957             private Key key;
 958
 959             /// <summary>
 960             /// Key.
 961             /// </summary>
 962             /// <since_tizen> 3 </since_tizen>
 963             public Key Key
 964             {
 965                 get
 966                 {
 967                     return key;
 968                 }
 969                 set
 970                 {
 971                     key = value;
 972                 }
 973             }
 974         }
 975
 976         /// <summary>
 977         /// Feeds a key event into the window.
 978         /// This resized event arguments.
 979         /// </summary>
 980         /// <since_tizen> 3 </since_tizen>
 981         public class ResizedEventArgs : EventArgs
 982         {
 983             Size2D windowSize;
 984
 985             /// <summary>
 986             /// This window size.
 987             /// </summary>
 988             /// <since_tizen> 4 </since_tizen>
 989             public Size2D WindowSize
 990             {
 991                 get
 992                 {
 993                     return windowSize;
 994                 }
 995                 set
 996                 {
 997                     windowSize = value;
 998                 }
 999             }
1000         }
1001
1002         /// <summary>
1003         /// Please do not use! this will be deprecated
1004         /// </summary>
1005         /// <since_tizen> 3 </since_tizen>
1006         [Obsolete("Please do not use! This will be deprecated! Please use FocusChangedEventArgs instead! " +
1007             "Like: " +
1008             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
1009             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
1010         [EditorBrowsable(EditorBrowsableState.Never)]
1011         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
1012         public class WindowFocusChangedEventArgs : EventArgs
1013         {
1014             /// <summary>
1015             /// Please do not use! this will be deprecated
1016             /// </summary>
1017             /// <since_tizen> 3 </since_tizen>
1018             public bool FocusGained
1019             {
1020                 get;
1021                 set;
1022             }
1023         }
1024
1025         /// <summary>
1026         /// Contains and encapsulates Native Window handle.
1027         /// </summary>
1028         /// <since_tizen> 4 </since_tizen>
1029         [Obsolete("Deprecated in API9, will be removed in API11. Please use Window.NativeHandle instead!")]
1030         public class SafeNativeWindowHandle : SafeHandle
1031         {
1032             /// <summary>
1033             ///Constructor, Native window handle is set to handle.
1034             /// </summary>
1035             /// <since_tizen> 4 </since_tizen>
1036             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
1037             {
1038                 SetHandle(NUIApplication.GetDefaultWindow().GetNativeWindowHandler());
1039             }
1040             /// <summary>
1041             /// Null check if the handle is valid or not.
1042             /// </summary>
1043             /// <since_tizen> 4 </since_tizen>
1044             public override bool IsInvalid
1045             {
1046                 get
1047                 {
1048                     return this.handle == IntPtr.Zero;
1049                 }
1050             }
1051             /// <summary>
1052             /// Release handle itself.
1053             /// </summary>
1054             /// <returns>true when released successfully.</returns>
1055             /// <since_tizen> 4 </since_tizen>
1056             protected override bool ReleaseHandle()
1057             {
1058                 return true;
1059             }
1060         }
1061
1062         /// <summary>
1063         /// TransitionEffectArgs
1064         /// </summary>
1065         [EditorBrowsable(EditorBrowsableState.Never)]
1066         public class TransitionEffectEventArgs : EventArgs
1067         {
1068             private EffectState state;
1069             private EffectType type;
1070
1071             /// <summary>
1072             /// State
1073             /// </summary>
1074             [EditorBrowsable(EditorBrowsableState.Never)]
1075             public EffectState State
1076             {
1077                 get
1078                 {
1079                     return state;
1080                 }
1081                 set
1082                 {
1083                     state = value;
1084                 }
1085             }
1086             /// <summary>
1087             /// Type
1088             /// </summary>
1089             [EditorBrowsable(EditorBrowsableState.Never)]
1090             public EffectType Type
1091             {
1092                 get
1093                 {
1094                     return type;
1095                 }
1096                 set
1097                 {
1098                     type = value;
1099                 }
1100             }
1101         }
1102
1103         private EventHandler<WheelEventArgs> DetentEventHandler;
1104
1105         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1106         private delegate void DetentEventCallbackType(IntPtr arg1);
1107
1108         private DetentEventCallbackType DetentEventCallback;
1109
1110         private void OnDetentEvent(IntPtr wheelEvent)
1111         {
1112             WheelEventArgs e = new WheelEventArgs();
1113
1114             if (wheelEvent != global::System.IntPtr.Zero)
1115             {
1116                 e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
1117             }
1118
1119             DetentEventHandler?.Invoke(this, e);
1120         }
1121
1122         /// <summary>
1123         /// VisibilityChangedArgs
1124         /// </summary>
1125         [EditorBrowsable(EditorBrowsableState.Never)]
1126         public class VisibilityChangedEventArgs : EventArgs
1127         {
1128             private bool visibility;
1129             /// <summary>
1130             /// Visibility
1131             /// </summary>
1132             [EditorBrowsable(EditorBrowsableState.Never)]
1133             public bool Visibility
1134             {
1135                 get => visibility;
1136                 set
1137                 {
1138                     visibility = value;
1139                 }
1140             }
1141         }
1142
1143         private void OnVisibilityChanged(IntPtr window, bool visibility)
1144         {
1145             if (window == global::System.IntPtr.Zero)
1146             {
1147                 NUILog.Error("[ERR] OnVisibilityChanged() window is null");
1148                 return;
1149             }
1150
1151             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1152             e.Visibility = visibility;
1153             if (VisibilityChangedEventHandler != null)
1154             {
1155                 VisibilityChangedEventHandler.Invoke(this, e);
1156             }
1157         }
1158
1159         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1160         private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
1161         private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
1162         private event EventHandler<VisibilityChangedEventArgs> VisibilityChangedEventHandler;
1163         private WindowVisibilityChangedEvent VisibilityChangedEventSignal;
1164
1165         /// <summary>
1166         /// EffectStart
1167         /// </summary>
1168         [EditorBrowsable(EditorBrowsableState.Never)]
1169         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
1170         {
1171             add
1172             {
1173                 if (VisibilityChangedEventHandler == null)
1174                 {
1175                     VisibilityChangedEventCallback = OnVisibilityChanged;
1176                     VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1177                     VisibilityChangedEventSignal.Connect(VisibilityChangedEventCallback);
1178                 }
1179                 VisibilityChangedEventHandler += value;
1180             }
1181             remove
1182             {
1183                 VisibilityChangedEventHandler -= value;
1184                 if (VisibilityChangedEventHandler == null)
1185                 {
1186                     if (VisibilityChangedEventSignal != null)
1187                     {
1188                         if (VisibilityChangedEventSignal.Empty() == false)
1189                         {
1190                             VisibilityChangedEventSignal.Disconnect(VisibilityChangedEventCallback);
1191                             if (VisibilityChangedEventSignal.Empty())
1192                             {
1193                                 VisibilityChangedEventCallback = null;
1194                             }
1195                         }
1196                     }
1197                 }
1198             }
1199         }
1200
1201         /// <summary>
1202         /// VisibiltyChangedSignalEmit
1203         /// </summary>
1204         [EditorBrowsable(EditorBrowsableState.Never)]
1205         public void VisibiltyChangedSignalEmit(bool visibility)
1206         {
1207             if (VisibilityChangedEventSignal == null)
1208             {
1209                 VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1210             }
1211             VisibilityChangedEventSignal.Emit(this, visibility);
1212         }
1213
1214         private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
1215         {
1216             if(kData == IntPtr.Zero || vData == IntPtr.Zero)
1217             {
1218                 return;
1219             }
1220
1221             using var tmp = new PropertyArray(optionsArray, false);
1222             var size = tmp.Size();
1223
1224             List<string> tmpList = new List<string>();
1225
1226             for (int i = 0; i < size; i++)
1227             {
1228                 string option = "none";
1229                 tmp.GetElementAt((uint)i).Get(out option);
1230                 tmpList.Add(option);
1231             }
1232
1233             tmp.Dispose();
1234
1235             AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
1236             e.Key = StringToVoidSignal.GetResult(kData);
1237             e.Value = StringToVoidSignal.GetResult(vData);;
1238             e.Options = tmpList;
1239
1240             auxiliaryMessageEventHandler?.Invoke(this, e);
1241         }
1242
1243         /// <summary>
1244         /// Auxiliary message is sent by displayer server when window's auxiliary was changed then display server sent the message.
1245         /// When client application added the window's auxiliary hint and if the auxiliary is changed,
1246         /// display server send the auxiliary message.
1247         /// Auxiliary message has the key, value and options.
1248         /// </summary>
1249         [EditorBrowsable(EditorBrowsableState.Never)]
1250         public event EventHandler<AuxiliaryMessageEventArgs> AuxiliaryMessage
1251         {
1252             add
1253             {
1254                 if (auxiliaryMessageEventHandler == null)
1255                 {
1256                     auxiliaryMessageEventCallback = OnAuxiliaryMessage;
1257                     using var signal = new WindowAuxiliaryMessageSignal(this);
1258                     signal.Connect(auxiliaryMessageEventCallback);
1259                 }
1260                 auxiliaryMessageEventHandler += value;
1261             }
1262             remove
1263             {
1264                 auxiliaryMessageEventHandler -= value;
1265                 if (auxiliaryMessageEventHandler == null)
1266                 {
1267                     if (auxiliaryMessageEventCallback != null)
1268                     {
1269                         using var signal = new WindowAuxiliaryMessageSignal(this);
1270                         signal.Disconnect(auxiliaryMessageEventCallback);
1271
1272                         if (signal.Empty())
1273                         {
1274                             auxiliaryMessageEventCallback = null;
1275                         }
1276                     }
1277                 }
1278             }
1279         }
1280
1281
1282     }
1283 }