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

[TemplatePart(Name = A_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = B_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = C_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = D_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = E_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = F_PARTNAME, Type = typeof(Border))]
[TemplatePart(Name = A_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = B_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = C_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = D_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = E_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = F_RECT_PARTNAME, Type = typeof(RectangleGeometry))]
[TemplatePart(Name = A_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = B_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = C_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = D_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = E_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = F_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = A_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = B_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = C_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = D_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = E_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = F_PRESENTER_PARTNAME, Type = typeof(ContentPresenter))]
[TemplatePart(Name = INNER_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = OUTER_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = INNER_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = OUTER_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = MARGIN_LEFT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = MARGIN_RIGHT_TRANS_PARTNAME, Type = typeof(CompositeTransform))]
[TemplatePart(Name = ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = ST_SHADOW_MARGIN_LEFT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = ST_SHADOW_MARGIN_RIGHT_PARTNAME, Type = typeof(StackPanel))]
[TemplatePart(Name = BOOK_CONTAINER_PARTNAME, Type = typeof(Image))]
[TemplatePart(Name = GRD_CONTENT_PARTNAME, Type = typeof(Grid))]
/// <summary>
/// 作者:王韧竹
/// 版本:1.1
/// 根据偏移量算法 计算是否为放大 或者翻页 保证两者不冲突。
/// 18/6/2013 23：06
/// windows8 翻书特效组件
/// </summary>
public sealed class FlipBookControl : ItemsControl
{
#region Member Variables
/// <summary>
/// 0 初始 翻页状态1 翻页状态2
/// </summary>
private int Status = 0;
/// <summary>
/// 是否翻下一页
/// true 下一页 false 上一页
/// </summary>
private bool isNext = false;
/// <summary>
/// 触发向左翻页动画
/// true 发生偏移  false 停止偏移
/// </summary>
private bool turnLeft = false;
/// <summary>
/// 触发向右翻页动画
/// true 发生偏移  false 停止偏移
/// </summary>
private bool turnRight = false;
/// <summary>
/// 触发向右翻页还原动画
/// true 发生偏移  false 停止偏移
/// </summary>
private bool rightRestore = false;
/// <summary>
/// 触发向左翻页还原动画
/// true 发生偏移  false 停止偏移
/// </summary>
private bool leftRestore = false;
/// <summary>
/// 是否多点操作中
/// true 是 false 否
/// </summary>
private bool isManipulating = false;
/// <summary>
/// 最近一次偏移量
/// </summary>
private double lastDeltaOffset = 0.0;
/// <summary>
/// 横向偏移量
/// </summary>
private double offsetWidth = 0.0;
/// <summary>
/// 竖向偏移量
/// </summary>
private double offsetHeight = 0.0;
/// <summary>
/// 是否加载
/// </summary>
private bool isLoaded = false;
/// <summary>
/// 是否初始化
/// </summary>
private bool isInit = false;

/// <summary>
/// 控制是否翻页
/// </summary>
private bool isFlip = true;

/// <summary>
/// 是否释放
/// </summary>
private bool isRelease = true;
Border nextPage;
Border prevPage;
Border leftPage;
Border rightPage;
Border leftTopPage;
Border rightTopPage;
CompositeTransform nextTrans;
CompositeTransform prevTrans;
Border A;
Border B;
Border C;
Border D;
Border E;
Border F;
ContentPresenter APresenter;
ContentPresenter BPresenter;
ContentPresenter CPresenter;
ContentPresenter DPresenter;
ContentPresenter EPresenter;
ContentPresenter FPresenter;
RectangleGeometry ARect;
RectangleGeometry BRect;
RectangleGeometry CRect;
RectangleGeometry DRect;
RectangleGeometry ERect;
RectangleGeometry FRect;
CompositeTransform transA;
CompositeTransform transB;
CompositeTransform transC;
CompositeTransform transD;
CompositeTransform transE;
CompositeTransform transF;
CompositeTransform innerLeftTrans;
CompositeTransform outerLeftTrans;
CompositeTransform innerRightTrans;
CompositeTransform outerRightTrans;
CompositeTransform marginLeftTrans;
CompositeTransform marginRightTrans;
StackPanel stShadowSplitOuterLeft;
StackPanel stShadowSplitInnerLeft;
StackPanel stShadowSplitOuterRight;
StackPanel stShadowSplitInnerRight;
StackPanel stShadowMarginLeft;
StackPanel stShadowMarginRight;
Grid grdContent;
Image bookContainer;
ImageBrush leftBrush;
ImageBrush rightBrush;
private TransformGroup _transformGroup;
private MatrixTransform _previousTransform;
private CompositeTransform _compositeTransform;
#endregion

#region Template Part
/// <summary>
/// 矩形
/// </summary>
const string A_PARTNAME = "A";
/// <summary>
/// 矩形遮掩
/// </summary>
const string A_RECT_PARTNAME = "ARect";
/// <summary>
/// 矩形偏移
/// </summary>
const string A_TRANS_PARTNAME = "transA";
const string A_PRESENTER_PARTNAME = "APresenter";
const string B_PARTNAME = "B";
const string B_RECT_PARTNAME = "BRect";
const string B_TRANS_PARTNAME = "transB";
const string B_PRESENTER_PARTNAME = "BPresenter";
const string C_PARTNAME = "C";
const string C_RECT_PARTNAME = "CRect";
const string C_TRANS_PARTNAME = "transC";
const string C_PRESENTER_PARTNAME = "CPresenter";
const string D_PARTNAME = "D";
const string D_RECT_PARTNAME = "DRect";
const string D_TRANS_PARTNAME = "transD";
const string D_PRESENTER_PARTNAME = "DPresenter";
const string E_PARTNAME = "E";
const string E_RECT_PARTNAME = "ERect";
const string E_TRANS_PARTNAME = "transE";
const string E_PRESENTER_PARTNAME = "EPresenter";
const string F_PARTNAME = "F";
const string F_RECT_PARTNAME = "FRect";
const string F_TRANS_PARTNAME = "transF";
const string F_PRESENTER_PARTNAME = "FPresenter";
const string ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME = "stShadowSplitOuterRight";
const string ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME = "stShadowSplitInnerRight";
const string ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME = "stShadowSplitOuterLeft";
const string ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME = "stShadowSplitInnerLeft";
const string ST_SHADOW_MARGIN_LEFT_PARTNAME = "stShadowMarginLeft";
const string ST_SHADOW_MARGIN_RIGHT_PARTNAME = "stShadowMarginRight";
const string OUTER_LEFT_TRANS_PARTNAME = "outerLeftTrans";
const string INNER_LEFT_TRANS_PARTNAME = "innerLeftTrans";
const string OUTER_RIGHT_TRANS_PARTNAME = "outerRightTrans";
const string INNER_RIGHT_TRANS_PARTNAME = "innerRightTrans";
const string MARGIN_LEFT_TRANS_PARTNAME = "marginLeftTrans";
const string MARGIN_RIGHT_TRANS_PARTNAME = "marginRightTrans";
/// <summary>
/// 书壳
/// </summary>
const string BOOK_CONTAINER_PARTNAME = "bookContainer";
const string GRD_CONTENT_PARTNAME = "grdContent";
#endregion

#region DependencyProperties
#region DelayLoad
public TimeSpan DelayLoad
{
get { return (TimeSpan)GetValue(DelayLoadProperty); }
set { SetValue(DelayLoadProperty, value); }
}

// Using a DependencyProperty as the backing store for DelayLoad.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty DelayLoadProperty =
DependencyProperty.Register("DelayLoad", typeof(TimeSpan), typeof(FlipBookControl), new PropertyMetadata(TimeSpan.FromSeconds(0)));
#endregion

#region BookBackgroundBrush
public ImageBrush BookBackgroundBrush
{
get { return (ImageBrush)GetValue(BookBackgroundBrushProperty); }
set { SetValue(BookBackgroundBrushProperty, value); }
}

// Using a DependencyProperty as the backing store for BookBackgroundBrush.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty BookBackgroundBrushProperty =
DependencyProperty.Register("BookBackgroundBrush", typeof(ImageBrush), typeof(FlipBookControl), new PropertyMetadata(null, OnBookBackgroundBrushChangedCallBack));

private static async void OnBookBackgroundBrushChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)
{

var ctrl = (d as FlipBookControl);
if (ctrl.isLoaded)
await ctrl.GetCropBrush();
}
#endregion

