public void Insert(TItem newItem)
{
TItem currentNodeValue = NodeData;
if (currentNodeValue.CompareTo(newItem) > 0)
{
//Insert the new item to left subtree
if (LeftTree == null)
{
LeftTree = new Tree <TItem>(newItem);
}
else
{
LeftTree.Insert(newItem);
}
}
else
{
//Insert the new item to right subtree
if (RightTree == null)
{
RightTree = new Tree <TItem>(newItem);
}
else
{
RightTree.Insert(newItem);
}
}
}
public TreeNode GetNodeWithIndex(int index)
{
if (Number.Equals(index))
{
return(this);
}
if (LeftTree != null)
{
TreeNode leftIndex = LeftTree.GetNodeWithIndex(index);
if (leftIndex != null)
{
return(leftIndex);
}
}
if (RightTree != null)
{
TreeNode rightIndex = RightTree.GetNodeWithIndex(index);
if (rightIndex != null)
{
return(rightIndex);
}
}
return(null);
}
public override void Compile(TScriptData scriptData)
{
LeftTree.Compile(scriptData);
RightTree.Compile(scriptData);
switch (type)
{
case TokenType.PLUS:
scriptData.CodeList.Add(new AddOpCode());
break;
case TokenType.MINUS:
scriptData.CodeList.Add(new SubOpCode());
break;
case TokenType.MUL:
scriptData.CodeList.Add(new MulOpCode());
break;
case TokenType.DIV:
scriptData.CodeList.Add(new DivOpCode());
break;
default:
break;
}
}
public void Insert(T item)//create method and pass parameter item
{
T currentNodeValue = NodeData;
if ((currentNodeValue.CompareTo(item)) > 0)
{
if (LeftTree == null)
{
LeftTree = new BST <T>(item);
}
else
{
LeftTree.Insert(item);
}
}
else
{
if (RightTree == null)
{
RightTree = new BST <T>(item);
}
else
{
RightTree.Insert(item);
}
}
}
public void Insert(TI newItem)
{
TI currentNodeValue = NodeData;
if (currentNodeValue.CompareTo(newItem) > 0)
{
if (LeftTree == null)
{
LeftTree = new Tree <TI>(newItem);
}
else
{
LeftTree.Insert(newItem);
}
}
else
{
if (RightTree == null)
{
RightTree = new Tree <TI>(newItem);
}
else
{
RightTree.Insert(newItem);
}
}
}
public virtual bool LoadLowestLevelHashs(FileDataIO fileInput)
{
if (DataSize <= BaseSize)
{ // sanity
// lowest level, read hash
Hash.Read(fileInput);
//theApp.AddDebugLogLine(false,Hash.GetString());
HashValid = true;
return(true);
}
else
{
ulong nBlocks = DataSize / BaseSize + ((DataSize % BaseSize != 0) ? (ulong)1 : (ulong)0);
ulong nLeft = (((IsLeftBranch) ? nBlocks + 1 : nBlocks) / 2) * BaseSize;
ulong nRight = DataSize - nLeft;
if (LeftTree == null)
{
LeftTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nLeft, true, (nLeft <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
if (RightTree == null)
{
RightTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nRight, false, (nRight <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(LeftTree.LoadLowestLevelHashs(fileInput) &&
RightTree.LoadLowestLevelHashs(fileInput));
}
}
public virtual bool WriteLowestLevelHashs(FileDataIO fileDataOut, uint wHashIdent, bool bNoIdent, bool b32BitIdent)
{
wHashIdent <<= 1;
wHashIdent |= (IsLeftBranch) ? (uint)1 : (uint)0;
if (LeftTree == null && RightTree == null)
{
if (DataSize <= BaseSize && HashValid)
{
if (!bNoIdent && !b32BitIdent)
{
fileDataOut.WriteUInt16((ushort)wHashIdent);
}
else if (!bNoIdent && b32BitIdent)
{
fileDataOut.WriteUInt32(wHashIdent);
}
Hash.Write(fileDataOut);
return(true);
}
else
{
return(false);
}
}
else if (LeftTree == null || RightTree == null)
{
return(false);
}
else
{
return(LeftTree.WriteLowestLevelHashs(fileDataOut, wHashIdent, bNoIdent, b32BitIdent) &&
RightTree.WriteLowestLevelHashs(fileDataOut, wHashIdent, bNoIdent, b32BitIdent));
}
}
public void PrintInorderTraversal()
{
if (LeftTree != null)
{
LeftTree.PrintInorderTraversal();
}
Console.Write(Number + " ");
if (RightTree != null)
{
RightTree.PrintInorderTraversal();
}
}
private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
{
if (FChangeExecuting)
{
return;
}
FChangeExecuting = true;
LeftTree.SelectedNode = e.Node;
LeftTree.BeginUpdate();
CheckAllChildNodes(e.Node, e.Node.Checked);
LeftTree.EndUpdate();
FChangeExecuting = false;
}
public void WalkTree()
{
if (LeftTree != null)
{
LeftTree.WalkTree();
}
Console.WriteLine(NodeData.ToString());
if (RightTree != null)
{
RightTree.WalkTree();
}
}
public void Display()
{
if (LeftTree != null)
{
LeftCount++;
LeftTree.Display();
}
Console.Write(NodeData.ToString() + "-->");
if (RightTree != null)
{
RightCount++;
RightTree.Display();
}
}
public string WalkTree()
{
string result = "";
if (LeftTree != null)
{
result = LeftTree.WalkTree();
}
result += $" {NodeData.ToString()} ";
if (this.RightTree != null)
{
result += RightTree.WalkTree();
}
return(result);
}
public void SwapTreesAtHeight(int h)
{
if (Depth % h == 0)
{
var temp = LeftTree;
LeftTree = RightTree;
RightTree = temp;
}
if (LeftTree != null)
{
LeftTree.SwapTreesAtHeight(h);
}
if (RightTree != null)
{
RightTree.SwapTreesAtHeight(h);
}
}
public string WalkTree()
{
var result = "";
if (LeftTree != null)
{
result = LeftTree.WalkTree();
}
result += string.Format(" {0} ", NodeData);
if (RightTree != null)
{
result += RightTree.WalkTree();
}
return(result);
}
private void openPccToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog opf = new OpenFileDialog();
opf.Title = "Select game package on disk";
opf.Filter = "Mass Effect Package|*.pcc;*.sfm;*.upk";
opf.Multiselect = true;
if (opf.ShowDialog() == DialogResult.OK)
{
try
{
int NoMorphPcc = 0;
this.Cursor = Cursors.WaitCursor;
foreach (string pccPath in opf.FileNames)
{
TreeNode node = data.BuildPccTree(pccPath);
if (node != null)
{
LeftTree.Nodes.Add(node);
LeftTree.Refresh();
}
else
{
NoMorphPcc++;
}
}
if (NoMorphPcc > 0)
{
MessageBox.Show("Some pcc files were not added because they do not contain any morph or because they have been already added to the tree before.");
}
}
catch (ArgumentException ex)
{
MessageBox.Show(ex.Message);
}
finally
{
this.Cursor = Cursors.Default;
}
}
}
public IEnumerable <TItem> PreOrder(TItem node)
{
if (node != null)
{
yield return(node);
if (LeftTree != null)
{
foreach (var x in LeftTree.PreOrder(LeftTree.Node))
{
yield return(x);
}
}
if (RightTree != null)
{
foreach (var x in RightTree.PreOrder(RightTree.Node))
{
yield return(x);
}
}
}
}
public bool SetHash(FileDataIO fileInput, uint wHashIdent, sbyte nLevel, bool bAllowOverwrite)
{
if (nLevel == -1)
{
// first call, check how many level we need to go
byte i;
for (i = 0; i != 32 && (wHashIdent & 0x80000000) == 0; i++)
{
wHashIdent <<= 1;
}
if (i > 31)
{
//TODO:Log
//theApp.QueueDebugLogLine(/*DLP_HIGH,*/ false, _T("CAICHHashTree::SetHash - found invalid HashIdent (0)"));
return(false);
}
else
{
nLevel = (sbyte)(31 - i);
}
}
if (nLevel == 0)
{
// this is the searched hash
if (HashValid && !bAllowOverwrite)
{
// not allowed to overwrite this hash, however move the filepointer by reading a hash
AICHHash hash = MuleApplication.Instance.AICHObjectManager.CreateAICHHash(fileInput);
return(true);
}
Hash.Read(fileInput);
HashValid = true;
return(true);
}
else if (DataSize <= BaseSize)
{ // sanity
// this is already the last level, cant go deeper
return(false);
}
else
{
// adjust ident to point the path to the next node
wHashIdent <<= 1;
nLevel--;
ulong nBlocks = DataSize / BaseSize + ((DataSize % BaseSize != 0) ? (ulong)1 : (ulong)0);
ulong nLeft = (((IsLeftBranch) ? nBlocks + 1 : nBlocks) / 2) * BaseSize;
ulong nRight = DataSize - nLeft;
if ((wHashIdent & 0x80000000) > 0)
{
if (LeftTree == null)
{
LeftTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nLeft, true, (nLeft <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(LeftTree.SetHash(fileInput, wHashIdent, nLevel));
}
else
{
if (RightTree == null)
{
RightTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nRight, false, (nRight <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(RightTree.SetHash(fileInput, wHashIdent, nLevel));
}
}
}
public int GetCount()
{
return(1 + (LeftTree?.GetCount() ?? 0) + (RightTree?.GetCount() ?? 0));
}
private void SortButton_Click(object sender, EventArgs e)
{
LeftTree.Sort();
}
private void CompileButton_Click(object sender, EventArgs e)
{
XmlDataDocument xmldoc = new XmlDataDocument();
XmlNodeList xmlnode, xmlCheck;
FTokenLst.Clear();
string StartupPath = Application.StartupPath;
if (StartupPath[StartupPath.Length - 1] != '\\')
{
StartupPath += '\\';
}
FileStream fs = new FileStream(StartupPath + "SQLScriptSorterConfig.xml", FileMode.Open, FileAccess.Read);
xmldoc.Load(fs);
xmlnode = xmldoc.GetElementsByTagName("SQLScript");
for (int i = 0; i < xmlnode.Count; i++)
{
XmlNode XmlN = xmlnode[i];
TreeNode TreeN = LeftTree.Nodes.Add(XmlN.Attributes["TreeName"].Value);
switch (XmlN.Attributes["TreeKey"].Value.ToUpper())
{
case "FUN":
TreeN.ImageIndex = 0;
break;
case "VIEW":
TreeN.ImageIndex = 3;
break;
case "TABLE":
TreeN.ImageIndex = 2;
break;
case "PROC":
TreeN.ImageIndex = 1;
break;
}
TreeN.StateImageIndex = TreeN.SelectedImageIndex = TreeN.ImageIndex;
FTokenLst.Add(new TokenItem(TreeN, XmlN.InnerText));
}
xmlCheck = xmldoc.GetElementsByTagName("MissObject");
for (int i = 0; i < xmlCheck.Count; i++)
{
XmlNode CheckXml = xmlCheck[i];
for (int j = 0; j < xmlnode.Count; j++)
{
XmlNode XmlN = xmlnode[j];
if (CheckXml.Attributes["TreeKey"].Value == XmlN.Attributes["TreeKey"].Value)
{
NotCheckedId.Add(XmlN.Attributes["TreeName"].Value);
break;
}
}
eScript.Text += NotCheckedId[i].ToString() + "\n";
NotCheckedValue.Add(CheckXml.InnerText);
eScript.Text += NotCheckedValue[i].ToString() + "\n";
}
fs.Close();
string ScriptTxt = "";
ScriptItem ScriptI = null;
for (int i = 0; i < SQLFileList.Count; i++)
{
string LineTxt = SQLFileList[i].ToUpper();
string ScriptName = SQLFileList[i];
if (LineTxt.Length > 6 && LineTxt.Substring(0, 6) == "CREATE")
{
ScriptTxt = "";
string t1 = LineTxt.Remove(0, 7);
ScriptName = ScriptName.Remove(0, 7);
int SpacePos = t1.IndexOf(" ");
if (SpacePos > 0)
{
string TokenKind = t1.Substring(0, SpacePos);
TokenItem TokenI = FTokenLst.GetItem(TokenKind);
if (TokenI != null)
{
ScriptI = new ScriptItem(ScriptName);
TokenI.Scripts.Add(ScriptI);
}
}
}
if (SQLFileList[i].Trim() != "")
{
if (ScriptTxt != "")
{
ScriptTxt += Environment.NewLine;
}
ScriptTxt += SQLFileList[i];
}
if (SQLFileList[i] == "GO")
{
if (ScriptI != null)
{
ScriptI.Text = ScriptTxt;
}
ScriptI = null;
ScriptTxt = "";
}
}
LeftTree.BeginUpdate();
FTokenLst.BuildTree();
foreach (TreeNode N in LeftTree.Nodes)
{
N.Expand();
}
LeftTree.EndUpdate();
SaveCompileTextButton.Enabled = true;
CompileButton.Enabled = false;
}