src/Tizen.NUI/src/internal/PageTurnView.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 using System;
  18 using System.Runtime.InteropServices;
  19 using Tizen.NUI.BaseComponents;
  20
  21 namespace Tizen.NUI
  22 {
  23     internal class PageTurnView : View
  24     {
  25         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  26
  27         internal PageTurnView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.PageTurnView.PageTurnView_SWIGUpcast(cPtr), cMemoryOwn)
  28         {
  29             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  30         }
  31
  32         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PageTurnView obj)
  33         {
  34             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  35         }
  36
  37         protected override void Dispose(DisposeTypes type)
  38         {
  39             if (disposed)
  40             {
  41                 return;
  42             }
  43
  44             //Release your own unmanaged resources here.
  45             //You should not access any managed member here except static instance.
  46             //because the execution order of Finalizes is non-deterministic.
  47
  48             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  49             {
  50                 if (swigCMemOwn)
  51                 {
  52                     swigCMemOwn = false;
  53                     Interop.PageTurnView.delete_PageTurnView(swigCPtr);
  54                 }
  55                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  56             }
  57
  58             base.Dispose(type);
  59         }
  60
  61         /// <since_tizen> 3 </since_tizen>
  62         public class PagePanStartedEventArgs : EventArgs
  63         {
  64             private PageTurnView _pageTurnView;
  65
  66             /// <since_tizen> 3 </since_tizen>
  67             public PageTurnView PageTurnView
  68             {
  69                 get
  70                 {
  71                     return _pageTurnView;
  72                 }
  73                 set
  74                 {
  75                     _pageTurnView = value;
  76                 }
  77             }
  78         }
  79
  80         /// <since_tizen> 3 </since_tizen>
  81         public class PagePanFinishedEventArgs : EventArgs
  82         {
  83             private PageTurnView _pageTurnView;
  84
  85             /// <since_tizen> 3 </since_tizen>
  86             public PageTurnView PageTurnView
  87             {
  88                 get
  89                 {
  90                     return _pageTurnView;
  91                 }
  92                 set
  93                 {
  94                     _pageTurnView = value;
  95                 }
  96             }
  97         }
  98
  99         /// <since_tizen> 3 </since_tizen>
 100         public class PageTurnStartedEventArgs : EventArgs
 101         {
 102             private PageTurnView _pageTurnView;
 103             private uint _pageIndex;
 104             private bool _isTurningForward;
 105
 106             /// <since_tizen> 3 </since_tizen>
 107             public PageTurnView PageTurnView
 108             {
 109                 get
 110                 {
 111                     return _pageTurnView;
 112                 }
 113                 set
 114                 {
 115                     _pageTurnView = value;
 116                 }
 117             }
 118
 119             /// <since_tizen> 3 </since_tizen>
 120             public uint PageIndex
 121             {
 122                 get
 123                 {
 124                     return _pageIndex;
 125                 }
 126                 set
 127                 {
 128                     _pageIndex = value;
 129                 }
 130             }
 131
 132             /// <since_tizen> 3 </since_tizen>
 133             public bool IsTurningForward
 134             {
 135                 get
 136                 {
 137                     return _isTurningForward;
 138                 }
 139                 set
 140                 {
 141                     _isTurningForward = value;
 142                 }
 143             }
 144
 145         }
 146
 147         /// <since_tizen> 3 </since_tizen>
 148         public class PageTurnFinishedEventArgs : EventArgs
 149         {
 150             private PageTurnView _pageTurnView;
 151             private uint _pageIndex;
 152             private bool _isTurningForward;
 153
 154             /// <since_tizen> 3 </since_tizen>
 155             public PageTurnView PageTurnView
 156             {
 157                 get
 158                 {
 159                     return _pageTurnView;
 160                 }
 161                 set
 162                 {
 163                     _pageTurnView = value;
 164                 }
 165             }
 166
 167             /// <since_tizen> 3 </since_tizen>
 168             public uint PageIndex
 169             {
 170                 get
 171                 {
 172                     return _pageIndex;
 173                 }
 174                 set
 175                 {
 176                     _pageIndex = value;
 177                 }
 178             }
 179
 180             /// <since_tizen> 3 </since_tizen>
 181             public bool IsTurningForward
 182             {
 183                 get
 184                 {
 185                     return _isTurningForward;
 186                 }
 187                 set
 188                 {
 189                     _isTurningForward = value;
 190                 }
 191             }
 192
 193         }
 194
 195         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 196         private delegate void PagePanStartedCallbackDelegate(IntPtr page);
 197         private DaliEventHandler<object, PagePanStartedEventArgs> _pageTurnViewPagePanStartedEventHandler;
 198         private PagePanStartedCallbackDelegate _pageTurnViewPagePanStartedCallbackDelegate;
 199
 200         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 201         private delegate void PagePanFinishedCallbackDelegate(IntPtr page);
 202         private DaliEventHandler<object, PagePanFinishedEventArgs> _pageTurnViewPagePanFinishedEventHandler;
 203         private PagePanFinishedCallbackDelegate _pageTurnViewPagePanFinishedCallbackDelegate;
 204
 205         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 206         private delegate void PageTurnStartedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
 207         private DaliEventHandler<object, PageTurnStartedEventArgs> _pageTurnViewPageTurnStartedEventHandler;
 208         private PageTurnStartedCallbackDelegate _pageTurnViewPageTurnStartedCallbackDelegate;
 209
 210         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 211         private delegate void PageTurnFinishedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
 212         private DaliEventHandler<object, PageTurnFinishedEventArgs> _pageTurnViewPageTurnFinishedEventHandler;
 213         private PageTurnFinishedCallbackDelegate _pageTurnViewPageTurnFinishedCallbackDelegate;
 214
 215         public event DaliEventHandler<object, PagePanStartedEventArgs> PagePanStarted
 216         {
 217             add
 218             {
 219                 lock (this)
 220                 {
 221                     // Restricted to only one listener
 222                     if (_pageTurnViewPagePanStartedEventHandler == null)
 223                     {
 224                         _pageTurnViewPagePanStartedEventHandler += value;
 225
 226                         _pageTurnViewPagePanStartedCallbackDelegate = new PagePanStartedCallbackDelegate(OnPagePanStarted);
 227                         this.PagePanStartedSignal().Connect(_pageTurnViewPagePanStartedCallbackDelegate);
 228                     }
 229                 }
 230             }
 231
 232             remove
 233             {
 234                 lock (this)
 235                 {
 236                     if (_pageTurnViewPagePanStartedEventHandler != null)
 237                     {
 238                         this.PagePanStartedSignal().Disconnect(_pageTurnViewPagePanStartedCallbackDelegate);
 239                     }
 240
 241                     _pageTurnViewPagePanStartedEventHandler -= value;
 242                 }
 243             }
 244         }
 245
 246         // Callback for PageTurnView PagePanStarted signal
 247         private void OnPagePanStarted(IntPtr page)
 248         {
 249             PagePanStartedEventArgs e = new PagePanStartedEventArgs();
 250
 251             // Populate all members of "e" (PagePanStartedEventArgs) with real page
 252             e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr(page);
 253
 254             if (_pageTurnViewPagePanStartedEventHandler != null)
 255             {
 256                 //here we send all page to user event handlers
 257                 _pageTurnViewPagePanStartedEventHandler(this, e);
 258             }
 259         }
 260
 261         public event DaliEventHandler<object, PagePanFinishedEventArgs> PagePanFinished
 262         {
 263             add
 264             {
 265                 lock (this)
 266                 {
 267                     // Restricted to only one listener
 268                     if (_pageTurnViewPagePanFinishedEventHandler == null)
 269                     {
 270                         _pageTurnViewPagePanFinishedEventHandler += value;
 271
 272                         _pageTurnViewPagePanFinishedCallbackDelegate = new PagePanFinishedCallbackDelegate(OnPagePanFinished);
 273                         this.PagePanFinishedSignal().Connect(_pageTurnViewPagePanFinishedCallbackDelegate);
 274                     }
 275                 }
 276             }
 277
 278             remove
 279             {
 280                 lock (this)
 281                 {
 282                     if (_pageTurnViewPagePanFinishedEventHandler != null)
 283                     {
 284                         this.PagePanFinishedSignal().Disconnect(_pageTurnViewPagePanFinishedCallbackDelegate);
 285                     }
 286
 287                     _pageTurnViewPagePanFinishedEventHandler -= value;
 288                 }
 289             }
 290         }
 291
 292         // Callback for PageTurnView PagePanFinished signal
 293         private void OnPagePanFinished(IntPtr page)
 294         {
 295             PagePanFinishedEventArgs e = new PagePanFinishedEventArgs();
 296
 297             // Populate all members of "e" (PagePanFinishedEventArgs) with real page
 298             e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr(page);
 299
 300             if (_pageTurnViewPagePanFinishedEventHandler != null)
 301             {
 302                 //here we send all page to user event handlers
 303                 _pageTurnViewPagePanFinishedEventHandler(this, e);
 304             }
 305         }
 306
 307
 308         public event DaliEventHandler<object, PageTurnStartedEventArgs> PageTurnStarted
 309         {
 310             add
 311             {
 312                 lock (this)
 313                 {
 314                     // Restricted to only one listener
 315                     if (_pageTurnViewPageTurnStartedEventHandler == null)
 316                     {
 317                         _pageTurnViewPageTurnStartedEventHandler += value;
 318
 319                         _pageTurnViewPageTurnStartedCallbackDelegate = new PageTurnStartedCallbackDelegate(OnPageTurnStarted);
 320                         this.PageTurnStartedSignal().Connect(_pageTurnViewPageTurnStartedCallbackDelegate);
 321                     }
 322                 }
 323             }
 324
 325             remove
 326             {
 327                 lock (this)
 328                 {
 329                     if (_pageTurnViewPageTurnStartedEventHandler != null)
 330                     {
 331                         this.PageTurnStartedSignal().Disconnect(_pageTurnViewPageTurnStartedCallbackDelegate);
 332                     }
 333
 334                     _pageTurnViewPageTurnStartedEventHandler -= value;
 335                 }
 336             }
 337         }
 338
 339         // Callback for PageTurnView PageTurnStarted signal
 340         private void OnPageTurnStarted(IntPtr page, uint pageIndex, bool isTurningForward)
 341         {
 342             PageTurnStartedEventArgs e = new PageTurnStartedEventArgs();
 343
 344             // Populate all members of "e" (PageTurnStartedEventArgs) with real page
 345             e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr(page);
 346             e.PageIndex = pageIndex;
 347             e.IsTurningForward = isTurningForward;
 348
 349
 350             if (_pageTurnViewPageTurnStartedEventHandler != null)
 351             {
 352                 //here we send all page to user event handlers
 353                 _pageTurnViewPageTurnStartedEventHandler(this, e);
 354             }
 355         }
 356
 357
 358         public event DaliEventHandler<object, PageTurnFinishedEventArgs> PageTurnFinished
 359         {
 360             add
 361             {
 362                 lock (this)
 363                 {
 364                     // Restricted to only one listener
 365                     if (_pageTurnViewPageTurnFinishedEventHandler == null)
 366                     {
 367                         _pageTurnViewPageTurnFinishedEventHandler += value;
 368
 369                         _pageTurnViewPageTurnFinishedCallbackDelegate = new PageTurnFinishedCallbackDelegate(OnPageTurnFinished);
 370                         this.PageTurnFinishedSignal().Connect(_pageTurnViewPageTurnFinishedCallbackDelegate);
 371                     }
 372                 }
 373             }
 374
 375             remove
 376             {
 377                 lock (this)
 378                 {
 379                     if (_pageTurnViewPageTurnFinishedEventHandler != null)
 380                     {
 381                         this.PageTurnFinishedSignal().Disconnect(_pageTurnViewPageTurnFinishedCallbackDelegate);
 382                     }
 383
 384                     _pageTurnViewPageTurnFinishedEventHandler -= value;
 385                 }
 386             }
 387         }
 388
 389         // Callback for PageTurnView PageTurnFinished signal
 390         private void OnPageTurnFinished(IntPtr page, uint pageIndex, bool isTurningForward)
 391         {
 392             PageTurnFinishedEventArgs e = new PageTurnFinishedEventArgs();
 393
 394             // Populate all members of "e" (PageTurnFinishedEventArgs) with real page
 395             e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr(page);
 396             e.PageIndex = pageIndex;
 397             e.IsTurningForward = isTurningForward;
 398
 399
 400             if (_pageTurnViewPageTurnFinishedEventHandler != null)
 401             {
 402                 //here we send all page to user event handlers
 403                 _pageTurnViewPageTurnFinishedEventHandler(this, e);
 404             }
 405         }
 406
 407         public static PageTurnView GetPageTurnViewFromPtr(global::System.IntPtr cPtr)
 408         {
 409             PageTurnView ret = new PageTurnView(cPtr, false);
 410             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 411             return ret;
 412         }
 413
 414         internal new class Property
 415         {
 416             internal static readonly int VIEW_PAGE_SIZE = Interop.PageTurnView.PageTurnView_Property_VIEW_PAGE_SIZE_get();
 417             internal static readonly int CURRENT_PAGE_ID = Interop.PageTurnView.PageTurnView_Property_CURRENT_PAGE_ID_get();
 418             internal static readonly int SPINE_SHADOW = Interop.PageTurnView.PageTurnView_Property_SPINE_SHADOW_get();
 419         }
 420
 421         public PageTurnView() : this(Interop.PageTurnView.new_PageTurnView__SWIG_0(), true)
 422         {
 423             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 424         }
 425
 426         public PageTurnView(PageTurnView handle) : this(Interop.PageTurnView.new_PageTurnView__SWIG_1(PageTurnView.getCPtr(handle)), true)
 427         {
 428             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 429         }
 430
 431         public PageTurnView Assign(PageTurnView handle)
 432         {
 433             PageTurnView ret = new PageTurnView(Interop.PageTurnView.PageTurnView_Assign(swigCPtr, PageTurnView.getCPtr(handle)), false);
 434             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 435             return ret;
 436         }
 437
 438         public static PageTurnView DownCast(BaseHandle handle)
 439         {
 440             PageTurnView ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as PageTurnView;
 441             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 442             return ret;
 443         }
 444
 445         public PageTurnSignal PageTurnStartedSignal()
 446         {
 447             PageTurnSignal ret = new PageTurnSignal(Interop.PageTurnView.PageTurnView_PageTurnStartedSignal(swigCPtr), false);
 448             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 449             return ret;
 450         }
 451
 452         public PageTurnSignal PageTurnFinishedSignal()
 453         {
 454             PageTurnSignal ret = new PageTurnSignal(Interop.PageTurnView.PageTurnView_PageTurnFinishedSignal(swigCPtr), false);
 455             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 456             return ret;
 457         }
 458
 459         public PagePanSignal PagePanStartedSignal()
 460         {
 461             PagePanSignal ret = new PagePanSignal(Interop.PageTurnView.PageTurnView_PagePanStartedSignal(swigCPtr), false);
 462             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 463             return ret;
 464         }
 465
 466         public PagePanSignal PagePanFinishedSignal()
 467         {
 468             PagePanSignal ret = new PagePanSignal(Interop.PageTurnView.PageTurnView_PagePanFinishedSignal(swigCPtr), false);
 469             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470             return ret;
 471         }
 472
 473
 474         public Vector2 PageSize
 475         {
 476             get
 477             {
 478                 Vector2 temp = new Vector2(0.0f, 0.0f);
 479                 GetProperty(PageTurnView.Property.VIEW_PAGE_SIZE).Get(temp);
 480                 return temp;
 481             }
 482             set
 483             {
 484                 SetProperty(PageTurnView.Property.VIEW_PAGE_SIZE, new Tizen.NUI.PropertyValue(value));
 485             }
 486         }
 487         public int CurrentPageId
 488         {
 489             get
 490             {
 491                 int temp = 0;
 492                 GetProperty(PageTurnView.Property.CURRENT_PAGE_ID).Get(out temp);
 493                 return temp;
 494             }
 495             set
 496             {
 497                 SetProperty(PageTurnView.Property.CURRENT_PAGE_ID, new Tizen.NUI.PropertyValue(value));
 498             }
 499         }
 500         public Vector2 SpineShadow
 501         {
 502             get
 503             {
 504                 Vector2 temp = new Vector2(0.0f, 0.0f);
 505                 GetProperty(PageTurnView.Property.SPINE_SHADOW).Get(temp);
 506                 return temp;
 507             }
 508             set
 509             {
 510                 SetProperty(PageTurnView.Property.SPINE_SHADOW, new Tizen.NUI.PropertyValue(value));
 511             }
 512         }
 513     }
 514 }