private void TextSearch()
{
string searchTerm = boxSearch.Text.Trim().ToLower();
if (searchTerm == "")
{
return; //don't search blank
}
int pos = DisplayedString_ListBox.SelectedIndex;
pos += 1; //search this and 1 forward
for (int i = 0; i < CleanedStrings.Count; i++)
{
int curIndex = (i + pos) % CleanedStrings.Count;
TLKStringRef node = CleanedStrings[curIndex];
if (CleanedStrings[curIndex].StringID.ToString().Contains(searchTerm))
{
//ID Search
DisplayedString_ListBox.SelectedIndex = curIndex;
return;
}
else if (CleanedStrings[curIndex].Data != null && CleanedStrings[curIndex].Data.ToLower().Contains(searchTerm))
{
DisplayedString_ListBox.SelectedIndex = curIndex;
DisplayedString_ListBox.ScrollIntoView(DisplayedString_ListBox.SelectedItem);
return;
}
}
//Not found
SystemSounds.Beep.Play();
}
private void Evt_AddString(object sender, RoutedEventArgs e)
{
var blankstringref = new TLKStringRef(100, 1, "New Blank Line");
LoadedStrings.Add(blankstringref);
CleanedStrings.Add(blankstringref);
DisplayedString_ListBox.SelectedIndex = CleanedStrings.Count() - 1; //Set focus to new line (which is the last one)
DisplayedString_ListBox.ScrollIntoView(DisplayedString_ListBox.SelectedItem); //Scroll to last item
SetNewID();
FileModified = true;
}
/// <summary>
/// Loads a TLK file into memory.
/// </summary>
/// <param name="fileName"></param>
public void LoadTlkData(string fileName)
{
path = fileName;
name = Path.GetFileNameWithoutExtension(fileName);
/* **************** STEP ONE ****************
* -- load TLK file header --
*
* reading first 28 (4 * 7) bytes
*/
Stream fs = File.OpenRead(fileName);
BinaryReader r = new BinaryReader(fs);
Header = new TLKHeader(r);
//DebugTools.PrintHeader(Header);
/* **************** STEP TWO ****************
* -- read and store Huffman Tree nodes --
*/
/* jumping to the beginning of Huffmann Tree stored in TLK file */
long pos = r.BaseStream.Position;
r.BaseStream.Seek(pos + (Header.MaleEntryCount + Header.FemaleEntryCount) * 8, SeekOrigin.Begin);
CharacterTree = new List <HuffmanNode>();
for (int i = 0; i < Header.treeNodeCount; i++)
{
CharacterTree.Add(new HuffmanNode(r));
}
/* **************** STEP THREE ****************
* -- read all of coded data into memory --
*/
byte[] data = new byte[Header.dataLen];
r.BaseStream.Read(data, 0, data.Length);
/* and store it as raw bits for further processing */
Bits = new BitArray(data);
/* rewind BinaryReader just after the Header
* at the beginning of TLK Entries data */
r.BaseStream.Seek(pos, SeekOrigin.Begin);
/* **************** STEP FOUR ****************
* -- decode (basing on Huffman Tree) raw bits data into actual strings --
* and store them in a Dictionary<int, string> where:
* int: bit offset of the beginning of data (offset starting at 0 and counted for Bits array)
* so offset == 0 means the first bit in Bits array
* string: actual decoded string */
Dictionary <int, string> rawStrings = new Dictionary <int, string>();
int offset = 0;
// int maxOffset = 0;
while (offset < Bits.Length)
{
int key = offset;
// if (key > maxOffset)
// maxOffset = key;
/* read the string and update 'offset' variable to store NEXT string offset */
string s = GetString(ref offset);
rawStrings.Add(key, s);
}
// Console.WriteLine("Max offset = " + maxOffset);
/* **************** STEP FIVE ****************
* -- bind data to String IDs --
* go through Entries in TLK file and read it's String ID and offset
* then check if offset is a key in rawStrings and if it is, then bind data.
* Sometimes there's no such key, in that case, our String ID is probably a substring
* of another String present in rawStrings.
*/
StringRefs = new List <TLKStringRef>();
for (int i = 0; i < Header.MaleEntryCount + Header.FemaleEntryCount; i++)
{
TLKStringRef sref = new TLKStringRef(r);
sref.position = i;
if (sref.BitOffset >= 0)
{
if (!rawStrings.ContainsKey(sref.BitOffset))
{
int tmpOffset = sref.BitOffset;
string partString = GetString(ref tmpOffset);
/* actually, it should store the fullString and subStringOffset,
* but as we don't have to use this compression feature,
* we will store only the part of string we need */
/* int key = rawStrings.Keys.Last(c => c < sref.BitOffset);
* string fullString = rawStrings[key];
* int subStringOffset = fullString.LastIndexOf(partString);
* sref.StartOfString = subStringOffset;
* sref.Data = fullString;
*/
sref.Data = partString;
}
else
{
sref.Data = rawStrings[sref.BitOffset];
}
}
StringRefs.Add(sref);
}
r.Close();
}
/* for sorting */
private static int CompareTlkStringRef(TLKStringRef strRef1, TLKStringRef strRef2)
{
int result = strRef1.StringID.CompareTo(strRef2.StringID);
return(result);
}
/// <summary>
/// Loads a TLK file into memory.
/// </summary>
/// <param name="fileName"></param>
public void LoadTlkData(string fileName)
{
path = fileName;
name = Path.GetFileNameWithoutExtension(fileName);
/* **************** STEP ONE ****************
* -- load TLK file header --
*
* reading first 28 (4 * 7) bytes
*/
Stream fs = File.OpenRead(fileName);
BinaryReader r = new BinaryReader(fs);
Header = new TLKHeader(r);
//DebugTools.PrintHeader(Header);
/* **************** STEP TWO ****************
* -- read and store Huffman Tree nodes --
*/
/* jumping to the beginning of Huffmann Tree stored in TLK file */
long pos = r.BaseStream.Position;
r.BaseStream.Seek(pos + (Header.MaleEntryCount + Header.FemaleEntryCount) * 8, SeekOrigin.Begin);
CharacterTree = new List<HuffmanNode>();
for (int i = 0; i < Header.treeNodeCount; i++)
CharacterTree.Add(new HuffmanNode(r));
/* **************** STEP THREE ****************
* -- read all of coded data into memory --
*/
byte[] data = new byte[Header.dataLen];
r.BaseStream.Read(data, 0, data.Length);
/* and store it as raw bits for further processing */
Bits = new BitArray(data);
/* rewind BinaryReader just after the Header
* at the beginning of TLK Entries data */
r.BaseStream.Seek(pos, SeekOrigin.Begin);
/* **************** STEP FOUR ****************
* -- decode (basing on Huffman Tree) raw bits data into actual strings --
* and store them in a Dictionary<int, string> where:
* int: bit offset of the beginning of data (offset starting at 0 and counted for Bits array)
* so offset == 0 means the first bit in Bits array
* string: actual decoded string */
Dictionary<int, string> rawStrings = new Dictionary<int, string>();
int offset = 0;
// int maxOffset = 0;
while (offset < Bits.Length)
{
int key = offset;
// if (key > maxOffset)
// maxOffset = key;
/* read the string and update 'offset' variable to store NEXT string offset */
string s = GetString(ref offset);
rawStrings.Add(key, s);
}
// Console.WriteLine("Max offset = " + maxOffset);
/* **************** STEP FIVE ****************
* -- bind data to String IDs --
* go through Entries in TLK file and read it's String ID and offset
* then check if offset is a key in rawStrings and if it is, then bind data.
* Sometimes there's no such key, in that case, our String ID is probably a substring
* of another String present in rawStrings.
*/
StringRefs = new List<TLKStringRef>();
for (int i = 0; i < Header.MaleEntryCount + Header.FemaleEntryCount; i++)
{
TLKStringRef sref = new TLKStringRef(r);
sref.position = i;
if (sref.BitOffset >= 0)
{
if (!rawStrings.ContainsKey(sref.BitOffset))
{
int tmpOffset = sref.BitOffset;
string partString = GetString(ref tmpOffset);
/* actually, it should store the fullString and subStringOffset,
* but as we don't have to use this compression feature,
* we will store only the part of string we need */
/* int key = rawStrings.Keys.Last(c => c < sref.BitOffset);
* string fullString = rawStrings[key];
* int subStringOffset = fullString.LastIndexOf(partString);
* sref.StartOfString = subStringOffset;
* sref.Data = fullString;
*/
sref.Data = partString;
}
else
{
sref.Data = rawStrings[sref.BitOffset];
}
}
StringRefs.Add(sref);
}
r.Close();
}
/* for sorting */
private static int CompareTlkStringRef(TLKStringRef strRef1, TLKStringRef strRef2)
{
int result = strRef1.StringID.CompareTo(strRef2.StringID);
return result;
}
public void LoadTlkData()
{
BinaryReader r = new BinaryReader(new MemoryStream(pcc.Exports[index].Data), Encoding.Unicode);
//skip properties
r.BaseStream.Seek(40, SeekOrigin.Begin);
//hashtable
int entryCount = r.ReadInt32();
StringRefs = new TLKStringRef[entryCount];
for (int i = 0; i < entryCount; i++)
{
StringRefs[i] = new TLKStringRef(r);
}
//Huffman tree
nodes = new List <HuffmanNode>();
int nodeCount = r.ReadInt32();
bool leaf;
for (int i = 0; i < nodeCount; i++)
{
leaf = r.ReadBoolean();
if (leaf)
{
nodes.Add(new HuffmanNode(r.ReadChar()));
}
else
{
nodes.Add(new HuffmanNode(r.ReadInt16(), r.ReadInt16()));
}
}
//TraverseHuffmanTree(nodes[0], new List<bool>());
//encoded data
int stringCount = r.ReadInt32();
byte[] data = new byte[r.BaseStream.Length - r.BaseStream.Position];
r.Read(data, 0, data.Length);
Bits = new BitArray(data);
//decompress encoded data with huffman tree
int offset = 4;
int size;
List <string> rawStrings = new List <string>(stringCount);
while (offset * 8 < Bits.Length)
{
size = BitConverter.ToInt32(data, offset);
offset += 4;
string s = GetString(offset * 8);
offset += size + 4;
rawStrings.Add(s);
}
//associate StringIDs with strings
for (int i = 0; i < StringRefs.Length; i++)
{
if (StringRefs[i].Flags[0] == 1)
{
StringRefs[i].Data = rawStrings[StringRefs[i].Index];
}
}
}
