public void DropEmptyFieldOnNewLineItem()
{
ifvm.PopulateToolbox();
GroupType gt = wvm.PageList[14].GroupTypeOrders[0].Group; // First group on Page 15
gtvm.Group = gt;
List <ToolboxItem> tbsiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbsi = tbsiList.Find(x => x.ItemType.DesignID.Equals("197"));
ItemTypeOrder dropTargetItemTypeOrder = new ItemTypeOrder()
{
DesignID = null,
GroupTypeID = null,
IncludedTypeID = null,
Item = null,
ItemOrder = 7
};
gtvm.HandleToolboxItemDrop(gt, tbsi, dropTargetItemTypeOrder);
Assert.AreEqual(gt.ItemOrder[7].DesignID, tbsi.ItemType.DesignID);
ItemTypeOrder targetItemTypeOrder = gt.ItemOrder[7];
ItemTypeOrder draggedItemTypeOrder = gt.ItemOrder[2];
gtvm.HandleDropAndDropBetweenItems(gt, targetItemTypeOrder, draggedItemTypeOrder);
Assert.AreEqual(6, gt.ItemOrder.IndexOf(targetItemTypeOrder));
Assert.AreEqual(7, gt.ItemOrder.IndexOf(draggedItemTypeOrder));
Assert.AreEqual(7, gt.ItemOrder[7].ItemOrder);
Assert.AreEqual(6, gt.ItemOrder[6].ItemOrder);
}
/// <summary>
/// Creates an exact copy of a grouptype, including its list of ItemTypeOrders
/// </summary>
/// <param name="gt"></param>
/// <returns></returns>
public GroupType DeepCopyGroupType(GroupType gt)
{
GroupType deepCopyGroupType = new GroupType();
deepCopyGroupType.DanishTranslationText = gt.DanishTranslationText;
deepCopyGroupType.EnglishTranslationText = gt.EnglishTranslationText;
deepCopyGroupType.GroupHeader = gt.GroupHeader;
deepCopyGroupType.GroupTypeID = gt.GroupTypeID;
deepCopyGroupType.ItemOrder = gt.ItemOrder;
deepCopyGroupType.LanguageID = gt.LanguageID;
deepCopyGroupType.ResourceID = gt.ResourceID;
deepCopyGroupType.ResourceType = gt.ResourceType;
deepCopyGroupType.ResourceTypeID = gt.ResourceTypeID;
ObservableCollection <ItemTypeOrder> deepCopyItemTypeOrders = new ObservableCollection <ItemTypeOrder>();
foreach (ItemTypeOrder ito in gt.ItemOrder)
{
ItemTypeOrder clonedito = new ItemTypeOrder();
clonedito.DesignID = ito.DesignID;
clonedito.GroupTypeID = ito.GroupTypeID;
clonedito.IncludedTypeID = ito.IncludedTypeID;
clonedito.Item = ito.Item;
clonedito.ItemOrder = ito.ItemOrder;
deepCopyItemTypeOrders.Add(clonedito);
}
deepCopyGroupType.ItemOrder = deepCopyItemTypeOrders;
return(deepCopyGroupType);
}
private Border CreateItemCell(ItemTypeOrder itemType)
{
Border bCell = CreateBorderContainer(_cellBorderColor, _cellColor);
bCell.DataContext = itemType;
bCell.MouseEnter += border_MouseEnter;
bCell.MouseLeave += border_MouseLeave;
bCell.AllowDrop = true;
bCell.Drop += border_Drop;
bCell.DragEnter += border_DragEnter;
bCell.DragLeave += border_DragLeave;
bCell.DragOver += border_DragOver;
TextBlock tb = new TextBlock
{
FontSize = 14.0,
HorizontalAlignment = HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Stretch
};
tb.SetBinding(TextBlock.TextProperty, "Item.Header");
//bCell.SetBinding(Border.ToolTipProperty, "Item.ToolTip");
tb.SetBinding(TextBlock.ToolTipProperty, "Item.ToolTip");
//ToolTipService.SetInitialShowDelay(bCell, 700);
Grid gridCell = new Grid();
CreateColumns(gridCell, 2);
Button clearCellBtn = CreateClearCellBtn();
Grid.SetColumn(clearCellBtn, 1);
Grid.SetColumn(tb, 0);
gridCell.Children.Add(clearCellBtn);
gridCell.Children.Add(tb);
bCell.Child = gridCell;
return(bCell);
}
public void DropToolboxSpecialNewLineItemOnItem()
{
GroupType gt = wvm.PageList[14].GroupTypeOrders[1].Group; // Second group on Page 15
List <ToolboxItem> tbiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbi = tbiList.Find(x => x.ItemType.DesignID.Equals("198")); //ItemType-Name: NewLineItem
GroupType deepCopyGroupType = DeepCopyGroupType(gt);
ObservableCollection <ItemTypeOrder> modifiedItemTypeOrderList = deepCopyGroupType.ItemOrder;
gtvm.Group = deepCopyGroupType;
gtvm.AdjustItemOrder(gtvm.Group);
ItemTypeOrder dropTargetItemTypeOrder = deepCopyGroupType.ItemOrder[3];
List <ItemTypeOrder> unmodifiedItemTypeList = gt.ItemOrder.ToList();
int i = 0;
gtvm.HandleToolboxItemDrop(deepCopyGroupType, tbi, dropTargetItemTypeOrder);
int skipped = 0;
//gt.ItemOrder[i - 1].ItemOrder + (4 - (gt.ItemOrder[i - 1].ItemOrder % 4));
//while (i < unmodifiedItemTypeList.Count - skipped)
while (i < modifiedItemTypeOrderList.Count)
{
Assert.AreEqual(i + skipped, modifiedItemTypeOrderList[i].ItemOrder);
if (modifiedItemTypeOrderList[i].DesignID.Equals("198"))
{
skipped = skipped + (int)(4 - (modifiedItemTypeOrderList[i].ItemOrder % 4)) - 1;
}
i++;
}
Assert.AreEqual(modifiedItemTypeOrderList[3].Item.DesignID, tbi.ItemType.DesignID); //Check if dropped ItemType is inserted at the right location
}
/// <summary>
/// Handles drop logic for NewLineItem from toolbox
/// </summary>
/// <param name="dropTargetItemTypeOrder"></param>
/// <param name="tbi"></param>
/// <param name="gt"></param>
public void ToolboxSpecialNewLineItemDrop(ItemTypeOrder dropTargetItemTypeOrder, ToolboxItem tbi, GroupType gt)
{
CheckForNewLineItem(dropTargetItemTypeOrder);
ItemTypeOrder itemTypeOrder = new ItemTypeOrder();
itemTypeOrder.DesignID = tbi.ItemType.DesignID;
ItemType itemType = new ItemType();
itemType.DesignID = tbi.ItemType.DesignID;
itemType.Header = tbi.ItemType.Header;
itemTypeOrder.ItemOrder = dropTargetItemTypeOrder.ItemOrder;
itemType.DanishTranslationText = tbi.ItemType.DanishTranslationText;
itemType.EnglishTranslationText = tbi.ItemType.EnglishTranslationText;
itemType.LanguageID = tbi.ItemType.LanguageID;
itemTypeOrder.GroupTypeID = gt.GroupTypeID;
itemTypeOrder.IncludedTypeID = "1";
itemTypeOrder.Item = itemType;
int index = gt.ItemOrder.IndexOf(dropTargetItemTypeOrder);
gt.ItemOrder.Insert(index, itemTypeOrder);
int draggedIndex = gt.ItemOrder.IndexOf(itemTypeOrder);
AdjustItemOrderNewLineItemDrop(gt, draggedIndex);
//AdjustItemOrder(gt);
}
public void MoveItemsForward(int startPosition, ItemTypeOrder newItemType, GroupType gt)
{
ObservableCollection <ItemTypeOrder> itemTypeList = gt.ItemOrder;
bool stopCounting = false;
int i = startPosition;
while (i < itemTypeList.Count && !stopCounting)
{
if (itemTypeList[i].DesignID.Equals("198"))
{
if (itemTypeList[i].ItemOrder % 4 == 3)
{
itemTypeList.RemoveAt(i);
}
else
{
itemTypeList[i].ItemOrder++;
}
stopCounting = true;
}
else
{
itemTypeList[i].ItemOrder++;
i++;
}
}
itemTypeList.Add(newItemType);
itemTypeList.Sort(ito => ito.ItemOrder);
_wvm._changedFlag = true;
}
public void DropToolboxSpecialItemOnNullField()
{
ifvm.PopulateToolbox();
GroupType gt = wvm.PageList[14].GroupTypeOrders[0].Group; // Page 15
gtvm.Group = gt;
List <ToolboxItem> tbsiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbsi = tbsiList.Find(x => x.ItemType.DesignID.Equals("197"));
ItemTypeOrder dropTargetItemTypeOrder = new ItemTypeOrder()
{
DesignID = null,
GroupTypeID = null,
IncludedTypeID = null,
Item = null,
ItemOrder = 7
};
int lastIndex = gt.ItemOrder.Count - 1;
gtvm.HandleToolboxItemDrop(gt, tbsi, dropTargetItemTypeOrder);
Assert.AreEqual(gt.ItemOrder[7].DesignID, tbsi.ItemType.DesignID);
int i = lastIndex + 1;
while (i < gt.ItemOrder.Count - 1)
{
Assert.AreEqual(gt.ItemOrder[i].DesignID, "197");
i++;
}
}
/// <summary>
/// Handles drop logic on emptyfield
/// </summary>
/// <param name="dropTargetItemTypeOrder"></param>
/// <param name="tbi"></param>
/// <param name="gt"></param>
public void ToolboxItemDropOnEmptyField(ItemTypeOrder dropTargetItemTypeOrder, ToolboxItem tbi, GroupType gt)
{
dropTargetItemTypeOrder.DesignID = tbi.ItemType.DesignID;
dropTargetItemTypeOrder.Item.Header = tbi.ItemType.Header;
dropTargetItemTypeOrder.Item.DanishTranslationText = tbi.ItemType.DanishTranslationText;
dropTargetItemTypeOrder.Item.EnglishTranslationText = tbi.ItemType.EnglishTranslationText;
dropTargetItemTypeOrder.Item.LanguageID = tbi.ItemType.LanguageID;
dropTargetItemTypeOrder.GroupTypeID = gt.GroupTypeID;
dropTargetItemTypeOrder.IncludedTypeID = "1";
}
void HandleToolboxItemDrop(object sender, DragEventArgs e)
{
Border bCell = GetBorderByDropEvent(e);
ListBoxItem lbi = e.Data.GetData("System.Windows.Controls.ListBoxItem") as ListBoxItem;
ToolboxItem tbi = (ToolboxItem)lbi.Content;
ItemTypeOrder itToBeMoved = (ItemTypeOrder)bCell.DataContext;
GroupType gt = MyGroupTypeOrder.Group;
GTViewModel.HandleToolboxItemDrop(gt, tbi, itToBeMoved);
RefreshGroupTable();
DisableAllowDropByNewLineItem();
}
private void InsertItem(ItemTypeOrder item, int row, int column)
{
Border bCell = GetCellItem(row, column);
Grid cellItem = (Grid)bCell.Child;
TextBlock tb = (TextBlock)cellItem.Children[1];
ItemTypeOrder dummyItemType = (ItemTypeOrder)bCell.DataContext;
item.ItemOrder = dummyItemType.ItemOrder;
bCell.DataContext = item;
//tb.DataContext = itemType;
//tb.SetBinding(TextBlock.TextProperty, "Header");
tb.Foreground = new SolidColorBrush(_cellTextColor);
}
public void DropBetweenStandardItemsGT()
{
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // Page 15
GroupType gt = wvm.PageList[14].GroupTypeOrders[0].Group; // First on page 15
gtvm.Group = gt;
gtvm.GroupTypeOrderCollection = gtoList;
ItemTypeOrder targetItemTypeOrder = gt.ItemOrder[1];
ItemTypeOrder draggedItemTypeOrder = gt.ItemOrder[3];
gtvm.HandleDropAndDropBetweenItems(gt, targetItemTypeOrder, draggedItemTypeOrder);
Assert.AreEqual(2, gt.ItemOrder.IndexOf(targetItemTypeOrder));
Assert.AreEqual(1, gt.ItemOrder.IndexOf(draggedItemTypeOrder));
}
/// <summary>
/// Makes sure that a NewLineItem cannot be dropped on a row in a group that already contains a NewLineItem
/// </summary>
/// <param name="dropTargetItemTypeOrder"></param>
public void CheckForNewLineItem(ItemTypeOrder dropTargetItemTypeOrder)
{
int itemOrder = (int)dropTargetItemTypeOrder.ItemOrder;
int i = itemOrder - (itemOrder % 4);
int j = itemOrder + (4 - (itemOrder % 4));
while (i < j && i < Group.ItemOrder.Count - 1)
{
if (Group.ItemOrder[i].DesignID.Equals("198"))
{
throw new Exception("The row already contains a <NewLineItem>");
}
i++;
}
}
public void DropStandardItemOnNewLineItem()
{
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // Page 15
GroupType gt = wvm.PageList[14].GroupTypeOrders[1].Group; // Second group on page 15
gtvm.Group = gt;
gtvm.GroupTypeOrderCollection = gtoList;
ItemTypeOrder targetItemTypeOrder = gt.ItemOrder[4];
ItemTypeOrder draggedItemTypeOrder = gt.ItemOrder[7];
gtvm.HandleDropAndDropBetweenItems(gt, targetItemTypeOrder, draggedItemTypeOrder);
Assert.AreEqual(5, gt.ItemOrder.IndexOf(targetItemTypeOrder));
Assert.AreEqual(4, gt.ItemOrder.IndexOf(draggedItemTypeOrder));
Assert.AreEqual(8, gt.ItemOrder[5].ItemOrder);
Assert.AreEqual(4, gt.ItemOrder[4].ItemOrder);
}
private List <ItemTypeOrder> GetItemsByRow(int row)
{
List <UIElement> uieList = GroupTable.GetGridCellChildrenByRow(row);
List <ItemTypeOrder> itemTypeListCheck = new List <ItemTypeOrder>();
foreach (UIElement uie in uieList)
{
if (uie is Border)
{
Border bCell = (Border)uie;
ItemTypeOrder it = (ItemTypeOrder)bCell.DataContext;
itemTypeListCheck.Add(it);
}
}
return(itemTypeListCheck);
}
void HandleItemTypeDrop(object sender, DragEventArgs e)
{
Border target = GetBorderByDropEvent(e);
ItemTypeOrder targetItemType = (ItemTypeOrder)target.DataContext;
Border target2 = e.Data.GetData("System.Windows.Controls.Border") as Border;
ItemTypeOrder draggedItemType = (ItemTypeOrder)target2.DataContext;
Grid groupTable = (Grid)target2.Parent;
GroupTypeOrder gto = GetGroupType(groupTable);
GroupType gt = gto.Group;
GTViewModel.HandleDropAndDropBetweenItems(gt, targetItemType, draggedItemType);
gt.ItemOrder.Sort(i => i.ItemOrder);
RefreshGroupTable();
}
/// <summary>
/// Handles drop logic on null field
/// </summary>
/// <param name="dropTargetItemTypeOrder"></param>
/// <param name="tbi"></param>
/// <param name="gt"></param>
public void ToolboxItemDropOnNullField(ItemTypeOrder dropTargetItemTypeOrder, ToolboxItem tbi, GroupType gt)
{
dropTargetItemTypeOrder.DesignID = tbi.ItemType.DesignID;
ItemType itemType = new ItemType();
itemType.DesignID = tbi.ItemType.DesignID;
itemType.Header = tbi.ItemType.Header;
itemType.DanishTranslationText = tbi.ItemType.DanishTranslationText;
itemType.EnglishTranslationText = tbi.ItemType.EnglishTranslationText;
itemType.LanguageID = tbi.ItemType.LanguageID;
dropTargetItemTypeOrder.GroupTypeID = gt.GroupTypeID;
dropTargetItemTypeOrder.IncludedTypeID = "1";
dropTargetItemTypeOrder.Item = itemType;
gt.ItemOrder.Add(dropTargetItemTypeOrder);
GenerateEmptyFields(gt);
}
public ItemTypeOrder CreateEmptyField(GroupType gt, int itemOrder)
{
ItemTypeOrder itemTypeOrder = new ItemTypeOrder();
itemTypeOrder.GroupTypeID = gt.GroupTypeID;
itemTypeOrder.DesignID = "197";
ItemType emptyFieldItemType = new ItemType();
emptyFieldItemType.DesignID = "197";
emptyFieldItemType.Header = "<EmptyField>";
itemTypeOrder.IncludedTypeID = "1";
itemTypeOrder.ItemOrder = itemOrder;
itemTypeOrder.Item = emptyFieldItemType;
_wvm._changedFlag = true;
return(itemTypeOrder);
}
private void AddNewEmptyItemRow()
{
RowDefinition rd = new RowDefinition();
GroupTable.RowDefinitions.Add(rd);
int row = GroupTable.RowDefinitions.Count - 1;
int i = 0;
while (i < GroupTable.ColumnDefinitions.Count)
{
ItemTypeOrder item = new ItemTypeOrder();
item.ItemOrder = ((row - 1) * 4) + i;
Border border = CreateItemCell(item);
Grid.SetRow(border, row);
Grid.SetColumn(border, i);
GroupTable.Children.Add(border);
i++;
}
}
void border_MouseMove(object sender, MouseEventArgs e)
{
if (sender is Border && e.LeftButton == MouseButtonState.Pressed)
{
Border draggedItem = sender as Border;
if (draggedItem.DataContext is ItemTypeOrder) //Prevent dragging if GroupType
{
ItemTypeOrder ito = (ItemTypeOrder)draggedItem.DataContext;
ItemType it = ito.Item;
if (it != null)
{
draggedItem.BorderBrush = new SolidColorBrush(_cellBorderHighlightColor);
adorner = new DragAdornerItem(draggedItem, e.GetPosition(draggedItem));
AdornerLayer.GetAdornerLayer(this).Add(adorner);
if (it.DesignID.Equals("198"))
{
int row = Grid.GetRow(draggedItem);
EnableAllowDropNewLine(0, row);
}
DragDrop.DoDragDrop(draggedItem, draggedItem, DragDropEffects.None | DragDropEffects.Move);
if (AdornerLayer.GetAdornerLayer(this) != null)
{
AdornerLayer.GetAdornerLayer(this).Remove(adorner);
}
draggedItem.BorderBrush = new SolidColorBrush(Color.FromRgb(151, 203, 255));
}
}
if (draggedItem.DataContext is GroupTypeOrder)
{
Grid groupTable = (Grid)draggedItem.Parent;
adorner = new DragAdornerItem(groupTable, e.GetPosition(draggedItem));
AdornerLayer.GetAdornerLayer(this).Add(adorner);
DragDrop.DoDragDrop(draggedItem, groupTable, DragDropEffects.None | DragDropEffects.Move);
if (AdornerLayer.GetAdornerLayer(this) != null)
{
AdornerLayer.GetAdornerLayer(this).Remove(adorner);
}
}
}
}
void CheckItemTypeDrop(object sender, DragEventArgs e)
{
Border borderCell = GetBorderByDropEvent(e);
int row = Grid.GetRow(borderCell);
Border draggedBorderCell = (Border)e.Data.GetData("System.Windows.Controls.Border");
Grid draggedGridCell = (Grid)draggedBorderCell.Child;
TextBlock draggedTextBlock = (TextBlock)draggedGridCell.Children[1];
int draggedItemRow = Grid.GetRow(draggedBorderCell);
Grid draggedGroupTable = (Grid)draggedBorderCell.Parent;
GroupTypeOrder draggedGto = GetGroupType(draggedGroupTable);
GroupTypeOrder gto = GetGroupType(GroupTable);
GroupType draggedGt = draggedGto.Group;
GroupType gt = gto.Group;
ItemTypeOrder ito = (ItemTypeOrder)draggedTextBlock.DataContext;
ItemType it = ito.Item;
if (borderCell.DataContext is ItemTypeOrder)
{
//if (!draggedGt.GroupTypeID.Equals(gt.GroupTypeID))
//{
// e.Effects = DragDropEffects.None;
//}
//else
//{
bool containsRow = CheckForNewLineItem(row);
if (it.DesignID.Equals("198") && containsRow && draggedItemRow != row)
{
e.Effects = DragDropEffects.None;
}
else
{
e.Effects = DragDropEffects.Move;
}
//}
}
if (borderCell.DataContext is GroupTypeOrder)
{
e.Effects = DragDropEffects.None;
}
}
public void Bind(Models.DTO.Order.Get.OrderModel model)
{
CellContentRootView?.SetBackgroundColor(ColorConstants.BackroundCell, 5);
if (!ItemTypeOrder.IsNull())
{
ItemTypeOrder.Text = model.Type == 1 ? @ROrderBar.OrderAtBar : ROrderTable.OrderAtTable;
ItemTypeOrder?.SetTextColor(ColorConstants.WhiteColor);
ItemTypeOrder.SetFont(FontsConstant.OpenSansBold, FontsConstant.Size14);
}
if (!PriceText.IsNull())
{
PriceText.Text = "€" + model.TotalAmount;
PriceText?.SetTextColor(ColorConstants.SelectorHome);
PriceText?.SetFont(FontsConstant.OpenSansBold, FontsConstant.Size14);
}
if (!OrderIdText.IsNull())
{
OrderIdText.Text = "#" + model.Id;
OrderIdText?.SetTextColor(ColorConstants.SelectorHome);
OrderIdText?.SetFont(FontsConstant.OpenSansBold, FontsConstant.Size36);
}
if (DateTimeText.IsNull())
{
return;
}
DateTimeText.Text = model.UpdatedAt.UnixTimeStampToDateTime().ToString("dd.MM.yyyy / hh:mm");
DateTimeText?.SetTextColor(ColorConstants.WhiteColor);
DateTimeText?.SetFont(FontsConstant.OpenSansRegular, FontsConstant.Size14);
if (CellContentRootView.IsNull())
{
return;
}
CellContentRootView.Tag = model;
CellContentRootView.Click -= CellContentRootView_Click;
CellContentRootView.Click += CellContentRootView_Click;
}
/// <summary>
/// Handles drop logic for standard item from toolbox
/// </summary>
/// <param name="dropTargetItemTypeOrder"></param>
/// <param name="tbi"></param>
/// <param name="gt"></param>
public void ToolboxItemDropOnStandardItem(ItemTypeOrder dropTargetItemTypeOrder, ToolboxItem tbi, GroupType gt)
{
ItemTypeOrder itemTypeOrder = new ItemTypeOrder();
itemTypeOrder.DesignID = tbi.ItemType.DesignID;
ItemType itemType = new ItemType {
DesignID = tbi.ItemType.DesignID, Header = tbi.ItemType.Header
};
itemTypeOrder.ItemOrder = dropTargetItemTypeOrder.ItemOrder;
itemType.DanishTranslationText = tbi.ItemType.DanishTranslationText;
itemType.EnglishTranslationText = tbi.ItemType.EnglishTranslationText;
itemType.LanguageID = tbi.ItemType.LanguageID;
itemTypeOrder.GroupTypeID = gt.GroupTypeID;
itemTypeOrder.IncludedTypeID = "1";
itemTypeOrder.Item = itemType;
int startPosition = gt.ItemOrder.IndexOf(dropTargetItemTypeOrder);
MoveItemsForward(startPosition, itemTypeOrder, gt);
}
public void DropOnRowContainingNewLineItem()
{
try
{
List <ToolboxItem> tbsiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbsi = tbsiList.Find(x => x.ItemType.DesignID.Equals("198"));
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // Page 15
GroupType gt = gtoList[1].Group;
gtvm.Group = gt;
ItemTypeOrder dropTargetItemTypeOrder = gt.ItemOrder[4];
gtvm.GroupTypeOrderCollection = gtoList;
gtvm.Group = gt;
gtvm.HandleToolboxItemDrop(gt, tbsi, dropTargetItemTypeOrder);
Assert.Fail("Should throw an exception");
}
catch (Exception e)
{
Assert.AreEqual("The row already contains a <NewLineItem>", e.Message);
}
}
private void btnRemoveItem_Click(object sender, RoutedEventArgs e)
{
Button btn = sender as Button;
btn.Visibility = Visibility.Hidden;
Grid gridCell = (Grid)btn.Parent;
Border border = (Border)gridCell.Parent;
Grid gridGroupTable = (Grid)border.Parent;
GroupTypeOrder gto = (GroupTypeOrder)gridGroupTable.DataContext;
GroupType gt = gto.Group;
ItemTypeOrder itToBeDeleted = (ItemTypeOrder)border.DataContext;
//gt.ItemOrder.Remove(itToBeDeleted);
GTViewModel.RemoveItemTypeOrder(gt, itToBeDeleted);
GTViewModel.AdjustItemOrder(gt);
RefreshGroupTable();
DisableAllowDropByNewLineItem();
PreviousGroupTypeOrder = null;
}
/// <summary>
/// Handles drop logic for items from toolbox. Drop logic depends on the type of the dropped item
/// </summary>
/// <param name="gt"></param>
/// <param name="tbi"></param>
/// <param name="dropTargetItemTypeOrder"></param>
public void HandleToolboxItemDrop(GroupType gt, ToolboxItem tbi, ItemTypeOrder dropTargetItemTypeOrder)
{
string dropTargetDesignID = dropTargetItemTypeOrder.DesignID;
if (tbi.ItemType.DesignID.Equals("198") && dropTargetDesignID != null)
{
ToolboxSpecialNewLineItemDrop(dropTargetItemTypeOrder, tbi, gt);
}
if (dropTargetDesignID != null && !tbi.ItemType.DesignID.Equals("198") && !dropTargetDesignID.Equals("197"))
{
ToolboxItemDropOnStandardItem(dropTargetItemTypeOrder, tbi, gt);
}
if (dropTargetDesignID == null) //drop on null field
{
ToolboxItemDropOnNullField(dropTargetItemTypeOrder, tbi, gt);
}
if (dropTargetDesignID != null && dropTargetDesignID.Equals("197") && !tbi.ItemType.DesignID.Equals("198"))
{
ToolboxItemDropOnEmptyField(dropTargetItemTypeOrder, tbi, gt);
}
}
public void DropStandardItemOnNullField()
{
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // Page 15
GroupType gt = wvm.PageList[14].GroupTypeOrders[0].Group;
gtvm.Group = gt;
gtvm.GroupTypeOrderCollection = gtoList;
ItemTypeOrder draggedItemTypeOrder = gt.ItemOrder[3];
ItemTypeOrder targetItemTypeOrder = new ItemTypeOrder()
{
DesignID = null,
GroupTypeID = null,
IncludedTypeID = null,
Item = null,
ItemOrder = 7
};
gtvm.HandleDropAndDropBetweenItems(gt, targetItemTypeOrder, draggedItemTypeOrder);
Assert.AreEqual(7, gt.ItemOrder.IndexOf(draggedItemTypeOrder));
Assert.AreEqual(7, gt.ItemOrder[7].ItemOrder);
}
public void DropToolboxSpecialEmptyFieldItemOnItem()
{
ifvm.PopulateToolbox();
GroupType gt = wvm.PageList[14].GroupTypeOrders[1].Group;
gtvm.Group = gt;
List <ToolboxItem> tbiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbi = tbiList.Find(x => x.ItemType.DesignID.Equals("197")); //ItemType-Name: EmptyField
int l = 0;
while (l < gt.ItemOrder.Count)
{
GroupType deepCopyGroupType = DeepCopyGroupType(gt);
ObservableCollection <ItemTypeOrder> modifiedItemTypeOrderList = deepCopyGroupType.ItemOrder;
gtvm.Group = deepCopyGroupType;
gtvm.AdjustItemOrder(gtvm.Group);
ItemTypeOrder dropTargetItemTypeOrder = deepCopyGroupType.ItemOrder[l];
List <ItemTypeOrder> unmodifiedItemTypeList = gt.ItemOrder.ToList();
int i = deepCopyGroupType.ItemOrder.IndexOf(dropTargetItemTypeOrder);
gtvm.HandleToolboxItemDrop(deepCopyGroupType, tbi, dropTargetItemTypeOrder);
int skipped = 0;
while (i < unmodifiedItemTypeList.Count - skipped)
{
Assert.AreEqual(modifiedItemTypeOrderList[i + 1].ItemOrder,
unmodifiedItemTypeList[i].ItemOrder + 1); //For each itemtype, check if ItemOrder is incremented by 1
if (!unmodifiedItemTypeList[i].DesignID.Equals("198"))
{
Assert.AreEqual(modifiedItemTypeOrderList[i + 1].Item, unmodifiedItemTypeList[i + skipped].Item);
}
else
{
skipped++;
Assert.AreEqual(modifiedItemTypeOrderList[i + 1].Item, unmodifiedItemTypeList[i + skipped].Item);
}
i++;
}
Assert.AreEqual(modifiedItemTypeOrderList[l].Item.DesignID, tbi.ItemType.DesignID); //Check if dropped ItemType is inserted at the right location
l++;
}
}
public void DropToolboxItemOnEmptyField()
{
ifvm.PopulateToolbox();
GroupType gt = wvm.PageList[14].GroupTypeOrders[0].Group; // Page 15
gtvm.Group = gt;
List <ToolboxItem> tbiList = ifvm.DesignItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbi = tbiList.Find(x => x.ItemType.DesignID.Equals("38")); //ItemType-Name: Temperatur
List <ToolboxItem> tbsiList = sfvm.SpecialItemsView.Cast <ToolboxItem>().ToList();
ToolboxItem tbsi = tbsiList.Find(x => x.ItemType.DesignID.Equals("197"));
ItemTypeOrder dropTargetItemTypeOrder = new ItemTypeOrder()
{
DesignID = null,
GroupTypeID = null,
IncludedTypeID = null,
Item = null,
ItemOrder = gt.ItemOrder.Count()
};
gtvm.HandleToolboxItemDrop(gt, tbi, dropTargetItemTypeOrder);
Assert.AreEqual(gt.ItemOrder[gt.ItemOrder.Count() - 1].Item.DesignID, tbi.ItemType.DesignID);
}
void border_MouseEnter(object sender, MouseEventArgs e)
{
Border bCell = sender as Border;
Grid cellItem = (Grid)bCell.Child;
if (bCell.DataContext is ItemTypeOrder)
{
ItemTypeOrder ito = (ItemTypeOrder)bCell.DataContext;
ItemType it = ito.Item;
if (it != null)
{
Button btnClearCell = (Button)cellItem.Children[0];
btnClearCell.Visibility = Visibility.Visible;
}
}
if (bCell.DataContext is GroupTypeOrder)
{
StackPanel spBtn = (StackPanel)cellItem.Children[0];
Button btnEditGroup = (Button)spBtn.Children[0];
Button btnRemoveGroup = (Button)spBtn.Children[1];
btnEditGroup.Visibility = Visibility.Visible;
btnRemoveGroup.Visibility = Visibility.Visible;
}
}
/// <summary>
/// Removes an ItemTypeOrder from a group
/// </summary>
/// <param name="gt"></param>
/// <param name="ito">The ItemTypeOrder to be removed</param>
public void RemoveItemTypeOrder(GroupType gt, ItemTypeOrder ito)
{
gt.ItemOrder.Remove(ito);
AdjustItemOrder(gt);
}
