private void ThumbDragDelta(object sender, DragDeltaEventArgs e)
{
if (Thumb.IsDragging)
{
if (Value > Max) Value = Max;
}
}
private void GridSplitterOnDragDeltaHandler(object sender, DragDeltaEventArgs e)
{
UpdateAdornersPositions();
}
void ResizeControl_DragDelta(object sender, DragDeltaEventArgs e)
{
DiagramElement DiagramElement = this.DataContext as DiagramElement;
DiagramCanvas designer = VisualTreeHelper.GetParent(DiagramElement) as DiagramCanvas;
if (DiagramElement != null && designer != null && DiagramElement.IsSelected)
{
double minLeft, minTop, minDeltaHorizontal, minDeltaVertical;
double dragDeltaVertical, dragDeltaHorizontal, scale;
IEnumerable <DiagramElement> selectedDiagramElements = designer.SelectionService.CurrentSelection.OfType <DiagramElement>();
CalculateDragLimits(selectedDiagramElements, out minLeft, out minTop,
out minDeltaHorizontal, out minDeltaVertical);
foreach (DiagramElement item in selectedDiagramElements)
{
if (item != null && item.ParentID == Guid.Empty)
{
switch (base.VerticalAlignment)
{
case VerticalAlignment.Bottom:
dragDeltaVertical = Math.Min(-e.VerticalChange, minDeltaVertical);
scale = (item.ActualHeight - dragDeltaVertical) / item.ActualHeight;
DragBottom(scale, item, designer.SelectionService);
break;
case VerticalAlignment.Top:
double top = Canvas.GetTop(item);
dragDeltaVertical = Math.Min(Math.Max(-minTop, e.VerticalChange), minDeltaVertical);
scale = (item.ActualHeight - dragDeltaVertical) / item.ActualHeight;
DragTop(scale, item, designer.SelectionService);
break;
default:
break;
}
switch (base.HorizontalAlignment)
{
case HorizontalAlignment.Left:
double left = Canvas.GetLeft(item);
dragDeltaHorizontal = Math.Min(Math.Max(-minLeft, e.HorizontalChange), minDeltaHorizontal);
scale = (item.ActualWidth - dragDeltaHorizontal) / item.ActualWidth;
DragLeft(scale, item, designer.SelectionService);
break;
case HorizontalAlignment.Right:
dragDeltaHorizontal = Math.Min(-e.HorizontalChange, minDeltaHorizontal);
scale = (item.ActualWidth - dragDeltaHorizontal) / item.ActualWidth;
DragRight(scale, item, designer.SelectionService);
break;
default:
break;
}
}
}
e.Handled = true;
}
}
protected override void OnThumbDragDelta(DragDeltaEventArgs e)
{
base.OnThumbDragDelta(e);
this.ShowCurrentValue();
}
private void BottomSizeOnDragDelta(object sender, DragDeltaEventArgs e)
{
Height = Math.Max(Height + Screen.VerticalPixelToDpi(this, e.VerticalChange), MinHeight);
}
private void OnDragDelta(object sender, DragDeltaEventArgs e)
{
this.isDragging = true;
this.owner.OnButtonDragDelta(this, e);
}
void strip_DragDelta(object sender, DragDeltaEventArgs e)
{
MoveStop(newStop, startOffset, e);
e.Handled = true;
}
private void Thumb_DragDelta(object sender, DragDeltaEventArgs e)
{
GanttChartView ganttChartView;
ScrollViewer scrollViewer;
GanttChartItem dataContext = this.Thumb.DataContext as GanttChartItem;
if (dataContext != null)
{
ganttChartView = dataContext.GanttChartView as GanttChartView;
if ((ganttChartView != null) && !dataContext.HasChildren)
{
this.horizontalChange = e.HorizontalChange;
scrollViewer = ganttChartView.ScrollViewer;
if (!this.isDuringInternalScrollOperation)
{
double x = this.originalHorizontalPosition + this.horizontalChange;
double itemHeight = ganttChartView.ItemHeight;
Point p = new Point(x, 0.0);
this.isDuringInternalScrollOperation = true;
base.Dispatcher.BeginInvoke((Action)(() =>
{
double previousHorizontalOffset = scrollViewer.HorizontalOffset;
ScrollContentPresenter visual = ganttChartView.ScrollContentPresenter;
if ((scrollViewer != null) && (visual != null))
{
try
{
p = this.TransformToVisual(visual).Transform(p);
if (p.X < itemHeight)
{
scrollViewer.ScrollToHorizontalOffset(scrollViewer.HorizontalOffset - itemHeight);
}
if (p.X > (scrollViewer.ViewportWidth - itemHeight))
{
scrollViewer.ScrollToHorizontalOffset(scrollViewer.HorizontalOffset + itemHeight);
}
}
catch
{
}
}
this.Dispatcher.BeginInvoke((Action)(() =>
{
this.originalHorizontalPosition -= scrollViewer.HorizontalOffset - previousHorizontalOffset;
this.isDuringInternalScrollOperation = false;
}));
}));
}
switch (this.Role)
{
case DragTaskThumbRole.UpdateFinish:
if (!dataContext.IsMilestone)
{
double num3 = ganttChartView.GetPosition(dataContext.Finish) + e.HorizontalChange;
dataContext.Finish = ganttChartView.GetPreviousVisibleWorkingTime(ganttChartView.GetUpdateScaleTime(ganttChartView.GetDateTime(num3)));
return;
}
return;
case DragTaskThumbRole.UpdateCompletedFinish:
if (!dataContext.IsMilestone)
{
double num4 = ganttChartView.GetPosition(dataContext.CompletedFinish) + e.HorizontalChange;
dataContext.CompletedFinish = ganttChartView.GetPreviousVisibleWorkingTime(ganttChartView.GetUpdateScaleTime(ganttChartView.GetDateTime(num4)));
return;
}
return;
}
double position = ganttChartView.GetPosition(dataContext.Start) + e.HorizontalChange;
TimeSpan effort = dataContext.Effort;
TimeSpan completedEffort = dataContext.CompletedEffort;
dataContext.Start = ganttChartView.GetNextVisibleWorkingTime(ganttChartView.GetUpdateScaleTime(ganttChartView.GetDateTime(position)));
if (!dataContext.IsMilestone)
{
dataContext.Effort = effort;
dataContext.CompletedEffort = completedEffort;
}
}
}
}
private void EndPortDragDelta(object sender, DragDeltaEventArgs e)
{
MoveEndPort(e.HorizontalChange, e.VerticalChange);
}
private static void SizeThumbOnDragDelta(object sender, DragDeltaEventArgs dragDeltaEventArgs)
{
var thumb = ((Thumb)sender);
var dragablzItem = thumb.VisualTreeAncestory().OfType <DragablzItem>().FirstOrDefault();
if (dragablzItem == null)
{
return;
}
var sizeGrip = (SizeGrip)thumb.GetValue(SizeGripProperty);
var width = dragablzItem.ActualWidth;
var height = dragablzItem.ActualHeight;
var x = dragablzItem.X;
var y = dragablzItem.Y;
switch (sizeGrip)
{
case SizeGrip.NotApplicable:
break;
case SizeGrip.Left:
width += -dragDeltaEventArgs.HorizontalChange;
x += dragDeltaEventArgs.HorizontalChange;
break;
case SizeGrip.TopLeft:
width += -dragDeltaEventArgs.HorizontalChange;
height += -dragDeltaEventArgs.VerticalChange;
x += dragDeltaEventArgs.HorizontalChange;
y += dragDeltaEventArgs.VerticalChange;
break;
case SizeGrip.Top:
height += -dragDeltaEventArgs.VerticalChange;
y += dragDeltaEventArgs.VerticalChange;
break;
case SizeGrip.TopRight:
height += -dragDeltaEventArgs.VerticalChange;
width += dragDeltaEventArgs.HorizontalChange;
y += dragDeltaEventArgs.VerticalChange;
break;
case SizeGrip.Right:
width += dragDeltaEventArgs.HorizontalChange;
break;
case SizeGrip.BottomRight:
width += dragDeltaEventArgs.HorizontalChange;
height += dragDeltaEventArgs.VerticalChange;
break;
case SizeGrip.Bottom:
height += dragDeltaEventArgs.VerticalChange;
break;
case SizeGrip.BottomLeft:
height += dragDeltaEventArgs.VerticalChange;
width += -dragDeltaEventArgs.HorizontalChange;
x += dragDeltaEventArgs.HorizontalChange;
break;
default:
throw new ArgumentOutOfRangeException();
}
dragablzItem.SetCurrentValue(XProperty, x);
dragablzItem.SetCurrentValue(YProperty, y);
dragablzItem.SetCurrentValue(WidthProperty, Math.Max(width, thumb.DesiredSize.Width));
dragablzItem.SetCurrentValue(HeightProperty, Math.Max(height, thumb.DesiredSize.Height));
}
void control_DragDelta(object sender, DragDeltaEventArgs e)
{
InvalidateArrange();
}
void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
// Set up the data sources we'll need to work with
DesignerItemBaseVM sourceItem = this.DataContext as DesignerItemBaseVM;
DesignerVM vm = sourceItem.ParentForm;
// Make sure something exists and is selected
if (sourceItem != null && sourceItem.IsSelected)
{
// Set up the selected items
var selectedItems = vm.ActiveTab.SelectedItems;
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
/*
* // if more than one item is selected, treat them as a group -
* // when one stops moving, they all do
* double TopmostItemTop = vm.Height;
* double LeftmostItemLeft = 0;
* double RightmostItemLeft = 0;
* double BottomMostItemTop = 0;
*
* if (vm.SelectedItems.Count > 1)
* {
* foreach (DesignerItemBaseVM item in selectedItems.OfType<DesignerItemBaseVM>())
* {
*
* if (item.Top < TopmostItemTop) TopmostItemTop = item.Top;
* if (item.Left < LeftmostItemLeft) LeftmostItemLeft = item.Left;
* if (item.Top > BottomMostItemTop) BottomMostItemTop = item.Top;
* if (item.Left < RightmostItemLeft) RightmostItemLeft = item.Left;
*
* }
* System.Console.WriteLine("Extreme edges: Top({0}), Left({1}), Right({2}), Bottom({3})", TopmostItemTop, LeftmostItemLeft, RightmostItemLeft, BottomMostItemTop);
* } */
foreach (DesignerItemBaseVM item in selectedItems.OfType <DesignerItemBaseVM>())
{
double maxItemLeft = vm.Width - item.Width;
double maxItemTop = vm.Height - item.Height;
minLeft = double.IsNaN(item.Left) ? 0 : Math.Min(item.Left, minLeft);
minTop = double.IsNaN(item.Top) ? 0 : Math.Min(item.Top, minTop);
double deltaHorizontal = Math.Max(-minLeft, e.HorizontalChange);
double deltaVertical = Math.Max(-minTop, e.VerticalChange);
double desiredLeft = item.Left + deltaHorizontal;
double desiredTop = item.Top + deltaVertical;
if (desiredLeft > maxItemLeft)
{
item.Left = maxItemLeft;
}
else
{
item.Left += deltaHorizontal;
}
if (desiredTop > maxItemTop)
{
item.Top = maxItemTop;
}
else
{
item.Top += deltaVertical;
}
}
e.Handled = true;
}
}
// Handles resize vertical drag
private void OnResizeVerticalDelta(object sender, DragDeltaEventArgs e)
{
SetDragHeight(e);
}
private void RangeSlider_OnCentralThumbDragDelta(object sender, DragDeltaEventArgs e)
{
//TestBlock.Text = "central thumb drag delta";
}
private void RangeSlider_OnUpperThumbDragDelta(object sender, DragDeltaEventArgs e)
{
}
private void Center_DragDelta(object sender, DragDeltaEventArgs e)
{
X = X + e.HorizontalChange;
Y = Y + e.VerticalChange;
}
double IDragDeltaEventArgsResolver.VerticalChange(DragDeltaEventArgs e) => e.VerticalChange;
private static void OnDragDelta(object sender, DragDeltaEventArgs e)
{
((SimpleGridSplitter)sender).OnDragDelta(e);
}
static void ClassDragDelta(object sender, DragDeltaEventArgs e)
{
(sender as GradientSlider).thumb_DragDelta(sender, e);
}
private void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
NameColumnWidth = Math.Max(0, NameColumnWidth + e.HorizontalChange);
}
void thumb_DragDelta(object sender, DragDeltaEventArgs e)
{
var stop = (e.OriginalSource as GradientThumb).GradientStop;
MoveStop(stop, stop.Offset, e);
}
/// <summary> /// Gets the horizontal change in the <see cref="Thumb"/> position /// since the last <see cref="Thumb.DragDelta"/> event. /// </summary> /// <param name="e">The requested <see cref="DragDeltaEventArgs"/>.</param> /// <returns> /// The horizontal change in the <see cref="Thumb"/> position /// since the last <see cref="Thumb.DragDelta"/> event. /// </returns> public static double HorizontalChange(this DragDeltaEventArgs e) => Resolver.HorizontalChange(e);
//usually, you should override this method to drag
protected virtual void OnDragDelta(object sender, DragDeltaEventArgs e)
{
}
/// <summary> /// Gets a reference to the object that raised the event. /// This is often a template part of a control rather than an element that was declared in your app UI. /// </summary> /// <param name="e">The requested <see cref="DragDeltaEventArgs"/>.</param> /// <returns>The object that raised the event.</returns> public static object OriginalSource(this DragDeltaEventArgs e) => Resolver.OriginalSource(e);
private void RightSizeBarOnDragDelta(object sender, DragDeltaEventArgs e)
{
Width = Math.Max(Width + Screen.HorizontalPixelToDpi(this, e.HorizontalChange), MinWidth);
}
/// <summary> /// Gets the vertical change in the <see cref="Thumb"/> position /// since the last <see cref="Thumb.DragDelta"/> event. /// </summary> /// <param name="e">The requested <see cref="DragDeltaEventArgs"/>.</param> /// <returns> /// The vertical change in the <see cref="Thumb"/> position /// since the last <see cref="Thumb.DragDelta"/> event. /// </returns> public static double VerticalChange(this DragDeltaEventArgs e) => Resolver.VerticalChange(e);
private void headerThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
Left = Left + e.HorizontalChange;
Top = Top + e.VerticalChange;
}
double IDragDeltaEventArgsResolver.HorizontalChange(DragDeltaEventArgs e) => e.HorizontalChange;
private void DragWidget_DragDelta(object sender, DragDeltaEventArgs e)
{
ProcessMove(e);
}
object IDragDeltaEventArgsResolver.OriginalSource(DragDeltaEventArgs e) => e.OriginalSource;
/// <summary>
/// Handle the drag delta event to update the UI for the resize operation in progress
/// </summary>
internal void DragValidator_DragDeltaEvent(object sender, DragDeltaEventArgs e)
{
if (_resizeData != null)
{
double horizontalChange = e.HorizontalChange;
double verticalChange = e.VerticalChange;
if (_resizeData.ShowsPreview)
{
if (_resizeData.ResizeDirection == GridResizeDirection.Columns)
{
_resizeData.PreviewControl.OffsetX = Math.Min(Math.Max(horizontalChange, _resizeData.MinChange), _resizeData.MaxChange);
}
else
{
_resizeData.PreviewControl.OffsetY = Math.Min(Math.Max(verticalChange, _resizeData.MinChange), _resizeData.MaxChange);
}
}
else
{
MoveSplitter(horizontalChange, verticalChange);
}
}
}
void ChangeHeight(Thumb thumb, DragDeltaEventArgs args)
{
Height = Math.Max(Height + args.VerticalChange, thumb.DesiredSize.Height);
}
