src/Tizen.NUI/src/internal/CustomAlgorithmInterface.cs

   1 /*
   2  * Copyright(c) 2017 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.Reflection;
  19 using Tizen.NUI.BaseComponents;
  20
  21 namespace Tizen.NUI
  22 {
  23
  24     internal class CustomAlgorithmInterface : global::System.IDisposable
  25     {
  26         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  27         protected bool swigCMemOwn;
  28
  29         internal CustomAlgorithmInterface(global::System.IntPtr cPtr, bool cMemoryOwn)
  30         {
  31             swigCMemOwn = cMemoryOwn;
  32             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  33         }
  34
  35         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CustomAlgorithmInterface obj)
  36         {
  37             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  38         }
  39
  40         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  41         private bool isDisposeQueued = false;
  42         //A Flat to check if it is already disposed.
  43         protected bool disposed = false;
  44
  45
  46         ~CustomAlgorithmInterface()
  47         {
  48             if (!isDisposeQueued)
  49             {
  50                 isDisposeQueued = true;
  51                 DisposeQueue.Instance.Add(this);
  52             }
  53         }
  54
  55         public void Dispose()
  56         {
  57             //Throw excpetion if Dispose() is called in separate thread.
  58             if (!Window.IsInstalled())
  59             {
  60                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  61             }
  62
  63             if (isDisposeQueued)
  64             {
  65                 Dispose(DisposeTypes.Implicit);
  66             }
  67             else
  68             {
  69                 Dispose(DisposeTypes.Explicit);
  70                 System.GC.SuppressFinalize(this);
  71             }
  72         }
  73
  74         protected virtual void Dispose(DisposeTypes type)
  75         {
  76             if (disposed)
  77             {
  78                 return;
  79             }
  80
  81             if (type == DisposeTypes.Explicit)
  82             {
  83                 //Called by User
  84                 //Release your own managed resources here.
  85                 //You should release all of your own disposable objects here.
  86
  87             }
  88
  89             //Release your own unmanaged resources here.
  90             //You should not access any managed member here except static instance.
  91             //because the execution order of Finalizes is non-deterministic.
  92
  93             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  94             {
  95                 if (swigCMemOwn)
  96                 {
  97                     swigCMemOwn = false;
  98                     NDalicPINVOKE.delete_CustomAlgorithmInterface(swigCPtr);
  99                 }
 100                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 101             }
 102
 103             disposed = true;
 104         }
 105
 106         public virtual View GetNextFocusableView(View current, View proposed, View.FocusDirection direction)
 107         {
 108             View ret = new View(NDalicPINVOKE.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, View.getCPtr(current), View.getCPtr(proposed), (int)direction), true);
 109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 110             return ret;
 111         }
 112
 113         internal CustomAlgorithmInterface() : this(NDalicPINVOKE.new_CustomAlgorithmInterface(), true)
 114         {
 115             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 116             SwigDirectorConnect();
 117         }
 118
 119         private void SwigDirectorConnect()
 120         {
 121             if (SwigDerivedClassHasMethod("GetNextFocusableView", swigMethodTypes0))
 122                 swigDelegate0 = new SwigDelegateCustomAlgorithmInterface_0(SwigDirectorGetNextFocusableView);
 123             NDalicPINVOKE.CustomAlgorithmInterface_director_connect(swigCPtr, swigDelegate0);
 124         }
 125
 126         private bool SwigDerivedClassHasMethod(string methodName, global::System.Type[] methodTypes)
 127         {
 128             global::System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, methodTypes);
 129             bool hasDerivedMethod = this.GetType().GetTypeInfo().IsSubclassOf(typeof(CustomAlgorithmInterface));
 130             return hasDerivedMethod && (methodInfo != null);
 131         }
 132
 133         private global::System.IntPtr SwigDirectorGetNextFocusableView(global::System.IntPtr current, global::System.IntPtr proposed, int direction)
 134         {
 135             View currentView = Registry.GetManagedBaseHandleFromNativePtr(current) as View;
 136             View proposedView = Registry.GetManagedBaseHandleFromNativePtr(proposed) as View;
 137
 138             return View.getCPtr(GetNextFocusableView(currentView, proposedView, (View.FocusDirection)direction)).Handle;
 139         }
 140
 141         internal delegate global::System.IntPtr SwigDelegateCustomAlgorithmInterface_0(global::System.IntPtr current, global::System.IntPtr proposed, int direction);
 142
 143         private SwigDelegateCustomAlgorithmInterface_0 swigDelegate0;
 144
 145         private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(View), typeof(View), typeof(View.FocusDirection) };
 146     }
 147
 148 }