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

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

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

 

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. <Style TargetType="local:FlipBookControl">
6. <Setter Property="Template">
7. <Setter.Value>
8. <ControlTemplate TargetType="local:FlipBookControl">
9. <Grid
10. x:Name="grdContent"
11. Background="{TemplateBinding Background}">
12. <Grid.RowDefinitions>
13. <RowDefinition Height="30*"/>
14. <RowDefinition Height="750*"/>
15. <RowDefinition Height="30*"/>
16. </Grid.RowDefinitions>
17. <Grid.ColumnDefinitions>
18. <ColumnDefinition Width="50*"/>
19. <ColumnDefinition Width="600*"/>
20. <ColumnDefinition Width="600*"/>
21. <ColumnDefinition Width="50*"/>
22. </Grid.ColumnDefinitions>
23. <Image
24. x:Name="bookContainer"
25. Stretch="Fill"
26. Canvas.ZIndex="2"
27. Grid.ColumnSpan="4"
28. IsHitTestVisible="False"
29. Grid.RowSpan="3"/>
30. <Border
31. Grid.Row="1"
32. Grid.Column="1"
33. BorderThickness="0"
34. x:Name="C">
35. <Border.Clip>
36. <RectangleGeometry x:Name="CRect">
37. </RectangleGeometry>
38. </Border.Clip>
39. <Border.RenderTransform>
40. <CompositeTransform x:Name="transC"></CompositeTransform>
41. </Border.RenderTransform>
42. <ContentPresenter x:Name="CPresenter" Style="{TemplateBinding ItemContainerStyle}"
43. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
44. </Border>
45. <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
46. x:Name="D">
47. <Border.Clip>
48. <RectangleGeometry x:Name="DRect">
49. </RectangleGeometry>
50. </Border.Clip>
51. <Border.RenderTransform>
52. <CompositeTransform x:Name="transD"></CompositeTransform>
53. </Border.RenderTransform>
54. <ContentPresenter x:Name="DPresenter" Style="{TemplateBinding ItemContainerStyle}"
55. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
56. </Border>
57. <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
58. x:Name="E">
59. <Border.Clip>
60. <RectangleGeometry x:Name="ERect">
61. </RectangleGeometry>
62. </Border.Clip>
63. <Border.RenderTransform>
64. <CompositeTransform x:Name="transE"/>
65. </Border.RenderTransform>
66. <ContentPresenter x:Name="EPresenter" Style="{TemplateBinding ItemContainerStyle}"
67. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
68. </Border>
69. <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
70. x:Name="F">
71. <Border.Clip>
72. <RectangleGeometry x:Name="FRect">
73. </RectangleGeometry>
74. </Border.Clip>
75. <Border.RenderTransform>
76. <CompositeTransform x:Name="transF"></CompositeTransform>
77. </Border.RenderTransform>
78. <ContentPresenter x:Name="FPresenter" Style="{TemplateBinding ItemContainerStyle}"
79. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
80. </Border>
81. <Border Grid.Row="1" Grid.Column="1" BorderThickness="0"
82. x:Name="A">
83. <Border.Clip>
84. <RectangleGeometry x:Name="ARect">
85. </RectangleGeometry>
86. </Border.Clip>
87. <Border.RenderTransform>
88. <CompositeTransform x:Name="transA"></CompositeTransform>
89. </Border.RenderTransform>
90. <ContentPresenter x:Name="APresenter" Style="{TemplateBinding ItemContainerStyle}"
91. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
92. </Border>
93. <Border Grid.Row="1" Grid.Column="1"  BorderThickness="0"
94. x:Name="B">
95. <Border.Clip>
96. <RectangleGeometry x:Name="BRect">
97. </RectangleGeometry>
98. </Border.Clip>
99. <Border.RenderTransform>
100. <CompositeTransform x:Name="transB"/>
101. </Border.RenderTransform>
102. <ContentPresenter x:Name="BPresenter" Style="{TemplateBinding ItemContainerStyle}"
103. ContentTemplate="{TemplateBinding ItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"></ContentPresenter>
104. </Border>
105. <StackPanel  Canvas.ZIndex="3"
106. x:Name="stShadowSplitOuterLeft"
107. Width="43"
108. Opacity="0"
109. Grid.Row="1"
110. Grid.Column="1"
111. HorizontalAlignment="Left" Margin="-43,0,0,0" RenderTransformOrigin="0.5,0.5">
112. <StackPanel.RenderTransform>
113. <CompositeTransform x:Name="outerLeftTrans" TranslateX="0"/>
114. </StackPanel.RenderTransform>
115. <StackPanel.Background>
116. <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
117. <GradientStop Color="#99000000"/>
118. <GradientStop Color="Transparent" Offset="1"/>
119. </LinearGradientBrush>
120. </StackPanel.Background>
121. </StackPanel>
122. <StackPanel Canvas.ZIndex="3"
123. x:Name="stShadowSplitInnerLeft"
124. Width="51"
125. Opacity="0"
126. Grid.Row="1"
127. Grid.Column="1"
128. HorizontalAlignment="Left" RenderTransformOrigin="0.5,0.5">
129. <StackPanel.RenderTransform>
130. <CompositeTransform x:Name="innerLeftTrans" TranslateX="0"/>
131. </StackPanel.RenderTransform>
132. <StackPanel.Background>
133. <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
134. <GradientStop Color="#99000000"/>
135. <GradientStop Color="#01FFFFFF" Offset="1"/>
136. </LinearGradientBrush>
137. </StackPanel.Background>
138. </StackPanel>
139. <StackPanel Canvas.ZIndex="3"
140. x:Name="stShadowSplitOuterRight"
141. Width="43"
142. Opacity="0"
143. Grid.Row="1"
144. Grid.Column="2"
145. HorizontalAlignment="Right" Margin="0,0,-43,0" RenderTransformOrigin="0.5,0.5">
146. <StackPanel.RenderTransform>
147. <CompositeTransform x:Name="outerRightTrans" TranslateX="0"/>
148. </StackPanel.RenderTransform>
149. <StackPanel.Background>
150. <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
151. <GradientStop Color="#99000000"/>
152. <GradientStop Color="Transparent" Offset="1"/>
153. </LinearGradientBrush>
154. </StackPanel.Background>
155. </StackPanel>
156. <StackPanel  Canvas.ZIndex="3"
157. x:Name="stShadowSplitInnerRight"
158. Width="51"
159. Opacity="0"
160. Grid.Row="1"
161. Grid.Column="2"
162. HorizontalAlignment="Right" RenderTransformOrigin="0.5,0.5">
163. <StackPanel.RenderTransform>
164. <CompositeTransform x:Name="innerRightTrans" TranslateX="0"/>
165. </StackPanel.RenderTransform>
166. <StackPanel.Background>
167. <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
168. <GradientStop Color="#99000000"/>
169. <GradientStop Color="#01FFFFFF" Offset="1"/>
170. </LinearGradientBrush>
171. </StackPanel.Background>
172. </StackPanel>
173. <StackPanel x:Name="stShadowMarginLeft" Width="30" HorizontalAlignment="Left"
174. Opacity="0" Grid.Row="1" Grid.Column="1" Canvas.ZIndex="3">
175. <StackPanel.RenderTransform>
176. <CompositeTransform x:Name="marginLeftTrans" TranslateX="0"/>
177. </StackPanel.RenderTransform>
178. <StackPanel.Background>
179. <LinearGradientBrush EndPoint="1,1" StartPoint="0,1">
180. <GradientStop Color="#99000000"/>
181. <GradientStop Color="Transparent" Offset="1"/>
182. </LinearGradientBrush>
183. </StackPanel.Background>
184. </StackPanel>
185. <StackPanel x:Name="stShadowMarginRight" Width="30" HorizontalAlignment="Right"
186. Opacity="0" Grid.Row="1" Grid.Column="2" Canvas.ZIndex="3">
187. <StackPanel.RenderTransform>
188. <CompositeTransform x:Name="marginRightTrans" TranslateX="0"/>
189. </StackPanel.RenderTransform>
190. <StackPanel.Background>
191. <LinearGradientBrush EndPoint="0,0" StartPoint="1,0">
192. <GradientStop Color="#99000000"/>
193. <GradientStop Color="Transparent" Offset="1"/>
194. </LinearGradientBrush>
195. </StackPanel.Background>
196. </StackPanel>
197. </Grid>
198. </ControlTemplate>
199. </Setter.Value>
200. </Setter>
201. </Style>
202. </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个依赖项 请在使用前填写。用于释放图片流 以及恢复 源

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