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