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