public void Should_RemoveDraggableItem()
{
var service = new DragDropService(null);
dynamic isDelegateCalled = new { };
service.RegisterDropzone(1, new DropzoneOptions()
{
});
var draggable = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d, i) => isDelegateCalled = d
};
service.RegisterDraggableForDropzone(draggable);
Assert.IsTrue(service.HasDropzoneDraggables(1));
service.RemoveDraggableItem(draggable);
Assert.IsFalse(service.HasDropzoneDraggables(1));
}
public void Should_ClearActiveItemUponDropInSameDropzone()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
});
service.RegisterDropzone(2, new DropzoneOptions()
{
});
var draggable1 = new DraggableItem(service)
{
Id = 1,
DropzoneId = 2,
};
var draggable2 = new DraggableItem(service)
{
Id = 2,
DropzoneId = 2,
};
service.ActiveItem = draggable1;
service.DropActiveItem(2);
Assert.IsTrue(service.ActiveItem == null);
}
public void Should_AllowSwappingInSameDropzone_And_MaxItems()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
MaxItems = 2
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
var draggable2 = new DraggableItem(service)
{
Id = 2, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable1);
service.RegisterDraggableForDropzone(draggable2);
Assert.AreEqual(0, draggable1.OrderPosition);
Assert.AreEqual(1, draggable2.OrderPosition);
service.ActiveItem = draggable1;
service.SwapOrInsert(2);
Assert.AreEqual(0, draggable2.OrderPosition);
Assert.AreEqual(1, draggable1.OrderPosition);
}
public void Should_DropActiveItemAndCallOnDrop_SameDropzones()
{
var service = new DragDropService(null);
dynamic isDelegateCalled = new { };
service.RegisterDropzone(1, new DropzoneOptions()
{
});
var draggable = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d, i) => isDelegateCalled = d
};
service.RegisterDraggableForDropzone(draggable);
service.ActiveItem = draggable;
service.DropActiveItem(1);
Assert.AreEqual("OnDropTagTest", isDelegateCalled.Test);
}
public void Should_Limit_Dropzone_To_MaxItems()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
});
service.RegisterDropzone(2, new DropzoneOptions()
{
MaxItems = 1
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
var draggable2 = new DraggableItem(service)
{
Id = 2, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable1);
service.RegisterDraggableForDropzone(draggable2);
service.ActiveItem = draggable1;
service.DropActiveItem(2);
service.ActiveItem = draggable2;
service.DropActiveItem(2);
var result = service.GetDraggablesForDropzone(2).Single();
Assert.AreEqual(draggable1.Id, result.Id);
}
bool DraggableItem.IDragDropListener.OnPrepareToDragItem(DraggableItem item)
{
var dragged = GetItemViewsHolderIfVisible(item.RT);
if (dragged == null)
{
return(false);
}
int index = dragged.ItemIndex;
var modelOfDragged = Data[index];
Debug.Log("Dragging with id " + modelOfDragged.id + ", ItemIndex " + index);
// Modifying the list manually, because RemoveItemWithViewsHolder will do a Remove itself
Data.List.RemoveAt(index);
RemoveItemWithViewsHolder(dragged, true, false);
UpdateScaleOfVisibleItems(dragged);
// Insert back an empty slot in its place, with the same size
var emptyModel = new EmptyModel();
_DragManager.EnterState_PreparingForDrag(dragged, modelOfDragged, emptyModel);
InsertPlaceholderAtNewIndex(index);
return(true);
}
public void Should_Execute_AcceptFuncOfDropzone_AcceptTest()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
});
service.RegisterDropzone(2, new DropzoneOptions()
{
Accepts = (d) => d.Name == "Testme"
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1, Tag = new { Name = "Testme" }
};
service.RegisterDraggableForDropzone(draggable1);
service.ActiveItem = draggable1;
service.DropActiveItem(2);
var result = service.GetDraggablesForDropzone(2);
Assert.AreEqual(1, result.Count);
}
/**
* Return the item in this slot as the
* draggable item.
*
**/
public override DraggableItem Drag()
{
DraggableItem tmp = item.GetComponent <DraggableItem>();
items[position] = null;
return(tmp);
}
public void Should_GetDropzoneByName()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
Name = "Dropzone1"
});
service.RegisterDropzone(2, new DropzoneOptions()
{
Name = "Dropzone2"
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable1);
service.ActiveItem = draggable1;
service.DropActiveItem(2);
var result = service.GetDraggablesForDropzone("Dropzone2");
Assert.AreEqual(1, result.Count);
Assert.AreEqual(result[0].Id, 1);
}
public void Should_ReturnFalse_HasDropzoneDraggables()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
Name = "Dropzone1"
});
service.RegisterDropzone(2, new DropzoneOptions()
{
Name = "Dropzone2"
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable1);
service.ActiveItem = draggable1;
service.DropActiveItem(2);
var result = service.HasDropzoneDraggables("Dropzone1");
Assert.AreEqual(false, result);
}
public void Should_ReturnFalse_HasDropzoneDraggables_GivenInvalidName()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
Name = "Dropzone1"
});
service.RegisterDropzone(2, new DropzoneOptions()
{
Name = "Dropzone2"
});
var draggable1 = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable1);
service.ActiveItem = draggable1;
service.DropActiveItem(2);
Assert.ThrowsException <ArgumentException>(() => service.HasDropzoneDraggables("Dropzone3"));
}
public void Should_DropActiveItem()
{
var service = new DragDropService(null);
service.RegisterDropzone(1, new DropzoneOptions()
{
});
service.RegisterDropzone(2, new DropzoneOptions()
{
});
var draggable = new DraggableItem(service)
{
Id = 1, DropzoneId = 1
};
service.RegisterDraggableForDropzone(draggable);
service.ActiveItem = draggable;
service.DropActiveItem(2);
var result = service.GetDraggablesForDropzone(2).Single();
Assert.AreEqual(draggable.Id, result.Id);
}
public void Should_DropActiveItemAndCallOnDrop()
{
var service = new DragDropService(null);
dynamic isDelegateCalled = new { };
service.RegisterDropzone(1, new DropzoneOptions()
{
});
service.RegisterDropzone(2, new DropzoneOptions()
{
});
var draggable = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d) => isDelegateCalled = d
};
service.RegisterDraggableForDropzone(draggable);
service.ActiveItem = draggable;
service.DropActiveItem(2);
var result = service.GetDraggablesForDropzone(2).Single();
Assert.AreEqual(draggable.Id, result.Id);
Assert.AreEqual("OnDropTagTest", isDelegateCalled.Test);
}
/**
* Draw the specific inventory item
**/
public static void Render(Rect position, GUIContent guiContent, GUIStyle guiStyle, DraggableHandler handler)
{
GUI.Box(position, guiContent, guiStyle);
// if the position of the current mouse event is within the rendering window
if (position.Contains(UnityEngine.Event.current.mousePosition))
{
// trigger either Hover event
if (draggedItem.item == null)
{
handler.Hover();
}
else
{
handler.Hover(draggedItem.item);
}
// holding the item that will be dragged
// (if any)
DraggableItem item = null;
// if a drag is initiated, notify the handler
if (UnityEngine.Event.current.type == EventType.MouseDrag && draggedItem.item == null)
{
item = handler.Drag();
UnityEngine.Event.current.Use();
}
// if a mouse up event happens, notify the handler
// whether or not there is an item being dragged
if (UnityEngine.Event.current.type == EventType.MouseUp)
{
if (draggedItem.item == null)
{
item = handler.Click();
}
else
{
// remove the dragged item if the handler returns true
item = handler.ItemDropped(draggedItem.item);
if (item != null)
{
item.Pickup();
draggedItem.item = item;
}
else
{
draggedItem.item = null;
}
}
UnityEngine.Event.current.Use();
}
if (item != null)
{
item.Pickup();
draggedItem.item = item;
}
}
}
private void PhaseChangedSlot(object[] parameters)
{
DraggableItem item = (DraggableItem)parameters[0];
EventMapping mapping = (EventMapping)item.Data;
//Debug.Log(string.Format("PhaseChangedSlot: {0}", mapping));
EventMappingDescriptor.ProcessPhases(Adapter, null, mapping, mapping.Enabled);
}
void PutItemIntoSlot(DraggableItem item)
{
if (item != null)
{
//Debug.Log($"{item.name} dropped on {name}");
//logic is inside Item class (in order to simplify loading)
item.AttachToItemSlot(this);
}
}
public override void CollectViews()
{
base.CollectViews();
draggableComponent = root.GetComponent <DraggableItem>();
root.GetComponentAtPath("ScalableViews", out scalableViews);
scalableViews.GetComponentAtPath("TitlePanel/TitleText", out titleText);
scalableViews.GetComponentAtPath("Background", out background);
}
/**
* On MouseUp, we check to see if there's currently an item
* being dragged. If there is, we drop it into this slot.
*
**/
public override bool ItemDropped(DraggableItem item)
{
if (item.GetComponent <InventoryItem>() != null)
{
inventory[inventoryPosition.x, inventoryPosition.y] = item.gameObject;
return(true);
}
return(false);
}
/// <summary>
/// Place item in itemDropTarget (reparent, reposition)
/// </summary>
/// <param name="item"></param>
public void PlaceItem(DraggableItem item)
{
var newItemPosition = this.transform.position;
newItemPosition.x += placementOffsetX;
newItemPosition.y += placementOffsetY;
item.transform.position = newItemPosition;
onItemPlaced.Invoke();
}
public void OnDrop(PointerEventData eventData)
{
DraggableItem item = eventData.pointerDrag.GetComponent <DraggableItem>();
if (item != null)
{
item.original_slot = this.transform;
}
}
/**
* When an item is dropped on the slot, verify that it's
* an ActionItem and place it in items[]
**/
public override bool ItemDropped(DraggableItem item)
{
ActionItem actionItem = item.GetComponent <ActionItem>();
if (actionItem != null)
{
items[position] = actionItem;
return(true);
}
return(false);
}
public static void UpdateInventory()
{
bool reload = false;
foreach (GameObject invItem in Globals._Inventory.GetComponent <Inventory>().items)
{
bool found = false;
DraggableItem di = invItem.GetComponent <DraggableItem>();
Data.Items.Item item = di.item_dat;
foreach (Data.Characters.Inventory.Inventory.ItemData dat in Globals.InventoryItemsNew)
{
if (dat.Item.Name == item.Name)
{
found = true;
}
}
if (!found)
{
reload = true;
}
}
foreach (Data.Characters.Inventory.Inventory.ItemData dat in Globals.InventoryItemsNew)
{
bool found1 = false;
foreach (GameObject invItem in Globals._Inventory.GetComponent <Inventory>().items)
{
if (dat.Item.Name == invItem.GetComponent <DraggableItem>().item_dat.Name)
{
found1 = true;
}
}
if (!found1)
{
reload = true;
}
}
if (reload)
{
Globals._Inventory.GetComponent <Inventory>().items.Clear();
foreach (Data.Characters.Inventory.Inventory.ItemData dat in Globals.InventoryItemsNew)
{
GameObject newItem = GameObject.Instantiate(GameObject.Find("DragMe"));
newItem.AddComponent <DraggableItem>();
newItem.GetComponent <DraggableItem>().item_name = dat.Item.Name;
newItem.GetComponent <DraggableItem>().item_dat = dat.Item;
Globals._Inventory.GetComponent <Inventory>().addItem(newItem);
}
Globals.InventoryItems = Globals.InventoryItemsNew;
}
}
/**
* If an item is dropped on this slot, check if it is an EquipmentItem
* AND it is the proper EquipmentType
* if so, equip it and return the previously equipped item (to be dragged)
*
* Otherwise, return null
*
**/
public override DraggableItem ItemDropped(DraggableItem item)
{
EquipmentItem equipmentItem = item.GetComponent <EquipmentItem>();
if (equipmentItem != null && equipmentItem.equipmentType == equipmentType)
{
EquipmentItem tmpEquipmentItem = equipment.Unequip(equipmentType);
equipment.Equip(equipmentType, item.GetComponent <EquipmentItem>());
return(tmpEquipmentItem);
}
return(item);
}
public void OnPointerExit(PointerEventData eventData)
{
if (eventData.pointerDrag == null)
{
return;
}
DraggableItem item = eventData.pointerDrag.GetComponent <DraggableItem>();
if (item != null && item.placeholder_parent == this.transform)
{
item.placeholder_parent = item.original_slot;
}
}
/**
* When an item is dropped on this slot, we'll check to
* see if that item is an EquipmentItem and if it matches
* this slot's type.
*
* Currently does not swap out equipment of different types.
*
**/
public override bool ItemDropped(DraggableItem item)
{
EquipmentItem equipmentItem = item.GetComponent <EquipmentItem>();
if (equipmentItem != null && equipmentItem.equipmentType == equipmentType)
{
if (equipment.IsSlotFree(equipmentType))
{
equipment.Equip(equipmentType, equipmentItem);
return(true);
}
}
return(false);
}
void SpawnObj()
{
GameObject instance = Instantiate(Resources.Load("ListItem", typeof(GameObject))) as GameObject;
instance.transform.SetParent(transform, false);
instance.transform.SetAsFirstSibling();
DraggableItem draggableItemComponent = instance.GetComponent <DraggableItem>();
if (draggableItemComponent != null)
{
draggableItemComponent.m_onEndDragItem += onListItemDragEnded;
draggableItemComponent.SetImage(m_itemSprites[Random.Range(0, m_itemSprites.Length)]);
}
}
public void OnPointerEnter(PointerEventData eventData)
{
if (eventData.pointerDrag == null)
{
return;
}
DraggableItem item = eventData.pointerDrag.GetComponent <DraggableItem>();
if (item != null)
{
item.placeholder_parent = this.transform;
}
}
public void Should_CheckAllowDrag_False()
{
var service = new DragDropService(null);
var draggable1 = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = false },
AllowDrag = (d) => d.Tag.Test
};
var isDragable = service.IsDraggable(draggable1);
Assert.AreEqual(false, isDragable);
}
public void Should_RemoveAllItemFromDropzone()
{
var service = new DragDropService(null);
DraggableItem isDelegateCalled = null;
service.RegisterDropzone(1, new DropzoneOptions()
{
Name = "Testzone"
});
var draggable = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d) => isDelegateCalled = d
};
var draggable1 = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d) => isDelegateCalled = d
};
var draggable2 = new DraggableItem(service)
{
Id = 1,
DropzoneId = 1,
Tag = new { Test = "OnDropTagTest" },
OnDrop = (d) => isDelegateCalled = d
};
service.RegisterDraggableForDropzone(draggable);
service.RegisterDraggableForDropzone(draggable1);
service.RegisterDraggableForDropzone(draggable2);
Assert.IsTrue(service.HasDropzoneDraggables(1));
service.ClearDropzone("Testzone");
Assert.IsFalse(service.HasDropzoneDraggables(1));
}
bool TryGrabOrphanedItemVH(PointerEventData eventData, DraggableItem orphanedItemWithBundle)
{
bool isPointInViewport;
var closestVH = GetClosestVHAtScreenPoint(eventData, out isPointInViewport);
if (!isPointInViewport)
{
return(false);
}
orphanedItemWithBundle.dragDropListener = this;
int atIndex = 0;
if (closestVH == null) // no items present, but the point is in viewport => add it to the list
{
atIndex = 0;
}
else
{
atIndex = closestVH.ItemIndex;
}
var vh = orphanedItemWithBundle.OrphanedBundle.views as MyViewsHolder;
var model = orphanedItemWithBundle.OrphanedBundle.model as MyModel;
Debug.Log("Dropped with id " + model.id + ", ItemIndex " + vh.ItemIndex + ", droppedAtItemIndex " + atIndex);
// Modifying the list manually, because InsertItemWithViewsHolder will do an Insert itself
Data.List.Insert(atIndex, model);
float itemSizeToUse = vh.root.rect.height; // for vertical ScrollViews, "size" = height
InsertItemWithViewsHolder(vh, atIndex, false);
// The adapter will use _Params.DefaultItemSize to set the item's size, but we want it to keep the same size.
// The alternative way of doing it (a bit faster, but negligeable) is to store <itemSizeToUse> somewhere and
// pass it in CollectItemsSizes for <atIndex>. CollectItemsSizes() is always called during count changes, including during InsertItemWithViewsHolder()
RequestChangeItemSizeAndUpdateLayout(atIndex, itemSizeToUse, false, true);
//// Restore the scale of all items;
//UpdateScaleOfVisibleItems(null);
return(true);
}