#region Speed
/// <summary>
/// 动画速度 默认为30pixel
/// </summary>
public int Speed
{
get { return (int)GetValue(SpeedProperty); }
set { SetValue(SpeedProperty, value); }
}

// Using a DependencyProperty as the backing store for Speed.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty SpeedProperty =
DependencyProperty.Register("Speed", typeof(int), typeof(FlipBookControl), new PropertyMetadata(30));
#endregion

#region BookContainerSource
public ImageSource BookContainerSource
{
get { return (ImageSource)GetValue(BookContainerSourceProperty); }
set { SetValue(BookContainerSourceProperty, value); }
}

// Using a DependencyProperty as the backing store for BookContainerSource.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty BookContainerSourceProperty =
DependencyProperty.Register("BookContainerSource", typeof(ImageSource), typeof(FlipBookControl), new PropertyMetadata(null, OnBookContainerSourceChangedCallBack));

private static void OnBookContainerSourceChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var ctrl = (d as FlipBookControl);
if (null != ctrl.BookContainerSource && ctrl.bookContainer != null && ctrl.isLoaded)
ctrl.bookContainer.Source = ctrl.BookContainerSource;
}

#endregion

#region PageIndex
public int PageIndex
{
get { return (int)GetValue(PageIndexProperty); }
set { SetValue(PageIndexProperty, value); }
}

// Using a DependencyProperty as the backing store for PageIndex.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty PageIndexProperty =
DependencyProperty.Register("PageIndex", typeof(int), typeof(FlipBookControl), new PropertyMetadata(0, OnPageIndexChangedCallBack));

private static void OnPageIndexChangedCallBack(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var ctrl = (d as FlipBookControl);
if (ctrl.isLoaded)
{
var isNext = Convert.ToInt32(e.NewValue) > Convert.ToInt32(e.OldValue);
var presenters = ctrl.GetPresentersByPageIndex(isNext);
if (null != presenters)
ctrl.LoadPageContentByPageIndex(Convert.ToInt32(e.NewValue), isNext, presenters[0], presenters[1]);
}
}
#endregion

#region DisposeAction
public Action<object> DisposeAction
{
get { return (Action<object>)GetValue(DisposeActionProperty); }
set { SetValue(DisposeActionProperty, value); }
}

// Using a DependencyProperty as the backing store for DisposeAction.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty DisposeActionProperty =
DependencyProperty.Register("DisposeAction", typeof(Action<object>), typeof(FlipBookControl), new PropertyMetadata(null));
#endregion

#region RestoreItemAction
public Action<object> RestoreItemAction
{
get { return (Action<object>)GetValue(RestoreItemActionProperty); }
set { SetValue(RestoreItemActionProperty, value); }
}

// Using a DependencyProperty as the backing store for RestoreItemAction.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty RestoreItemActionProperty =
DependencyProperty.Register("RestoreItemAction", typeof(Action<object>), typeof(FlipBookControl), new PropertyMetadata(null));
#endregion

#region CanScale
public bool CanScale
{
get { return (bool)GetValue(CanScaleProperty); }
set { SetValue(CanScaleProperty, value); }
}

// 能否进行放大缩小
public static readonly DependencyProperty CanScaleProperty =
DependencyProperty.Register("CanScale", typeof(bool), typeof(FlipBookControl), new PropertyMetadata(false));
#endregion
#endregion

#region Event
/// <summary>
/// 翻书结束事件
/// </summary>
private delegate void Fliped(object sender, FlipEventArgs args);

private event Fliped Fliping;
/// <summary>
/// 加载事件
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public delegate void NeedLoadItems(object sender, FlipLoadArgs args);

public event NeedLoadItems NeedLoadingItem;
#endregion

#region Constructor
public FlipBookControl()
{
this.DefaultStyleKey = typeof(FlipBookControl);
this.Loaded += FlipBookControlLoaded;
this.Unloaded += FlipBookControlUnLoaded;
CompositionTarget.Rendering += RenderAnimation;
this.Fliping += FlipEnded;
}

