public string ToDataString(ColumnInfo inColumn)
{
if (DataValue == null && inColumn.Type != ColumnType.Index)
{
return(SourceString);
}
if (DataValue is int && (int)DataValue == int.MinValue)
{
return(SourceString);
}
switch (inColumn.Type)
{
case ColumnType.Index:
return(ParentRow.Index.ToString());
case ColumnType.Label:
case ColumnType.String:
case ColumnType.ScriptRef:
case ColumnType.ScriptConst:
case ColumnType.Enum:
return((string)DataValue);
case ColumnType.Integer:
return(((int)DataValue).ToString());
case ColumnType.Flags:
return("0x" + ((UInt32)DataValue).ToString("X"));
case ColumnType.Float:
return(((float)DataValue).ToString());
case ColumnType.TableRef:
{
TableDocument doc = CTCore.GetOpenProject().GetDocument <TableDocument>(inColumn.ReferenceTo);
Guid refID = (Guid)DataValue;
if (refID != Guid.Empty)
{
return(doc.GetRow(refID).Index.ToString());
}
else
{
return(SourceString);
}
}
case ColumnType.TLKRef:
{
object[] data = (object[])DataValue;
if ((int)data[1] == -1)
{
return(SourceString);
}
return(CTCore.GetOpenProject().GetTlkStack().GetIndex((int)data[1], (string)data[0]).ToString());
}
default: return("INVALID_CELL_DATA");
}
}
private string GetTableInfoPath()
{
// If there's a resource just for us, use it
string defaultResourcePath = (Owner.GetResourcePath(CTResourceType.TableInfo, Name, true, false));
if (File.Exists(defaultResourcePath))
{
return(defaultResourcePath);
}
// If not, check wildcards
var collection = CTCore.GetOpenProject().GetAllResourcesOfType(CTResourceType.TableInfo);
Array.Sort <CTResource>(collection, new ResourceLengthComparer());
foreach (CTResource infoResource in collection)
{
if (Name.StartsWith(infoResource.Filename))
{
return(infoResource.Path);
}
}
// If there's nothing for us yet, make one.
return(defaultResourcePath);
}
public TableDocument(string name)
: base(CTCore.GetOpenProject(), name)
{
m_columns = new TableInfo();
m_docRows = new List <DataRow>();
m_byLabels = new Dictionary <string, DataRow>();
m_removedRows = new Dictionary <string, DataRow>();
m_columnIndeces = new Dictionary <string, int>();
m_dupeWarnings = new List <string>();
DocType = CTDocument.DocumentType.Table;
HasUnresolvedReferences = false;
CanSave = true;
s_allOpenTables.Add(name, this);
}
public void ResolveReferences()
{
if (HasUnresolvedReferences)
{
CTDebug.Info("Resolving references in {0}", Name);
foreach (ColumnInfo col in m_columns)
{
if (col.Type == ColumnType.TableRef)
{
TableDocument table = CTCore.GetOpenProject().GetDocument <TableDocument>(col.ReferenceTo);
table.PrintDuplicationWarnings();
}
}
foreach (DataRow row in m_docRows)
{
row.ResolveReferences();
}
HasUnresolvedReferences = false;
}
}
public TableInfo(string[] columnNames)
{
Group = CTCore.GetArg("default2dagroup", "default");
this.Add(new ColumnInfo("Index", ColumnType.Index));
foreach (string column in columnNames)
{
ColumnType type;
string name = column;
switch (column.ToLowerInvariant())
{
case "label": type = ColumnType.Label; name = "Label"; break;
case "removed": type = ColumnType.Integer; break;
default: type = ColumnType.String; break;
}
this.Add(new ColumnInfo(name, type));
}
}
public override void Compile()
{
List <TlkContents> ret = new List <TlkContents>();
List <TlkDocument> docStack = CTCore.GetOpenProject().GetTlkStack().GetDocuments();
for (int i = 0; i < docStack.Count; ++i)
{
TlkDocument doc = docStack[i];
CTDebug.Info("Writing from {0}.tlk ({1} lines)", doc.Name, doc.Contents.Length);
ret.AddRange(doc.Contents);
}
try
{
TLKWriter.SaveFileContents(Path, ret.ToArray());
}
catch (Exception)
{
CTDebug.Error("Could not save {0}. Make sure the file is not in use.", Path);
}
}
private void ReadManifestLine(string input)
{
string[] tokens = FileUtils.Tokenize(input);
switch (tokens[1].ToLowerInvariant())
{
case "2da":
tokens[0] = tokens[0].ToLowerInvariant();
foreach (var doc in _2da.TableDocument.OpenTables)
{
if (tokens[0] == "all" || tokens[0] == doc.Value.Category)
{
string name = doc.Key;
string path = CTCore.GetOpenProject().GetResourcePath(CTResourceType.TableRaw, name);
CTArtifact afx = new HakComponentArtifact(CTArtifactType.TableRaw, name, path);
m_afx.Add(name, afx);
}
}
break;
}
}
public override void Compile()
{
TableDocument doc = CTCore.GetOpenProject().GetDocument <TableDocument>(m_tableName);
string[] output = new string[] { "Invalid table." };
switch (ArtifactType)
{
case CTArtifactType.TableCT:
break;
case CTArtifactType.TableFriendly:
output = doc.SaveFriendly();
break;
case CTArtifactType.TableRaw:
output = doc.SaveCompiled();
break;
}
System.IO.File.WriteAllLines(Path, output);
}
public TlkDocument(string name)
: base(CTCore.GetOpenProject(), name)
{
DocType = DocumentType.TLK;
}
public TlkDocumentStacked(string name)
: base(CTCore.GetOpenProject(), name)
{
m_subDocuments = new List <TlkDocument>();
}
public MdbDocument(string name)
: base(CTCore.GetOpenProject(), name)
{
m_packetHeaders = new List <MdbPacketHeader>();
m_packets = new List <MdbPacket>();
}
private static Object ReadDataString(string input, ColumnInfo inColumn, out bool refResolved)
{
refResolved = true;
try
{
switch (inColumn.Type)
{
case ColumnType.Index:
return(null);
case ColumnType.Label:
case ColumnType.String:
case ColumnType.ScriptRef:
case ColumnType.ScriptConst:
case ColumnType.Enum:
return(input);
case ColumnType.Integer:
return(FileUtils.ParseInt(input));
case ColumnType.Flags:
if (input[0] == '0')
{
UInt32 hex = 0;
if (UInt32.TryParse(input.Substring(2), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out hex))
{
return(hex);
}
else
{
return(null);
}
}
else
{
return(null);
}
case ColumnType.Float:
{
float parsed;
if (float.TryParse(input, out parsed))
{
return(parsed);
}
else
{
return(null);
}
}
case ColumnType.TableRef:
{
TableDocument doc = CTCore.GetOpenProject().GetDocument <TableDocument>(inColumn.ReferenceTo);
if (doc != null && doc.IsLoaded)
{
int index = FileUtils.ParseInt(input);
DataRow row = doc.GetRow(index);
if (row != null)
{
return(row.ID);
}
else
{
return(Guid.Empty);
}
}
else
{
refResolved = false;
return(FileUtils.ParseInt(input));
}
}
case ColumnType.TLKRef:
{
string docName;
int localVal;
int index;
if (int.TryParse(input, out index))
{
CTCore.GetOpenProject().GetTlkStack().GetEntry(index, out docName, out localVal);
return(new Object[] { docName, localVal });
}
else
{
return(null);
}
}
default: throw new FormatException("Input was incorrectly formatted.");;
}
}
catch (FormatException)
{
return(null);
}
}
private static Object ReadFriendlyString(string input, ColumnInfo inColumn, out bool refResolved)
{
refResolved = true;
switch (inColumn.Type)
{
case ColumnType.Index:
return(null);
case ColumnType.Label:
case ColumnType.String:
case ColumnType.ScriptRef:
case ColumnType.ScriptConst:
case ColumnType.Enum:
return(input);
case ColumnType.Integer:
return(FileUtils.ParseInt(input));
case ColumnType.Flags:
if (input[0] == '0')
{
UInt32 hex = 0;
if (UInt32.TryParse(input.Substring(2), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out hex))
{
return(hex);
}
else
{
return(null);
}
}
else
{
return(null);
}
case ColumnType.Float:
{
float parsed;
if (float.TryParse(input, out parsed))
{
return(parsed);
}
else
{
return(null);
}
}
case ColumnType.TableRef:
{
TableDocument doc = CTCore.GetOpenProject().GetDocument <TableDocument>(inColumn.ReferenceTo);
if (doc != null && doc.IsLoaded)
{
if (input != "****")
{
if (doc.GetRow(input) != null)
{
return(doc.GetRow(input).ID);
}
else
{
return(Guid.Empty);
}
}
else
{
return(Guid.Empty);
}
}
else
{
refResolved = false;
return(input);
}
}
case ColumnType.TLKRef:
{
TlkDocument doc;
string[] parsed = input.Split(':');
if (parsed.Length == 1)
{
return new Object[] { "tlk", -1 }
}
;
doc = CTCore.GetOpenProject().GetDocument <TlkDocument>(parsed[0]);
if (parsed[0] == TlkDocument.DialogTlk.Name)
{
doc = TlkDocument.DialogTlk;
}
int index;
int.TryParse(parsed[1], out index);
return(new Object[] { doc.Name, index });
}
default: throw new FormatException("Input was incorrectly formatted.");;
}
}
