Added scrollMode property to ScrollView to simplify Rulers
[platform/core/uifw/dali-toolkit.git] / plugins / dali-sharp / sharp / internal / Layer.cs
1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 *
15 */
16
17 namespace Dali
18 {
19
20     public class Layer : Animatable
21     {
22         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
23
24         internal Layer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Layer_SWIGUpcast(cPtr), cMemoryOwn)
25         {
26             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
27         }
28
29         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Layer obj)
30         {
31             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
32         }
33
34         ~Layer()
35         {
36             DisposeQueue.Instance.Add(this);
37         }
38
39         public virtual void Dispose()
40         {
41             if (!Window.IsInstalled())
42             {
43                 DisposeQueue.Instance.Add(this);
44                 return;
45             }
46
47             lock (this)
48             {
49                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
50                 {
51                     if (swigCMemOwn)
52                     {
53                         swigCMemOwn = false;
54                         NDalicPINVOKE.delete_Layer(swigCPtr);
55                     }
56                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
57                 }
58                 global::System.GC.SuppressFinalize(this);
59             }
60         }
61
62
63         public class Property : global::System.IDisposable
64         {
65             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
66             protected bool swigCMemOwn;
67
68             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
69             {
70                 swigCMemOwn = cMemoryOwn;
71                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
72             }
73
74             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
75             {
76                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
77             }
78
79             ~Property()
80             {
81                 Dispose();
82             }
83
84             public virtual void Dispose()
85             {
86                 lock (this)
87                 {
88                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
89                     {
90                         if (swigCMemOwn)
91                         {
92                             swigCMemOwn = false;
93                             NDalicPINVOKE.delete_Layer_Property(swigCPtr);
94                         }
95                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
96                     }
97                     global::System.GC.SuppressFinalize(this);
98                 }
99             }
100
101             public Property() : this(NDalicPINVOKE.new_Layer_Property(), true)
102             {
103                 if (NDalicPINVOKE.SWIGPendingException.Pending)
104                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
105             }
106
107             public static readonly int CLIPPING_ENABLE = NDalicPINVOKE.Layer_Property_CLIPPING_ENABLE_get();
108             public static readonly int CLIPPING_BOX = NDalicPINVOKE.Layer_Property_CLIPPING_BOX_get();
109             public static readonly int BEHAVIOR = NDalicPINVOKE.Layer_Property_BEHAVIOR_get();
110
111         }
112
113         public Layer() : this(NDalicPINVOKE.Layer_New(), true)
114         {
115             if (NDalicPINVOKE.SWIGPendingException.Pending)
116                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
117
118         }
119
120         public new static Layer DownCast(BaseHandle handle)
121         {
122             Layer ret = new Layer(NDalicPINVOKE.Layer_DownCast(BaseHandle.getCPtr(handle)), true);
123             if (NDalicPINVOKE.SWIGPendingException.Pending)
124                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
125             return ret;
126         }
127
128         public Layer(Layer copy) : this(NDalicPINVOKE.new_Layer__SWIG_1(Layer.getCPtr(copy)), true)
129         {
130             if (NDalicPINVOKE.SWIGPendingException.Pending)
131                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
132         }
133
134         public Layer Assign(Layer rhs)
135         {
136             Layer ret = new Layer(NDalicPINVOKE.Layer_Assign(swigCPtr, Layer.getCPtr(rhs)), false);
137             if (NDalicPINVOKE.SWIGPendingException.Pending)
138                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
139             return ret;
140         }
141
142         public View FindChildById(uint id)
143         {
144             View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
145             if (NDalicPINVOKE.SWIGPendingException.Pending)
146                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
147             return ret;
148         }
149
150         public void Add(View child)
151         {
152             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
153             if (NDalicPINVOKE.SWIGPendingException.Pending)
154                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
155         }
156
157         public void Remove(View child)
158         {
159             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
160             if (NDalicPINVOKE.SWIGPendingException.Pending)
161                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
162         }
163
164         public uint GetDepth()
165         {
166             uint ret = NDalicPINVOKE.Layer_GetDepth(swigCPtr);
167             if (NDalicPINVOKE.SWIGPendingException.Pending)
168                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
169             return ret;
170         }
171
172         public void Raise()
173         {
174             NDalicPINVOKE.Layer_Raise(swigCPtr);
175             if (NDalicPINVOKE.SWIGPendingException.Pending)
176                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
177         }
178
179         public void Lower()
180         {
181             NDalicPINVOKE.Layer_Lower(swigCPtr);
182             if (NDalicPINVOKE.SWIGPendingException.Pending)
183                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
184         }
185
186         public void RaiseAbove(Layer target)
187         {
188             NDalicPINVOKE.Layer_RaiseAbove(swigCPtr, Layer.getCPtr(target));
189             if (NDalicPINVOKE.SWIGPendingException.Pending)
190                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
191         }
192
193         public void LowerBelow(Layer target)
194         {
195             NDalicPINVOKE.Layer_LowerBelow(swigCPtr, Layer.getCPtr(target));
196             if (NDalicPINVOKE.SWIGPendingException.Pending)
197                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
198         }
199
200         public void RaiseToTop()
201         {
202             NDalicPINVOKE.Layer_RaiseToTop(swigCPtr);
203             if (NDalicPINVOKE.SWIGPendingException.Pending)
204                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
205         }
206
207         public void LowerToBottom()
208         {
209             NDalicPINVOKE.Layer_LowerToBottom(swigCPtr);
210             if (NDalicPINVOKE.SWIGPendingException.Pending)
211                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
212         }
213
214         public void MoveAbove(Layer target)
215         {
216             NDalicPINVOKE.Layer_MoveAbove(swigCPtr, Layer.getCPtr(target));
217             if (NDalicPINVOKE.SWIGPendingException.Pending)
218                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
219         }
220
221         public void MoveBelow(Layer target)
222         {
223             NDalicPINVOKE.Layer_MoveBelow(swigCPtr, Layer.getCPtr(target));
224             if (NDalicPINVOKE.SWIGPendingException.Pending)
225                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
226         }
227
228         public void SetBehavior(Layer.LayerBehavior behavior)
229         {
230             NDalicPINVOKE.Layer_SetBehavior(swigCPtr, (int)behavior);
231             if (NDalicPINVOKE.SWIGPendingException.Pending)
232                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
233         }
234
235         public Layer.LayerBehavior GetBehavior()
236         {
237             Layer.LayerBehavior ret = (Layer.LayerBehavior)NDalicPINVOKE.Layer_GetBehavior(swigCPtr);
238             if (NDalicPINVOKE.SWIGPendingException.Pending)
239                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
240             return ret;
241         }
242
243         public void SetClipping(bool enabled)
244         {
245             NDalicPINVOKE.Layer_SetClipping(swigCPtr, enabled);
246             if (NDalicPINVOKE.SWIGPendingException.Pending)
247                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
248         }
249
250         public bool IsClipping()
251         {
252             bool ret = NDalicPINVOKE.Layer_IsClipping(swigCPtr);
253             if (NDalicPINVOKE.SWIGPendingException.Pending)
254                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
255             return ret;
256         }
257
258         public void SetClippingBox(int x, int y, int width, int height)
259         {
260             NDalicPINVOKE.Layer_SetClippingBox__SWIG_0(swigCPtr, x, y, width, height);
261             if (NDalicPINVOKE.SWIGPendingException.Pending)
262                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
263         }
264
265         public void SetClippingBox(Rectangle box)
266         {
267             NDalicPINVOKE.Layer_SetClippingBox__SWIG_1(swigCPtr, Rectangle.getCPtr(box));
268             if (NDalicPINVOKE.SWIGPendingException.Pending)
269                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
270         }
271
272         public Rectangle GetClippingBox()
273         {
274             Rectangle ret = new Rectangle(NDalicPINVOKE.Layer_GetClippingBox(swigCPtr), true);
275             if (NDalicPINVOKE.SWIGPendingException.Pending)
276                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
277             return ret;
278         }
279
280         public void SetDepthTestDisabled(bool disable)
281         {
282             NDalicPINVOKE.Layer_SetDepthTestDisabled(swigCPtr, disable);
283             if (NDalicPINVOKE.SWIGPendingException.Pending)
284                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
285         }
286
287         public bool IsDepthTestDisabled()
288         {
289             bool ret = NDalicPINVOKE.Layer_IsDepthTestDisabled(swigCPtr);
290             if (NDalicPINVOKE.SWIGPendingException.Pending)
291                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
292             return ret;
293         }
294
295         public void SetSortFunction(SWIGTYPE_p_f_r_q_const__Dali__Vector3__float function)
296         {
297             NDalicPINVOKE.Layer_SetSortFunction(swigCPtr, SWIGTYPE_p_f_r_q_const__Dali__Vector3__float.getCPtr(function));
298             if (NDalicPINVOKE.SWIGPendingException.Pending)
299                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
300         }
301
302         public void SetTouchConsumed(bool consume)
303         {
304             NDalicPINVOKE.Layer_SetTouchConsumed(swigCPtr, consume);
305             if (NDalicPINVOKE.SWIGPendingException.Pending)
306                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
307         }
308
309         public bool IsTouchConsumed()
310         {
311             bool ret = NDalicPINVOKE.Layer_IsTouchConsumed(swigCPtr);
312             if (NDalicPINVOKE.SWIGPendingException.Pending)
313                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
314             return ret;
315         }
316
317         public void SetHoverConsumed(bool consume)
318         {
319             NDalicPINVOKE.Layer_SetHoverConsumed(swigCPtr, consume);
320             if (NDalicPINVOKE.SWIGPendingException.Pending)
321                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
322         }
323
324         public bool IsHoverConsumed()
325         {
326             bool ret = NDalicPINVOKE.Layer_IsHoverConsumed(swigCPtr);
327             if (NDalicPINVOKE.SWIGPendingException.Pending)
328                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
329             return ret;
330         }
331
332         public enum LayerBehavior
333         {
334             LAYER_2D,
335             LAYER_UI = LAYER_2D,
336             LAYER_3D
337         }
338
339         public enum TreeDepthMultiplier
340         {
341             TREE_DEPTH_MULTIPLIER = 10000
342         }
343
344         public bool ClippingEnable
345         {
346             get
347             {
348                 bool temp = false;
349                 GetProperty(Layer.Property.CLIPPING_ENABLE).Get(ref temp);
350                 return temp;
351             }
352             set
353             {
354                 SetProperty(Layer.Property.CLIPPING_ENABLE, new Dali.Property.Value(value));
355             }
356         }
357
358         public Rectangle ClippingBox
359         {
360             get
361             {
362                 Rectangle temp = new Rectangle(0, 0, 0, 0);
363                 GetProperty(Layer.Property.CLIPPING_BOX).Get(temp);
364                 return temp;
365             }
366             set
367             {
368                 SetProperty(Layer.Property.CLIPPING_BOX, new Dali.Property.Value(value));
369             }
370         }
371
372         public Layer.LayerBehavior Behavior
373         {
374             get
375             {
376                 return GetBehavior();
377             }
378             set
379             {
380                 SetBehavior(value);
381             }
382         }
383
384     }
385
386 }