zoukankan      html  css  js  c++  java

  • winrt 上的翻书特效组件 源码分享 转载请说明

    http://blog.csdn.net/wangrenzhu2011/article/details/10207413 (转)

    [csharp] view plaincopyprint?
     
    1. [TemplatePart(Name = A_PARTNAME, Type = typeof(Border))]  
    2. [TemplatePart(Name = B_PARTNAME, Type = typeof(Border))]  
    3. [TemplatePart(Name = C_PARTNAME, Type = typeof(Border))]  
    4. [TemplatePart(Name = D_PARTNAME, Type = typeof(Border))]  
    5. [TemplatePart(Name = E_PARTNAME, Type = typeof(Border))]  
    6. [TemplatePart(Name = F_PARTNAME, Type = typeof(Border))]  
    7. [TemplatePart(Name = A_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    8. [TemplatePart(Name = B_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    9. [TemplatePart(Name = C_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    10. [TemplatePart(Name = D_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    11. [TemplatePart(Name = E_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    12. [TemplatePart(Name = F_RECT_PARTNAME, Type = typeof(RectangleGeometry))]  
    13. [TemplatePart(Name = A_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    14. [TemplatePart(Name = B_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    15. [TemplatePart(Name = C_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    16. [TemplatePart(Name = D_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    17. [TemplatePart(Name = E_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    18. [TemplatePart(Name = F_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    19. [TemplatePart(Name = A_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    20. [TemplatePart(Name = B_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    21. [TemplatePart(Name = C_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    22. [TemplatePart(Name = D_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    23. [TemplatePart(Name = E_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    24. [TemplatePart(Name = F_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]  
    25. [TemplatePart(Name = INNER_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    26. [TemplatePart(Name = OUTER_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    27. [TemplatePart(Name = INNER_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    28. [TemplatePart(Name = OUTER_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    29. [TemplatePart(Name = MARGIN_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    30. [TemplatePart(Name = MARGIN_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]  
    31. [TemplatePart(Name = ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME, Type = typeof(StackPanel))]  
    32. [TemplatePart(Name = ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME, Type = typeof(StackPanel))]  
    33. [TemplatePart(Name = ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME, Type = typeof(StackPanel))]  
    34. [TemplatePart(Name = ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME, Type = typeof(StackPanel))]  
    35. [TemplatePart(Name = ST_SHADOW_MARGIN_LEFT_PARTNAME, Type = typeof(StackPanel))]  
    36. [TemplatePart(Name = ST_SHADOW_MARGIN_RIGHT_PARTNAME, Type = typeof(StackPanel))]  
    37. [TemplatePart(Name = BOOK_CONTAINER_PARTNAME, Type = typeof(Image))]  
    38. [TemplatePart(Name = GRD_CONTENT_PARTNAME, Type = typeof(Grid))]  
    39. /// <summary>  
    40. /// 作者:王韧竹  
    41. /// 版本:1.1  
    42. /// 根据偏移量算法 计算是否为放大 或者翻页 保证两者不冲突。  
    43. /// 18/6/2013 23：06  
    44. /// windows8 翻书特效组件  
    45. /// </summary>  
    46. public sealed class FlipBookControl : ItemsControl  
    47. {  
    48.     #region Member Variables  
    49.     /// <summary>  
    50.     /// 0 初始 翻页状态1 翻页状态2  
    51.     /// </summary>  
    52.     private int Status = 0;  
    53.     /// <summary>  
    54.     /// 是否翻下一页  
    55.     /// true 下一页 false 上一页  
    56.     /// </summary>  
    57.     private bool isNext = false;  
    58.     /// <summary>  
    59.     /// 触发向左翻页动画  
    60.     /// true 发生偏移  false 停止偏移  
    61.     /// </summary>  
    62.     private bool turnLeft = false;  
    63.     /// <summary>  
    64.     /// 触发向右翻页动画  
    65.     /// true 发生偏移  false 停止偏移  
    66.     /// </summary>  
    67.     private bool turnRight = false;  
    68.     /// <summary>  
    69.     /// 触发向右翻页还原动画  
    70.     /// true 发生偏移  false 停止偏移  
    71.     /// </summary>  
    72.     private bool rightRestore = false;  
    73.     /// <summary>  
    74.     /// 触发向左翻页还原动画  
    75.     /// true 发生偏移  false 停止偏移  
    76.     /// </summary>  
    77.     private bool leftRestore = false;  
    78.     /// <summary>  
    79.     /// 是否多点操作中  
    80.     /// true 是 false 否  
    81.     /// </summary>  
    82.     private bool isManipulating = false;  
    83.     /// <summary>  
    84.     /// 最近一次偏移量  
    85.     /// </summary>  
    86.     private double lastDeltaOffset = 0.0;  
    87.     /// <summary>  
    88.     /// 横向偏移量  
    89.     /// </summary>  
    90.     private double offsetWidth = 0.0;  
    91.     /// <summary>  
    92.     /// 竖向偏移量  
    93.     /// </summary>  
    94.     private double offsetHeight = 0.0;  
    95.     /// <summary>  
    96.     /// 是否加载  
    97.     /// </summary>  
    98.     private bool isLoaded = false;  
    99.     /// <summary>  
    100.     /// 是否初始化  
    101.     /// </summary>  
    102.     private bool isInit = false;  
    103.   
    104.     /// <summary>  
    105.     /// 控制是否翻页  
    106.     /// </summary>  
    107.     private bool isFlip = true;  
    108.   
    109.     /// <summary>  
    110.     /// 是否释放  
    111.     /// </summary>  
    112.     private bool isRelease = true;  
    113.     Border nextPage;  
    114.     Border prevPage;  
    115.     Border leftPage;  
    116.     Border rightPage;  
    117.     Border leftTopPage;  
    118.     Border rightTopPage;  
    119.     CompositeTransform nextTrans;  
    120.     CompositeTransform prevTrans;  
    121.     Border A;  
    122.     Border B;  
    123.     Border C;  
    124.     Border D;  
    125.     Border E;  
    126.     Border F;  
    127.     ContentPresenter APresenter;  
    128.     ContentPresenter BPresenter;  
    129.     ContentPresenter CPresenter;  
    130.     ContentPresenter DPresenter;  
    131.     ContentPresenter EPresenter;  
    132.     ContentPresenter FPresenter;  
    133.     RectangleGeometry ARect;  
    134.     RectangleGeometry BRect;  
    135.     RectangleGeometry CRect;  
    136.     RectangleGeometry DRect;  
    137.     RectangleGeometry ERect;  
    138.     RectangleGeometry FRect;  
    139.     CompositeTransform transA;  
    140.     CompositeTransform transB;  
    141.     CompositeTransform transC;  
    142.     CompositeTransform transD;  
    143.     CompositeTransform transE;  
    144.     CompositeTransform transF;  
    145.     CompositeTransform innerLeftTrans;  
    146.     CompositeTransform outerLeftTrans;  
    147.     CompositeTransform innerRightTrans;  
    148.     CompositeTransform outerRightTrans;  
    149.     CompositeTransform marginLeftTrans;  
    150.     CompositeTransform marginRightTrans;  
    151.     StackPanel stShadowSplitOuterLeft;  
    152.     StackPanel stShadowSplitInnerLeft;  
    153.     StackPanel stShadowSplitOuterRight;  
    154.     StackPanel stShadowSplitInnerRight;  
    155.     StackPanel stShadowMarginLeft;  
    156.     StackPanel stShadowMarginRight;  
    157.     Grid grdContent;  
    158.     Image bookContainer;  
    159.     ImageBrush leftBrush;  
    160.     ImageBrush rightBrush;  
    161.     private TransformGroup _transformGroup;  
    162.     private MatrixTransform _previousTransform;  
    163.     private CompositeTransform _compositeTransform;  
    164.     #endregion  
    165.  
    166.     #region Template Part  
    167.     /// <summary>  
    168.     /// 矩形  
    169.     /// </summary>  
    170.     const string A_PARTNAME = "A";  
    171.     /// <summary>  
    172.     /// 矩形遮掩  
    173.     /// </summary>  
    174.     const string A_RECT_PARTNAME = "ARect";  
    175.     /// <summary>  
    176.     /// 矩形偏移  
    177.     /// </summary>  
    178.     const string A_TRANS_PARTNAME = "transA";  
    179.     const string A_PRESENTER_PARTNAME = "APresenter";  
    180.     const string B_PARTNAME = "B";  
    181.     const string B_RECT_PARTNAME = "BRect";  
    182.     const string B_TRANS_PARTNAME = "transB";  
    183.     const string B_PRESENTER_PARTNAME = "BPresenter";  
    184.     const string C_PARTNAME = "C";  
    185.     const string C_RECT_PARTNAME = "CRect";  
    186.     const string C_TRANS_PARTNAME = "transC";  
    187.     const string C_PRESENTER_PARTNAME = "CPresenter";  
    188.     const string D_PARTNAME = "D";  
    189.     const string D_RECT_PARTNAME = "DRect";  
    190.     const string D_TRANS_PARTNAME = "transD";  
    191.     const string D_PRESENTER_PARTNAME = "DPresenter";  
    192.     const string E_PARTNAME = "E";  
    193.     const string E_RECT_PARTNAME = "ERect";  
    194.     const string E_TRANS_PARTNAME = "transE";  
    195.     const string E_PRESENTER_PARTNAME = "EPresenter";  
    196.     const string F_PARTNAME = "F";  
    197.     const string F_RECT_PARTNAME = "FRect";  
    198.     const string F_TRANS_PARTNAME = "transF";  
    199.     const string F_PRESENTER_PARTNAME = "FPresenter";  
    200.     const string ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME = "stShadowSplitOuterRight";  
    201.     const string ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME = "stShadowSplitInnerRight";  
    202.     const string ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME = "stShadowSplitOuterLeft";  
    203.     const string ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME = "stShadowSplitInnerLeft";  
    204.     const string ST_SHADOW_MARGIN_LEFT_PARTNAME = "stShadowMarginLeft";  
    205.     const string ST_SHADOW_MARGIN_RIGHT_PARTNAME = "stShadowMarginRight";  
    206.     const string OUTER_LEFT_TRANS_PARTNAME = "outerLeftTrans";  
    207.     const string INNER_LEFT_TRANS_PARTNAME = "innerLeftTrans";  
    208.     const string OUTER_RIGHT_TRANS_PARTNAME = "outerRightTrans";  
    209.     const string INNER_RIGHT_TRANS_PARTNAME = "innerRightTrans";  
    210.     const string MARGIN_LEFT_TRANS_PARTNAME = "marginLeftTrans";  
    211.     const string MARGIN_RIGHT_TRANS_PARTNAME = "marginRightTrans";  
    212.     /// <summary>  
    213.     /// 书壳  
    214.     /// </summary>  
    215.     const string BOOK_CONTAINER_PARTNAME = "bookContainer";  
    216.     const string GRD_CONTENT_PARTNAME = "grdContent";  
    217.     #endregion  
    218.  
    219.     #region DependencyProperties  
    220.     #region DelayLoad  
    221.     public TimeSpan DelayLoad  
    222.     {  
    223.         get { return (TimeSpan)GetValue(DelayLoadProperty); }  
    224.         set { SetValue(DelayLoadProperty, value); }  
    225.     }  
    226.   
    227.     // Using a DependencyProperty as the backing store for DelayLoad.  This enables animation, styling, binding, etc...  
    228.     public static readonly DependencyProperty DelayLoadProperty =  
    229.         DependencyProperty.Register("DelayLoad", typeof(TimeSpan), typeof(FlipBookControl), new PropertyMetadata(TimeSpan.FromSeconds(0)));  
    230.     #endregion  
    231.  
    232.     #region BookBackgroundBrush  
    233.     public ImageBrush BookBackgroundBrush  
    234.     {  
    235.         get { return (ImageBrush)GetValue(BookBackgroundBrushProperty); }  
    236.         set { SetValue(BookBackgroundBrushProperty, value); }  
    237.     }  
    238.   
    239.     // Using a DependencyProperty as the backing store for BookBackgroundBrush.  This enables animation, styling, binding, etc...  
    240.     public static readonly DependencyProperty BookBackgroundBrushProperty =  
    241.         DependencyProperty.Register("BookBackgroundBrush", typeof(ImageBrush), typeof(FlipBookControl), new PropertyMetadata(null, OnBookBackgroundBrushChangedCallBack));  
    242.   
    243.     private static async void OnBookBackgroundBrushChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)  
    244.     {  
    245.   
    246.         var ctrl = (d as FlipBookControl);  
    247.         if (ctrl.isLoaded)  
    248.             await ctrl.GetCropBrush();  
    249.     }  
    250.     #endregion  
    251.  
    252.     #region Speed  
    253.     /// <summary>  
    254.     /// 动画速度 默认为30pixel  
    255.     /// </summary>  
    256.     public int Speed  
    257.     {  
    258.         get { return (int)GetValue(SpeedProperty); }  
    259.         set { SetValue(SpeedProperty, value); }  
    260.     }  
    261.   
    262.     // Using a DependencyProperty as the backing store for Speed.  This enables animation, styling, binding, etc...  
    263.     public static readonly DependencyProperty SpeedProperty =  
    264.         DependencyProperty.Register("Speed", typeof(int), typeof(FlipBookControl), new PropertyMetadata(30));  
    265.     #endregion  
    266.  
    267.     #region BookContainerSource  
    268.     public ImageSource BookContainerSource  
    269.     {  
    270.         get { return (ImageSource)GetValue(BookContainerSourceProperty); }  
    271.         set { SetValue(BookContainerSourceProperty, value); }  
    272.     }  
    273.   
    274.     // Using a DependencyProperty as the backing store for BookContainerSource.  This enables animation, styling, binding, etc...  
    275.     public static readonly DependencyProperty BookContainerSourceProperty =  
    276.         DependencyProperty.Register("BookContainerSource", typeof(ImageSource), typeof(FlipBookControl), new PropertyMetadata(null, OnBookContainerSourceChangedCallBack));  
    277.   
    278.     private static void OnBookContainerSourceChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)  
    279.     {  
    280.         var ctrl = (d as FlipBookControl);  
    281.         if (null != ctrl.BookContainerSource && ctrl.bookContainer != null && ctrl.isLoaded)  
    282.             ctrl.bookContainer.Source = ctrl.BookContainerSource;  
    283.     }  
    284.  
    285.     #endregion  
    286.  
    287.     #region PageIndex  
    288.     public int PageIndex  
    289.     {  
    290.         get { return (int)GetValue(PageIndexProperty); }  
    291.         set { SetValue(PageIndexProperty, value); }  
    292.     }  
    293.   
    294.     // Using a DependencyProperty as the backing store for PageIndex.  This enables animation, styling, binding, etc...  
    295.     public static readonly DependencyProperty PageIndexProperty =  
    296.         DependencyProperty.Register("PageIndex", typeof(int), typeof(FlipBookControl), new PropertyMetadata(0, OnPageIndexChangedCallBack));  
    297.   
    298.     private static void OnPageIndexChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)  
    299.     {  
    300.         var ctrl = (d as FlipBookControl);  
    301.         if (ctrl.isLoaded)  
    302.         {  
    303.             var isNext = Convert.ToInt32(e.NewValue) > Convert.ToInt32(e.OldValue);  
    304.             var presenters = ctrl.GetPresentersByPageIndex(isNext);  
    305.             if (null != presenters)  
    306.                 ctrl.LoadPageContentByPageIndex(Convert.ToInt32(e.NewValue), isNext, presenters[0], presenters[1]);  
    307.         }  
    308.     }  
    309.     #endregion  
    310.  
    311.     #region DisposeAction  
    312.     public Action<object> DisposeAction  
    313.     {  
    314.         get { return (Action<object>)GetValue(DisposeActionProperty); }  
    315.         set { SetValue(DisposeActionProperty, value); }  
    316.     }  
    317.   
    318.     // Using a DependencyProperty as the backing store for DisposeAction.  This enables animation, styling, binding, etc...  
    319.     public static readonly DependencyProperty DisposeActionProperty =  
    320.         DependencyProperty.Register("DisposeAction", typeof(Action<object>), typeof(FlipBookControl), new PropertyMetadata(null));  
    321.     #endregion  
    322.  
    323.     #region RestoreItemAction  
    324.     public Action<object> RestoreItemAction  
    325.     {  
    326.         get { return (Action<object>)GetValue(RestoreItemActionProperty); }  
    327.         set { SetValue(RestoreItemActionProperty, value); }  
    328.     }  
    329.   
    330.     // Using a DependencyProperty as the backing store for RestoreItemAction.  This enables animation, styling, binding, etc...  
    331.     public static readonly DependencyProperty RestoreItemActionProperty =  
    332.         DependencyProperty.Register("RestoreItemAction", typeof(Action<object>), typeof(FlipBookControl), new PropertyMetadata(null));  
    333.     #endregion  
    334.  
    335.     #region CanScale  
    336.     public bool CanScale  
    337.     {  
    338.         get { return (bool)GetValue(CanScaleProperty); }  
    339.         set { SetValue(CanScaleProperty, value); }  
    340.     }  
    341.   
    342.     // 能否进行放大缩小  
    343.     public static readonly DependencyProperty CanScaleProperty =  
    344.         DependencyProperty.Register("CanScale", typeof(bool), typeof(FlipBookControl), new PropertyMetadata(false));  
    345.     #endregion  
    346.     #endregion  
    347.  
    348.     #region Event  
    349.     /// <summary>  
    350.     /// 翻书结束事件  
    351.     /// </summary>  
    352.     private delegate void Fliped(object sender, FlipEventArgs args);  
    353.   
    354.     private event Fliped Fliping;  
    355.     /// <summary>  
    356.     /// 加载事件  
    357.     /// </summary>  
    358.     /// <param name="sender"></param>  
    359.     /// <param name="args"></param>  
    360.     public delegate void NeedLoadItems(object sender, FlipLoadArgs args);  
    361.   
    362.     public event NeedLoadItems NeedLoadingItem;  
    363.     #endregion  
    364.  
    365.     #region Constructor  
    366.     public FlipBookControl()  
    367.     {  
    368.         this.DefaultStyleKey = typeof(FlipBookControl);  
    369.         this.Loaded += FlipBookControlLoaded;  
    370.         this.Unloaded += FlipBookControlUnLoaded;  
    371.         CompositionTarget.Rendering += RenderAnimation;  
    372.         this.Fliping += FlipEnded;  
    373.     }  
    374.   
    375.     /// <summary>  
    376.     /// 初始化完毕开始载入数据  
    377.     /// </summary>  
    378.     /// <param name="sender"></param>  
    379.     /// <param name="e"></param>  
    380.     private async void FlipBookControlLoaded(object sender, RoutedEventArgs e)  
    381.     {  
    382.         grdContent.ManipulationMode =  
    383.           ManipulationModes.TranslateInertia |  
    384.           ManipulationModes.TranslateX |  
    385.           ManipulationModes.Scale |  
    386.           ManipulationModes.ScaleInertia |  
    387.           ManipulationModes.TranslateY;  
    388.         grdContent.ManipulationDelta += FlipManipulationDelta;  
    389.         grdContent.ManipulationCompleted += FlipManipulationCompleted;  
    390.         grdContent.ManipulationStarting += FlipManipulationStarting;  
    391.         grdContent.ManipulationInertiaStarting += FlipManipulationInertiaStarting;  
    392.         A.PointerPressed += PointerPressed;  
    393.         B.PointerPressed += PointerPressed;  
    394.         C.PointerPressed += PointerPressed;  
    395.         D.PointerPressed += PointerPressed;  
    396.         E.PointerPressed += PointerPressed;  
    397.         F.PointerPressed += PointerPressed;  
    398.         offsetWidth = A.ActualWidth;  
    399.         offsetHeight = A.ActualHeight;  
    400.         await GetCropBrush();  
    401.         bookContainer.Source = BookContainerSource;  
    402.         RefreshPageByStatus();  
    403.         InitPages();  
    404.         isLoaded = true;  
    405.     }  
    406.   
    407.     private void FlipBookControlUnLoaded(object sender, RoutedEventArgs e)  
    408.     {  
    409.         CompositionTarget.Rendering -= RenderAnimation;  
    410.         grdContent.ManipulationDelta -= FlipManipulationDelta;  
    411.         grdContent.ManipulationCompleted -= FlipManipulationCompleted;  
    412.         grdContent.ManipulationStarting -= FlipManipulationStarting;  
    413.         grdContent.ManipulationInertiaStarting -= FlipManipulationInertiaStarting;  
    414.         this.Fliping -= FlipEnded;  
    415.         A.PointerPressed -= PointerPressed;  
    416.         B.PointerPressed -= PointerPressed;  
    417.         C.PointerPressed -= PointerPressed;  
    418.         D.PointerPressed -= PointerPressed;  
    419.         E.PointerPressed -= PointerPressed;  
    420.         F.PointerPressed -= PointerPressed;  
    421.     }  
    422.   
    423.     public void InitPosition()  
    424.     {  
    425.         _compositeTransform = new CompositeTransform();  
    426.         _previousTransform = new MatrixTransform() { Matrix = Matrix.Identity };  
    427.         _transformGroup = new TransformGroup();  
    428.         _transformGroup.Children.Add(_previousTransform);  
    429.         _transformGroup.Children.Add(_compositeTransform);  
    430.         this.RenderTransform = _transformGroup;  
    431.     }  
    432.   
    433.     public async void InitPages()  
    434.     {  
    435.         if (!isInit && PageIndex == 0 && this.Items.Count > 0)  
    436.         {  
    437.             await Task.Delay(DelayLoad);  
    438.             List<object> needLoadItems = new List<object>();  
    439.             //第一次加载 载入4页  
    440.             CPresenter.DataContext = this.Items[0];  
    441.             needLoadItems.Add(Items[0]);  
    442.             if (this.Items.Count > 1)  
    443.             {  
    444.                 DPresenter.DataContext = this.Items[1];  
    445.                 needLoadItems.Add(Items[1]);  
    446.             }  
    447.             if (this.Items.Count > 2)  
    448.             {  
    449.                 EPresenter.DataContext = this.Items[2];  
    450.                 needLoadItems.Add(Items[2]);  
    451.             }  
    452.             if (this.Items.Count > 3)  
    453.             {  
    454.                 FPresenter.DataContext = this.Items[3];  
    455.                 needLoadItems.Add(Items[3]);  
    456.             }  
    457.             if (null != NeedLoadingItem)  
    458.                 NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, false));  
    459.             isInit = true;  
    460.         }  
    461.         else  
    462.         {  
    463.             Status = 0;  
    464.             this.PageIndex = 0;  
    465.             if (null != APresenter)  
    466.             {  
    467.                 APresenter.DataContext = null;  
    468.                 BPresenter.DataContext = null;  
    469.                 CPresenter.DataContext = null;  
    470.                 DPresenter.DataContext = null;  
    471.                 EPresenter.DataContext = null;  
    472.                 FPresenter.DataContext = null;  
    473.             }  
    474.         }  
    475.         InitPosition();  
    476.     }  
    477.     #endregion  
    478.  
    479.     #region EventMethod  
    480.     #region OnApplyTemplate  
    481.     protected override void OnApplyTemplate()  
    482.     {  
    483.         bookContainer = GetTemplateChild(BOOK_CONTAINER_PARTNAME) as Image;  
    484.         A = GetTemplateChild(A_PARTNAME) as Border;  
    485.         B = GetTemplateChild(B_PARTNAME) as Border;  
    486.         C = GetTemplateChild(C_PARTNAME) as Border;  
    487.         D = GetTemplateChild(D_PARTNAME) as Border;  
    488.         E = GetTemplateChild(E_PARTNAME) as Border;  
    489.         F = GetTemplateChild(F_PARTNAME) as Border;  
    490.         APresenter = GetTemplateChild(A_PRESENTER_PARTNAME) as ContentPresenter;  
    491.         BPresenter = GetTemplateChild(B_PRESENTER_PARTNAME) as ContentPresenter;  
    492.         CPresenter = GetTemplateChild(C_PRESENTER_PARTNAME) as ContentPresenter;  
    493.         DPresenter = GetTemplateChild(D_PRESENTER_PARTNAME) as ContentPresenter;  
    494.         EPresenter = GetTemplateChild(E_PRESENTER_PARTNAME) as ContentPresenter;  
    495.         FPresenter = GetTemplateChild(F_PRESENTER_PARTNAME) as ContentPresenter;  
    496.         ARect = GetTemplateChild(A_RECT_PARTNAME) as RectangleGeometry;  
    497.         BRect = GetTemplateChild(B_RECT_PARTNAME) as RectangleGeometry;  
    498.         CRect = GetTemplateChild(C_RECT_PARTNAME) as RectangleGeometry;  
    499.         DRect = GetTemplateChild(D_RECT_PARTNAME) as RectangleGeometry;  
    500.         ERect = GetTemplateChild(E_RECT_PARTNAME) as RectangleGeometry;  
    501.         FRect = GetTemplateChild(F_RECT_PARTNAME) as RectangleGeometry;  
    502.         transA = GetTemplateChild(A_TRANS_PARTNAME) as CompositeTransform;  
    503.         transB = GetTemplateChild(B_TRANS_PARTNAME) as CompositeTransform;  
    504.         transC = GetTemplateChild(C_TRANS_PARTNAME) as CompositeTransform;  
    505.         transD = GetTemplateChild(D_TRANS_PARTNAME) as CompositeTransform;  
    506.         transE = GetTemplateChild(E_TRANS_PARTNAME) as CompositeTransform;  
    507.         transF = GetTemplateChild(F_TRANS_PARTNAME) as CompositeTransform;  
    508.         grdContent = GetTemplateChild(GRD_CONTENT_PARTNAME) as Grid;  
    509.         innerLeftTrans = GetTemplateChild(INNER_LEFT_TRANS_PARTNAME) as CompositeTransform;  
    510.         outerLeftTrans = GetTemplateChild(OUTER_LEFT_TRANS_PARTNAME) as CompositeTransform;  
    511.         innerRightTrans = GetTemplateChild(INNER_RIGHT_TRANS_PARTNAME) as CompositeTransform;  
    512.         outerRightTrans = GetTemplateChild(OUTER_RIGHT_TRANS_PARTNAME) as CompositeTransform;  
    513.         marginLeftTrans = GetTemplateChild(MARGIN_LEFT_TRANS_PARTNAME) as CompositeTransform;  
    514.         marginRightTrans = GetTemplateChild(MARGIN_RIGHT_TRANS_PARTNAME) as CompositeTransform;  
    515.         stShadowSplitInnerLeft = GetTemplateChild(ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME) as StackPanel;  
    516.         stShadowSplitOuterLeft = GetTemplateChild(ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME) as StackPanel;  
    517.         stShadowSplitInnerRight = GetTemplateChild(ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME) as StackPanel;  
    518.         stShadowSplitOuterRight = GetTemplateChild(ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME) as StackPanel;  
    519.         stShadowMarginLeft = GetTemplateChild(ST_SHADOW_MARGIN_LEFT_PARTNAME) as StackPanel;  
    520.         stShadowMarginRight = GetTemplateChild(ST_SHADOW_MARGIN_RIGHT_PARTNAME) as StackPanel;  
    521.         base.OnApplyTemplate();  
    522.     }  
    523.     #endregion  
    524.  
    525.     #region PointerPressed  
    526.     /// <summary>  
    527.     /// 确定翻页方向  
    528.     /// </summary>  
    529.     /// <param name="sender"></param>  
    530.     /// <param name="e"></param>  
    531.     private void PointerPressed(object sender, PointerRoutedEventArgs e)  
    532.     {  
    533.         if (!isManipulating)  
    534.         {  
    535.             if (sender.Equals(leftPage))  
    536.                 isNext = false;  
    537.             else if (sender.Equals(rightPage))  
    538.                 isNext = true;  
    539.             else  
    540.                 RefreshPageByStatus();  
    541.             Debug.WriteLine("按下:" + isNext);  
    542.             Debug.WriteLine("点击的壳:" + (sender as Border).Name + " 左页壳:" + (sender as Border).Name);  
    543.         }  
    544.     }  
    545.     #endregion  
    546.  
    547.     #region OnPointerReleased  
    548.     protected override void OnPointerReleased(PointerRoutedEventArgs e)  
    549.     {  
    550.         base.OnPointerReleased(e);  
    551.     }  
    552.     #endregion  
    553.  
    554.     #region FlipEnded  
    555.     /// <summary>  
    556.     /// 翻页完毕  
    557.     /// </summary>  
    558.     /// <param name="sender"></param>  
    559.     /// <param name="args"></param>  
    560.     private async void FlipEnded(object sender, FlipEventArgs args)  
    561.     {  
    562.         Debug.WriteLine("翻页完毕:" + args.isNext);  
    563.         if (args.isNext) PageIndex += 2;  
    564.         else PageIndex -= 2;  
    565.         await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>  
    566.         RefreshPageByStatus());  
    567.     }  
    568.     #endregion  
    569.  
    570.     #region Manipulation  多点触控操作翻书特效  
    571.     #region FlipManipulationStarting  
    572.     private void FlipManipulationStarting(object sender, ManipulationStartingRoutedEventArgs e)  
    573.     {  
    574.         isManipulating = true;  
    575.         e.Handled = true;  
    576.         if (isNext)  
    577.         {  
    578.             if (PageIndex >= this.Items.Count - 2)  
    579.             {  
    580.                 isFlip = false;  
    581.                 isManipulating = false;  
    582.             }  
    583.         }  
    584.         else  
    585.         {  
    586.             if (this.PageIndex == 0)  
    587.             {  
    588.                 isFlip = false;  
    589.                 isManipulating = false;  
    590.             }  
    591.         }  
    592.     }  
    593.     #endregion  
    594.  
    595.     #region FlipManipulationInertiaStarting  
    596.     private void FlipManipulationInertiaStarting(object sender, ManipulationInertiaStartingRoutedEventArgs e)  
    597.     {  
    598.         e.TranslationBehavior.DesiredDeceleration = 5 * 96.0 / (1000.0 * 1000.0);  
    599.         e.ExpansionBehavior.DesiredDeceleration = 100 * 96 / 1000.0 * 1000.0;  
    600.     }  
    601.     #endregion  
    602.  
    603.     #region FlipManipulationCompleted  
    604.     private async void FlipManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e)  
    605.     {  
    606.         isManipulating = false;  
    607.         if (isFlip)  
    608.         {  
    609.             IsHitVisible(false);  
    610.             var leftTopOffset = leftTopPage.Clip.Rect.X;  
    611.             var rightTopOffset = rightTopPage.Clip.Rect.X;  
    612.             await Task.Run(() =>  
    613.             {  
    614.                 if (isNext)  
    615.                 {  
    616.                     if (lastDeltaOffset < 0)  
    617.                     {  
    618.                         Status = Status < 2 ? Status + 1 : 0;  
    619.                         turnRight = true;  
    620.                     }  
    621.                     else if (rightTopOffset != 0.0)  
    622.                         rightRestore = true;  
    623.                     else IsHitVisible(true);  
    624.                     Debug.WriteLine("下一页:" + turnRight);  
    625.                 }  
    626.                 else  
    627.                 {  
    628.                     if (lastDeltaOffset > 0)  
    629.                     {  
    630.                         Status = Status > 0 ? Status - 1 : 2;  
    631.                         turnLeft = true;  
    632.                     }  
    633.                     else if (leftTopOffset != 0.0)  
    634.                         leftRestore = true;  
    635.                     else IsHitVisible(true);  
    636.                     Debug.WriteLine("上一页" + turnLeft);  
    637.                 }  
    638.             });  
    639.   
    640.             Debug.WriteLine("翻页状态:" + Status);  
    641.         }  
    642.         isFlip = true;  
    643.         CanScale = false;  
    644.     }  
    645.     #endregion  
    646.  
    647.     #region FlipManipulationDelta  
    648.     private void FlipManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)  
    649.     {  
    650.         var scale = e.Delta.Scale;  
    651.         var translateX = e.Delta.Translation.X;  
    652.         var translateY = e.Delta.Translation.Y;  
    653.         var nTtranX = nextTrans.TranslateX;  
    654.         var nTtranY = nextTrans.TranslateY;  
    655.         var ctranlateX = e.Cumulative.Translation.X;  
    656.         var ctranlateY = e.Cumulative.Translation.Y;  
    657.         CanScale = Task.Run(() =>  
    658.         {  
    659.             if (scale != 1.0 || (Math.Abs(ctranlateX * 1.15) < Math.Abs(ctranlateY))) return true;  
    660.             else return false;  
    661.         }).Result;  
    662.         if (isManipulating && !CanScale)  
    663.         {  
    664.             if (isNext)  
    665.             {  
    666.                 #region 下一页  
    667.                 var rightTopNect = rightTopPage.Clip.Rect;  
    668.                 var nextRect = nextPage.Clip.Rect;  
    669.                 var nextTransOffset = nTtranX + translateX * 2;  
    670.   
    671.                 SetShadowOperacity(Math.Abs(nextTransOffset), offsetWidth, false);  
    672.                 var nextRectXOffset = nextRect.X - e.Delta.Translation.X;  
    673.                 lastDeltaOffset = e.Delta.Translation.X;  
    674.                 if (nextRectXOffset < 0 && nextRectXOffset > -offsetWidth)  
    675.                 {  
    676.                     outerRightTrans.TranslateX += e.Delta.Translation.X;  
    677.                     innerRightTrans.TranslateX += e.Delta.Translation.X;  
    678.                     marginRightTrans.TranslateX += e.Delta.Translation.X * 2;  
    679.   
    680.                     nextTrans.TranslateX = nextTransOffset;  
    681.                     if (nextRectXOffset < 0)  
    682.                         nextRect.X = nextRectXOffset;  
    683.                     rightTopNect.X += e.Delta.Translation.X;  
    684.                     nextPage.Clip.Rect = nextRect;  
    685.                     rightTopPage.Clip.Rect = rightTopNect;  
    686.                 }  
    687.                 else  
    688.                 {  
    689.                     e.Complete();  
    690.                     if (nextTransOffset < 0)  
    691.                     {  
    692.                         nextTrans.TranslateX = -offsetWidth;  
    693.                         nextRect.X = 0;  
    694.                         rightTopNect.X = 0;  
    695.                         nextPage.Clip.Rect = nextRect;  
    696.                         rightTopPage.Clip.Rect = rightTopNect;  
    697.                     }  
    698.                     else  
    699.                     {  
    700.                         nextTrans.TranslateX = offsetWidth;  
    701.                         nextRect.X = -offsetWidth;  
    702.                         rightTopNect.X = offsetWidth;  
    703.                         nextPage.Clip.Rect = nextRect;  
    704.                         rightTopPage.Clip.Rect = rightTopNect;  
    705.                     }  
    706.                 }  
    707.                 #endregion  
    708.             }  
    709.             else  
    710.             {  
    711.                 #region 上一页  
    712.                 var leftTopNect = leftTopPage.Clip.Rect;  
    713.                 var prevRect = prevPage.Clip.Rect;  
    714.                 var prevTransOffset = prevTrans.TranslateX + e.Delta.Translation.X * 2;  
    715.                 var prevRectXOffset = prevRect.X - e.Delta.Translation.X;  
    716.                 SetShadowOperacity(Math.Abs(prevTransOffset), offsetWidth, true);  
    717.                 lastDeltaOffset = e.Delta.Translation.X;  
    718.                 if (prevRectXOffset > 0 && prevRectXOffset < offsetWidth)  
    719.                 {  
    720.                     innerLeftTrans.TranslateX += translateX;  
    721.                     outerLeftTrans.TranslateX += translateX;  
    722.                     marginLeftTrans.TranslateX += translateX * 2;  
    723.   
    724.                     prevTrans.TranslateX = prevTransOffset;  
    725.                     if (prevRectXOffset > 0)  
    726.                         prevRect.X = prevRectXOffset;  
    727.                     leftTopNect.X += e.Delta.Translation.X;  
    728.                     prevPage.Clip.Rect = prevRect;  
    729.                     leftTopPage.Clip.Rect = leftTopNect;  
    730.                 }  
    731.                 else  
    732.                 {  
    733.                     e.Complete();  
    734.                     if (prevTransOffset < 0)  
    735.                     {  
    736.                         prevTrans.TranslateX = -offsetWidth;  
    737.                         prevRect.X = offsetWidth;  
    738.                         leftTopNect.X = -offsetWidth;  
    739.                         prevPage.Clip.Rect = prevRect;  
    740.                         leftTopPage.Clip.Rect = leftTopNect;  
    741.   
    742.                     }  
    743.                     else  
    744.                     {  
    745.                         prevTrans.TranslateX = offsetWidth;  
    746.                         prevRect.X = 0;  
    747.                         leftTopNect.X = 0;  
    748.                         prevPage.Clip.Rect = prevRect;  
    749.                         leftTopPage.Clip.Rect = leftTopNect;  
    750.                     }  
    751.                 }  
    752.                 #endregion  
    753.             }  
    754.         }  
    755.         if (CanScale)  
    756.         {  
    757.             _previousTransform.Matrix = _transformGroup.Value;  
    758.             Point center = _previousTransform.TransformPoint(new Point(e.Position.X, e.Position.Y));  
    759.             _compositeTransform.CenterX = center.X;  
    760.             _compositeTransform.CenterY = center.Y;  
    761.             _compositeTransform.ScaleX = e.Delta.Scale;  
    762.             _compositeTransform.ScaleY = e.Delta.Scale;  
    763.             _compositeTransform.TranslateX = e.Delta.Translation.X;  
    764.             _compositeTransform.TranslateY = e.Delta.Translation.Y;  
    765.         }  
    766.     }  
    767.     #endregion  
    768.     #endregion  
    769.  
    770.     #region RenderAnimation 绘制翻页动画  
    771.     private void RenderAnimation(object sender, object e)  
    772.     {  
    773.         if (turnLeft)  
    774.         {  
    775.             rightRestore = false;  
    776.             turnRight = false;  
    777.             var prevRect = prevPage.Clip.Rect;  
    778.             var leftTopRect = leftTopPage.Clip.Rect;  
    779.             var prevOffset = prevRect.X - Speed / 2;  
    780.             if (prevOffset > 0)  
    781.             {  
    782.                 prevRect.X = prevOffset;  
    783.                 prevTrans.TranslateX += Speed;  
    784.                 leftTopRect.X += Speed / 2;  
    785.                 innerLeftTrans.TranslateX += Speed / 2;  
    786.                 outerLeftTrans.TranslateX += Speed / 2;  
    787.                 marginLeftTrans.TranslateX += Speed;  
    788.                 SetShadowOperacity(Math.Abs(prevTrans.TranslateX), offsetWidth, true);  
    789.             }  
    790.             else  
    791.             {  
    792.                 prevRect.X = 0;  
    793.                 leftTopRect.X = 0;  
    794.                 turnLeft = false;  
    795.                 prevTrans.TranslateX = offsetWidth;  
    796.                 Fliping(sender, new FlipEventArgs(false));  
    797.   
    798.             }  
    799.             prevPage.Clip.Rect = prevRect;  
    800.             leftTopPage.Clip.Rect = leftTopRect;  
    801.             IsHitVisible(true);  
    802.         }  
    803.         else if (leftRestore)  
    804.         {  
    805.             turnLeft = false;  
    806.             turnRight = false;  
    807.             rightRestore = false;  
    808.             var prevRect = prevPage.Clip.Rect;  
    809.             var leftTopRect = leftTopPage.Clip.Rect;  
    810.             var prevOffset = prevRect.X + Speed / 2;  
    811.             if (prevOffset < offsetWidth)  
    812.             {  
    813.                 prevRect.X = prevOffset;  
    814.                 prevTrans.TranslateX -= Speed;  
    815.                 leftTopRect.X -= Speed / 2;  
    816.                 innerLeftTrans.TranslateX -= Speed / 2;  
    817.                 outerLeftTrans.TranslateX -= Speed / 2;  
    818.                 marginLeftTrans.TranslateX -= Speed;  
    819.                 SetShadowOperacity(Math.Abs(prevTrans.TranslateX), offsetWidth, true);  
    820.             }  
    821.             else  
    822.             {  
    823.                 prevRect.X = offsetWidth;  
    824.                 leftTopRect.X = -offsetWidth;  
    825.                 prevTrans.TranslateX = -offsetWidth;  
    826.                 innerLeftTrans.TranslateX = 0;  
    827.                 outerLeftTrans.TranslateX = 0;  
    828.                 marginLeftTrans.TranslateX = 0;  
    829.                 leftRestore = false;  
    830.   
    831.             }  
    832.             prevPage.Clip.Rect = prevRect;  
    833.             leftTopPage.Clip.Rect = leftTopRect;  
    834.             IsHitVisible(true);  
    835.         }  
    836.         else if (turnRight)  
    837.         {  
    838.   
    839.             rightRestore = false;  
    840.             turnLeft = false;  
    841.             var nextRect = nextPage.Clip.Rect;  
    842.             var rightTopRect = rightTopPage.Clip.Rect;  
    843.             var nextOffset = nextRect.X + Speed / 2;  
    844.             if (nextOffset < 0)  
    845.             {  
    846.                 nextRect.X = nextOffset;  
    847.                 nextTrans.TranslateX -= Speed;  
    848.                 rightTopRect.X -= Speed / 2;  
    849.                 innerRightTrans.TranslateX -= Speed / 2;  
    850.                 outerRightTrans.TranslateX -= Speed / 2;  
    851.                 marginRightTrans.TranslateX -= Speed;  
    852.                 SetShadowOperacity(Math.Abs(nextTrans.TranslateX), offsetWidth, false);  
    853.             }  
    854.             else  
    855.             {  
    856.                 nextRect.X = 0;  
    857.                 nextTrans.TranslateX = -offsetWidth;  
    858.                 turnRight = false;  
    859.                 rightTopRect.X = 0;  
    860.                 Fliping(sender, new FlipEventArgs(true));  
    861.             }  
    862.             nextPage.Clip.Rect = nextRect;  
    863.             rightTopPage.Clip.Rect = rightTopRect;  
    864.             IsHitVisible(true);  
    865.         }  
    866.         else if (rightRestore)  
    867.         {  
    868.   
    869.             turnRight = false;  
    870.             turnLeft = false;  
    871.             leftRestore = false;  
    872.             var nextRect = nextPage.Clip.Rect;  
    873.             var rightTopRect = rightTopPage.Clip.Rect;  
    874.             var nextOffset = nextRect.X - Speed / 2;  
    875.             if (nextRect.X - Speed / 2 > -offsetWidth)  
    876.             {  
    877.                 nextRect.X = nextOffset;  
    878.                 nextTrans.TranslateX += Speed;  
    879.                 rightTopRect.X += Speed / 2;  
    880.                 innerRightTrans.TranslateX += Speed / 2;  
    881.                 outerRightTrans.TranslateX += Speed / 2;  
    882.                 marginRightTrans.TranslateX += Speed;  
    883.                 SetShadowOperacity(Math.Abs(nextTrans.TranslateX), offsetWidth, false);  
    884.             }  
    885.             else  
    886.             {  
    887.                 nextRect.X = -offsetWidth;  
    888.                 rightTopRect.X = offsetWidth;  
    889.                 nextTrans.TranslateX = offsetWidth;  
    890.                 innerRightTrans.TranslateX = 0;  
    891.                 outerRightTrans.TranslateX = 0;  
    892.                 marginRightTrans.TranslateX = 0;  
    893.                 rightRestore = false;  
    894.             }  
    895.             rightTopPage.Clip.Rect = rightTopRect;  
    896.             nextPage.Clip.Rect = nextRect;  
    897.             IsHitVisible(true);  
    898.         }  
    899.     }  
    900.     #endregion  
    901.     #endregion  
    902.  
    903.     #region Method  
    904.     #region LoadPageContentByPageIndex  
    905.     private void LoadPageContentByPageIndex(int PageIndex, bool isNextOrPrev, ContentPresenter firstPresenter, ContentPresenter secondPresenter)  
    906.     {  
    907.         List<object> needLoadItems = new List<object>();  
    908.         if (isNextOrPrev)  
    909.         {  
    910.             //加载下一页模板  
    911.             if (PageIndex + 2 < this.Items.Count)  
    912.             {  
    913.                 firstPresenter.Content = null;  
    914.                 firstPresenter.DataContext = null;  
    915.                 object item = null;  
    916.                 if (this.Items.Count > PageIndex + 2)  
    917.                 {  
    918.                     item = this.Items[PageIndex + 2];  
    919.                     needLoadItems.Add(item);  
    920.                     firstPresenter.DataContext = item;  
    921.                 }  
    922.             }  
    923.             else firstPresenter.DataContext = null;  
    924.             if (PageIndex + 3 < this.Items.Count)  
    925.             {  
    926.                 object item = null;  
    927.                 secondPresenter.Content = null;  
    928.                 secondPresenter.DataContext = null;  
    929.                 if (this.Items.Count > PageIndex + 3)  
    930.                 {  
    931.                     item = this.Items[PageIndex + 3];  
    932.                     needLoadItems.Add(item);  
    933.                     secondPresenter.DataContext = item;  
    934.                 }  
    935.             }  
    936.             else secondPresenter.DataContext = null;  
    937.             if (null != NeedLoadingItem)  
    938.                 NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, true));  
    939.             RecycleData(true, needLoadItems);  
    940.         }  
    941.         else  
    942.         {  
    943.             if (PageIndex - 2 >= 0 && Items.Count > PageIndex - 2)  
    944.             {  
    945.                 needLoadItems.Add(this.Items[PageIndex - 2]);  
    946.                 secondPresenter.Content = null;  
    947.                 secondPresenter.DataContext = null;  
    948.                 secondPresenter.DataContext = this.Items[PageIndex - 2];  
    949.             }  
    950.             if (PageIndex - 1 >= 0 && Items.Count > PageIndex - 1)  
    951.             {  
    952.                 firstPresenter.Content = null;  
    953.                 firstPresenter.DataContext = null;  
    954.                 firstPresenter.DataContext = this.Items[PageIndex - 1];  
    955.                 needLoadItems.Add(this.Items[PageIndex - 1]);  
    956.             }  
    957.             //加载上一页模板  
    958.             if (null != NeedLoadingItem)  
    959.                 NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, false));  
    960.             RecycleData(false, needLoadItems);  
    961.         }  
    962.     }  
    963.     #endregion  
    964.  
    965.     #region RecycleData  
    966.     private async void RecycleData(bool isNext, List<object> needItems)  
    967.     {  
    968.         await Task.Run(async () =>  
    969.         {  
    970.             foreach (var o in needItems)  
    971.             {  
    972.                 await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>  
    973.                 {  
    974.                     if (null != this.RestoreItemAction)  
    975.                         this.RestoreItemAction.Invoke(o);  
    976.                 });  
    977.             }  
    978.             if (isNext)  
    979.             {  
    980.                 var index = -1;  
    981.                 try  
    982.                 {  
    983.                     index = this.Items.IndexOf(needItems[0]);  
    984.   
    985.                 }  
    986.                 catch  
    987.                 {  
    988.                     index = -1;  
    989.                 }  
    990.                 if (index != -1 && index - 8 > 0)  
    991.                 {  
    992.                     for (int i = index - 8; i < index - 6; i++)  
    993.                         await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>  
    994.                         {  
    995.                             if (null != this.DisposeAction)  
    996.                                 DisposeAction.Invoke(this.Items[i]);  
    997.                         });  
    998.                 }  
    999.             }  
    1000.             else  
    1001.             {  
    1002.                 var index = -1;  
    1003.                 try  
    1004.                 {  
    1005.                     index = this.Items.IndexOf(needItems.Last());  
    1006.   
    1007.                 }  
    1008.                 catch (Exception ex)  
    1009.                 {  
    1010.                     index = -1;  
    1011.                 }  
    1012.                 if (index != -1 && this.Items.Count > index + 7)  
    1013.                 {  
    1014.                     for (int i = index + 5; i < index + 7; i++)  
    1015.                         await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>  
    1016.                         {  
    1017.                             if (null != this.DisposeAction)  
    1018.                                 DisposeAction.Invoke(this.Items[i]);  
    1019.                         });  
    1020.                 }  
    1021.             }  
    1022.         });  
    1023.     }  
    1024.     #endregion  
    1025.  
    1026.     #region OnItemsChanged  
    1027.     /// <summary>  
    1028.     /// 刷新数据   
    1029.     /// </summary>  
    1030.     /// <param name="e"></param>  
    1031.     protected override void OnItemsChanged(object e)  
    1032.     {  
    1033.         isInit = false;  
    1034.         InitPages();  
    1035.         base.OnItemsChanged(e);  
    1036.     }  
    1037.     #endregion  
    1038.  
    1039.     #region GetPresentersByPageIndex  
    1040.     private List<ContentPresenter> GetPresentersByPageIndex(bool isNext)  
    1041.     {  
    1042.         List<ContentPresenter> presenters = new List<ContentPresenter>();  
    1043.         if (isNext)  
    1044.         {  
    1045.             presenters.Add(leftTopPage.Child as ContentPresenter);  
    1046.             presenters.Add(prevPage.Child as ContentPresenter);  
    1047.         }  
    1048.         else  
    1049.         {  
    1050.             presenters.Add(rightTopPage.Child as ContentPresenter);  
    1051.             presenters.Add(nextPage.Child as ContentPresenter);  
    1052.         }  
    1053.         Debug.WriteLine("presenter0Name:" + presenters[0].Name);  
    1054.         Debug.WriteLine("presenter1Name:" + presenters[1].Name);  
    1055.         return presenters;  
    1056.     }  
    1057.     #endregion  
    1058.  
    1059.     #region Crop  
    1060.     /// <summary>  
    1061.     /// 图形切割  
    1062.     /// </summary>  
    1063.     /// <param name="source"></param>  
    1064.     /// <param name="x1"></param>  
    1065.     /// <param name="y1"></param>  
    1066.     /// <param name="x2"></param>  
    1067.     /// <param name="y2"></param>  
    1068.     /// <returns></returns>  
    1069.     public WriteableBitmap Crop(WriteableBitmap source, int x1, int y1, int x2, int y2)  
    1070.     {  
    1071.         if (x1 >= x2 ||  
    1072.             y1 >= y2 ||  
    1073.             x1 < 0 ||  
    1074.             y1 < 0 ||  
    1075.             x2 < 0 ||  
    1076.             y2 < 0 ||  
    1077.             x1 > source.PixelWidth ||  
    1078.             y1 > source.PixelHeight ||  
    1079.             x2 > source.PixelWidth ||  
    1080.             y2 > source.PixelHeight)  
    1081.         {  
    1082.             throw new ArgumentException();  
    1083.         }  
    1084.   
    1085.         //var buffer = source.PixelBuffer.GetPixels();  
    1086.         var cw = x2 - x1;  
    1087.         var ch = y2 - y1;  
    1088.         var target = new WriteableBitmap(cw, ch);  
    1089.   
    1090.         var croppedBytes =  
    1091.             new byte[4 * cw * ch];  
    1092.         var inputStream = source.PixelBuffer.AsStream();  
    1093.         inputStream.Seek(4 * (source.PixelWidth * y1 + x1), SeekOrigin.Current);  
    1094.         for (int i = 0; i < ch; i++)  
    1095.         {  
    1096.             inputStream.Read(croppedBytes, 4 * cw * i, 4 * cw);  
    1097.             inputStream.Seek(4 * (source.PixelWidth - cw), SeekOrigin.Current);  
    1098.         }  
    1099.   
    1100.         var outputStream = target.PixelBuffer.AsStream();  
    1101.         outputStream.Seek(0, SeekOrigin.Begin);  
    1102.         outputStream.Write(croppedBytes, 0, croppedBytes.Length);  
    1103.         target.Invalidate();  
    1104.   
    1105.         return target;  
    1106.     }  
    1107.     #endregion  
    1108.  
    1109.     #region IsHitVisible  
    1110.     /// <summary>  
    1111.     /// 禁止点击  
    1112.     /// </summary>  
    1113.     /// <param name="o"></param>  
    1114.     private async void IsHitVisible(bool o)  
    1115.     {  
    1116.         await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>  
    1117.         {  
    1118.             this.grdContent.IsHitTestVisible = o;  
    1119.             this.leftPage.IsHitTestVisible = o;  
    1120.             this.rightPage.IsHitTestVisible = o;  
    1121.             this.nextPage.IsHitTestVisible = o;  
    1122.             this.prevPage.IsHitTestVisible = o;  
    1123.             this.leftTopPage.IsHitTestVisible = o;  
    1124.             this.rightTopPage.IsHitTestVisible = o;  
    1125.         });  
    1126.     }  
    1127.     #endregion  
    1128.  
    1129.     #region RefreshPageByStatus  
    1130.     /// <summary>  
    1131.     /// 翻页成功后刷新控件状态  
    1132.     /// </summary>  
    1133.     private void RefreshPageByStatus()  
    1134.     {  
    1135.   
    1136.         switch (Status)  
    1137.         {  
    1138.             case 0:  
    1139.                 Canvas.SetZIndex(A, 2);  
    1140.                 Canvas.SetZIndex(B, 2);  
    1141.                 Canvas.SetZIndex(C, 0);  
    1142.                 Canvas.SetZIndex(D, 0);  
    1143.                 Canvas.SetZIndex(E, 2);  
    1144.                 Canvas.SetZIndex(F, 2);  
    1145.                 Grid.SetColumn(A, 1);  
    1146.                 Grid.SetColumn(B, 1);  
    1147.                 Grid.SetColumn(C, 1);  
    1148.                 Grid.SetColumn(D, 2);  
    1149.                 Grid.SetColumn(E, 2);  
    1150.                 Grid.SetColumn(F, 2);  
    1151.                 transA.TranslateX = 0;  
    1152.                 transB.TranslateX = -offsetWidth;  
    1153.                 transC.TranslateX = 0;  
    1154.                 transD.TranslateX = 0;  
    1155.                 transE.TranslateX = offsetWidth;  
    1156.                 transF.TranslateX = 0;  
    1157.                 ARect.Rect = new Rect(-this.A.ActualWidth, 0, this.A.ActualWidth, this.A.ActualHeight);  
    1158.                 CRect.Rect = new Rect(0, 0, this.C.ActualWidth, this.C.ActualHeight);  
    1159.                 DRect.Rect = new Rect(0, 0, this.D.ActualWidth, this.D.ActualHeight);  
    1160.                 FRect.Rect = new Rect(this.F.ActualWidth, 0, this.F.ActualWidth, this.F.ActualHeight);  
    1161.                 BRect.Rect = new Rect(this.B.ActualWidth, 0, this.B.ActualWidth, this.B.ActualHeight);  
    1162.                 ERect.Rect = new Rect(-this.E.ActualWidth, 0, this.E.ActualWidth, this.E.ActualHeight);  
    1163.                 nextPage = E;  
    1164.                 prevPage = B;  
    1165.                 leftPage = C;  
    1166.                 rightPage = D;  
    1167.                 leftTopPage = A;  
    1168.                 rightTopPage = F;  
    1169.                 nextTrans = transE;  
    1170.                 prevTrans = transB;  
    1171.                 //A.PointerPressed -= this.PointerPressed;  
    1172.                 //B.PointerPressed -= this.PointerPressed;  
    1173.                 //C.PointerPressed += this.PointerPressed;  
    1174.                 //D.PointerPressed += this.PointerPressed;  
    1175.                 break;  
    1176.             case 1:  
    1177.                 Canvas.SetZIndex(A, 2);  
    1178.                 Canvas.SetZIndex(B, 2);  
    1179.                 Canvas.SetZIndex(C, 2);  
    1180.                 Canvas.SetZIndex(D, 2);  
    1181.                 Canvas.SetZIndex(E, 0);  
    1182.                 Canvas.SetZIndex(F, 0);  
    1183.                 Grid.SetColumn(A, 2);  
    1184.                 Grid.SetColumn(B, 2);  
    1185.                 Grid.SetColumn(C, 1);  
    1186.                 Grid.SetColumn(D, 1);  
    1187.                 Grid.SetColumn(E, 1);  
    1188.                 Grid.SetColumn(F, 2);  
    1189.                 transA.TranslateX = offsetWidth;  
    1190.                 transB.TranslateX = 0;  
    1191.                 transC.TranslateX = 0;  
    1192.                 transD.TranslateX = -offsetWidth;  
    1193.                 transE.TranslateX = 0;  
    1194.                 transF.TranslateX = 0;  
    1195.                 ARect.Rect = new Rect(-this.A.ActualWidth, 0, this.A.ActualWidth, this.A.ActualHeight);  
    1196.                 CRect.Rect = new Rect(-this.C.ActualWidth, 0, this.C.ActualWidth, this.C.ActualHeight);  
    1197.                 DRect.Rect = new Rect(this.D.ActualWidth, 0, this.D.ActualWidth, this.D.ActualHeight);  
    1198.                 FRect.Rect = new Rect(0, 0, this.F.ActualWidth, this.F.ActualHeight);  
    1199.                 BRect.Rect = new Rect(this.B.ActualWidth, 0, this.B.ActualWidth, this.B.ActualHeight);  
    1200.                 ERect.Rect = new Rect(0, 0, this.E.ActualWidth, this.E.ActualHeight);  
    1201.                 nextPage = A;  
    1202.                 prevPage = D;  
    1203.                 leftPage = E;  
    1204.                 rightPage = F;  
    1205.                 leftTopPage = C;  
    1206.                 rightTopPage = B;  
    1207.                 nextTrans = transA;  
    1208.                 prevTrans = transD;  
    1209.                 //C.PointerPressed -= this.PointerPressed;  
    1210.                 //D.PointerPressed -= this.PointerPressed;  
    1211.                 //E.PointerPressed += this.PointerPressed;  
    1212.                 //F.PointerPressed += this.PointerPressed;  
    1213.                 break;  
    1214.             case 2:  
    1215.                 Canvas.SetZIndex(A, 0);  
    1216.                 Canvas.SetZIndex(B, 0);  
    1217.                 Canvas.SetZIndex(C, 2);  
    1218.                 Canvas.SetZIndex(D, 2);  
    1219.                 Canvas.SetZIndex(E, 2);  
    1220.                 Canvas.SetZIndex(F, 2);  
    1221.                 Grid.SetColumn(A, 1);  
    1222.                 Grid.SetColumn(B, 2);  
    1223.                 Grid.SetColumn(C, 2);  
    1224.                 Grid.SetColumn(D, 2);  
    1225.                 Grid.SetColumn(E, 1);  
    1226.                 Grid.SetColumn(F, 1);  
    1227.                 transA.TranslateX = 0;  
    1228.                 transB.TranslateX = 0;  
    1229.                 transC.TranslateX = offsetWidth;  
    1230.                 transD.TranslateX = 0;  
    1231.                 transE.TranslateX = 0;  
    1232.                 transF.TranslateX = -offsetWidth;  
    1233.                 ARect.Rect = new Rect(0, 0, this.A.ActualWidth, this.A.ActualHeight);  
    1234.                 CRect.Rect = new Rect(-this.C.ActualWidth, 0, this.C.ActualWidth, this.C.ActualHeight);  
    1235.                 DRect.Rect = new Rect(this.D.ActualWidth, 0, this.D.ActualWidth, this.D.ActualHeight);  
    1236.                 FRect.Rect = new Rect(this.F.ActualWidth, 0, this.F.ActualWidth, this.F.ActualHeight);  
    1237.                 BRect.Rect = new Rect(0, 0, this.B.ActualWidth, this.B.ActualHeight);  
    1238.                 ERect.Rect = new Rect(-this.E.ActualWidth, 0, this.E.ActualWidth, this.E.ActualHeight);  
    1239.                 nextPage = C;  
    1240.                 prevPage = F;  
    1241.                 leftPage = A;  
    1242.                 rightPage = B;  
    1243.                 leftTopPage = E;  
    1244.                 rightTopPage = D;  
    1245.                 nextTrans = transC;  
    1246.                 prevTrans = transF;  
    1247.                 //E.PointerPressed -= this.PointerPressed;  
    1248.                 //F.PointerPressed -= this.PointerPressed;  
    1249.                 //A.PointerPressed += this.PointerPressed;  
    1250.                 //B.PointerPressed += this.PointerPressed;  
    1251.                 break;  
    1252.             default:  
    1253.                 break;  
    1254.         }  
    1255.         stShadowSplitInnerLeft.Opacity = 0;  
    1256.         stShadowSplitInnerRight.Opacity = 0;  
    1257.         stShadowSplitOuterLeft.Opacity = 0;  
    1258.         stShadowSplitOuterRight.Opacity = 0;  
    1259.         outerRightTrans.TranslateX = 0;  
    1260.         innerRightTrans.TranslateX = 0;  
    1261.         outerLeftTrans.TranslateX = 0;  
    1262.         innerLeftTrans.TranslateX = 0;  
    1263.         marginLeftTrans.TranslateX = 0;  
    1264.         marginRightTrans.TranslateX = 0;  
    1265.         leftTopPage.Background = leftBrush;  
    1266.         prevPage.Background = rightBrush;  
    1267.         leftPage.Background = leftBrush;  
    1268.         rightPage.Background = rightBrush;  
    1269.         nextPage.Background = leftBrush;  
    1270.         rightTopPage.Background = rightBrush;  
    1271.     }  
    1272.     #endregion  
    1273.  
    1274.     #region GetCropBookBrush  
    1275.     private async Task GetCropBrush()  
    1276.     {  
    1277.         if (null != this.BookBackgroundBrush)  
    1278.         {  
    1279.             var orginSource = this.BookBackgroundBrush.ImageSource as BitmapImage;  
    1280.             if (!orginSource.UriSource.AbsolutePath.Equals(string.Empty))  
    1281.             {  
    1282.                 var uri = new Uri("ms-appx://" + orginSource.UriSource.AbsolutePath);  
    1283.                 try  
    1284.                 {  
    1285.                     var file = await StorageFile.GetFileFromApplicationUriAsync(uri);  
    1286.                     WriteableBitmap leftSource = new WriteableBitmap(Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));  
    1287.                     await LoadAsync(leftSource, file);  
    1288.                     WriteableBitmap rightSource = new WriteableBitmap(Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));  
    1289.                     await LoadAsync(rightSource, file);  
    1290.                     leftBrush = new ImageBrush();  
    1291.                     rightBrush = new ImageBrush();  
    1292.                     rightBrush.Stretch = Stretch.Fill;  
    1293.                     leftBrush.Stretch = Stretch.Fill;  
    1294.                     leftSource = Crop(leftSource, 0, 0, Convert.ToInt32(offsetWidth), Convert.ToInt32(offsetHeight));  
    1295.                     leftBrush.ImageSource = leftSource;  
    1296.                     rightSource = Crop(rightSource, Convert.ToInt32(offsetWidth), 0, Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));  
    1297.                     rightBrush.ImageSource = rightSource;  
    1298.                 }  
    1299.                 catch  
    1300.                 {  
    1301.                 }  
    1302.             }  
    1303.         }  
    1304.     }  
    1305.     #endregion  
    1306.  
    1307.     #region LoadWriteableBitmap  
    1308.     public async Task<WriteableBitmap> LoadAsync(  
    1309.         WriteableBitmap writeableBitmap,  
    1310.        StorageFile storageFile)  
    1311.     {  
    1312.         using (var stream = await storageFile.OpenReadAsync())  
    1313.         {  
    1314.             await writeableBitmap.SetSourceAsync(  
    1315.                 stream);  
    1316.         }  
    1317.         return writeableBitmap;  
    1318.     }  
    1319.  
    1320.     #endregion  
    1321.  
    1322.     #region SetShadowOperacity  
    1323.     private async void SetShadowOperacity(double pos, double pageWidth, bool direction)  
    1324.     {  
    1325.         var opacity = await Task.Run(() =>  
    1326.         {  
    1327.             double num = (pageWidth - pos) / 2.0;  
    1328.             double num2 = Math.Abs((double)((pageWidth / 2.0) - num));  
    1329.             return (1.0 * (1.0 - (num2 / (pageWidth / 2.0))));  
    1330.         });  
    1331.         if (direction)  
    1332.         {  
    1333.             this.stShadowSplitOuterLeft.Opacity = opacity;  
    1334.             this.stShadowSplitInnerLeft.Opacity = opacity;  
    1335.             this.stShadowMarginLeft.Opacity = opacity;  
    1336.         }  
    1337.         else  
    1338.         {  
    1339.             this.stShadowSplitOuterRight.Opacity = opacity;  
    1340.             this.stShadowSplitInnerRight.Opacity = opacity;  
    1341.             this.stShadowMarginRight.Opacity = opacity;  
    1342.         }  
    1343.     }  
    1344.     #endregion  
    1345.     #endregion  
    1346. }  
    1347.   
    1348. /// <summary>  
    1349. /// 抛出需要加载的项数据  
    1350. /// </summary>  
    1351. public class FlipLoadArgs : EventArgs  
    1352. {  
    1353.     public readonly List<object> needItems;  
    1354.     public readonly bool isNext;  
    1355.   
    1356.     public FlipLoadArgs(List<object> _needItems, bool _isNext)  
    1357.     {  
    1358.         this.needItems = _needItems;  
    1359.         this.isNext = _isNext;  
    1360.     }  
    1361. }  
    1362.   
    1363. public class FlipEventArgs : EventArgs  
    1364. {  
    1365.     public readonly bool isNext;  
    1366.   
    1367.     public FlipEventArgs(bool _isNext)  
    1368.     {  
    1369.         this.isNext = _isNext;  
    1370.     }  
    1371. }  
     
    [html] view plaincopyprint?
     
    1. <ResourceDictionary  
    2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
    3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
    4.     xmlns:local="using:WinRTXamlToolkit.Controls">  
    5.   
    6.     <Style TargetType="local:FlipBookControl">  
    7.         <Setter Property="Template">  
    8.             <Setter.Value>  
    9.                 <ControlTemplate TargetType="local:FlipBookControl">  
    10.                     <Grid   
    11.                         x:Name="grdContent"   
    12.                         Background="{TemplateBinding Background}">  
    13.                         <Grid.RowDefinitions>  
    14.                             <RowDefinition Height="30*"/>  
    15.                             <RowDefinition Height="750*"/>  
    16.                             <RowDefinition Height="30*"/>  
    17.                         </Grid.RowDefinitions>  
    18.                         <Grid.ColumnDefinitions>  
    19.                             <ColumnDefinition Width="50*"/>  
    20.                             <ColumnDefinition Width="600*"/>  
    21.                             <ColumnDefinition Width="600*"/>  
    22.                             <ColumnDefinition Width="50*"/>  
    23.                         </Grid.ColumnDefinitions>  
    24.                         <Image   
    25.                             x:Name="bookContainer"   
    26.                             Stretch="Fill"   
    27.                             Canvas.ZIndex="2"   
    28.                             Grid.ColumnSpan="4"   
    29.                             IsHitTestVisible="False"   
    30.                             Grid.RowSpan="3"/>  
    31.                         <Border   
    32.                             Grid.Row="1"   
    33.                             Grid.Column="1"   
    34.                             BorderThickness="0"  
    35.                             x:Name="C">  
    36.                             <Border.Clip>  
    37.                                 <RectangleGeometry x:Name="CRect">  
    38.                                 </RectangleGeometry>  
    39.                             </Border.Clip>  
    40.                             <Border.RenderTransform>  
    41.                                 <CompositeTransform x:Name="transC"></CompositeTransform>  
    42.                             </Border.RenderTransform>  
    43.                             <ContentPresenter x:Name="CPresenter" Style="{TemplateBinding ItemContainerStyle}"  
    44.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    45.                         </Border>  
    46.                         <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"  
    47.                             x:Name="D">  
    48.                             <Border.Clip>  
    49.                                 <RectangleGeometry x:Name="DRect">  
    50.                                 </RectangleGeometry>  
    51.                             </Border.Clip>  
    52.                             <Border.RenderTransform>  
    53.                                 <CompositeTransform x:Name="transD"></CompositeTransform>  
    54.                             </Border.RenderTransform>  
    55.                             <ContentPresenter x:Name="DPresenter" Style="{TemplateBinding ItemContainerStyle}"  
    56.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    57.                         </Border>  
    58.                         <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"  
    59.                             x:Name="E">  
    60.                             <Border.Clip>  
    61.                                 <RectangleGeometry x:Name="ERect">  
    62.                                 </RectangleGeometry>  
    63.                             </Border.Clip>  
    64.                             <Border.RenderTransform>  
    65.                                 <CompositeTransform x:Name="transE"/>  
    66.                             </Border.RenderTransform>  
    67.                             <ContentPresenter x:Name="EPresenter" Style="{TemplateBinding ItemContainerStyle}"  
    68.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    69.                         </Border>  
    70.                         <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"  
    71.                             x:Name="F">  
    72.                             <Border.Clip>  
    73.                                 <RectangleGeometry x:Name="FRect">  
    74.                                 </RectangleGeometry>  
    75.                             </Border.Clip>  
    76.                             <Border.RenderTransform>  
    77.                                 <CompositeTransform x:Name="transF"></CompositeTransform>  
    78.                             </Border.RenderTransform>  
    79.                             <ContentPresenter x:Name="FPresenter" Style="{TemplateBinding ItemContainerStyle}"  
    80.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    81.                         </Border>  
    82.                         <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"  
    83.                             x:Name="A">  
    84.                             <Border.Clip>  
    85.                                 <RectangleGeometry x:Name="ARect">  
    86.                                 </RectangleGeometry>  
    87.                             </Border.Clip>  
    88.                             <Border.RenderTransform>  
    89.                                 <CompositeTransform x:Name="transA"></CompositeTransform>  
    90.                             </Border.RenderTransform>  
    91.                             <ContentPresenter x:Name="APresenter" Style="{TemplateBinding ItemContainerStyle}"  
    92.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    93.                         </Border>  
    94.                         <Border Grid.Row="1" Grid.Column="1"  BorderThickness="0"  
    95.                                 x:Name="B">  
    96.                             <Border.Clip>  
    97.                                 <RectangleGeometry x:Name="BRect">  
    98.                                 </RectangleGeometry>  
    99.                             </Border.Clip>  
    100.                             <Border.RenderTransform>  
    101.                                 <CompositeTransform x:Name="transB"/>  
    102.                             </Border.RenderTransform>  
    103.                             <ContentPresenter x:Name="BPresenter" Style="{TemplateBinding ItemContainerStyle}"  
    104.                                               ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>  
    105.                         </Border>  
    106.                         <StackPanel  Canvas.ZIndex="3"  
    107.                             x:Name="stShadowSplitOuterLeft"   
    108.                             Width="43"   
    109.                             Opacity="0"  
    110.                             Grid.Row="1"    
    111.                             Grid.Column="1"  
    112.                             HorizontalAlignment="Left" Margin="-43,0,0,0" RenderTransformOrigin="0.5,0.5">  
    113.                             <StackPanel.RenderTransform>  
    114.                                 <CompositeTransform x:Name="outerLeftTrans" TranslateX="0"/>  
    115.                             </StackPanel.RenderTransform>  
    116.                             <StackPanel.Background>  
    117.                                 <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">  
    118.                                     <GradientStop Color="#99000000"/>  
    119.                                     <GradientStop Color="Transparent" Offset="1"/>  
    120.                                 </LinearGradientBrush>  
    121.                             </StackPanel.Background>  
    122.                         </StackPanel>  
    123.                         <StackPanel Canvas.ZIndex="3"  
    124.                             x:Name="stShadowSplitInnerLeft"   
    125.                             Width="51"   
    126.                             Opacity="0"  
    127.                             Grid.Row="1"    
    128.                             Grid.Column="1"  
    129.                             HorizontalAlignment="Left" RenderTransformOrigin="0.5,0.5">  
    130.                             <StackPanel.RenderTransform>  
    131.                                 <CompositeTransform x:Name="innerLeftTrans" TranslateX="0"/>  
    132.                             </StackPanel.RenderTransform>  
    133.                             <StackPanel.Background>  
    134.                                 <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">  
    135.                                     <GradientStop Color="#99000000"/>  
    136.                                     <GradientStop Color="#01FFFFFF" Offset="1"/>  
    137.                                 </LinearGradientBrush>  
    138.                             </StackPanel.Background>  
    139.                         </StackPanel>  
    140.                         <StackPanel Canvas.ZIndex="3"  
    141.                             x:Name="stShadowSplitOuterRight"   
    142.                             Width="43"  
    143.                             Opacity="0"  
    144.                             Grid.Row="1"    
    145.                             Grid.Column="2"  
    146.                             HorizontalAlignment="Right" Margin="0,0,-43,0" RenderTransformOrigin="0.5,0.5">  
    147.                             <StackPanel.RenderTransform>  
    148.                                 <CompositeTransform x:Name="outerRightTrans" TranslateX="0"/>  
    149.                             </StackPanel.RenderTransform>  
    150.                             <StackPanel.Background>  
    151.                                 <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">  
    152.                                     <GradientStop Color="#99000000"/>  
    153.                                     <GradientStop Color="Transparent" Offset="1"/>  
    154.                                 </LinearGradientBrush>  
    155.                             </StackPanel.Background>  
    156.                         </StackPanel>  
    157.                         <StackPanel  Canvas.ZIndex="3"  
    158.                             x:Name="stShadowSplitInnerRight"   
    159.                             Width="51"   
    160.                             Opacity="0"  
    161.                             Grid.Row="1"    
    162.                             Grid.Column="2"  
    163.                             HorizontalAlignment="Right" RenderTransformOrigin="0.5,0.5">  
    164.                             <StackPanel.RenderTransform>  
    165.                                 <CompositeTransform x:Name="innerRightTrans" TranslateX="0"/>  
    166.                             </StackPanel.RenderTransform>  
    167.                             <StackPanel.Background>  
    168.                                 <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">  
    169.                                     <GradientStop Color="#99000000"/>  
    170.                                     <GradientStop Color="#01FFFFFF" Offset="1"/>  
    171.                                 </LinearGradientBrush>  
    172.                             </StackPanel.Background>  
    173.                         </StackPanel>  
    174.                         <StackPanel x:Name="stShadowMarginLeft" Width="30" HorizontalAlignment="Left"  
    175.                     Opacity="0" Grid.Row="1" Grid.Column="1" Canvas.ZIndex="3">  
    176.                             <StackPanel.RenderTransform>  
    177.                                 <CompositeTransform x:Name="marginLeftTrans" TranslateX="0"/>  
    178.                             </StackPanel.RenderTransform>  
    179.                             <StackPanel.Background>  
    180.                                 <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">  
    181.                                     <GradientStop Color="#99000000"/>  
    182.                                     <GradientStop Color="Transparent" Offset="1"/>  
    183.                                 </LinearGradientBrush>  
    184.                             </StackPanel.Background>  
    185.                         </StackPanel>  
    186.                         <StackPanel x:Name="stShadowMarginRight" Width="30" HorizontalAlignment="Right"  
    187.                     Opacity="0" Grid.Row="1" Grid.Column="2" Canvas.ZIndex="3">  
    188.                             <StackPanel.RenderTransform>  
    189.                                 <CompositeTransform x:Name="marginRightTrans" TranslateX="0"/>  
    190.                             </StackPanel.RenderTransform>  
    191.                             <StackPanel.Background>  
    192.                                 <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">  
    193.                                     <GradientStop Color="#99000000"/>  
    194.                                     <GradientStop Color="Transparent" Offset="1"/>  
    195.                                 </LinearGradientBrush>  
    196.                             </StackPanel.Background>  
    197.                         </StackPanel>  
    198.                     </Grid>  
    199.                 </ControlTemplate>  
    200.             </Setter.Value>  
    201.         </Setter>  
    202.     </Style>  
    203. </ResourceDictionary>  


     

    Sample： 使用方法

      <local:FlipBookControl x:Name="fbc"  Speed="10"
                                                ItemTemplate="{StaticResource BookTemplate}">
                <local:FlipBookControl.Background>
                    <ImageBrush ImageSource="ms-appx:///Assets/bookbox-hori.png"/>
                </local:FlipBookControl.Background>
                <local:FlipBookControl.BookBackgroundBrush>
                    <ImageBrush ImageSource="ms-appx:///Assets/bg-7.jpg"/>
                </local:FlipBookControl.BookBackgroundBrush>
            </local:FlipBookControl>

    支持ItemsSource 数据源 以及ItemTemplate Binding

    DisposeAction  和RestoreItem 2个依赖项 请在使用前填写。用于释放图片流 以及恢复 源

    欢迎讨论，分享经验，以及更优的方法。
  • 相关阅读:
    Adaptive Cursor Sharing in Oracle Database 11g Release 1
    FORALL Support for NonConsecutive Indexes (Sparse Collections)
    设置会话TRACE的方法（一）
    Oracle 10g: UTL_MAIL
    Oracle :Parallel execution when table created.
    Server.MapPath
    Oracle10g :Nested Table Enhancements
    Asktom:Single Block IO Vs Multi Block IO
    Oracle10g新增DBMS_MONITOR包（一）
    设置会话TRACE的方法（二）
  • 原文地址：https://www.cnblogs.com/CharlesGrant/p/3639393.html
Copyright © 2011-2022 走看看