/// <summary>
/// 初始化完毕开始载入数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void FlipBookControlLoaded(object sender, RoutedEventArgs e)
{
grdContent.ManipulationMode =
ManipulationModes.TranslateInertia |
ManipulationModes.TranslateX |
ManipulationModes.Scale |
ManipulationModes.ScaleInertia |
ManipulationModes.TranslateY;
grdContent.ManipulationDelta += FlipManipulationDelta;
grdContent.ManipulationCompleted += FlipManipulationCompleted;
grdContent.ManipulationStarting += FlipManipulationStarting;
grdContent.ManipulationInertiaStarting += FlipManipulationInertiaStarting;
A.PointerPressed += PointerPressed;
B.PointerPressed += PointerPressed;
C.PointerPressed += PointerPressed;
D.PointerPressed += PointerPressed;
E.PointerPressed += PointerPressed;
F.PointerPressed += PointerPressed;
offsetWidth = A.ActualWidth;
offsetHeight = A.ActualHeight;
await GetCropBrush();
bookContainer.Source = BookContainerSource;
RefreshPageByStatus();
InitPages();
isLoaded = true;
}

private void FlipBookControlUnLoaded(object sender, RoutedEventArgs e)
{
CompositionTarget.Rendering -= RenderAnimation;
grdContent.ManipulationDelta -= FlipManipulationDelta;
grdContent.ManipulationCompleted -= FlipManipulationCompleted;
grdContent.ManipulationStarting -= FlipManipulationStarting;
grdContent.ManipulationInertiaStarting -= FlipManipulationInertiaStarting;
this.Fliping -= FlipEnded;
A.PointerPressed -= PointerPressed;
B.PointerPressed -= PointerPressed;
C.PointerPressed -= PointerPressed;
D.PointerPressed -= PointerPressed;
E.PointerPressed -= PointerPressed;
F.PointerPressed -= PointerPressed;
}

public void InitPosition()
{
_compositeTransform = new CompositeTransform();
_previousTransform = new MatrixTransform() { Matrix = Matrix.Identity };
_transformGroup = new TransformGroup();
_transformGroup.Children.Add(_previousTransform);
_transformGroup.Children.Add(_compositeTransform);
this.RenderTransform = _transformGroup;
}

public async void InitPages()
{
if (!isInit && PageIndex == 0 && this.Items.Count > 0)
{
await Task.Delay(DelayLoad);
List<object> needLoadItems = new List<object>();
//第一次加载 载入4页
CPresenter.DataContext = this.Items[0];
needLoadItems.Add(Items[0]);
if (this.Items.Count > 1)
{
DPresenter.DataContext = this.Items[1];
needLoadItems.Add(Items[1]);
}
if (this.Items.Count > 2)
{
EPresenter.DataContext = this.Items[2];
needLoadItems.Add(Items[2]);
}
if (this.Items.Count > 3)
{
FPresenter.DataContext = this.Items[3];
needLoadItems.Add(Items[3]);
}
if (null != NeedLoadingItem)
NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, false));
isInit = true;
}
else
{
Status = 0;
this.PageIndex = 0;
if (null != APresenter)
{
APresenter.DataContext = null;
BPresenter.DataContext = null;
CPresenter.DataContext = null;
DPresenter.DataContext = null;
EPresenter.DataContext = null;
FPresenter.DataContext = null;
}
}
InitPosition();
}
#endregion

#region EventMethod
#region OnApplyTemplate
protected override void OnApplyTemplate()
{
bookContainer = GetTemplateChild(BOOK_CONTAINER_PARTNAME) as Image;
A = GetTemplateChild(A_PARTNAME) as Border;
B = GetTemplateChild(B_PARTNAME) as Border;
C = GetTemplateChild(C_PARTNAME) as Border;
D = GetTemplateChild(D_PARTNAME) as Border;
E = GetTemplateChild(E_PARTNAME) as Border;
F = GetTemplateChild(F_PARTNAME) as Border;
APresenter = GetTemplateChild(A_PRESENTER_PARTNAME) as ContentPresenter;
BPresenter = GetTemplateChild(B_PRESENTER_PARTNAME) as ContentPresenter;
CPresenter = GetTemplateChild(C_PRESENTER_PARTNAME) as ContentPresenter;
DPresenter = GetTemplateChild(D_PRESENTER_PARTNAME) as ContentPresenter;
EPresenter = GetTemplateChild(E_PRESENTER_PARTNAME) as ContentPresenter;
FPresenter = GetTemplateChild(F_PRESENTER_PARTNAME) as ContentPresenter;
ARect = GetTemplateChild(A_RECT_PARTNAME) as RectangleGeometry;
BRect = GetTemplateChild(B_RECT_PARTNAME) as RectangleGeometry;
CRect = GetTemplateChild(C_RECT_PARTNAME) as RectangleGeometry;
DRect = GetTemplateChild(D_RECT_PARTNAME) as RectangleGeometry;
ERect = GetTemplateChild(E_RECT_PARTNAME) as RectangleGeometry;
FRect = GetTemplateChild(F_RECT_PARTNAME) as RectangleGeometry;
transA = GetTemplateChild(A_TRANS_PARTNAME) as CompositeTransform;
transB = GetTemplateChild(B_TRANS_PARTNAME) as CompositeTransform;
transC = GetTemplateChild(C_TRANS_PARTNAME) as CompositeTransform;
transD = GetTemplateChild(D_TRANS_PARTNAME) as CompositeTransform;
transE = GetTemplateChild(E_TRANS_PARTNAME) as CompositeTransform;
transF = GetTemplateChild(F_TRANS_PARTNAME) as CompositeTransform;
grdContent = GetTemplateChild(GRD_CONTENT_PARTNAME) as Grid;
innerLeftTrans = GetTemplateChild(INNER_LEFT_TRANS_PARTNAME) as CompositeTransform;
outerLeftTrans = GetTemplateChild(OUTER_LEFT_TRANS_PARTNAME) as CompositeTransform;
innerRightTrans = GetTemplateChild(INNER_RIGHT_TRANS_PARTNAME) as CompositeTransform;
outerRightTrans = GetTemplateChild(OUTER_RIGHT_TRANS_PARTNAME) as CompositeTransform;
marginLeftTrans = GetTemplateChild(MARGIN_LEFT_TRANS_PARTNAME) as CompositeTransform;
marginRightTrans = GetTemplateChild(MARGIN_RIGHT_TRANS_PARTNAME) as CompositeTransform;
stShadowSplitInnerLeft = GetTemplateChild(ST_SHADOW_SPLIT_INNER_LEFT_PARTNAME) as StackPanel;
stShadowSplitOuterLeft = GetTemplateChild(ST_SHADOW_SPLIT_OUTER_LEFT_PARTNAME) as StackPanel;
stShadowSplitInnerRight = GetTemplateChild(ST_SHADOW_SPLIT_INNER_RIGHT_PARTNAME) as StackPanel;
stShadowSplitOuterRight = GetTemplateChild(ST_SHADOW_SPLIT_OUTER_RIGHT_PARTNAME) as StackPanel;
stShadowMarginLeft = GetTemplateChild(ST_SHADOW_MARGIN_LEFT_PARTNAME) as StackPanel;
stShadowMarginRight = GetTemplateChild(ST_SHADOW_MARGIN_RIGHT_PARTNAME) as StackPanel;
base.OnApplyTemplate();
}
#endregion

