src/Tizen.NUI/src/internal/Transition/TransitionSet.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
  22 namespace Tizen.NUI
  23 {
  24     /// <summary>
  25     /// TransitionSet is used to control lifetime of multiple Transitions.
  26     /// For the one page transition, may multiple transitions are played coincidently.
  27     /// Every transitions added on a TransitionSet have same play lifetime. And emit a single Finished signal.
  28     /// </summary>
  29     internal class TransitionSet : BaseHandle
  30     {
  31         private TransitionSetFinishedEventCallbackType transitionSetFinishedEventCallback;
  32         private System.IntPtr finishedCallbackOfNative;
  33
  34         /// <summary>
  35         /// Creates an initialized transitionSet.<br />
  36         /// </summary>
  37         /// <remarks>DurationmSeconds must be greater than zero.</remarks>
  38         public TransitionSet() : this(Interop.TransitionSet.New(), true)
  39         {
  40             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  41         }
  42
  43         internal TransitionSet(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  44         {
  45             transitionSetFinishedEventCallback = OnFinished;
  46             finishedCallbackOfNative = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(transitionSetFinishedEventCallback);
  47         }
  48
  49         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  50         private delegate void TransitionSetFinishedEventCallbackType(IntPtr data);
  51
  52         private event EventHandler transitionSetFinishedEventHandler;
  53
  54         /**
  55         * @brief Event for the finished signal which can be used to subscribe or unsubscribe the event handler.
  56         * The finished signal is emitted when an transitionSet's transitionSets have finished.
  57         */
  58         public event EventHandler Finished
  59         {
  60             add
  61             {
  62                 if (transitionSetFinishedEventHandler == null && disposed == false)
  63                 {
  64                     TransitionSetFinishedSignal finishedSignal = FinishedSignal();
  65                     finishedSignal.Connect(finishedCallbackOfNative);
  66                     finishedSignal.Dispose();
  67                 }
  68                 transitionSetFinishedEventHandler += value;
  69             }
  70             remove
  71             {
  72                 transitionSetFinishedEventHandler -= value;
  73
  74                 TransitionSetFinishedSignal finishedSignal = FinishedSignal();
  75                 if (transitionSetFinishedEventHandler == null && finishedSignal.Empty() == false)
  76                 {
  77                     finishedSignal.Disconnect(finishedCallbackOfNative);
  78                 }
  79                 finishedSignal.Dispose();
  80             }
  81         }
  82
  83         /// <summary>
  84         /// Downcasts a handle to transitionSet handle.<br />
  85         /// If handle points to an transitionSet object, the downcast produces a valid handle.<br />
  86         /// If not, the returned handle is left uninitialized.<br />
  87         /// </summary>
  88         /// <param name="handle">Handle to an object.</param>
  89         /// <returns>Handle to an transitionSet object or an uninitialized handle.</returns>
  90         /// <exception cref="ArgumentNullException"> Thrown when handle is null. </exception>
  91         internal static TransitionSet DownCast(BaseHandle handle)
  92         {
  93             if (handle == null)
  94             {
  95                 throw new ArgumentNullException(nameof(handle));
  96             }
  97             TransitionSet ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TransitionSet;
  98             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  99             return ret;
 100         }
 101
 102         public void AddTransition(TransitionItemBase transition)
 103         {
 104             if (transition is TransitionGroupItem)
 105             {
 106                 TransitionGroupItem transitionGroup = transition as TransitionGroupItem;
 107                 for (int index = 0; index < transitionGroup.TransitionCount; ++index)
 108                 {
 109                     this.AddTransition(transitionGroup.GetTransitionAt(index));
 110                 }
 111             }
 112             else
 113             {
 114                 Interop.TransitionSet.AddTransition(SwigCPtr, transition.SwigCPtr);
 115                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 116             }
 117         }
 118
 119         public TransitionItemBase GetTransitionAt(uint index)
 120         {
 121             IntPtr cPtr = Interop.TransitionSet.GetTransitionAt(SwigCPtr, index);
 122             TransitionItemBase ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as TransitionItemBase;
 123             if (ret != null)
 124             {
 125                 Interop.BaseHandle.DeleteBaseHandle(new HandleRef(this, cPtr));
 126             }
 127             else
 128             {
 129                 ret = new TransitionItemBase(cPtr, true);
 130             }
 131             NDalicPINVOKE.ThrowExceptionIfExists();
 132             return ret;
 133         }
 134
 135         public uint GetTransitionCount()
 136         {
 137             uint ret = Interop.TransitionSet.GetTransitionCount(SwigCPtr);
 138             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 139             return ret;
 140         }
 141
 142         /// <summary>
 143         /// Plays the transitionSet.
 144         /// </summary>
 145         public void Play()
 146         {
 147             Interop.TransitionSet.Play(SwigCPtr);
 148             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 149         }
 150
 151         internal TransitionSet(TransitionSet handle) : this(Interop.TransitionSet.NewTransitionSet(TransitionSet.getCPtr(handle)), true)
 152         {
 153             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 154         }
 155
 156         internal TransitionSet Assign(TransitionSet rhs)
 157         {
 158             TransitionSet ret = new TransitionSet(Interop.TransitionSet.Assign(SwigCPtr, TransitionSet.getCPtr(rhs)), false);
 159             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 160             return ret;
 161         }
 162
 163         internal TransitionSetFinishedSignal FinishedSignal()
 164         {
 165             TransitionSetFinishedSignal ret = new TransitionSetFinishedSignal(Interop.TransitionSet.FinishedSignal(SwigCPtr), false);
 166             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 167             return ret;
 168         }
 169
 170         /// <summary>
 171         /// To make transitionSet instance be disposed.
 172         /// </summary>
 173         protected override void Dispose(DisposeTypes type)
 174         {
 175             if (disposed)
 176             {
 177                 return;
 178             }
 179
 180             if (transitionSetFinishedEventHandler != null)
 181             {
 182                 TransitionSetFinishedSignal finishedSignal = FinishedSignal();
 183                 finishedSignal?.Disconnect(finishedCallbackOfNative);
 184                 finishedSignal?.Dispose();
 185                 transitionSetFinishedEventHandler = null;
 186             }
 187
 188             base.Dispose(type);
 189         }
 190
 191         /// This will not be public opened.
 192         [EditorBrowsable(EditorBrowsableState.Never)]
 193         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 194         {
 195             if (swigCPtr.Handle == IntPtr.Zero || Disposed)
 196             {
 197                 Tizen.Log.Fatal("NUI", $"[ERROR] TransitionSet ReleaseSwigCPtr()! IntPtr=0x{swigCPtr.Handle:X} Disposed={Disposed}");
 198                 return;
 199             }
 200             Interop.TransitionSet.Delete(swigCPtr);
 201         }
 202
 203         private void OnFinished(IntPtr data)
 204         {
 205             if (transitionSetFinishedEventHandler != null)
 206             {
 207                 //here we send all data to user event handlers
 208                 transitionSetFinishedEventHandler(this, null);
 209             }
 210         }
 211     }
 212 }