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