private TreeNodeHeader *CreateNode(int index, Slice key, TreeNodeFlags flags, int len)
{
Debug.Assert(index <= NumberOfEntries && index >= 0);
Debug.Assert(IsBranch == false || index != 0 || key.Size == 0);// branch page's first item must be the implicit ref
if (HasSpaceFor(key, len) == false)
{
throw new InvalidOperationException(string.Format("The page is full and cannot add an entry, this is probably a bug. Key: {0}, data length: {1}, size left: {2}", key, len, SizeLeft));
}
// move higher pointers up one slot
ushort *offsets = KeysOffsets;
for (int i = NumberOfEntries; i > index; i--)
{
offsets[i] = offsets[i - 1];
}
var nodeSize = TreeSizeOf.NodeEntry(PageMaxSpace, key, len);
var node = AllocateNewNode(index, nodeSize);
node->Flags = flags;
Debug.Assert(key.Size <= ushort.MaxValue);
node->KeySize = (ushort)key.Size;
if (key.Options == SliceOptions.Key && node->KeySize > 0)
{
key.CopyTo((byte *)node + Constants.Tree.NodeHeaderSize);
}
return(node);
}
public static unsafe bool CollapsingHeader(string label, TreeNodeFlags flags)
{
fixed(byte *bytes = System.Text.Encoding.UTF8.GetBytes(label))
{
return(ImGuiNative.igCollapsingHeader(bytes, flags));
}
}
public TreePageSplitter(LowLevelTransaction tx,
Tree tree,
Slice newKey,
int len,
long pageNumber,
TreeNodeFlags nodeType,
TreeCursor cursor,
bool splittingOnDecompressed = false)
{
_tx = tx;
_tree = tree;
_newKey = newKey;
_len = len;
_pageNumber = pageNumber;
_nodeType = nodeType;
_cursor = cursor;
_splittingOnDecompressed = splittingOnDecompressed;
TreePage page = _cursor.Pages.Peek();
if (_splittingOnDecompressed == false)
{
_page = _tree.ModifyPage(page);
}
else
{
Debug.Assert(page is DecompressedLeafPage);
_page = page;
}
_cursor.Pop();
}
private bool TryOverwriteDataOrMultiValuePageRefNode(TreeNodeHeader *updatedNode, int len,
TreeNodeFlags requestedNodeType, out byte *pos)
{
switch (requestedNodeType)
{
case TreeNodeFlags.Data:
case TreeNodeFlags.MultiValuePageRef:
{
if (updatedNode->DataSize == len &&
(updatedNode->Flags == TreeNodeFlags.Data || updatedNode->Flags == TreeNodeFlags.MultiValuePageRef))
{
updatedNode->Flags = requestedNodeType;
pos = (byte *)updatedNode + Constants.Tree.NodeHeaderSize + updatedNode->KeySize;
return(true);
}
break;
}
case TreeNodeFlags.PageRef:
throw new InvalidOperationException("We never add PageRef explicitly");
default:
throw new ArgumentOutOfRangeException();
}
pos = null;
return(false);
}
public unsafe byte *DirectAdd(string key, int len, TreeNodeFlags nodeType = TreeNodeFlags.Data)
{
Slice keySlice;
using (Slice.From(_llt.Allocator, key, ByteStringType.Immutable, out keySlice))
{
return(DirectAdd(keySlice, len, nodeType));
}
}
public DirectAddScope DirectAdd(string key, int len, TreeNodeFlags nodeType, out byte *ptr)
{
Slice keySlice;
using (Slice.From(_llt.Allocator, key, ByteStringType.Immutable, out keySlice))
{
return(DirectAdd(keySlice, len, nodeType, out ptr));
}
}
public void WriteBTreePageCreated(PagePosition pos, TreeNodeFlags flags, byte depth)
{
if (LogEnable)
{
Logger.Add((byte)LogFlags.BPAGE_CREATED);
Logger.AddRange(BitConverter.GetBytes(pos.FileId));
Logger.AddRange(BitConverter.GetBytes(pos.PageNumber));
Logger.Add((byte)flags);
Logger.Add(depth);
Modified = true;
Modifies.Add(pos);
}
}
public TreePageSplitter(LowLevelTransaction tx,
Tree tree,
Slice newKey,
int len,
long pageNumber,
TreeNodeFlags nodeType,
TreeCursor cursor)
{
_tx = tx;
_tree = tree;
_newKey = newKey;
_len = len;
_pageNumber = pageNumber;
_nodeType = nodeType;
_cursor = cursor;
TreePage page = _cursor.Pages.Peek();
_page = _tree.ModifyPage(page);
_cursor.Pop();
}
private bool TryOverwriteDataOrMultiValuePageRefNode(TreeNodeHeader *updatedNode, Slice key, int len,
TreeNodeFlags requestedNodeType, ushort?version, out byte *pos)
{
switch (requestedNodeType)
{
case TreeNodeFlags.Data:
case TreeNodeFlags.MultiValuePageRef:
{
if (updatedNode->DataSize == len &&
(updatedNode->Flags == TreeNodeFlags.Data || updatedNode->Flags == TreeNodeFlags.MultiValuePageRef))
{
CheckConcurrency(key, version, updatedNode->Version, TreeActionType.Add);
if (updatedNode->Version == ushort.MaxValue)
{
updatedNode->Version = 0;
}
updatedNode->Version++;
updatedNode->Flags = requestedNodeType;
{
pos = (byte *)updatedNode + Constants.NodeHeaderSize + updatedNode->KeySize;
return(true);
}
}
break;
}
case TreeNodeFlags.PageRef:
throw new InvalidOperationException("We never add PageRef explicitly");
default:
throw new ArgumentOutOfRangeException();
}
pos = null;
return(false);
}
public byte *DirectAdd(Slice key, int len, TreeNodeFlags nodeType = TreeNodeFlags.Data, ushort?version = null)
{
Debug.Assert(nodeType == TreeNodeFlags.Data || nodeType == TreeNodeFlags.MultiValuePageRef);
if (State.InWriteTransaction)
{
State.IsModified = true;
}
if (_llt.Flags == (TransactionFlags.ReadWrite) == false)
{
throw new ArgumentException("Cannot add a value in a read only transaction");
}
if (AbstractPager.IsKeySizeValid(key.Size) == false)
{
throw new ArgumentException($"Key size is too big, must be at most {AbstractPager.MaxKeySize} bytes, but was {(key.Size + AbstractPager.RequiredSpaceForNewNode)}", nameof(key));
}
Func <TreeCursor> cursorConstructor;
TreeNodeHeader * node;
var foundPage = FindPageFor(key, out node, out cursorConstructor);
var page = ModifyPage(foundPage);
ushort nodeVersion = 0;
bool? shouldGoToOverflowPage = null;
if (page.LastMatch == 0) // this is an update operation
{
node = page.GetNode(page.LastSearchPosition);
Debug.Assert(SliceComparer.EqualsInline(TreeNodeHeader.ToSlicePtr(_llt.Allocator, node), key));
shouldGoToOverflowPage = ShouldGoToOverflowPage(len);
byte *pos;
if (shouldGoToOverflowPage == false)
{
// optimization for Data and MultiValuePageRef - try to overwrite existing node space
if (TryOverwriteDataOrMultiValuePageRefNode(node, key, len, nodeType, version, out pos))
{
return(pos);
}
}
else
{
// optimization for PageRef - try to overwrite existing overflows
if (TryOverwriteOverflowPages(node, key, len, version, out pos))
{
return(pos);
}
}
RemoveLeafNode(page, out nodeVersion);
}
else // new item should be recorded
{
State.NumberOfEntries++;
}
CheckConcurrency(key, version, nodeVersion, TreeActionType.Add);
var lastSearchPosition = page.LastSearchPosition; // searching for overflow pages might change this
byte *overFlowPos = null;
var pageNumber = -1L;
if (shouldGoToOverflowPage ?? ShouldGoToOverflowPage(len))
{
pageNumber = WriteToOverflowPages(len, out overFlowPos);
len = -1;
nodeType = TreeNodeFlags.PageRef;
}
byte *dataPos;
if (page.HasSpaceFor(_llt, key, len) == false)
{
using (var cursor = cursorConstructor())
{
cursor.Update(cursor.Pages.First, page);
var pageSplitter = new TreePageSplitter(_llt, this, key, len, pageNumber, nodeType, nodeVersion, cursor);
dataPos = pageSplitter.Execute();
}
DebugValidateTree(State.RootPageNumber);
}
else
{
switch (nodeType)
{
case TreeNodeFlags.PageRef:
dataPos = page.AddPageRefNode(lastSearchPosition, key, pageNumber);
break;
case TreeNodeFlags.Data:
dataPos = page.AddDataNode(lastSearchPosition, key, len, nodeVersion);
break;
case TreeNodeFlags.MultiValuePageRef:
dataPos = page.AddMultiValueNode(lastSearchPosition, key, len, nodeVersion);
break;
default:
throw new NotSupportedException("Unknown node type for direct add operation: " + nodeType);
}
page.DebugValidate(_llt, State.RootPageNumber);
}
if (overFlowPos != null)
{
return(overFlowPos);
}
return(dataPos);
}
public static bool TreeNodeEx(string label, TreeNodeFlags flags = 0)
{
return(ImGuiNative.igTreeNodeEx(label, flags));
}
private unsafe TreePageEntry AllocateEntry(ILowLevelTransaction tx, TreeNodeFlags nodeFlags, TreePageEntry parent, int index)
{
var page = tx.AllocateTrees(Id, 1)[0];
ref var header = ref page.Header;
private void SetFlag(TreeNodeFlags bit, bool value)
{
if (value)
{
myFlags |= bit;
}
else
{
myFlags &= ~bit;
}
}
public override void DrawSettingsMenu()
{
TreeNodeFlags collapsingHeaderFlags = TreeNodeFlags.CollapsingHeader;
if (ImGui.TreeNodeEx("Plugin Options", collapsingHeaderFlags))
{
Settings.EnableInHideout.Value = ImGuiExtension.Checkbox("Enable in Hideout", Settings.EnableInHideout);
ImGui.Separator();
Settings.TicksPerSecond.Value = ImGuiExtension.IntSlider("Ticks Per Second", Settings.TicksPerSecond); ImGuiExtension.ToolTipWithText("(?)", "Determines how many times the plugin checks flasks every second.\nLower for less resources, raise for faster response (but higher chance to chug potions).");
ImGui.Separator();
Settings.Debug.Value = ImGuiExtension.Checkbox("Debug Mode", Settings.Debug);
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Flask Options", collapsingHeaderFlags))
{
if (ImGui.TreeNode("Individual Flask Settings"))
{
for (int i = 0; i < 5; i++)
{
FlaskSetting currentFlask = Settings.FlaskSettings[i];
if (ImGui.TreeNode("Flask " + (i + 1) + " Settings"))
{
currentFlask.Enabled.Value = ImGuiExtension.Checkbox("Enable", currentFlask.Enabled);
currentFlask.Hotkey.Value = ImGuiExtension.HotkeySelector("Hotkey", currentFlask.Hotkey);
currentFlask.ReservedUses.Value = ImGuiExtension.IntSlider("Reserved Uses", currentFlask.ReservedUses); ImGuiExtension.ToolTipWithText("(?)", "The absolute number of uses reserved on a flask.\nSet to 1 to always have 1 use of the flask available for manual use.");
ImGui.TreePop();
}
}
ImGui.TreePop();
}
if (ImGui.TreeNode("Health and Mana"))
{
Settings.AutoFlask.Value = ImGuiExtension.Checkbox("Enable", Settings.AutoFlask);
ImGuiExtension.SpacedTextHeader("Settings");
Settings.ForceBubblingAsInstantOnly = ImGuiExtension.Checkbox("Force Bubbling as Instant only", Settings.ForceBubblingAsInstantOnly);
ImGuiExtension.ToolTipWithText("(?)", "When enabled, flasks with the Bubbling mod will only be used as an instant flask.");
Settings.ForcePanickedAsInstantOnly = ImGuiExtension.Checkbox("Force Panicked as Instant only", Settings.ForcePanickedAsInstantOnly);
ImGuiExtension.ToolTipWithText("(?)", "When enabled, flasks with the Panicked mod will only be used as an instant flask. \nNote, Panicked will not be used until under 35%% with this enabled."); //
ImGuiExtension.SpacedTextHeader("Health Flask");
Settings.HPPotion.Value = ImGuiExtension.IntSlider("Min Life % Auto HP Flask", Settings.HPPotion);
Settings.InstantHPPotion.Value = ImGuiExtension.IntSlider("Min Life % Auto Instant HP Flask", Settings.InstantHPPotion);
Settings.DisableLifeSecUse.Value = ImGuiExtension.Checkbox("Disable Life/Hybrid Flask Offensive/Defensive Usage", Settings.DisableLifeSecUse);
ImGuiExtension.SpacedTextHeader("Mana Flask");
ImGui.Spacing(); Settings.ManaPotion.Value = ImGuiExtension.IntSlider("Min Mana % Auto Mana Flask", Settings.ManaPotion);
Settings.InstantManaPotion.Value = ImGuiExtension.IntSlider("Min Mana % Auto Instant MP Flask", Settings.InstantManaPotion);
Settings.MinManaFlask.Value = ImGuiExtension.IntSlider("Min Mana Auto Mana Flask", Settings.MinManaFlask);
ImGui.TreePop();
}
if (ImGui.TreeNode("Remove Ailments"))
{
Settings.RemAilment.Value = ImGuiExtension.Checkbox("Enable", Settings.RemAilment);
ImGuiExtension.SpacedTextHeader("Ailments");
Settings.RemFrozen.Value = ImGuiExtension.Checkbox("Frozen", Settings.RemFrozen);
ImGui.SameLine();
Settings.RemBurning.Value = ImGuiExtension.Checkbox("Burning", Settings.RemBurning);
Settings.RemShocked.Value = ImGuiExtension.Checkbox("Shocked", Settings.RemShocked);
ImGui.SameLine();
Settings.RemCurse.Value = ImGuiExtension.Checkbox("Cursed", Settings.RemCurse);
Settings.RemPoison.Value = ImGuiExtension.Checkbox("Poison", Settings.RemPoison);
ImGui.SameLine();
Settings.RemBleed.Value = ImGuiExtension.Checkbox("Bleed", Settings.RemBleed);
Settings.CorruptCount.Value = ImGuiExtension.IntSlider("Corrupting Blood Stacks", Settings.CorruptCount);
ImGui.TreePop();
}
if (ImGui.TreeNode("Speed Flasks"))
{
Settings.SpeedFlaskEnable.Value = ImGuiExtension.Checkbox("Enable", Settings.SpeedFlaskEnable);
ImGuiExtension.SpacedTextHeader("Flasks");
Settings.QuicksilverFlaskEnable.Value = ImGuiExtension.Checkbox("Quicksilver Flask", Settings.QuicksilverFlaskEnable);
Settings.SilverFlaskEnable.Value = ImGuiExtension.Checkbox("Silver Flask", Settings.SilverFlaskEnable);
ImGuiExtension.SpacedTextHeader("Settings");
Settings.MinMsPlayerMoving.Value = ImGuiExtension.IntSlider("Milliseconds Spent Moving", Settings.MinMsPlayerMoving); ImGuiExtension.ToolTipWithText("(?)", "Milliseconds spent moving before flask will be used.\n1000 milliseconds = 1 second");
ImGui.TreePop();
}
if (ImGui.TreeNode("Defensive Flasks"))
{
Settings.DefensiveFlaskEnable.Value = ImGuiExtension.Checkbox("Enable", Settings.DefensiveFlaskEnable);
ImGui.Spacing();
ImGui.Separator();
Settings.HPPercentDefensive.Value = ImGuiExtension.IntSlider("Min Life %", Settings.HPPercentDefensive);
Settings.ESPercentDefensive.Value = ImGuiExtension.IntSlider("Min ES %", Settings.ESPercentDefensive);
Settings.OffensiveAsDefensiveEnable.Value = ImGuiExtension.Checkbox("Use offensive flasks for defense", Settings.OffensiveAsDefensiveEnable);
ImGui.Separator();
Settings.DefensiveMonsterCount.Value = ImGuiExtension.IntSlider("Monster Count", Settings.DefensiveMonsterCount);
Settings.DefensiveMonsterDistance.Value = ImGuiExtension.IntSlider("Monster Distance", Settings.DefensiveMonsterDistance);
Settings.DefensiveCountNormalMonsters = ImGuiExtension.Checkbox("Normal Monsters", Settings.DefensiveCountNormalMonsters);
Settings.DefensiveCountRareMonsters = ImGuiExtension.Checkbox("Rare Monsters", Settings.DefensiveCountRareMonsters);
Settings.DefensiveCountMagicMonsters = ImGuiExtension.Checkbox("Magic Monsters", Settings.DefensiveCountMagicMonsters);
Settings.DefensiveCountUniqueMonsters = ImGuiExtension.Checkbox("Unique Monsters", Settings.DefensiveCountUniqueMonsters);
ImGui.TreePop();
}
if (ImGui.TreeNode("Offensive Flasks"))
{
Settings.OffensiveFlaskEnable.Value = ImGuiExtension.Checkbox("Enable", Settings.OffensiveFlaskEnable);
ImGui.Spacing();
ImGui.Separator();
Settings.HPPercentOffensive.Value = ImGuiExtension.IntSlider("Min Life %", Settings.HPPercentOffensive);
Settings.ESPercentOffensive.Value = ImGuiExtension.IntSlider("Min ES %", Settings.ESPercentOffensive);
ImGui.Separator();
Settings.OffensiveMonsterCount.Value = ImGuiExtension.IntSlider("Monster Count", Settings.OffensiveMonsterCount);
Settings.OffensiveMonsterDistance.Value = ImGuiExtension.IntSlider("Monster Distance", Settings.OffensiveMonsterDistance);
Settings.OffensiveCountNormalMonsters = ImGuiExtension.Checkbox("Normal Monsters", Settings.OffensiveCountNormalMonsters);
Settings.OffensiveCountRareMonsters = ImGuiExtension.Checkbox("Rare Monsters", Settings.OffensiveCountRareMonsters);
Settings.OffensiveCountMagicMonsters = ImGuiExtension.Checkbox("Magic Monsters", Settings.OffensiveCountMagicMonsters);
Settings.OffensiveCountUniqueMonsters = ImGuiExtension.Checkbox("Unique Monsters", Settings.OffensiveCountUniqueMonsters);
ImGui.TreePop();
}
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("UI Settings", collapsingHeaderFlags))
{
if (ImGui.TreeNodeEx("Flask UI", TreeNodeFlags.Framed))
{
Settings.FlaskUiEnable.Value = ImGuiExtension.Checkbox("Enable", Settings.FlaskUiEnable);
Settings.FlaskPositionX.Value = ImGuiExtension.FloatSlider("X Position", Settings.FlaskPositionX);
Settings.FlaskPositionY.Value = ImGuiExtension.FloatSlider("Y Position", Settings.FlaskPositionY);
Settings.FlaskTextSize.Value = ImGuiExtension.IntSlider("Text Size", Settings.FlaskTextSize);
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Buff UI", TreeNodeFlags.Framed))
{
Settings.BuffUiEnable.Value = ImGuiExtension.Checkbox("Enable", Settings.BuffUiEnable);
Settings.BuffPositionX.Value = ImGuiExtension.FloatSlider("X Position", Settings.BuffPositionX);
Settings.BuffPositionY.Value = ImGuiExtension.FloatSlider("Y Position", Settings.BuffPositionY);
Settings.BuffTextSize.Value = ImGuiExtension.IntSlider("Text Size", Settings.BuffTextSize);
Settings.EnableFlaskAuraBuff.Value = ImGuiExtension.Checkbox("Enable Flask Or Aura Debuff/Buff", Settings.EnableFlaskAuraBuff);
ImGui.TreePop();
}
ImGui.TreePop();
}
}
private bool GetAnyFlag(TreeNodeFlags bits)
{
return (myFlags & bits) != 0;
}
private static void ThrowUnknownNodeTypeAddOperation(TreeNodeFlags nodeType)
{
throw new NotSupportedException("Unknown node type for direct add operation: " + nodeType);
}
public void InfoDumpMenu(int idIn, out int idPop)
{
TreeNodeFlags collapsingHeaderFlags = TreeNodeFlags.CollapsingHeader;
idPop = idIn;
if (ImGui.TreeNodeEx("Basic Options", collapsingHeaderFlags))
{
ImGui.PushID(idPop);
Settings.LegionThings.Value = ImGuiExtension.Checkbox(Settings.LegionThings.Value ? "Enable Features" : "Enable Features", Settings.LegionThings);
idPop++;
ImGui.PopID();
Settings.DrawChests.Value = ImGuiExtension.Checkbox(Settings.DrawChests.Value ? "Draw chests" : "Draw Chests", Settings.DrawChests);
idPop++;
ImGui.PopID();
Settings.DrawMobs.Value = ImGuiExtension.Checkbox(Settings.DrawMobs.Value ? "Draw Reward Mobs" : "Draw Reward Mobs", Settings.DrawMobs);
idPop++;
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Icons", collapsingHeaderFlags))
{
ImGui.PushID(idPop);
Settings.DrawFancyIcons.Value = ImGuiExtension.Checkbox(Settings.DrawFancyIcons.Value ? "Detailed Loot Icons & Labels" : "Detailed Loot Icons & Labels", Settings.DrawFancyIcons);
idPop++;
ImGui.PopID();
Settings.DrawMonolithIcon.Value = ImGuiExtension.Checkbox(Settings.DrawMobLines.Value ? "Draw Monolith Icon" : "Draw Monolith Icon", Settings.DrawMonolithIcon);
idPop++;
ImGui.PopID();
Settings.IconSizeGeneral.Value = ImGuiExtension.IntSlider("Generals Icon Size", Settings.IconSizeGeneral);
idPop++;
ImGui.PopID();
Settings.IconSizeLoot.Value = ImGuiExtension.IntSlider("Loot Icon Size", Settings.IconSizeLoot);
idPop++;
ImGui.PopID();
Settings.IconSizeChest.Value = ImGuiExtension.IntSlider("Chest Icon Size", Settings.IconSizeChest);
idPop++;
ImGui.PopID();
Settings.IconSizeHoard.Value = ImGuiExtension.IntSlider("War Hoard Icon Size", Settings.IconSizeHoard);
idPop++;
ImGui.PopID();
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Text Labels", collapsingHeaderFlags))
{
ImGui.PushID(idPop);
Settings.TextLabels.Value = ImGuiExtension.Checkbox(Settings.TextLabels.Value ? "Icon Text Labels" : "Icon Text Labels", Settings.TextLabels);
idPop++;
ImGui.PopID();
Settings.LootTextLabels.Value = ImGuiExtension.Checkbox(Settings.LootTextLabels.Value ? "Loot Type as Text Label" : "Loot Type as Text Label", Settings.LootTextLabels);
idPop++;
ImGui.PopID();
Settings.TextLabelsOnly.Value = ImGuiExtension.Checkbox(Settings.TextLabelsOnly.Value ? "Text Labels Only" : "Text Labels Only", Settings.TextLabelsOnly);
idPop++;
ImGui.PopID();
Settings.TextSize.Value = ImGuiExtension.IntSlider("Text Label Font Size", Settings.TextSize);
idPop++;
ImGui.PopID();
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("World Icons", collapsingHeaderFlags))
{
ImGui.PushID(idPop);
Settings.DrawWorldIcons.Value = ImGuiExtension.Checkbox(Settings.DrawWorldIcons.Value ? "Draw Icons in World" : "Draw Icons in World", Settings.DrawWorldIcons);
idPop++;
ImGui.PopID();
Settings.IconSizeWorld.Value = ImGuiExtension.IntSlider("World Icon Size", Settings.IconSizeWorld);
idPop++;
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Lines to Things", collapsingHeaderFlags))
{
ImGui.PushID(idPop);
Settings.DrawChestsLines.Value = ImGuiExtension.Checkbox(Settings.DrawChestsLines.Value ? "Draw Lines to Chests" : "Draw Lines to Chests", Settings.DrawChestsLines);
idPop++;
ImGui.PopID();
Settings.DrawMobLines.Value = ImGuiExtension.Checkbox(Settings.DrawMobLines.Value ? "Draw Lines to Reward Mobs" : "Draw Lines to Reward Mobs", Settings.DrawMobLines);
idPop++;
ImGui.PopID();
Settings.DrawMonolithLine.Value = ImGuiExtension.Checkbox(Settings.DrawMobLines.Value ? "Draw Line to Monolith" : "Draw Line to Monolith", Settings.DrawMonolithLine);
idPop++;
ImGui.PopID();
Settings.LineThickness.Value = ImGuiExtension.IntSlider("Line Thickness", Settings.LineThickness);
idPop++;
ImGui.PopID();
Settings.LineAlpha.Value = ImGuiExtension.IntSlider("Line Alpha", Settings.LineAlpha);
idPop++;
ImGui.TreePop();
}
if (ImGui.TreeNodeEx("Color Pickers", collapsingHeaderFlags))
{
ImGui.Text("Color Selection:");
Settings.KaruiColor = ImGuiExtension.ColorPicker("Karui Color", Settings.KaruiColor);
idPop++;
ImGui.PopID();
Settings.EternalColor = ImGuiExtension.ColorPicker("Eternal Empire Color", Settings.EternalColor);
idPop++;
ImGui.PopID();
Settings.TemplarColor = ImGuiExtension.ColorPicker("Templar Color", Settings.TemplarColor);
idPop++;
ImGui.PopID();
Settings.VaalColor = ImGuiExtension.ColorPicker("Vaal Color", Settings.VaalColor);
idPop++;
ImGui.PopID();
Settings.MarakethColor = ImGuiExtension.ColorPicker("Maraketh Color", Settings.MarakethColor);
idPop++;
ImGui.TreePop();
}
}
//obsolete!
public static bool CollapsingHeader(string label, string id, bool displayFrame, bool defaultOpen)
{
TreeNodeFlags default_open_flags = TreeNodeFlags.DefaultOpen;
return(ImGuiNative.igCollapsingHeader(label, (defaultOpen ? default_open_flags : 0)));
}
public static extern bool igCollapsingHeader(string label, ref bool p_open, TreeNodeFlags flags = 0);
public static bool CollapsingHeader(string label, TreeNodeFlags flags)
{
return(ImGuiNative.igCollapsingHeader(label, flags));
}
public unsafe byte *DirectAdd(string key, int len, TreeNodeFlags nodeType = TreeNodeFlags.Data, ushort?version = null)
{
var keySlice = Slice.From(_llt.Allocator, key, Sparrow.ByteStringType.Immutable);
return(DirectAdd(keySlice, len, nodeType, version));
}
private bool GetFlag(TreeNodeFlags bit)
{
return (myFlags & bit) == bit;
}
public DirectAddScope DirectAdd(Slice key, int len, TreeNodeFlags nodeType, out byte *ptr)
{
if (_llt.Flags == TransactionFlags.ReadWrite)
{
State.IsModified = true;
}
else
{
ThreadCannotAddInReadTx();
}
if (AbstractPager.IsKeySizeValid(key.Size) == false)
{
ThrowInvalidKeySize(key);
}
var foundPage = FindPageFor(key, node: out TreeNodeHeader * node, cursor: out TreeCursorConstructor cursorConstructor, allowCompressed: true);
var page = ModifyPage(foundPage);
bool?shouldGoToOverflowPage = null;
if (page.LastMatch == 0) // this is an update operation
{
if ((nodeType & TreeNodeFlags.NewOnly) == TreeNodeFlags.NewOnly)
{
ThrowConcurrencyException();
}
node = page.GetNode(page.LastSearchPosition);
#if DEBUG
using (TreeNodeHeader.ToSlicePtr(_llt.Allocator, node, out Slice nodeCheck))
{
Debug.Assert(SliceComparer.EqualsInline(nodeCheck, key));
}
#endif
shouldGoToOverflowPage = ShouldGoToOverflowPage(len);
byte *pos;
if (shouldGoToOverflowPage == false)
{
// optimization for Data and MultiValuePageRef - try to overwrite existing node space
if (TryOverwriteDataOrMultiValuePageRefNode(node, len, nodeType, out pos))
{
ptr = pos;
return(new DirectAddScope(this));
}
}
else
{
// optimization for PageRef - try to overwrite existing overflows
if (TryOverwriteOverflowPages(node, len, out pos))
{
ptr = pos;
return(new DirectAddScope(this));
}
}
RemoveLeafNode(page);
}
else // new item should be recorded
{
State.NumberOfEntries++;
}
nodeType &= ~TreeNodeFlags.NewOnly;
Debug.Assert(nodeType == TreeNodeFlags.Data || nodeType == TreeNodeFlags.MultiValuePageRef);
var lastSearchPosition = page.LastSearchPosition; // searching for overflow pages might change this
byte *overFlowPos = null;
var pageNumber = -1L;
if (shouldGoToOverflowPage ?? ShouldGoToOverflowPage(len))
{
pageNumber = WriteToOverflowPages(len, out overFlowPos);
len = -1;
nodeType = TreeNodeFlags.PageRef;
}
byte *dataPos;
if (page.HasSpaceFor(_llt, key, len) == false)
{
if (IsLeafCompressionSupported == false || TryCompressPageNodes(key, len, page) == false)
{
using (var cursor = cursorConstructor.Build(key))
{
cursor.Update(cursor.Pages, page);
var pageSplitter = new TreePageSplitter(_llt, this, key, len, pageNumber, nodeType, cursor);
dataPos = pageSplitter.Execute();
}
DebugValidateTree(State.RootPageNumber);
ptr = overFlowPos == null ? dataPos : overFlowPos;
return(new DirectAddScope(this));
}
// existing values compressed and put at the end of the page, let's insert from Upper position
lastSearchPosition = 0;
}
switch (nodeType)
{
case TreeNodeFlags.PageRef:
dataPos = page.AddPageRefNode(lastSearchPosition, key, pageNumber);
break;
case TreeNodeFlags.Data:
dataPos = page.AddDataNode(lastSearchPosition, key, len);
break;
case TreeNodeFlags.MultiValuePageRef:
dataPos = page.AddMultiValueNode(lastSearchPosition, key, len);
break;
default:
ThrowUnknownNodeTypeAddOperation(nodeType);
dataPos = null; // never executed
break;
}
page.DebugValidate(this, State.RootPageNumber);
ptr = overFlowPos == null ? dataPos : overFlowPos;
return(new DirectAddScope(this));
}
