Tizen.NUI/src/public/FocusManager.cs

   1 // Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved\r
   2 // PROPRIETARY/CONFIDENTIAL \r
   3 // This software is the confidential and proprietary\r
   4 // information of SAMSUNG ELECTRONICS ("Confidential Information"). You shall\r
   5 // not disclose such Confidential Information and shall use it only in\r
   6 // accordance with the terms of the license agreement you entered into with\r
   7 // SAMSUNG ELECTRONICS. SAMSUNG make no representations or warranties about the\r
   8 // suitability of the software, either express or implied, including but not\r
   9 // limited to the implied warranties of merchantability, fitness for a\r
  10 // particular purpose, or non-infringement. SAMSUNG shall not be liable for any\r
  11 // damages suffered by licensee as a result of using, modifying or distributing\r
  12 // this software or its derivatives.\r
  13 \r
  14 // Copyright (c) 2017 Samsung Electronics Co., Ltd.\r
  15 //\r
  16 // Licensed under the Apache License, Version 2.0 (the "License");\r
  17 // you may not use this file except in compliance with the License.\r
  18 // You may obtain a copy of the License at\r
  19 //\r
  20 // http://www.apache.org/licenses/LICENSE-2.0\r
  21 //\r
  22 // Unless required by applicable law or agreed to in writing, software\r
  23 // distributed under the License is distributed on an "AS IS" BASIS,\r
  24 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  25 // See the License for the specific language governing permissions and\r
  26 // limitations under the License.\r
  27 //\r
  28 \r
  29 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts\r
  30 // Some have been manually changed\r
  31 \r
  32 \r
  33 namespace Tizen.NUI\r
  34 {\r
  35 \r
  36     using System;\r
  37     using System.Runtime.InteropServices;\r
  38 \r
  39     public class FocusManager : BaseHandle\r
  40     {\r
  41         private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
  42 \r
  43         internal FocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.FocusManager_SWIGUpcast(cPtr), cMemoryOwn)\r
  44         {\r
  45             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
  46         }\r
  47 \r
  48         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FocusManager obj)\r
  49         {\r
  50             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
  51         }\r
  52 \r
  53         ~FocusManager()\r
  54         {\r
  55             DisposeQueue.Instance.Add(this);\r
  56         }\r
  57 \r
  58         public override void Dispose()\r
  59         {\r
  60             if (!Stage.IsInstalled())\r
  61             {\r
  62                 DisposeQueue.Instance.Add(this);\r
  63                 return;\r
  64             }\r
  65 \r
  66             lock (this)\r
  67             {\r
  68                 if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
  69                 {\r
  70                     if (swigCMemOwn)\r
  71                     {\r
  72                         swigCMemOwn = false;\r
  73                         NDalicManualPINVOKE.delete_FocusManager(swigCPtr);\r
  74                     }\r
  75                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
  76                 }\r
  77                 global::System.GC.SuppressFinalize(this);\r
  78                 base.Dispose();\r
  79             }\r
  80         }\r
  81 \r
  82 \r
  83         /**\r
  84           * @brief Event arguments that passed via PreFocusChange signal\r
  85           *\r
  86           */\r
  87         public class PreFocusChangeEventArgs : EventArgs\r
  88         {\r
  89             private View _current;\r
  90             private View _proposed;\r
  91             private View.FocusDirection _direction;\r
  92 \r
  93             public View CurrentView\r
  94             {\r
  95                 get\r
  96                 {\r
  97                     return _current;\r
  98                 }\r
  99                 set\r
 100                 {\r
 101                     _current = value;\r
 102                 }\r
 103             }\r
 104 \r
 105             public View ProposedView\r
 106             {\r
 107                 get\r
 108                 {\r
 109                     return _proposed;\r
 110                 }\r
 111                 set\r
 112                 {\r
 113                     _proposed = value;\r
 114                 }\r
 115             }\r
 116 \r
 117             public View.FocusDirection Direction\r
 118             {\r
 119                 get\r
 120                 {\r
 121                     return _direction;\r
 122                 }\r
 123                 set\r
 124                 {\r
 125                     _direction = value;\r
 126                 }\r
 127             }\r
 128         }\r
 129 \r
 130         private EventHandlerWithReturnType<object, PreFocusChangeEventArgs, View> _preFocusChangeEventHandler;\r
 131         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 132         internal delegate IntPtr PreFocusChangeEventCallback(IntPtr current, IntPtr proposed, View.FocusDirection direction);\r
 133         private PreFocusChangeEventCallback _preFocusChangeCallback;\r
 134 \r
 135         public event EventHandlerWithReturnType<object, PreFocusChangeEventArgs, View> PreFocusChange\r
 136         {\r
 137             add\r
 138             {\r
 139                 if (_preFocusChangeEventHandler == null)\r
 140                 {\r
 141                     _preFocusChangeCallback = OnPreFocusChange;\r
 142                     PreFocusChangeSignal().Connect(_preFocusChangeCallback);\r
 143                 }\r
 144                 _preFocusChangeEventHandler += value;\r
 145             }\r
 146             remove\r
 147             {\r
 148                 _preFocusChangeEventHandler -= value;\r
 149                 if (_preFocusChangeEventHandler == null && _preFocusChangeCallback != null)\r
 150                 {\r
 151                     PreFocusChangeSignal().Disconnect(_preFocusChangeCallback);\r
 152                 }\r
 153             }\r
 154         }\r
 155 \r
 156         private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.FocusDirection direction)\r
 157         {\r
 158             View view = null;\r
 159             PreFocusChangeEventArgs e = new PreFocusChangeEventArgs();\r
 160 \r
 161             e.CurrentView = View.DownCast(Actor.GetActorFromPtr(current));\r
 162             e.ProposedView = View.DownCast(Actor.GetActorFromPtr(proposed));\r
 163             e.Direction = direction;\r
 164 \r
 165             if (_preFocusChangeEventHandler != null)\r
 166             {\r
 167                 view = _preFocusChangeEventHandler(this, e);\r
 168             }\r
 169             return view.GetPtrfromView();\r
 170         }\r
 171 \r
 172 \r
 173         /**\r
 174           * @brief Event arguments that passed via FocusChanged signal\r
 175           *\r
 176           */\r
 177         public class FocusChangedEventArgs : EventArgs\r
 178         {\r
 179             private View _current;\r
 180             private View _next;\r
 181 \r
 182             public View CurrentView\r
 183             {\r
 184                 get\r
 185                 {\r
 186                     return _current;\r
 187                 }\r
 188                 set\r
 189                 {\r
 190                     _current = value;\r
 191                 }\r
 192             }\r
 193 \r
 194             public View NextView\r
 195             {\r
 196                 get\r
 197                 {\r
 198                     return _next;\r
 199                 }\r
 200                 set\r
 201                 {\r
 202                     _next = value;\r
 203                 }\r
 204             }\r
 205         }\r
 206 \r
 207         private EventHandler<FocusChangedEventArgs> _focusChangedEventHandler;\r
 208         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 209         internal delegate void FocusChangedEventCallback(IntPtr current, IntPtr next);\r
 210         private FocusChangedEventCallback _focusChangedEventCallback;\r
 211 \r
 212         public event EventHandler<FocusChangedEventArgs> FocusChanged\r
 213         {\r
 214             add\r
 215             {\r
 216                 if (_focusChangedEventCallback == null)\r
 217                 {\r
 218                     _focusChangedEventCallback = OnFocusChanged;\r
 219                     FocusChangedSignal().Connect(_focusChangedEventCallback);\r
 220                 }\r
 221                 _focusChangedEventHandler += value;\r
 222             }\r
 223             remove\r
 224             {\r
 225                 _focusChangedEventHandler -= value;\r
 226 \r
 227                 if (_focusChangedEventCallback == null && _focusChangedEventCallback != null)\r
 228                 {\r
 229                     FocusChangedSignal().Disconnect(_focusChangedEventCallback);\r
 230                 }\r
 231             }\r
 232         }\r
 233 \r
 234         private void OnFocusChanged(IntPtr current, IntPtr next)\r
 235         {\r
 236             FocusChangedEventArgs e = new FocusChangedEventArgs();\r
 237 \r
 238             e.CurrentView = View.DownCast(Actor.GetActorFromPtr(current));\r
 239             e.NextView = View.DownCast(Actor.GetActorFromPtr(next));\r
 240 \r
 241             if (_focusChangedEventHandler != null)\r
 242             {\r
 243                 _focusChangedEventHandler(this, e);\r
 244             }\r
 245         }\r
 246 \r
 247 \r
 248         /**\r
 249           * @brief Event arguments that passed via FocusGroupChanged signal\r
 250           *\r
 251           */\r
 252         public class FocusGroupChangedEventArgs : EventArgs\r
 253         {\r
 254             private View _current;\r
 255             private bool _forwardDirection;\r
 256 \r
 257             public View CurrentView\r
 258             {\r
 259                 get\r
 260                 {\r
 261                     return _current;\r
 262                 }\r
 263                 set\r
 264                 {\r
 265                     _current = value;\r
 266                 }\r
 267             }\r
 268 \r
 269             public bool ForwardDirection\r
 270             {\r
 271                 get\r
 272                 {\r
 273                     return _forwardDirection;\r
 274                 }\r
 275                 set\r
 276                 {\r
 277                     _forwardDirection = value;\r
 278                 }\r
 279             }\r
 280         }\r
 281 \r
 282         private EventHandler<FocusGroupChangedEventArgs> _focusGroupChangedEventHandler;\r
 283         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 284         private delegate void FocusGroupChangedEventCallback(IntPtr current, bool forwardDirection);\r
 285         private FocusGroupChangedEventCallback _focusGroupChangedEventCallback;\r
 286 \r
 287         public event EventHandler<FocusGroupChangedEventArgs> FocusGroupChanged\r
 288         {\r
 289             add\r
 290             {\r
 291                 if (_focusGroupChangedEventCallback == null)\r
 292                 {\r
 293                     _focusGroupChangedEventCallback = OnFocusGroupChanged;\r
 294                     FocusGroupChangedSignal().Connect(_focusGroupChangedEventCallback);\r
 295                 }\r
 296                 _focusGroupChangedEventHandler += value;\r
 297             }\r
 298             remove\r
 299             {\r
 300                 _focusGroupChangedEventHandler -= value;\r
 301 \r
 302                 if (_focusGroupChangedEventCallback == null && _focusGroupChangedEventCallback != null)\r
 303                 {\r
 304                     FocusGroupChangedSignal().Disconnect(_focusGroupChangedEventCallback);\r
 305                 }\r
 306             }\r
 307         }\r
 308 \r
 309         private void OnFocusGroupChanged(IntPtr current, bool forwardDirection)\r
 310         {\r
 311             FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();\r
 312 \r
 313             e.CurrentView = View.DownCast(Actor.GetActorFromPtr(current));\r
 314             e.ForwardDirection = forwardDirection;\r
 315 \r
 316             if (_focusGroupChangedEventHandler != null)\r
 317             {\r
 318                 _focusGroupChangedEventHandler(this, e);\r
 319             }\r
 320         }\r
 321 \r
 322 \r
 323         /**\r
 324           * @brief Event arguments that passed via FocusedActorEnterKey signal\r
 325           *\r
 326           */\r
 327         public class FocusedViewEnterKeyEventArgs : EventArgs\r
 328         {\r
 329             private View _view;\r
 330 \r
 331             public View View\r
 332             {\r
 333                 get\r
 334                 {\r
 335                     return _view;\r
 336                 }\r
 337                 set\r
 338                 {\r
 339                     _view = value;\r
 340                 }\r
 341             }\r
 342         }\r
 343 \r
 344         private EventHandler<FocusedViewEnterKeyEventArgs> _focusedViewEnterKeyEventHandler;\r
 345         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 346         private delegate void FocusedViewEnterKeyEventCallback(IntPtr view);\r
 347         private FocusedViewEnterKeyEventCallback _focusedViewEnterKeyEventCallback;\r
 348 \r
 349         public event EventHandler<FocusedViewEnterKeyEventArgs> FocusedViewEnterKeyPressed\r
 350         {\r
 351             add\r
 352             {\r
 353                 if (_focusedViewEnterKeyEventCallback == null)\r
 354                 {\r
 355                     _focusedViewEnterKeyEventCallback = OnFocusedViewEnterKey;\r
 356                     FocusedActorEnterKeySignal().Connect(_focusedViewEnterKeyEventCallback);\r
 357                 }\r
 358                 _focusedViewEnterKeyEventHandler += value;\r
 359             }\r
 360             remove\r
 361             {\r
 362                 _focusedViewEnterKeyEventHandler -= value;\r
 363 \r
 364                 if (_focusedViewEnterKeyEventCallback == null && _focusedViewEnterKeyEventCallback != null)\r
 365                 {\r
 366                     FocusedActorEnterKeySignal().Disconnect(_focusedViewEnterKeyEventCallback);\r
 367                 }\r
 368             }\r
 369         }\r
 370 \r
 371         private void OnFocusedViewEnterKey(IntPtr view)\r
 372         {\r
 373             FocusedViewEnterKeyEventArgs e = new FocusedViewEnterKeyEventArgs();\r
 374 \r
 375             e.View = View.DownCast(Actor.GetActorFromPtr(view));\r
 376 \r
 377             if (_focusedViewEnterKeyEventHandler != null)\r
 378             {\r
 379                 _focusedViewEnterKeyEventHandler(this, e);\r
 380             }\r
 381         }\r
 382 \r
 383 \r
 384         internal FocusManager() : this(NDalicManualPINVOKE.new_FocusManager(), true)\r
 385         {\r
 386             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 387         }\r
 388 \r
 389         internal static FocusManager Get()\r
 390         {\r
 391             FocusManager ret = new FocusManager(NDalicManualPINVOKE.FocusManager_Get(), true);\r
 392             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 393             return ret;\r
 394         }\r
 395 \r
 396         public bool SetCurrentFocusView(View view)\r
 397         {\r
 398             Actor actor = (Tizen.NUI.Actor)view;\r
 399             bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));\r
 400             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 401             return ret;\r
 402         }\r
 403 \r
 404         public View GetCurrentFocusView()\r
 405         {\r
 406             Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true);\r
 407             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 408             return View.DownCast(ret);\r
 409         }\r
 410 \r
 411         public bool MoveFocus(View.FocusDirection direction)\r
 412         {\r
 413             bool ret = NDalicManualPINVOKE.FocusManager_MoveFocus(swigCPtr, (int)direction);\r
 414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 415             return ret;\r
 416         }\r
 417 \r
 418         public void ClearFocus()\r
 419         {\r
 420             NDalicManualPINVOKE.FocusManager_ClearFocus(swigCPtr);\r
 421             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 422         }\r
 423 \r
 424         public bool FocusGroupLoop\r
 425         {\r
 426             set\r
 427             {\r
 428                 SetFocusGroupLoop(value);\r
 429             }\r
 430             get\r
 431             {\r
 432                 return GetFocusGroupLoop();\r
 433             }\r
 434         }\r
 435 \r
 436         internal void SetFocusGroupLoop(bool enabled)\r
 437         {\r
 438             NDalicManualPINVOKE.FocusManager_SetFocusGroupLoop(swigCPtr, enabled);\r
 439             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 440         }\r
 441 \r
 442         internal bool GetFocusGroupLoop()\r
 443         {\r
 444             bool ret = NDalicManualPINVOKE.FocusManager_GetFocusGroupLoop(swigCPtr);\r
 445             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 446             return ret;\r
 447         }\r
 448 \r
 449         public void SetAsFocusGroup(View view, bool isFocusGroup)\r
 450         {\r
 451             Actor actor = (Tizen.NUI.Actor)view;\r
 452             NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);\r
 453             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 454         }\r
 455 \r
 456         public bool IsFocusGroup(View view)\r
 457         {\r
 458             Actor actor = (Tizen.NUI.Actor)view;\r
 459             bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));\r
 460             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 461             return ret;\r
 462         }\r
 463 \r
 464         public View GetFocusGroup(View view)\r
 465         {\r
 466             Actor actor = (Tizen.NUI.Actor)view;\r
 467             Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);\r
 468             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 469             return View.DownCast(ret);\r
 470         }\r
 471 \r
 472         public View FocusIndicator\r
 473         {\r
 474             set\r
 475             {\r
 476                 SetFocusIndicatorView(value);\r
 477             }\r
 478             get\r
 479             {\r
 480                 return GetFocusIndicatorView();\r
 481             }\r
 482         }\r
 483 \r
 484         internal void SetFocusIndicatorView(View indicator)\r
 485         {\r
 486             Actor actor = (Tizen.NUI.Actor)indicator;\r
 487             NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(actor));\r
 488             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 489         }\r
 490 \r
 491         internal View GetFocusIndicatorView()\r
 492         {\r
 493             Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true);\r
 494             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 495             return View.DownCast(ret);\r
 496         }\r
 497 \r
 498         internal PreFocusChangeSignal PreFocusChangeSignal()\r
 499         {\r
 500             PreFocusChangeSignal ret = new PreFocusChangeSignal(NDalicManualPINVOKE.FocusManager_PreFocusChangeSignal(swigCPtr), false);\r
 501             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 502             return ret;\r
 503         }\r
 504 \r
 505         internal FocusChangedSignal FocusChangedSignal()\r
 506         {\r
 507             FocusChangedSignal ret = new FocusChangedSignal(NDalicManualPINVOKE.FocusManager_FocusChangedSignal(swigCPtr), false);\r
 508             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 509             return ret;\r
 510         }\r
 511 \r
 512         internal FocusGroupChangedSignal FocusGroupChangedSignal()\r
 513         {\r
 514             FocusGroupChangedSignal ret = new FocusGroupChangedSignal(NDalicManualPINVOKE.FocusManager_FocusGroupChangedSignal(swigCPtr), false);\r
 515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 516             return ret;\r
 517         }\r
 518 \r
 519         internal ActorSignal FocusedActorEnterKeySignal()\r
 520         {\r
 521             ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);\r
 522             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 523             return ret;\r
 524         }\r
 525 \r
 526         private static readonly FocusManager instance = FocusManager.Get();\r
 527 \r
 528         public static FocusManager Instance\r
 529         {\r
 530             get\r
 531             {\r
 532                 return instance;\r
 533             }\r
 534         }\r
 535 \r
 536     }\r
 537 \r
 538 }\r