#region PointerPressed
/// <summary>
/// 确定翻页方向
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void PointerPressed(object sender, PointerRoutedEventArgs e)
{
if (!isManipulating)
{
if (sender.Equals(leftPage))
isNext = false;
else if (sender.Equals(rightPage))
isNext = true;
else
RefreshPageByStatus();
Debug.WriteLine("按下:" + isNext);
Debug.WriteLine("点击的壳:" + (sender as Border).Name + " 左页壳:" + (sender as Border).Name);
}
}
#endregion

#region OnPointerReleased
protected override void OnPointerReleased(PointerRoutedEventArgs e)
{
base.OnPointerReleased(e);
}
#endregion

#region FlipEnded
/// <summary>
/// 翻页完毕
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void FlipEnded(object sender, FlipEventArgs args)
{
Debug.WriteLine("翻页完毕:" + args.isNext);
if (args.isNext) PageIndex += 2;
else PageIndex -= 2;
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
RefreshPageByStatus());
}
#endregion

#region Manipulation  多点触控操作翻书特效
#region FlipManipulationStarting
private void FlipManipulationStarting(object sender, ManipulationStartingRoutedEventArgs e)
{
isManipulating = true;
e.Handled = true;
if (isNext)
{
if (PageIndex >= this.Items.Count - 2)
{
isFlip = false;
isManipulating = false;
}
}
else
{
if (this.PageIndex == 0)
{
isFlip = false;
isManipulating = false;
}
}
}
#endregion

#region FlipManipulationInertiaStarting
private void FlipManipulationInertiaStarting(object sender, ManipulationInertiaStartingRoutedEventArgs e)
{
e.TranslationBehavior.DesiredDeceleration = 5 * 96.0 / (1000.0 * 1000.0);
e.ExpansionBehavior.DesiredDeceleration = 100 * 96 / 1000.0 * 1000.0;
}
#endregion

#region FlipManipulationCompleted
private async void FlipManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e)
{
isManipulating = false;
if (isFlip)
{
IsHitVisible(false);
var leftTopOffset = leftTopPage.Clip.Rect.X;
var rightTopOffset = rightTopPage.Clip.Rect.X;
await Task.Run(() =>
{
if (isNext)
{
if (lastDeltaOffset < 0)
{
Status = Status < 2 ? Status + 1 : 0;
turnRight = true;
}
else if (rightTopOffset != 0.0)
rightRestore = true;
else IsHitVisible(true);
Debug.WriteLine("下一页:" + turnRight);
}
else
{
if (lastDeltaOffset > 0)
{
Status = Status > 0 ? Status - 1 : 2;
turnLeft = true;
}
else if (leftTopOffset != 0.0)
leftRestore = true;
else IsHitVisible(true);
Debug.WriteLine("上一页" + turnLeft);
}
});

Debug.WriteLine("翻页状态:" + Status);
}
isFlip = true;
CanScale = false;
}
#endregion

#region FlipManipulationDelta
private void FlipManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var scale = e.Delta.Scale;
var translateX = e.Delta.Translation.X;
var translateY = e.Delta.Translation.Y;
var nTtranX = nextTrans.TranslateX;
var nTtranY = nextTrans.TranslateY;
var ctranlateX = e.Cumulative.Translation.X;
var ctranlateY = e.Cumulative.Translation.Y;
CanScale = Task.Run(() =>
{
if (scale != 1.0 || (Math.Abs(ctranlateX * 1.15) < Math.Abs(ctranlateY))) return true;
else return false;
}).Result;
if (isManipulating && !CanScale)
{
if (isNext)
{
#region 下一页
var rightTopNect = rightTopPage.Clip.Rect;
var nextRect = nextPage.Clip.Rect;
var nextTransOffset = nTtranX + translateX * 2;

SetShadowOperacity(Math.Abs(nextTransOffset), offsetWidth, false);
var nextRectXOffset = nextRect.X - e.Delta.Translation.X;
lastDeltaOffset = e.Delta.Translation.X;
if (nextRectXOffset < 0 && nextRectXOffset > -offsetWidth)
{
outerRightTrans.TranslateX += e.Delta.Translation.X;
innerRightTrans.TranslateX += e.Delta.Translation.X;
marginRightTrans.TranslateX += e.Delta.Translation.X * 2;

nextTrans.TranslateX = nextTransOffset;
if (nextRectXOffset < 0)
nextRect.X = nextRectXOffset;
rightTopNect.X += e.Delta.Translation.X;
nextPage.Clip.Rect = nextRect;
rightTopPage.Clip.Rect = rightTopNect;
}
else
{
e.Complete();
if (nextTransOffset < 0)
{
nextTrans.TranslateX = -offsetWidth;
nextRect.X = 0;
rightTopNect.X = 0;
nextPage.Clip.Rect = nextRect;
rightTopPage.Clip.Rect = rightTopNect;
}
else
{
nextTrans.TranslateX = offsetWidth;
nextRect.X = -offsetWidth;
rightTopNect.X = offsetWidth;
nextPage.Clip.Rect = nextRect;
rightTopPage.Clip.Rect = rightTopNect;
}
}
#endregion
}
else
{
#region 上一页
var leftTopNect = leftTopPage.Clip.Rect;
var prevRect = prevPage.Clip.Rect;
var prevTransOffset = prevTrans.TranslateX + e.Delta.Translation.X * 2;
var prevRectXOffset = prevRect.X - e.Delta.Translation.X;
SetShadowOperacity(Math.Abs(prevTransOffset), offsetWidth, true);
lastDeltaOffset = e.Delta.Translation.X;
if (prevRectXOffset > 0 && prevRectXOffset < offsetWidth)
{
innerLeftTrans.TranslateX += translateX;
outerLeftTrans.TranslateX += translateX;
marginLeftTrans.TranslateX += translateX * 2;

prevTrans.TranslateX = prevTransOffset;
if (prevRectXOffset > 0)
prevRect.X = prevRectXOffset;
leftTopNect.X += e.Delta.Translation.X;
prevPage.Clip.Rect = prevRect;
leftTopPage.Clip.Rect = leftTopNect;
}
else
{
e.Complete();
if (prevTransOffset < 0)
{
prevTrans.TranslateX = -offsetWidth;
prevRect.X = offsetWidth;
leftTopNect.X = -offsetWidth;
prevPage.Clip.Rect = prevRect;
leftTopPage.Clip.Rect = leftTopNect;

}
else
{
prevTrans.TranslateX = offsetWidth;
prevRect.X = 0;
leftTopNect.X = 0;
prevPage.Clip.Rect = prevRect;
leftTopPage.Clip.Rect = leftTopNect;
}
}
#endregion
}
}
if (CanScale)
{
_previousTransform.Matrix = _transformGroup.Value;
Point center = _previousTransform.TransformPoint(new Point(e.Position.X, e.Position.Y));
_compositeTransform.CenterX = center.X;
_compositeTransform.CenterY = center.Y;
_compositeTransform.ScaleX = e.Delta.Scale;
_compositeTransform.ScaleY = e.Delta.Scale;
_compositeTransform.TranslateX = e.Delta.Translation.X;
_compositeTransform.TranslateY = e.Delta.Translation.Y;
}
}
#endregion
#endregion

