public Point GetCornerPoint(FoldPosition corner, RelativeTo relativeTo)
{
Point point;
switch (corner)
{
case FoldPosition.TopLeft:
point = relativeTo == RelativeTo.Book ? new Point(-1.0 * (this.book.ActualWidth / 2.0), 0.0) : new Point(0.0, 0.0);
break;
case FoldPosition.TopRight:
point = relativeTo == RelativeTo.Book ? new Point(this.book.ActualWidth, 0.0) : new Point(this.book.ActualWidth / 2.0, 0.0);
break;
case FoldPosition.BottomRight:
point = relativeTo == RelativeTo.Book ? new Point(this.book.ActualWidth, this.book.ActualHeight) : new Point(this.book.ActualWidth / 2.0, this.book.ActualHeight);
break;
case FoldPosition.BottomLeft:
point = relativeTo == RelativeTo.Book ? new Point(-1.0 * (this.book.ActualWidth / 2.0), this.book.ActualHeight) : new Point(0.0, this.book.ActualHeight);
break;
default:
point = new Point();
break;
}
return(point);
}
public PendingTurn(FoldPosition from, FoldPosition to, int newIndex, int oldIndex)
{
this.From = from;
this.To = to;
this.NewIndex = newIndex;
this.OldIndex = oldIndex;
}
private static FoldPosition GetOppositeCorner(FoldPosition corner)
{
FoldPosition foldPosition;
switch (corner)
{
case FoldPosition.TopLeft:
foldPosition = FoldPosition.TopRight;
break;
case FoldPosition.TopRight:
foldPosition = FoldPosition.TopLeft;
break;
case FoldPosition.BottomRight:
foldPosition = FoldPosition.BottomLeft;
break;
case FoldPosition.BottomLeft:
foldPosition = FoldPosition.BottomRight;
break;
default:
foldPosition = FoldPosition.None;
break;
}
return(foldPosition);
}
private void RaiseCornerLeave(FoldPosition exitedCorner)
{
if (exitedCorner != this.lastEnteredCorner || this.foldMouseLeave == null)
{
return;
}
this.foldMouseLeave((object)this, new CornerEventArgs(this.mousePoint, exitedCorner));
}
private void RadBookItem_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (!this.CanBeTurned)
{
return;
}
this.mousePoint = e.GetPosition((IInputElement)this);
if (!FoldHelper.MouseWithinFoldAreas(this.mousePoint, this) && this.FoldSize != new Size(0.0, 0.0))
{
return;
}
this.draggedCorner = FoldHelper.GetQuadrant(this.mousePoint, this);
this.targetCorner = RadBookItem.GetOppositeCorner(this.draggedCorner);
this.UpdatePageFold();
if (this.doubleClickMode && this.PageFlipMode == PageFlipMode.DoubleClick)
{
if (this.mouseDoubleClick != null)
{
this.mouseDoubleClick((object)this, new MouseClickEventArgs(this.targetCorner));
}
this.doubleClickMode = false;
this.doubleClickTimer.Stop();
}
else
{
this.singleClickMode = this.PageFlipMode == PageFlipMode.SingleClick;
this.doubleClickMode = this.PageFlipMode == PageFlipMode.DoubleClick;
this.dragStarted = true;
if (this.PageFlipMode == PageFlipMode.SingleClick)
{
this.singleClickTimer.Start();
}
else if (this.PageFlipMode == PageFlipMode.DoubleClick)
{
this.doubleClickTimer.Start();
}
else
{
this.singleClickTimer.Stop();
this.doubleClickTimer.Stop();
}
if (this.mouseDragStart == null)
{
return;
}
this.mouseDragStart((object)this, new DragStartedEventArgs(this.draggedCorner, this.mousePoint));
}
}
private void RaiseCornerEnterMove(FoldPosition corner, double offsetX, double offsetY)
{
Point mousePoint = new Point(this.mousePoint.X + offsetX, this.mousePoint.Y + offsetY);
if (corner != this.lastEnteredCorner)
{
if (this.foldMouseEnter == null)
{
return;
}
this.foldMouseEnter((object)this, new CornerEventArgs(mousePoint, corner));
}
else
{
if (this.foldMouseMove == null)
{
return;
}
this.foldMouseMove((object)this, new CornerEventArgs(mousePoint, corner));
}
}
private void UpdatePageFold()
{
if (this.Position == PagePosition.Right)
{
if (FoldHelper.MouseWithinTopRightFoldArea(this.mousePoint, this.FoldSize, this.ActualWidth))
{
this.RaiseCornerEnterMove(FoldPosition.TopRight, 0.0, 0.0);
this.lastEnteredCorner = FoldPosition.TopRight;
}
else if (FoldHelper.MouseWithinBottomRightFoldArea(this.mousePoint, this.FoldSize, this.ActualWidth, this.ActualHeight))
{
this.RaiseCornerEnterMove(FoldPosition.BottomRight, 0.0, 0.0);
this.lastEnteredCorner = FoldPosition.BottomRight;
}
else
{
this.RaiseCornerLeave(FoldHelper.GetQuadrant(this.mousePoint, this));
this.lastEnteredCorner = FoldPosition.None;
}
}
else if (FoldHelper.MouseWithinTopLeftFoldArea(this.mousePoint, this.FoldSize))
{
this.RaiseCornerEnterMove(FoldPosition.TopLeft, 0.0, 0.0);
this.lastEnteredCorner = FoldPosition.TopLeft;
}
else if (FoldHelper.MouseWithinBottomLeftFoldArea(this.mousePoint, this.FoldSize, this.ActualHeight))
{
this.RaiseCornerEnterMove(FoldPosition.BottomLeft, 0.0, 0.0);
this.lastEnteredCorner = FoldPosition.BottomLeft;
}
else
{
this.RaiseCornerLeave(FoldHelper.GetQuadrant(this.mousePoint, this));
this.lastEnteredCorner = FoldPosition.None;
}
}
public void TurnPage(Point from, FoldPosition to, RelativeTo relativeTo)
{
Point cornerPoint = this.GetCornerPoint(to, relativeTo);
this.TurnPage(from, cornerPoint);
}
public void TurnPage(FoldPosition from, FoldPosition to, RelativeTo cornerFromRelativeness, RelativeTo cornerToRelativeness)
{
this.TurnPage(this.GetCornerPoint(from, cornerFromRelativeness), this.GetCornerPoint(to, cornerToRelativeness));
}
public static RotateTransform GetRotateTransform(Point hoverPoint, double pageWidth, double pageHeight, FoldPosition draggedCorner, PagePosition position)
{
RotateTransform rotateTransform = new RotateTransform();
double num1 = draggedCorner == FoldPosition.TopRight || draggedCorner == FoldPosition.BottomRight ? pageWidth - hoverPoint.X : hoverPoint.X;
double y = hoverPoint.Y;
double curlY = CurlCalculator.GetCurlY(num1, y);
if (position == PagePosition.Left)
{
double num2 = 0.0;
double num3 = hoverPoint.Y > 0.0 ? 0.0 : pageHeight;
double d = Math.Atan2(num1, curlY - y) * 180.0 / Math.PI;
if (double.IsNaN(d) || double.IsInfinity(d) || d < 0.0)
{
d = 0.0;
}
rotateTransform.CenterY = num3;
rotateTransform.CenterX = num2;
rotateTransform.Angle = hoverPoint.Y >= 0.0 ? -d : 180.0 - d;
}
else
{
double num2 = pageWidth;
double num3 = hoverPoint.Y > 0.0 ? 0.0 : pageHeight;
double d = Math.Atan2(num1, curlY - y) * 180.0 / Math.PI;
if (double.IsNaN(d) || double.IsInfinity(d) || d < 0.0)
{
d = 0.0;
}
rotateTransform.CenterY = num3;
rotateTransform.CenterX = num2;
rotateTransform.Angle = hoverPoint.Y >= 0.0 ? d : d - 180.0;
}
return(rotateTransform);
}
public static TranslateTransform GetTranslateTransform(Point hoverPoint, double pageWidth, FoldPosition draggedCorner)
{
return(new TranslateTransform()
{
X = draggedCorner == FoldPosition.TopLeft || draggedCorner == FoldPosition.BottomLeft ? -2.0 * pageWidth + hoverPoint.X : hoverPoint.X + pageWidth,
Y = hoverPoint.Y
});
}
public MouseClickEventArgs(FoldPosition targetCorner)
{
this.TargetCorner = targetCorner;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Telerik.Windows.Controls.Book.DragStartedEventArgs"/> class.
///
/// </summary>
/// <param name="draggedCorner">The dragged corner.</param><param name="mousePosition">The mouse position.</param>
public DragStartedEventArgs(FoldPosition draggedCorner, Point mousePosition)
{
this.DraggedCorner = draggedCorner;
this.MousePoint = mousePosition;
}
public CornerEventArgs(Point mousePoint, FoldPosition corner)
{
this.MousePoint = mousePoint;
this.Corner = corner;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Telerik.Windows.Controls.FoldEventArgs"/> class.
///
/// </summary>
public FoldEventArgs(object source, FoldPosition position, RoutedEvent routedEvent)
: base(routedEvent, source)
{
this.Position = position;
}
public void TurnPage(FoldPosition from, Point to, RelativeTo relativeTo)
{
this.TurnPage(this.GetCornerPoint(from, relativeTo), to);
}
public void TurnPage(FoldPosition to, RelativeTo relativeTo)
{
this.TurnPage(this.GetCornerPoint(to, relativeTo));
}
private void RadBook_FoldActivated(object sender, Telerik.Windows.Controls.FoldEventArgs e)
{
FoldPosition position = e.Position;
}
public DragEndedEventArgs(bool dragEndedOutsidePage, FoldPosition targetCorner)
{
this.DragEndedOutsideOfPage = dragEndedOutsidePage;
this.TargetCorner = targetCorner;
}
internal void Reset()
{
this.lastEnteredCorner = FoldPosition.None;
}
