private void OnMouseMovePin(object sender, Point mouseLocation)
{
if (!IsDraggingPin)
{
Vector delta = mouseLocation - m_dragStartPoint;
if (DragDropHelpers.IsMovementBiggerThreshold(delta))
{
StartDraggingPin();
}
}
else
{
bool bPinHit = ((NodeGraphView)Content).HitTestConnection(mouseLocation, out CPinViewModel hitPin, out Point canvasHit);
PreviewConnection.EndPoint = canvasHit;
if (bPinHit)
{
PreviewConnection.IsValidDrop = hitPin.CanConnect(DraggedPin, out string errorMessage);
PreviewConnection.ErrorMessage = errorMessage;
Mouse.OverrideCursor = PreviewConnection.IsValidDrop ? Cursors.Hand : Cursors.No;
PreviewConnection.DropTarget = hitPin;
}
else
{
PreviewConnection.DropTarget = null;
PreviewConnection.IsValidDrop = true;
PreviewConnection.ErrorMessage = "";
Mouse.OverrideCursor = null;
}
}
}
void IDropTarget.DragOver(IDropInfo dropInfo)
{
DragDropHelpers.DragOver(dropInfo, (item, sourceType, targetType) =>
{
return(sourceType == typeof(TECIOModule));
});
}
public void DragDropHelpers_PreventDrop_DropResourceOntoItself_ReturnsFalse()
{
//------------Setup for test--------------------------
AppUsageStats.LocalHost = "http://localhost";
var resourceId = Guid.NewGuid();
var data = new ExplorerItemViewModel(new Mock <IServer>().Object, new Mock <IExplorerTreeItem>().Object,
a => { }, new Mock <IShellViewModel>().Object, new Mock <IPopupController>().Object)
{
ResourceType = "WorkflowService",
ResourceId = resourceId,
CanExecute = true,
CanView = true,
IsService = true,
IsSource = false
};
var dataContext = new Mock <IWorkflowDesignerViewModel>();
var resourceModel = new Mock <IContextualResourceModel>();
resourceModel.Setup(model => model.ID).Returns(resourceId);
var differentEnvironment = new Mock <IServer>();
differentEnvironment.Setup(model => model.EnvironmentID).Returns(Guid.Empty);
dataContext.Setup(model => model.Server).Returns(differentEnvironment.Object);
dataContext.Setup(model => model.ResourceModel).Returns(resourceModel.Object);
differentEnvironment.Setup(a => a.IsLocalHost).Returns(false);
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext.Object));
CustomContainer.Register(new Mock <IPopupController>().Object);
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemViewModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragOver(IDropInfo dropInfo)
{
if (SelectedController == null)
{
return;
}
List <IConnectable> connectables = new List <IConnectable>();
if (dropInfo.Data is FilteredConnectablesGroup group)
{
if (group.Scope == SelectedController)
{
return;
}
connectables = ConnectionHelper.GetConnectables(group.Scope, filterPredicate);
}
else if (dropInfo.Data is IEnumerable dropList && dropList.GetItemType() == typeof(FilteredConnectablesGroup))
{
foreach (FilteredConnectablesGroup item in dropList)
{
connectables.AddRange(ConnectionHelper.GetConnectables(item.Scope, filterPredicate));
}
}
if (ConnectionHelper.CanConnectToController(connectables, SelectedController))
{
DragDropHelpers.SetDragAdorners(dropInfo);
}
}
public void DragOver(IDropInfo dropInfo)
{
if (dropInfo.Data is TECProtocol && DragDropHelpers.TargetCollectionIsType(dropInfo, typeof(TECIO)))
{
DragDropHelpers.SetDragAdorners(dropInfo);
}
}
public void DragOver(IDropInfo dropInfo)
{
DragDropHelpers.DragOver(dropInfo,
(item, sourceType, targetType) =>
{
return(sourceType == targetType);
});
}
public void Drop(IDropInfo dropInfo)
{
object drop <T>(T item)
{
return(item);
}
DragDropHelpers.Drop(dropInfo, drop);
}
/// <inheritdoc />
public override bool AcceptDrop(NSOutlineView outlineView, NSDraggingInfo info, NSObject item, nint index)
{
DebugDragDropPrint("***** OutlineView.AcceptDrop, index: " + index);
var dropLocationTreeNode = item as NSTreeNode;
bool acceptedDrop = dropLocationTreeNode != null;
var viewModel = outlineView.GetInheritedValue <MenuLayoutViewModel>(IFakeDependencyObjectHelpers.DataContextPropertyName);
IEnumerable <FileNodeViewModel> draggedItems = null;
if (acceptedDrop)
{
var newParent = dropLocationTreeNode.GetRepresentedObject() as FolderViewModel;
var pasteboard = info.DraggingPasteboard;
acceptedDrop = newParent != null;
if (acceptedDrop && pasteboard.CanReadItemWithDataConformingToTypes(MenuLayoutPasteboardDataTypeArray))
{
draggedItems = DragDropHelpers.GetDataForType <IEnumerable <FileNodeViewModel> >(pasteboard, MenuLayoutPasteboardDataTypeArray);
if (acceptedDrop)
{
acceptedDrop = newParent.ShouldAcceptDraggedItems(draggedItems.Select(draggedItem => draggedItem.Model));
}
if (acceptedDrop)
{
var firstDraggedItem = draggedItems.First();
var parent = firstDraggedItem.Parent;
var parentViewModel = viewModel.FindViewModelForModel(parent);
if (parentViewModel == newParent)
{
var currentIndex = parent.IndexOfChild(firstDraggedItem.Model);
if (currentIndex < index)
{
--index;
}
}
acceptedDrop = newParent.MoveItems(viewModel, newParent, (int)index, draggedItems);
}
}
else if (acceptedDrop && pasteboard.CanReadItemWithDataConformingToTypes(ProgramDescriptionPasteboardDataTypeArray))
{
var droppedItems = DragDropHelpers.GetDataForType <IEnumerable <ProgramDescriptionViewModel> >(pasteboard, ProgramDescriptionPasteboardDataTypeArray).Select(draggedItem => draggedItem.Model);
newParent.AddItems(viewModel, (int)index, droppedItems);
}
else
{
acceptedDrop = false;
}
DebugDragDropPrint("*** OutlineView drop into: " + newParent);
}
if (acceptedDrop)
{
TreeData.RearrangeObjects();
if ((draggedItems != null) && draggedItems.Any())
{
viewModel.CurrentSelection = draggedItems.FirstOrDefault(i => i.Model != null);
}
}
return(acceptedDrop);
}
public void DragDropHelpers_PreventDrop_NoFormats_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectNoFormats());
//------------Assert Results-------------------------
Assert.IsFalse(canDoDrop);
}
public void DragDropHelpers_PreventDrop_FormatsReturnsNotResourceTreeViewModelOrWorkflowItemTypeNameFormat_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormat(new[] { "SomeText" }));
//------------Assert Results-------------------------
Assert.IsFalse(canDoDrop);
}
public void DragDropHelpers_PreventDrop_GetDataReturnsNull_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatNoData(new[] { "ExplorerItemViewModel", "SomeText" }));
//------------Assert Results-------------------------
Assert.IsFalse(canDoDrop);
}
public void Drop(IDropInfo dropInfo)
{
if (dropInfo.Data is TECSystem)
{
DragDropHelpers.SystemToTypicalDrop(dropInfo, Bid);
}
else
{
DragDropHelpers.StandardDrop(dropInfo, Bid);
}
}
void IDropTarget.Drop(IDropInfo dropInfo)
{
if (dropInfo.Data is TECTypical typ)
{
BoxItems.Add(new TECSystem(typ as TECSystem));
}
else
{
DragDropHelpers.StandardDrop(dropInfo, manager);
}
}
private string GetFilter()
{
List <string> filters = new List <string>();
var extensions = DragDropHelpers.GetSafeExtensions(this.Extension);
extensions.ForEach(ext =>
{
filters.Add(string.Format(CultureInfo.CurrentCulture, Resources.CreateElementFromPickedFileCommand_FilterFormat, ext));
});
filters.Add(Resources.CreateElementFromPickedFileCommand_AllFilesFilter);
return(string.Join(@"|", filters));
}
public void DragDropHelpers_PreventDrop_GetDataReturnsExplorerItemModelSource_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
var data = new ExplorerItemModel {
Permissions = Permissions.Execute, ResourceType = Common.Interfaces.Data.ResourceType.DbSource
};
//------------Execute Test---------------------------
bool canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragDropHelpers_PreventDrop_GetDataReturnsExplorerItemModelSource_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
var data = new ExplorerItemViewModel(new Mock <IServer>().Object, new Mock <IExplorerTreeItem>().Object, a => { }, new Mock <IShellViewModel>().Object, new Mock <IPopupController>().Object);
data.ResourceType = "DbSource";
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemViewModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragOver(IDropInfo dropInfo)
{
DragDropHelpers.DragOver(dropInfo, dropCondition);
bool dropCondition(object item, Type sourceType, Type targetType)
{
bool correctSource = sourceType == typeof(TECEquipment) || sourceType == typeof(TECProposalItem);
bool correctTarget = dropInfo.TargetCollection is IList <TECEquipment> ||
targetType == typeof(TECProposalItem) ||
System.ProposalItems.Any(x => x.ContainingScope == dropInfo.TargetCollection);
return(correctSource && correctTarget);
}
}
/// <inheritdoc />
public override bool OutlineViewwriteItemstoPasteboard(NSOutlineView outlineView, NSArray items, NSPasteboard pboard)
{
DebugDragDropPrint("***** OutlineView.OutlineViewwriteItemstoPasteboard");
#if DEBUG_DRAGDROP
var nodes = NSArray.FromArray <NSTreeNode>(items);
#endif // DEBUG_DRAGDROP
var draggedItems = NSArray.FromArray <NSTreeNode>(items).Select(node => node.RepresentedObject as FileNodeViewModel);
var startDrag = draggedItems.Any();
if (startDrag)
{
DragDropHelpers.PreparePasteboard(pboard, MenuLayoutViewModel.DragDataFormat, new NSDataWrapper(draggedItems));
}
return(startDrag);
}
private void OnMouseMove(object sender, MouseEventArgs e)
{
if (m_draggedData == null || m_draggedItem == null || e.LeftButton != MouseButtonState.Pressed)
{
return;
}
Vector delta = e.GetPosition(null) - m_dragStartPos;
if (DragDropHelpers.IsMovementBiggerThreshold(delta))
{
//DragDrop.DoDragDrop(m_draggedItem, m_draggedData, DragDropEffects.Link | DragDropEffects.Scroll);
}
}
public void DragDropHelpers_PreventDrop_FormatOfWorkflowItemTypeNameFormat_ReturnsFalse()
{
//------------Setup for test--------------------------
object dataContext = new object();
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext));
var data = new ExplorerItemModel {
Permissions = Permissions.Execute, ResourceType = Common.Interfaces.Data.ResourceType.DbService
};
//------------Execute Test---------------------------
bool canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "WorkflowItemTypeNameFormat" }, data));
//------------Assert Results-------------------------
Assert.IsFalse(canDoDrop);
}
public void DragDropHelpers_PreventDrop_GetDataReturnsExplorerItemModelSource_ReturnsFalse()
{
//------------Setup for test--------------------------
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView());
var data = new ExplorerItemModel(new Mock <IConnectControlSingleton>().Object, new Mock <IStudioResourceRepository>().Object)
{
Permissions = Permissions.Execute, ResourceType = ResourceType.DbSource
};
//------------Execute Test---------------------------
bool canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragDropHelpers_PreventDrop_UserIsNotAuthorized_True()
{
//------------Setup for test--------------------------
var data = new ExplorerItemViewModel(new Mock <IServer>().Object, new Mock <IExplorerTreeItem>().Object, a => { }, new Mock <IShellViewModel>().Object, new Mock <IPopupController>().Object);
data.ResourceType = "WorkflowService";
var dataContext = new object();
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext));
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemViewModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public QuotesVM(TECBid bid, ChangeWatcher watcher)
{
watcher.Changed += bidChanged;
NeedQuoteHardware = new ObservableCollection <TECHardware>(bid
.GetAll <TECSubScope>()
.SelectMany(ss => ss.Devices
.Where(x => x is TECHardware ware && ware.RequireQuote && ware.QuotedPrice == -1))
.Distinct()
.OfType <TECHardware>());
QuotedHardware = new ObservableCollection <TECHardware>(bid.Catalogs.GetAll <TECHardware>().Where(x => x.QuotedPrice != -1).Distinct());
QuotedHardware.CollectionChanged += quotedHardware_CollectionChanged;
var dropHandler = new EmptyDropTarget();
dropHandler.DragOverAction = info =>
{
DragDropHelpers.DragOver(info, (item, sourceType, targetType) =>
{
var hardware = item as TECHardware;
return(hardware != null && hardware.QuotedPrice == -1);
});
};
dropHandler.DropAction = info =>
{
DragDropHelpers.Drop(info, item =>
{
var hardware = item as TECHardware;
hardware.QuotedPrice = hardware.Cost;
return(hardware);
});
};
QuoteDropHandler = dropHandler;
CollectionsVM = new ScopeCollectionsTabVM(bid);
CollectionsVM.OmitCollections(new List <AllSearchableObjects>()
{
AllSearchableObjects.System,
AllSearchableObjects.Equipment,
AllSearchableObjects.SubScope,
AllSearchableObjects.Controllers,
AllSearchableObjects.Panels,
AllSearchableObjects.MiscCosts,
AllSearchableObjects.MiscWiring,
AllSearchableObjects.Tags,
AllSearchableObjects.AssociatedCosts,
AllSearchableObjects.Wires,
AllSearchableObjects.Conduits,
AllSearchableObjects.Protocols
});
}
public void DragDropHelpers_PreventDrop_UserIsNotAuthorized_True()
{
//------------Setup for test--------------------------
var data = new ExplorerItemModel {
Permissions = Permissions.View, ResourceType = Common.Interfaces.Data.ResourceType.WorkflowService
};
var dataContext = new object();
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext));
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragOver(IDropInfo dropInfo)
{
DragDropHelpers.StandardDragOver(dropInfo,
type =>
{
if (type == typeof(TECMisc) && dropInfo.Data is TECCost)
{
return(true);
}
else
{
return(false);
}
}
);
}
public void DragDropHelpers_PreventDrop_GetDataReturnsNonExplorerItemModel_ReturnsFalse()
{
//------------Setup for test--------------------------
var data = new Object();
var dataContext = new Mock <IWorkflowDesignerViewModel>();
var differentEnvironment = new Mock <IServer>();
differentEnvironment.Setup(model => model.EnvironmentID).Returns(Guid.Empty);
dataContext.Setup(model => model.Server).Returns(differentEnvironment.Object);
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext.Object));
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemViewModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragDropHelpers_PreventDrop_GetDataReturnsExplorerItemModelNotWorkflowServiceDataContextNotViewModel_ReturnsTrue()
{
//------------Setup for test--------------------------
object dataContext = new object();
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext));
var data = new ExplorerItemModel(new Mock <IConnectControlSingleton>().Object, new Mock <IStudioResourceRepository>().Object)
{
Permissions = Permissions.Execute, ResourceType = Common.Interfaces.Data.ResourceType.DbService
};
//------------Execute Test---------------------------
bool canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
public void DragDropHelpers_PreventDrop_UserIsNotAuthorized_True()
{
//------------Setup for test--------------------------
var data = new ExplorerItemModel(new Mock <IConnectControlSingleton>().Object, new Mock <IStudioResourceRepository>().Object)
{
Permissions = Permissions.View, ResourceType = ResourceType.WorkflowService
};
var dataContext = new object();
var dragDropHelpers = new DragDropHelpers(GetMockWorkflowDesignerView(dataContext));
//------------Execute Test---------------------------
var canDoDrop = dragDropHelpers.PreventDrop(GetMockDataObjectWithFormatData(new[] { "ExplorerItemModel" }, data));
//------------Assert Results-------------------------
Assert.IsTrue(canDoDrop);
}
/// <inheritdoc/>
public override void DraggingSessionWillBegin(NSTableView tableView, NSDraggingSession draggingSession, CGPoint willBeginAtScreenPoint, NSIndexSet rowIndexes)
{
DebugDragDrop("**** ROMLIST DRAG WILL BEGIN");
////var viewModel = tableView.GetInheritedValue(IFakeDependencyObjectHelpers.DataContextPropertyName) as RomListViewModel;
var draggedItems = new List <ProgramDescriptionViewModel>();
var items = RomListData.ArrangedObjects();
foreach (var index in rowIndexes)
{
draggedItems.Add(items[(int)index] as ProgramDescriptionViewModel);
}
if (draggedItems.Any())
{
var pasteboard = draggingSession.DraggingPasteboard;
DragDropHelpers.PreparePasteboard(pasteboard, ProgramDescriptionViewModel.DragDataFormat, new NSDataWrapper(draggedItems));
}
}
private void OnPreviewMouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton != MouseButtonState.Pressed || m_draggedData == null || m_draggedElement == null)
{
return;
}
// Get the current mouse position
Point mousePos = e.GetPosition(null);
Vector diff = m_sceneComponentDragStartPoint - mousePos;
if (DragDropHelpers.IsMovementBiggerThreshold(diff))
{
// Initialize the drag & drop operation
DragDrop.DoDragDrop(m_draggedElement, m_draggedData, DragDropEffects.Move | DragDropEffects.Link | DragDropEffects.Copy);
}
}