#region RenderAnimation 绘制翻页动画
private void RenderAnimation(object sender, object e)
{
if (turnLeft)
{
rightRestore = false;
turnRight = false;
var prevRect = prevPage.Clip.Rect;
var leftTopRect = leftTopPage.Clip.Rect;
var prevOffset = prevRect.X - Speed / 2;
if (prevOffset > 0)
{
prevRect.X = prevOffset;
prevTrans.TranslateX += Speed;
leftTopRect.X += Speed / 2;
innerLeftTrans.TranslateX += Speed / 2;
outerLeftTrans.TranslateX += Speed / 2;
marginLeftTrans.TranslateX += Speed;
SetShadowOperacity(Math.Abs(prevTrans.TranslateX), offsetWidth, true);
}
else
{
prevRect.X = 0;
leftTopRect.X = 0;
turnLeft = false;
prevTrans.TranslateX = offsetWidth;
Fliping(sender, new FlipEventArgs(false));

}
prevPage.Clip.Rect = prevRect;
leftTopPage.Clip.Rect = leftTopRect;
IsHitVisible(true);
}
else if (leftRestore)
{
turnLeft = false;
turnRight = false;
rightRestore = false;
var prevRect = prevPage.Clip.Rect;
var leftTopRect = leftTopPage.Clip.Rect;
var prevOffset = prevRect.X + Speed / 2;
if (prevOffset < offsetWidth)
{
prevRect.X = prevOffset;
prevTrans.TranslateX -= Speed;
leftTopRect.X -= Speed / 2;
innerLeftTrans.TranslateX -= Speed / 2;
outerLeftTrans.TranslateX -= Speed / 2;
marginLeftTrans.TranslateX -= Speed;
SetShadowOperacity(Math.Abs(prevTrans.TranslateX), offsetWidth, true);
}
else
{
prevRect.X = offsetWidth;
leftTopRect.X = -offsetWidth;
prevTrans.TranslateX = -offsetWidth;
innerLeftTrans.TranslateX = 0;
outerLeftTrans.TranslateX = 0;
marginLeftTrans.TranslateX = 0;
leftRestore = false;

}
prevPage.Clip.Rect = prevRect;
leftTopPage.Clip.Rect = leftTopRect;
IsHitVisible(true);
}
else if (turnRight)
{

rightRestore = false;
turnLeft = false;
var nextRect = nextPage.Clip.Rect;
var rightTopRect = rightTopPage.Clip.Rect;
var nextOffset = nextRect.X + Speed / 2;
if (nextOffset < 0)
{
nextRect.X = nextOffset;
nextTrans.TranslateX -= Speed;
rightTopRect.X -= Speed / 2;
innerRightTrans.TranslateX -= Speed / 2;
outerRightTrans.TranslateX -= Speed / 2;
marginRightTrans.TranslateX -= Speed;
SetShadowOperacity(Math.Abs(nextTrans.TranslateX), offsetWidth, false);
}
else
{
nextRect.X = 0;
nextTrans.TranslateX = -offsetWidth;
turnRight = false;
rightTopRect.X = 0;
Fliping(sender, new FlipEventArgs(true));
}
nextPage.Clip.Rect = nextRect;
rightTopPage.Clip.Rect = rightTopRect;
IsHitVisible(true);
}
else if (rightRestore)
{

turnRight = false;
turnLeft = false;
leftRestore = false;
var nextRect = nextPage.Clip.Rect;
var rightTopRect = rightTopPage.Clip.Rect;
var nextOffset = nextRect.X - Speed / 2;
if (nextRect.X - Speed / 2 > -offsetWidth)
{
nextRect.X = nextOffset;
nextTrans.TranslateX += Speed;
rightTopRect.X += Speed / 2;
innerRightTrans.TranslateX += Speed / 2;
outerRightTrans.TranslateX += Speed / 2;
marginRightTrans.TranslateX += Speed;
SetShadowOperacity(Math.Abs(nextTrans.TranslateX), offsetWidth, false);
}
else
{
nextRect.X = -offsetWidth;
rightTopRect.X = offsetWidth;
nextTrans.TranslateX = offsetWidth;
innerRightTrans.TranslateX = 0;
outerRightTrans.TranslateX = 0;
marginRightTrans.TranslateX = 0;
rightRestore = false;
}
rightTopPage.Clip.Rect = rightTopRect;
nextPage.Clip.Rect = nextRect;
IsHitVisible(true);
}
}
#endregion
#endregion

