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");
}
}
public DataRow(TableDocument table)
{
InTable = table;
m_data = new Dictionary <string, CellData>();
m_id = new CTRef(this);
Exists = false;
HasUnresolvedReferences = false;
m_dupeIndex = 0;
}
private void OpenDocument(CTDocument.DocumentType type, string name, string args = "")
{
if (name.ToLowerInvariant() == "all")
{
OpenAllDocuments(type, args);
return;
}
switch (type)
{
case CTDocument.DocumentType.Table:
{
try
{
CTDebug.Info("Opening Table: {0}", name);
_2da.TableDocument doc = new _2da.TableDocument(name);
if (args == "raw")
{
doc.LoadCompiled();
}
else if (args == "friendly")
{
doc.LoadFriendly();
}
else
{
doc.LoadNewest();
}
m_openDocuments.Add(name, doc);
}
catch (Exception e)
{
CTDebug.Error("{0}: {1}", e.GetType().Name, e.Message);
}
}
break;
case CTDocument.DocumentType.TLK:
if (name.ToLowerInvariant() != "dialog") // Don't open dialog.tlk as a document.
{
CTDebug.Info("Opening TLK: {0}", name);
Tlk.TlkDocument doc = new Tlk.TlkDocument(name);
m_openDocuments.Add(name, doc);
m_tlkStack.AddTlkFile(doc);
doc.LoadCompiled();
}
break;
}
}
public static DataRow ReadRaw(TableDocument table, string data)
{
DataRow ret = new DataRow(table);
string[] columnValues = FileUtils.Tokenize(data);
ret.Exists = true;
if (columnValues.Length == 0)
{
return(null);
}
if (columnValues.Length != table.Columns.Count)
{
throw new FormatException(string.Format("Row {0} is not correctly formatted.", columnValues[0]));
}
else
{
for (int i = 0; i < columnValues.Length; ++i)
{
ColumnInfo ci = table.Columns[i];
CellData cellContent = new CellData(ret);
cellContent.FromDataString(columnValues[i], ci);
ret.m_data.Add(ci.Name, cellContent);
if (ci.Type == ColumnType.Label && columnValues[i] == "****")
{
ret.Exists = false;
}
if (ci.Name.ToLowerInvariant() == "removed")
{
if (!char.IsNumber(columnValues[i][0]) || Int32.Parse(columnValues[i]) != 0)
{
ret.Exists = false;
}
}
if (cellContent.NeedsResolution)
{
ret.HasUnresolvedReferences = true;
}
}
}
return(ret);
}
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 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);
}
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.");;
}
}
