private static ILegendItem GetInsertTarget(ILegendItem startItem, ILegendItem dropItem)
{
if (startItem == null)
{
return(null);
}
if (dropItem == null)
{
return(null);
}
if (startItem.CanReceiveItem(dropItem))
{
return(startItem);
}
ILegendItem item = startItem;
while (item.GetParentItem() != null)
{
if (item.GetParentItem().CanReceiveItem(dropItem))
{
return(item);
}
item = item.GetParentItem();
}
return(null);
}
private void DoItemMouseDown(ItemMouseEventArgs e)
{
Point loc = new Point(e.X + ControlRectangle.X, e.Location.Y + ControlRectangle.Top);
// Toggle expansion
if (e.ItemBox.ExpandBox.Contains(loc))
{
e.ItemBox.Item.IsExpanded = !e.ItemBox.Item.IsExpanded;
if (ExpandBoxMouseDown != null)
{
ExpandBoxMouseDown(this, e);
}
ResetLegend();
return;
}
if (e.ItemBox.Item.IsSelected)
{
// if we are already selected, prepare to edit in textbox
_previousMouseDown = e.ItemBox;
// Start dragging
if (e.Button == MouseButtons.Left)
{
_isDragging = true;
ILegendItem li = e.ItemBox.Item;
while (li != null && li as ILayer == null)
{
li = li.GetParentItem();
}
ILayer lyr = li as ILayer;
if (lyr != null)
{
_dragItem = BoxFromItem(lyr);
}
else
{
_isDragging = false;
}
}
}
else
{
// Check for textbox clicking
if (e.ItemBox.Textbox.Contains(loc))
{
if (ModifierKeys != Keys.Shift)
{
ClearSelection();
}
e.ItemBox.Item.IsSelected = true;
//_selection.Add(e.ItemBox);
//IsInitialized = false;
//Invalidate();
//return;
}
}
}
/// <summary>
/// Tests the specified legend item. If the item is another layer or a group or a map-frame, then this
/// will return false. Furthermore, if the parent of the item is not also this object, then it will
/// also return false. The idea is that layers can have sub-nodes move around, but not transport from
/// place to place.
/// </summary>
/// <param name="item">the legend item to test</param>
/// <returns>Boolean that if true means that it is ok to insert the specified item into this layer.</returns>
public override bool CanReceiveItem(ILegendItem item)
{
if (item.GetParentItem() != this)
{
return(false);
}
ILayer lyr = item as ILayer;
if (lyr != null)
{
return(false);
}
IFrame mf = item as IFrame;
if (mf != null)
{
return(false);
}
IGroup gr = item as IGroup;
if (gr != null)
{
return(false);
}
return(true);
}
/// <summary>
/// This method starts with this legend item and tests to see if it can contain
/// the specified target. As it moves up the
/// </summary>
/// <param name="startItem">This legend item</param>
/// <param name="dropItem">The target legend item to test</param>
/// <returns>An ILegendItem that is one of the parent items of this item, but that can receive the target.</returns>
public static ILegendItem GetValidContainerFor(this ILegendItem startItem, ILegendItem dropItem)
{
if (startItem == null)
{
return(null);
}
if (dropItem == null)
{
return(null);
}
if (startItem.CanReceiveItem(dropItem))
{
return(startItem);
}
ILegendItem item = startItem;
while ((item = item.GetParentItem()) != null)
{
if (item.CanReceiveItem(dropItem))
{
return(item);
}
}
return(null);
}
/// <summary>
/// Gets the index at which the positionBase is situated in the parent. This can be used to determine the index the item that gets moved should be inserted.
/// </summary>
/// <param name="parent">The legend item the moving item should be added to.</param>
/// <param name="positionBase">The item that is used to determine the new position of the moving item.</param>
/// <returns>The new position of the moving item.</returns>
public static int InsertIndex(this ILegendItem parent, ILegendItem positionBase)
{
if (parent == null || positionBase == null)
{
return(-1);
}
ILegendItem item = positionBase;
if (item == parent)
{
return(item.LegendItems.Count());
}
while (item != null)
{
var p = item.GetParentItem();
if (p == parent)
{
var items = p.LegendItems.ToList();
return(items.IndexOf(item));
}
item = p;
}
return(-1);
}
/// <summary>
/// Tests the specified legend item. If the item is another layer or a group or a map-frame, then this
/// will return false. Furthermore, if the parent of the item is not also this object, then it will
/// also return false. The idea is that layers can have sub-nodes move around, but not transport from
/// place to place.
/// </summary>
/// <param name="item">the legend item to test.</param>
/// <returns>Boolean that if true means that it is ok to insert the specified item into this layer.</returns>
public override bool CanReceiveItem(ILegendItem item)
{
if (item.GetParentItem() != this)
{
return(false);
}
return(item is not ILayer lyr);
}
/// <summary>
/// Tests the specified legend item. If the item is another layer or a group or a map-frame, then this
/// will return false. Furthermore, if the parent of the item is not also this object, then it will
/// also return false. The idea is that layers can have sub-nodes move around, but not transport from
/// place to place.
/// </summary>
/// <param name="item">the legend item to test</param>
/// <returns>Boolean that if true means that it is ok to insert the specified item into this layer.</returns>
public override bool CanReceiveItem(ILegendItem item)
{
if (item.GetParentItem() != this)
{
return(false);
}
var lyr = item as ILayer;
return(lyr == null);
}
/// <summary>
/// This method starts with this legend item and searches through the
/// parent groups until it finds a valid mapframe.
/// </summary>
/// <param name="self">The ILegendItem to start from</param>
/// <returns>The IMapFrame that contains this item.</returns>
public static IFrame ParentMapFrame(this ILegendItem self)
{
ILegendItem current = self;
IFrame frame = current as IFrame;
while (current != null)
{
if (frame != null)
{
return(frame);
}
current = current.GetParentItem();
frame = current as IFrame;
}
return(null);
}
/// <summary>
/// Tests the specified legend item. If the item is another layer or a group or a map-frame, then this
/// will return false. Furthermore, if the parent of the item is not also this object, then it will
/// also return false. The idea is that layers can have sub-nodes move around, but not transport from
/// place to place.
/// </summary>
/// <param name="item">the legend item to test</param>
/// <returns>Boolean that if true means that it is ok to insert the specified item into this layer.</returns>
public override bool CanReceiveItem(ILegendItem item)
{
if (item.GetParentItem() != this) return false;
ILayer lyr = item as ILayer;
if (lyr != null) return false;
IFrame mf = item as IFrame;
if (mf != null) return false;
IGroup gr = item as IGroup;
if (gr != null) return false;
return true;
}
/// <summary>
/// Tests the specified legend item. If the item is another layer or a group or a map-frame, then this
/// will return false. Furthermore, if the parent of the item is not also this object, then it will
/// also return false. The idea is that layers can have sub-nodes move around, but not transport from
/// place to place.
/// </summary>
/// <param name="item">the legend item to test</param>
/// <returns>Boolean that if true means that it is ok to insert the specified item into this layer.</returns>
public override bool CanReceiveItem(ILegendItem item)
{
if (item.GetParentItem() != this) return false;
var lyr = item as ILayer;
if (lyr != null) return false;
return true;
}