#region Method
#region LoadPageContentByPageIndex
private void LoadPageContentByPageIndex(int PageIndex, bool isNextOrPrev, ContentPresenter firstPresenter, ContentPresenter secondPresenter)
{
List<object> needLoadItems = new List<object>();
if (isNextOrPrev)
{
//加载下一页模板
if (PageIndex + 2 < this.Items.Count)
{
firstPresenter.Content = null;
firstPresenter.DataContext = null;
object item = null;
if (this.Items.Count > PageIndex + 2)
{
item = this.Items[PageIndex + 2];
needLoadItems.Add(item);
firstPresenter.DataContext = item;
}
}
else firstPresenter.DataContext = null;
if (PageIndex + 3 < this.Items.Count)
{
object item = null;
secondPresenter.Content = null;
secondPresenter.DataContext = null;
if (this.Items.Count > PageIndex + 3)
{
item = this.Items[PageIndex + 3];
needLoadItems.Add(item);
secondPresenter.DataContext = item;
}
}
else secondPresenter.DataContext = null;
if (null != NeedLoadingItem)
NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, true));
RecycleData(true, needLoadItems);
}
else
{
if (PageIndex - 2 >= 0 && Items.Count > PageIndex - 2)
{
needLoadItems.Add(this.Items[PageIndex - 2]);
secondPresenter.Content = null;
secondPresenter.DataContext = null;
secondPresenter.DataContext = this.Items[PageIndex - 2];
}
if (PageIndex - 1 >= 0 && Items.Count > PageIndex - 1)
{
firstPresenter.Content = null;
firstPresenter.DataContext = null;
firstPresenter.DataContext = this.Items[PageIndex - 1];
needLoadItems.Add(this.Items[PageIndex - 1]);
}
//加载上一页模板
if (null != NeedLoadingItem)
NeedLoadingItem(this, new FlipLoadArgs(needLoadItems, false));
RecycleData(false, needLoadItems);
}
}
#endregion

#region RecycleData
private async void RecycleData(bool isNext, List<object> needItems)
{
await Task.Run(async () =>
{
foreach (var o in needItems)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
if (null != this.RestoreItemAction)
this.RestoreItemAction.Invoke(o);
});
}
if (isNext)
{
var index = -1;
try
{
index = this.Items.IndexOf(needItems[0]);

}
catch
{
index = -1;
}
if (index != -1 && index - 8 > 0)
{
for (int i = index - 8; i < index - 6; i++)
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
if (null != this.DisposeAction)
DisposeAction.Invoke(this.Items[i]);
});
}
}
else
{
var index = -1;
try
{
index = this.Items.IndexOf(needItems.Last());

}
catch (Exception ex)
{
index = -1;
}
if (index != -1 && this.Items.Count > index + 7)
{
for (int i = index + 5; i < index + 7; i++)
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
if (null != this.DisposeAction)
DisposeAction.Invoke(this.Items[i]);
});
}
}
});
}
#endregion

#region OnItemsChanged
/// <summary>
/// 刷新数据
/// </summary>
/// <param name="e"></param>
protected override void OnItemsChanged(object e)
{
isInit = false;
InitPages();
base.OnItemsChanged(e);
}
#endregion

#region GetPresentersByPageIndex
private List<ContentPresenter> GetPresentersByPageIndex(bool isNext)
{
List<ContentPresenter> presenters = new List<ContentPresenter>();
if (isNext)
{
presenters.Add(leftTopPage.Child as ContentPresenter);
presenters.Add(prevPage.Child as ContentPresenter);
}
else
{
presenters.Add(rightTopPage.Child as ContentPresenter);
presenters.Add(nextPage.Child as ContentPresenter);
}
Debug.WriteLine("presenter0Name:" + presenters[0].Name);
Debug.WriteLine("presenter1Name:" + presenters[1].Name);
return presenters;
}
#endregion

#region Crop
/// <summary>
/// 图形切割
/// </summary>
/// <param name="source"></param>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <returns></returns>
public WriteableBitmap Crop(WriteableBitmap source, int x1, int y1, int x2, int y2)
{
if (x1 >= x2 ||
y1 >= y2 ||
x1 < 0 ||
y1 < 0 ||
x2 < 0 ||
y2 < 0 ||
x1 > source.PixelWidth ||
y1 > source.PixelHeight ||
x2 > source.PixelWidth ||
y2 > source.PixelHeight)
{
throw new ArgumentException();
}

//var buffer = source.PixelBuffer.GetPixels();
var cw = x2 - x1;
var ch = y2 - y1;
var target = new WriteableBitmap(cw, ch);

var croppedBytes =
new byte[4 * cw * ch];
var inputStream = source.PixelBuffer.AsStream();
inputStream.Seek(4 * (source.PixelWidth * y1 + x1), SeekOrigin.Current);
for (int i = 0; i < ch; i++)
{
inputStream.Read(croppedBytes, 4 * cw * i, 4 * cw);
inputStream.Seek(4 * (source.PixelWidth - cw), SeekOrigin.Current);
}

var outputStream = target.PixelBuffer.AsStream();
outputStream.Seek(0, SeekOrigin.Begin);
outputStream.Write(croppedBytes, 0, croppedBytes.Length);
target.Invalidate();

return target;
}
#endregion

#region IsHitVisible
/// <summary>
/// 禁止点击
/// </summary>
/// <param name="o"></param>
private async void IsHitVisible(bool o)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
this.grdContent.IsHitTestVisible = o;
this.leftPage.IsHitTestVisible = o;
this.rightPage.IsHitTestVisible = o;
this.nextPage.IsHitTestVisible = o;
this.prevPage.IsHitTestVisible = o;
this.leftTopPage.IsHitTestVisible = o;
this.rightTopPage.IsHitTestVisible = o;
});
}
#endregion

#region RefreshPageByStatus
/// <summary>
/// 翻页成功后刷新控件状态
/// </summary>
private void RefreshPageByStatus()
{

switch (Status)
{
case 0:
Canvas.SetZIndex(A, 2);
Canvas.SetZIndex(B, 2);
Canvas.SetZIndex(C, 0);
Canvas.SetZIndex(D, 0);
Canvas.SetZIndex(E, 2);
Canvas.SetZIndex(F, 2);
Grid.SetColumn(A, 1);
Grid.SetColumn(B, 1);
Grid.SetColumn(C, 1);
Grid.SetColumn(D, 2);
Grid.SetColumn(E, 2);
Grid.SetColumn(F, 2);
transA.TranslateX = 0;
transB.TranslateX = -offsetWidth;
transC.TranslateX = 0;
transD.TranslateX = 0;
transE.TranslateX = offsetWidth;
transF.TranslateX = 0;
ARect.Rect = new Rect(-this.A.ActualWidth, 0, this.A.ActualWidth, this.A.ActualHeight);
CRect.Rect = new Rect(0, 0, this.C.ActualWidth, this.C.ActualHeight);
DRect.Rect = new Rect(0, 0, this.D.ActualWidth, this.D.ActualHeight);
FRect.Rect = new Rect(this.F.ActualWidth, 0, this.F.ActualWidth, this.F.ActualHeight);
BRect.Rect = new Rect(this.B.ActualWidth, 0, this.B.ActualWidth, this.B.ActualHeight);
ERect.Rect = new Rect(-this.E.ActualWidth, 0, this.E.ActualWidth, this.E.ActualHeight);
nextPage = E;
prevPage = B;
leftPage = C;
rightPage = D;
leftTopPage = A;
rightTopPage = F;
nextTrans = transE;
prevTrans = transB;
//A.PointerPressed -= this.PointerPressed;
//B.PointerPressed -= this.PointerPressed;
//C.PointerPressed += this.PointerPressed;
//D.PointerPressed += this.PointerPressed;
break;
case 1:
Canvas.SetZIndex(A, 2);
Canvas.SetZIndex(B, 2);
Canvas.SetZIndex(C, 2);
Canvas.SetZIndex(D, 2);
Canvas.SetZIndex(E, 0);
Canvas.SetZIndex(F, 0);
Grid.SetColumn(A, 2);
Grid.SetColumn(B, 2);
Grid.SetColumn(C, 1);
Grid.SetColumn(D, 1);
Grid.SetColumn(E, 1);
Grid.SetColumn(F, 2);
transA.TranslateX = offsetWidth;
transB.TranslateX = 0;
transC.TranslateX = 0;
transD.TranslateX = -offsetWidth;
transE.TranslateX = 0;
transF.TranslateX = 0;
ARect.Rect = new Rect(-this.A.ActualWidth, 0, this.A.ActualWidth, this.A.ActualHeight);
CRect.Rect = new Rect(-this.C.ActualWidth, 0, this.C.ActualWidth, this.C.ActualHeight);
DRect.Rect = new Rect(this.D.ActualWidth, 0, this.D.ActualWidth, this.D.ActualHeight);
FRect.Rect = new Rect(0, 0, this.F.ActualWidth, this.F.ActualHeight);
BRect.Rect = new Rect(this.B.ActualWidth, 0, this.B.ActualWidth, this.B.ActualHeight);
ERect.Rect = new Rect(0, 0, this.E.ActualWidth, this.E.ActualHeight);
nextPage = A;
prevPage = D;
leftPage = E;
rightPage = F;
leftTopPage = C;
rightTopPage = B;
nextTrans = transA;
prevTrans = transD;
//C.PointerPressed -= this.PointerPressed;
//D.PointerPressed -= this.PointerPressed;
//E.PointerPressed += this.PointerPressed;
//F.PointerPressed += this.PointerPressed;
break;
case 2:
Canvas.SetZIndex(A, 0);
Canvas.SetZIndex(B, 0);
Canvas.SetZIndex(C, 2);
Canvas.SetZIndex(D, 2);
Canvas.SetZIndex(E, 2);
Canvas.SetZIndex(F, 2);
Grid.SetColumn(A, 1);
Grid.SetColumn(B, 2);
Grid.SetColumn(C, 2);
Grid.SetColumn(D, 2);
Grid.SetColumn(E, 1);
Grid.SetColumn(F, 1);
transA.TranslateX = 0;
transB.TranslateX = 0;
transC.TranslateX = offsetWidth;
transD.TranslateX = 0;
transE.TranslateX = 0;
transF.TranslateX = -offsetWidth;
ARect.Rect = new Rect(0, 0, this.A.ActualWidth, this.A.ActualHeight);
CRect.Rect = new Rect(-this.C.ActualWidth, 0, this.C.ActualWidth, this.C.ActualHeight);
DRect.Rect = new Rect(this.D.ActualWidth, 0, this.D.ActualWidth, this.D.ActualHeight);
FRect.Rect = new Rect(this.F.ActualWidth, 0, this.F.ActualWidth, this.F.ActualHeight);
BRect.Rect = new Rect(0, 0, this.B.ActualWidth, this.B.ActualHeight);
ERect.Rect = new Rect(-this.E.ActualWidth, 0, this.E.ActualWidth, this.E.ActualHeight);
nextPage = C;
prevPage = F;
leftPage = A;
rightPage = B;
leftTopPage = E;
rightTopPage = D;
nextTrans = transC;
prevTrans = transF;
//E.PointerPressed -= this.PointerPressed;
//F.PointerPressed -= this.PointerPressed;
//A.PointerPressed += this.PointerPressed;
//B.PointerPressed += this.PointerPressed;
break;
default:
break;
}
stShadowSplitInnerLeft.Opacity = 0;
stShadowSplitInnerRight.Opacity = 0;
stShadowSplitOuterLeft.Opacity = 0;
stShadowSplitOuterRight.Opacity = 0;
outerRightTrans.TranslateX = 0;
innerRightTrans.TranslateX = 0;
outerLeftTrans.TranslateX = 0;
innerLeftTrans.TranslateX = 0;
marginLeftTrans.TranslateX = 0;
marginRightTrans.TranslateX = 0;
leftTopPage.Background = leftBrush;
prevPage.Background = rightBrush;
leftPage.Background = leftBrush;
rightPage.Background = rightBrush;
nextPage.Background = leftBrush;
rightTopPage.Background = rightBrush;
}
#endregion

#region GetCropBookBrush
private async Task GetCropBrush()
{
if (null != this.BookBackgroundBrush)
{
var orginSource = this.BookBackgroundBrush.ImageSource as BitmapImage;
if (!orginSource.UriSource.AbsolutePath.Equals(string.Empty))
{
var uri = new Uri("ms-appx://" + orginSource.UriSource.AbsolutePath);
try
{
var file = await StorageFile.GetFileFromApplicationUriAsync(uri);
WriteableBitmap leftSource = new WriteableBitmap(Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));
await LoadAsync(leftSource, file);
WriteableBitmap rightSource = new WriteableBitmap(Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));
await LoadAsync(rightSource, file);
leftBrush = new ImageBrush();
rightBrush = new ImageBrush();
rightBrush.Stretch = Stretch.Fill;
leftBrush.Stretch = Stretch.Fill;
leftSource = Crop(leftSource, 0, 0, Convert.ToInt32(offsetWidth), Convert.ToInt32(offsetHeight));
leftBrush.ImageSource = leftSource;
rightSource = Crop(rightSource, Convert.ToInt32(offsetWidth), 0, Convert.ToInt32(offsetWidth * 2), Convert.ToInt32(offsetHeight));
rightBrush.ImageSource = rightSource;
}
catch
{
}
}
}
}
#endregion

#region LoadWriteableBitmap
public async Task<WriteableBitmap> LoadAsync(
WriteableBitmap writeableBitmap,
StorageFile storageFile)
{
using (var stream = await storageFile.OpenReadAsync())
{
await writeableBitmap.SetSourceAsync(
stream);
}
return writeableBitmap;
}

#endregion

#region SetShadowOperacity
private async void SetShadowOperacity(double pos, double pageWidth, bool direction)
{
var opacity = await Task.Run(() =>
{
double num = (pageWidth - pos) / 2.0;
double num2 = Math.Abs((double)((pageWidth / 2.0) - num));
return (1.0 * (1.0 - (num2 / (pageWidth / 2.0))));
});
if (direction)
{
this.stShadowSplitOuterLeft.Opacity = opacity;
this.stShadowSplitInnerLeft.Opacity = opacity;
this.stShadowMarginLeft.Opacity = opacity;
}
else
{
this.stShadowSplitOuterRight.Opacity = opacity;
this.stShadowSplitInnerRight.Opacity = opacity;
this.stShadowMarginRight.Opacity = opacity;
}
}
#endregion
#endregion
}

/// <summary>
/// 抛出需要加载的项数据
/// </summary>
public class FlipLoadArgs : EventArgs
{
public readonly List<object> needItems;
public readonly bool isNext;

public FlipLoadArgs(List<object> _needItems, bool _isNext)
{
this.needItems = _needItems;
this.isNext = _isNext;
}
}

public class FlipEventArgs : EventArgs
{
public readonly bool isNext;

public FlipEventArgs(bool _isNext)
{
this.isNext = _isNext;
}
}
}

<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:WinRTXamlToolkit.Controls">

<Style TargetType="local:FlipBookControl">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="local:FlipBookControl">
<Grid
x:Name="grdContent"
Background="{TemplateBinding Background}">
<Grid.RowDefinitions>
<RowDefinition Height="30*"/>
<RowDefinition Height="750*"/>
<RowDefinition Height="30*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="50*"/>
<ColumnDefinition Width="600*"/>
<ColumnDefinition Width="600*"/>
<ColumnDefinition Width="50*"/>
</Grid.ColumnDefinitions>
<Image
x:Name="bookContainer"
Stretch="Fill"
Canvas.ZIndex="2"
Grid.ColumnSpan="4"
IsHitTestVisible="False"
Grid.RowSpan="3"/>
<Border
Grid.Row="1"
Grid.Column="1"
BorderThickness="0"
x:Name="C">
<Border.Clip>
<RectangleGeometry x:Name="CRect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transC"></CompositeTransform>
</Border.RenderTransform>
<ContentPresenter x:Name="CPresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
x:Name="D">
<Border.Clip>
<RectangleGeometry x:Name="DRect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transD"></CompositeTransform>
</Border.RenderTransform>
<ContentPresenter x:Name="DPresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
x:Name="E">
<Border.Clip>
<RectangleGeometry x:Name="ERect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transE"/>
</Border.RenderTransform>
<ContentPresenter x:Name="EPresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
x:Name="F">
<Border.Clip>
<RectangleGeometry x:Name="FRect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transF"></CompositeTransform>
</Border.RenderTransform>
<ContentPresenter x:Name="FPresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
x:Name="A">
<Border.Clip>
<RectangleGeometry x:Name="ARect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transA"></CompositeTransform>
</Border.RenderTransform>
<ContentPresenter x:Name="APresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<Border Grid.Row="1" Grid.Column="1"  BorderThickness="0"
x:Name="B">
<Border.Clip>
<RectangleGeometry x:Name="BRect">
</RectangleGeometry>
</Border.Clip>
<Border.RenderTransform>
<CompositeTransform x:Name="transB"/>
</Border.RenderTransform>
<ContentPresenter x:Name="BPresenter" Style="{TemplateBinding ItemContainerStyle}"
ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
</Border>
<StackPanel  Canvas.ZIndex="3"
x:Name="stShadowSplitOuterLeft"
Width="43"
Opacity="0"
Grid.Row="1"
Grid.Column="1"
HorizontalAlignment="Left" Margin="-43,0,0,0" RenderTransformOrigin="0.5,0.5">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="outerLeftTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
<GradientStop Color="#99000000"/>
<GradientStop Color="Transparent" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
<StackPanel Canvas.ZIndex="3"
x:Name="stShadowSplitInnerLeft"
Width="51"
Opacity="0"
Grid.Row="1"
Grid.Column="1"
HorizontalAlignment="Left" RenderTransformOrigin="0.5,0.5">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="innerLeftTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
<GradientStop Color="#99000000"/>
<GradientStop Color="#01FFFFFF" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
<StackPanel Canvas.ZIndex="3"
x:Name="stShadowSplitOuterRight"
Width="43"
Opacity="0"
Grid.Row="1"
Grid.Column="2"
HorizontalAlignment="Right" Margin="0,0,-43,0" RenderTransformOrigin="0.5,0.5">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="outerRightTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
<GradientStop Color="#99000000"/>
<GradientStop Color="Transparent" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
<StackPanel  Canvas.ZIndex="3"
x:Name="stShadowSplitInnerRight"
Width="51"
Opacity="0"
Grid.Row="1"
Grid.Column="2"
HorizontalAlignment="Right" RenderTransformOrigin="0.5,0.5">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="innerRightTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
<GradientStop Color="#99000000"/>
<GradientStop Color="#01FFFFFF" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
<StackPanel x:Name="stShadowMarginLeft" Width="30" HorizontalAlignment="Left"
Opacity="0" Grid.Row="1" Grid.Column="1" Canvas.ZIndex="3">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="marginLeftTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
<GradientStop Color="#99000000"/>
<GradientStop Color="Transparent" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
<StackPanel x:Name="stShadowMarginRight" Width="30" HorizontalAlignment="Right"
Opacity="0" Grid.Row="1" Grid.Column="2" Canvas.ZIndex="3">
<StackPanel.RenderTransform>
<CompositeTransform x:Name="marginRightTrans" TranslateX="0"/>
</StackPanel.RenderTransform>
<StackPanel.Background>
<LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
<GradientStop Color="#99000000"/>
<GradientStop Color="Transparent" Offset="1"/>
</LinearGradientBrush>
</StackPanel.Background>
</StackPanel>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</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个依赖项 请在使用前填写。用于释放图片流 以及恢复 源

欢迎讨论，分享经验，以及更优的方法。