Lucas de Vries
1096 lines
29 KiB
ActionScript
1096 lines
29 KiB
ActionScript
#priority init -200
|
|
import tabs.Tab;
|
|
import tabs.tabbar;
|
|
import editor.loader;
|
|
import editor.defs;
|
|
import editor.fields;
|
|
import editor.files;
|
|
import dialogs.InputDialog;
|
|
import dialogs.QuestionDialog;
|
|
import editor.hooks;
|
|
import Tab@ createResearchEditor(const string& fname, const string& ident) from "tabs.ResearchTab";
|
|
|
|
class FieldInfo {
|
|
LineDesc@ line;
|
|
FieldDef@ def;
|
|
Field@ elem;
|
|
bool hasOriginal = false;
|
|
string originalValue;
|
|
};
|
|
|
|
Field@ makeField(FieldDef@ def, IGuiElement@ parent, const recti& pos) {
|
|
auto@ fld = makeField(def.type, parent, pos);
|
|
if(def.options !is null) {
|
|
for(uint i = 0, cnt = def.options.length; i < cnt; ++i)
|
|
fld.addOption(def.options[i]);
|
|
}
|
|
return fld;
|
|
}
|
|
|
|
class BlockEditor : BaseGuiElement, QuestionDialogCallback {
|
|
FileDesc@ file;
|
|
BlockDef@ blockType;
|
|
LineDesc@ headLine;
|
|
string fname;
|
|
|
|
array<FieldInfo@> fields;
|
|
array<FieldInfo@> hooks;
|
|
array<BlockEditor@> blocks;
|
|
array<LineDesc@> extraLines;
|
|
|
|
GuiButton@ addHookButton;
|
|
array<GuiButton@> addBlockButtons;
|
|
array<GuiButton@> addFieldButtons;
|
|
array<FieldDef@> addFields;
|
|
|
|
bool expanded = true;
|
|
bool changed = false;
|
|
|
|
GuiButton@ label;
|
|
GuiTextbox@ text;
|
|
GuiButton@ removeButton;
|
|
GuiButton@ editButton;
|
|
|
|
BlockEditor(IGuiElement@ elem) {
|
|
super(elem, recti());
|
|
|
|
@label = GuiButton(this, Alignment(Left+12, Top, Left+400, Top+44));
|
|
label.font = FT_Medium;
|
|
label.horizAlign = 0.0;
|
|
label.style = SS_IconButton;
|
|
label.buttonIcon = icons::Minus;
|
|
@text = GuiTextbox(this, Alignment(Left+400, Top, Right-40, Top+44));
|
|
text.font = FT_Medium;
|
|
text.style = SS_HoverTextbox;
|
|
text.emptyText = "Enter identifier name for element...";
|
|
text.tabIndex = -1;
|
|
@removeButton = GuiButton(this, Alignment(Right-40, Top+4, Right-4, Top+40));
|
|
removeButton.color = colors::Red;
|
|
setMarkupTooltip(removeButton, "Remove this block and its associated element from the file.");
|
|
removeButton.setIcon(icons::Remove);
|
|
StrictBounds = true;
|
|
}
|
|
|
|
void parse(const string& filename, FileDef@ def) {
|
|
@file = FileDesc(filename);
|
|
fname = filename;
|
|
parseBlock(file, file.lines, -1, def.defaultBlock);
|
|
}
|
|
|
|
void fillTargets(Field@ sourceField, TargetChooser@ fld, bool selected = false) {
|
|
if(!selected) {
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i) {
|
|
if(blocks[i].hasField(sourceField)) {
|
|
blocks[i].fillTargets(sourceField, fld, true);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
auto@ tf = cast<TargetField>(fields[i].elem);
|
|
if(tf !is null) {
|
|
auto type = TargetType(tf.type.selected);
|
|
if(fld.targType == TT_Any || type == fld.targType)
|
|
fld.addOption(tf.box.text, tf.box.text+" ("+TARGET_TYPE_NAMES[type]+")");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool hasField(Field@ fld, bool recurse = true) {
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
if(fields[i].elem is fld)
|
|
return true;
|
|
}
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
|
|
if(hooks[i].elem is fld)
|
|
return true;
|
|
}
|
|
if(recurse) {
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i) {
|
|
if(blocks[i].hasField(fld))
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void clear() {
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i)
|
|
fields[i].elem.remove();
|
|
fields.length = 0;
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i)
|
|
blocks[i].remove();
|
|
blocks.length = 0;
|
|
for(uint i = 0, cnt = addBlockButtons.length; i < cnt; ++i)
|
|
addBlockButtons[i].remove();
|
|
addBlockButtons.length = 0;
|
|
for(uint i = 0, cnt = addFieldButtons.length; i < cnt; ++i)
|
|
addFieldButtons[i].remove();
|
|
addFieldButtons.length = 0;
|
|
addFields.length = 0;
|
|
extraLines.length = 0;
|
|
}
|
|
|
|
void insertLine(LineDesc@ line, int priority = 0) {
|
|
//Find the right place to insert this line
|
|
int pos = -1;
|
|
if(pos == -1 && headLine !is null)
|
|
pos = file.lines.find(headLine)+1;
|
|
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
if(fields[i].line !is null && fields[i].def.fieldPriority <= priority)
|
|
pos = max(pos, file.lines.find(fields[i].line)+1);
|
|
}
|
|
|
|
if(!line.isKey) {
|
|
for(uint i = 0, cnt = extraLines.length; i < cnt; ++i)
|
|
pos = max(pos, file.lines.find(extraLines[i])+1);
|
|
}
|
|
|
|
if(pos < 0 || pos > int(file.lines.length))
|
|
file.lines.insertLast(line);
|
|
else
|
|
file.lines.insertAt(pos, line);
|
|
}
|
|
|
|
void checkDuplicates() {
|
|
if(blockType is null || !blockType.hasIdentifier)
|
|
return;
|
|
bool dup = false;
|
|
if(blockType.duplicateCheck !is null) {
|
|
uint count = 0;
|
|
string ident = text.text;
|
|
for(uint i = 0, cnt = blockType.duplicateCheck.length; i < cnt; ++i) {
|
|
if(blockType.duplicateCheck[i].ident == ident)
|
|
count += 1;
|
|
}
|
|
if(count > 1)
|
|
dup = true;
|
|
}
|
|
|
|
if(dup) {
|
|
text.bgColor = colors::Red;
|
|
text.textColor = colors::Red;
|
|
setMarkupTooltip(text, "Duplicate identifier, '"+text.text+"' is already in use.");
|
|
}
|
|
else {
|
|
text.bgColor = colors::White;
|
|
text.textColor = colors::White;
|
|
setMarkupTooltip(text, "");
|
|
}
|
|
}
|
|
|
|
void setExpanded(bool value) {
|
|
if(value == expanded)
|
|
return;
|
|
expanded = value;
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i)
|
|
fields[i].elem.visible = expanded;
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i)
|
|
blocks[i].visible = expanded;
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
|
|
hooks[i].elem.visible = expanded;
|
|
updateAbsolutePosition();
|
|
label.buttonIcon = (expanded ? icons::Minus : icons::Plus);
|
|
if(addHookButton !is null)
|
|
addHookButton.visible = expanded;
|
|
if(editButton !is null)
|
|
editButton.visible = expanded;
|
|
for(uint i = 0, cnt = addBlockButtons.length; i < cnt; ++i)
|
|
addBlockButtons[i].visible = expanded;
|
|
for(uint i = 0, cnt = addFieldButtons.length; i < cnt; ++i)
|
|
addFieldButtons[i].visible = expanded;
|
|
emitChanged();
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& evt) {
|
|
if(evt.type == GUI_Clicked) {
|
|
if(evt.caller is removeButton) {
|
|
question("Are you sure you want to delete this entire block of fields? This cannot be undone.", this);
|
|
return true;
|
|
}
|
|
else if(evt.caller is addHookButton) {
|
|
addHook();
|
|
setExpanded(true);
|
|
return true;
|
|
}
|
|
else if(evt.caller is editButton) {
|
|
if(blockType.editMode == "research_grid") {
|
|
auto@ tab = createResearchEditor(getBasename(fname), text.text);
|
|
newTab(tab);
|
|
switchToTab(tab);
|
|
}
|
|
return true;
|
|
}
|
|
else if(evt.caller is label) {
|
|
setExpanded(!expanded);
|
|
return true;
|
|
}
|
|
else if(cast<HookField>(evt.caller.parent) !is null) {
|
|
auto@ hf = cast<HookField>(evt.caller.parent);
|
|
if(evt.caller is hf.resetButton) {
|
|
removeHook(hf);
|
|
return true;
|
|
}
|
|
}
|
|
else {
|
|
for(uint i = 0, cnt = addBlockButtons.length; i < cnt; ++i) {
|
|
if(evt.caller is addBlockButtons[i]) {
|
|
addBlock(blockType.blocks[i]);
|
|
setExpanded(true);
|
|
return true;
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = addFieldButtons.length; i < cnt; ++i) {
|
|
if(evt.caller is addFieldButtons[i]) {
|
|
addField(addFields[i]);
|
|
setExpanded(true);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(evt.caller is text) {
|
|
if(evt.type == GUI_Changed) {
|
|
changed = true;
|
|
checkDuplicates();
|
|
return true;
|
|
}
|
|
if(evt.type == GUI_Focus_Lost) {
|
|
if(changed) {
|
|
emitConfirmed();
|
|
checkDuplicates();
|
|
changed = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return BaseGuiElement::onGuiEvent(evt);
|
|
}
|
|
|
|
void addHook() {
|
|
LineDesc line;
|
|
line.line = "";
|
|
line.isKey = false;
|
|
insertLine(line);
|
|
|
|
HookField fld(this, recti());
|
|
fld.hookType = blockType.hookType;
|
|
fld.hookModule = blockType.hookModule;
|
|
fld.visible = expanded;
|
|
|
|
FieldInfo inf;
|
|
@inf.line = line;
|
|
@inf.elem = fld;
|
|
|
|
hooks.insertLast(inf);
|
|
|
|
emitConfirmed();
|
|
openHookList(fld);
|
|
}
|
|
|
|
void removeHook(HookField@ fld) {
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
|
|
auto@ hook = hooks[i];
|
|
if(fld is hook.elem) {
|
|
if(hook.line !is null)
|
|
file.lines.remove(hook.line);
|
|
hook.elem.remove();
|
|
hooks.removeAt(i);
|
|
emitConfirmed();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void addField(FieldDef@ fDef) {
|
|
FieldInfo inf;
|
|
@inf.line = null;
|
|
@inf.elem = makeField(fDef, this, recti());
|
|
@inf.def = fDef;
|
|
inf.elem.set(fDef.key, fDef.doc, fDef.defaultValue, fDef.icon);
|
|
inf.elem.value = fDef.defaultValue;
|
|
inf.elem.tabIndex = fields.length * 10;
|
|
inf.elem.visible = expanded;
|
|
|
|
fields.insertLast(inf);
|
|
emitConfirmed();
|
|
inf.elem.focus();
|
|
}
|
|
|
|
void addBlock(BlockDef@ type) {
|
|
BlockEditor@ blk = BlockEditor(cast<IGuiElement>(this));
|
|
blk.setType(type);
|
|
|
|
@blk.file = file;
|
|
@blk.headLine = LineDesc();
|
|
if(headLine !is null)
|
|
blk.headLine.indent = headLine.indent+1;
|
|
blk.headLine.key = type.key;
|
|
blk.headLine.isKey = true;
|
|
blk.visible = expanded;
|
|
blk.fname = fname;
|
|
blk.setExpanded(true);
|
|
insertLine(blk.headLine);
|
|
|
|
for(uint i = 0, cnt = type.fields.length; i < cnt; ++i) {
|
|
auto@ fDef = type.fields[i];
|
|
if(fDef.repeatable)
|
|
continue;
|
|
FieldInfo inf;
|
|
@inf.line = null;
|
|
@inf.elem = makeField(fDef, blk, recti());
|
|
@inf.def = fDef;
|
|
inf.elem.set(fDef.key, fDef.doc, fDef.defaultValue, fDef.icon);
|
|
inf.elem.value = fDef.defaultValue;
|
|
inf.elem.tabIndex = blk.fields.length * 10;
|
|
inf.elem.visible = blk.expanded;
|
|
|
|
blk.fields.insertLast(inf);
|
|
}
|
|
|
|
blocks.insertLast(blk);
|
|
|
|
emitConfirmed();
|
|
blk.text.focus();
|
|
}
|
|
|
|
void removeBlock() {
|
|
auto@ upper = cast<BlockEditor>(parent);
|
|
if(upper !is null)
|
|
upper.removeBlock(this);
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
if(fields[i].line !is null)
|
|
file.lines.remove(fields[i].line);
|
|
}
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
|
|
if(hooks[i].line !is null)
|
|
file.lines.remove(hooks[i].line);
|
|
}
|
|
for(uint i = 0, cnt = extraLines.length; i < cnt; ++i) {
|
|
file.lines.remove(extraLines[i]);
|
|
}
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i) {
|
|
blocks[i].removeBlock();
|
|
--i; --cnt;
|
|
}
|
|
if(headLine !is null)
|
|
file.lines.remove(headLine);
|
|
remove();
|
|
emitConfirmed();
|
|
}
|
|
|
|
void removeBlock(BlockEditor@ blk) {
|
|
blocks.remove(blk);
|
|
}
|
|
|
|
void questionCallback(QuestionDialog@ dialog, int answer) {
|
|
if(answer == QA_Yes) {
|
|
auto@ p = cast<BaseGuiElement>(parent);
|
|
removeBlock();
|
|
p.emitConfirmed();
|
|
}
|
|
}
|
|
|
|
void commit() {
|
|
int indent = 0;
|
|
if(headLine !is null) {
|
|
indent = headLine.indent;
|
|
headLine.value = text.text;
|
|
}
|
|
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
auto@ inf = fields[i];
|
|
string value = inf.elem.value;
|
|
if(value != inf.def.defaultValue || (inf.hasOriginal && value == inf.originalValue)) {
|
|
bool newLine = false;
|
|
if(inf.line is null) {
|
|
//Create a new line for the field
|
|
@inf.line = LineDesc();
|
|
newLine = true;
|
|
}
|
|
|
|
inf.line.indent = indent+1;
|
|
inf.line.isEmpty = false;
|
|
|
|
if(inf.def.fullLine) {
|
|
inf.line.isKey = false;
|
|
inf.line.line = value;
|
|
}
|
|
else {
|
|
inf.line.isKey = true;
|
|
inf.line.key = inf.def.key;
|
|
inf.line.value = value;
|
|
}
|
|
|
|
if(newLine)
|
|
insertLine(inf.line, inf.def.fieldPriority);
|
|
}
|
|
else {
|
|
if(inf.line !is null) {
|
|
file.lines.remove(inf.line);
|
|
@inf.line = null;
|
|
}
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i)
|
|
blocks[i].commit();
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
|
|
auto@ inf = hooks[i];
|
|
if(inf.line !is null) {
|
|
inf.line.isKey = false;
|
|
inf.line.isEmpty = false;
|
|
if(blockType !is null && blockType.hookPrefix.length != 0)
|
|
inf.line.line = blockType.hookPrefix+inf.elem.value;
|
|
else
|
|
inf.line.line = inf.elem.value;
|
|
inf.line.indent = indent+1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void setType(BlockDef@ def) {
|
|
@blockType = def;
|
|
label.visible = blockType.key.length != 0;
|
|
removeButton.visible = label.visible;
|
|
text.visible = label.visible && blockType.hasIdentifier;
|
|
label.text = blockType.key+":";
|
|
setMarkupTooltip(label, blockType.doc);
|
|
|
|
if(blockType.identifierLimit)
|
|
text.setIdentifierLimit();
|
|
else
|
|
text.characterLimit.clear();
|
|
|
|
if(blockType.hookType.length != 0) {
|
|
@addHookButton = GuiButton(this, recti(), "Add Hook");
|
|
addHookButton.visible = expanded;
|
|
}
|
|
if(blockType.editMode.length != 0) {
|
|
@editButton = GuiButton(this, recti(), "Edit");
|
|
editButton.color = Color(0x80ff80ff);
|
|
editButton.font = FT_Bold;
|
|
editButton.visible = expanded;
|
|
}
|
|
for(uint i = 0, cnt = blockType.blocks.length; i < cnt; ++i) {
|
|
GuiButton btn(this, recti());
|
|
btn.text = "Add "+blockType.blocks[i].key;
|
|
btn.visible = expanded;
|
|
setMarkupTooltip(btn, blockType.blocks[i].doc);
|
|
addBlockButtons.insertLast(btn);
|
|
}
|
|
for(uint i = 0, cnt = blockType.fields.length; i < cnt; ++i) {
|
|
auto@ fDef = blockType.fields[i];
|
|
if(!fDef.repeatable)
|
|
continue;
|
|
GuiButton btn(this, recti());
|
|
btn.text = "Add "+fDef.key;
|
|
btn.visible = expanded;
|
|
setMarkupTooltip(btn, fDef.doc);
|
|
addFieldButtons.insertLast(btn);
|
|
addFields.insertLast(fDef);
|
|
}
|
|
}
|
|
|
|
uint parseBlock(FileDesc@ file, array<LineDesc@>& lines, int pos, BlockDef@ def) {
|
|
clear();
|
|
@this.file = file;
|
|
setType(def);
|
|
|
|
int indent = -1;
|
|
if(pos >= 0) {
|
|
@headLine = lines[pos];
|
|
indent = headLine.indent;
|
|
text.text = headLine.value;
|
|
}
|
|
else {
|
|
@headLine = null;
|
|
text.text = "";
|
|
}
|
|
|
|
array<bool> haveFields(def.fields.length, false);
|
|
pos += 1;
|
|
for(int cnt = int(lines.length); pos < cnt; ++pos) {
|
|
auto@ line = lines[pos];
|
|
if(line.isEmpty) {
|
|
extraLines.insertLast(line);
|
|
continue;
|
|
}
|
|
if(int(line.indent) <= indent) {
|
|
pos -= 1;
|
|
break;
|
|
}
|
|
|
|
//Check if the line is associated with a field
|
|
auto@ fDef = def.getField(line.key);
|
|
if(fDef is null)
|
|
@fDef = def.getField(line);
|
|
if(fDef !is null) {
|
|
FieldInfo inf;
|
|
@inf.line = line;
|
|
@inf.elem = makeField(fDef, this, recti());
|
|
@inf.def = fDef;
|
|
inf.elem.set(fDef.key, fDef.doc, fDef.defaultValue, fDef.icon);
|
|
inf.elem.value = fDef.fullLine ? line.line : line.value;
|
|
inf.elem.tabIndex = fields.length * 10;
|
|
inf.elem.visible = expanded;
|
|
inf.hasOriginal = true;
|
|
inf.originalValue = inf.elem.value;
|
|
|
|
fields.insertLast(inf);
|
|
haveFields[fDef.index] = true;
|
|
continue;
|
|
}
|
|
|
|
//Check if the line is associated with a block
|
|
auto@ blockDef = def.getBlock(line.key);
|
|
if(blockDef !is null) {
|
|
BlockEditor@ blk = BlockEditor(cast<IGuiElement>(this)); //What the shit angelscript?
|
|
pos = blk.parseBlock(file, lines, pos, blockDef);
|
|
blk.visible = expanded;
|
|
blk.fname = fname;
|
|
blk.setExpanded(!blockDef.closeDefault);
|
|
blocks.insertLast(blk);
|
|
continue;
|
|
}
|
|
|
|
//Find hooks
|
|
if(def.hookType.length != 0) {
|
|
string str = line.line;
|
|
if(line.isKey)
|
|
str = line.key+":"+line.value;
|
|
if(def.hookPrefix.length != 0 && str.trimmed().startswith_nocase(def.hookPrefix.trimmed()))
|
|
str = str.trimmed().substr(def.hookPrefix.trimmed().length).trimmed();
|
|
|
|
if(str.findFirst("(") != -1) {
|
|
line.line = str;
|
|
line.isKey = false;
|
|
|
|
HookField fld(this, recti());
|
|
fld.hookType = def.hookType;
|
|
fld.hookModule = def.hookModule;
|
|
fld.value = str;
|
|
fld.visible = expanded;
|
|
|
|
FieldInfo inf;
|
|
@inf.line = line;
|
|
@inf.elem = fld;
|
|
|
|
hooks.insertLast(inf);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//Remember the line as spurious for this block
|
|
extraLines.insertLast(line);
|
|
}
|
|
|
|
for(uint i = 0, cnt = haveFields.length; i < cnt; ++i) {
|
|
if(haveFields[i])
|
|
continue;
|
|
auto@ fDef = def.fields[i];
|
|
if(fDef.repeatable)
|
|
continue;
|
|
FieldInfo inf;
|
|
@inf.line = null;
|
|
@inf.elem = makeField(fDef, this, recti());
|
|
@inf.def = fDef;
|
|
inf.elem.set(fDef.key, fDef.doc, fDef.defaultValue, fDef.icon);
|
|
inf.elem.value = fDef.defaultValue;
|
|
inf.elem.tabIndex = fields.length * 10;
|
|
inf.elem.visible = expanded;
|
|
|
|
fields.insertLast(inf);
|
|
}
|
|
|
|
checkDuplicates();
|
|
return pos;
|
|
}
|
|
|
|
uint get_needHeight() {
|
|
int h = text !is null && label.visible ? 44 : 0;
|
|
if(expanded) {
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i)
|
|
h += fields[i].elem.needHeight;
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i)
|
|
h += blocks[i].needHeight;
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
|
|
h += hooks[i].elem.needHeight;
|
|
if(btnCount != 0)
|
|
h += 44 * (btnCount/6+1);
|
|
}
|
|
return h;
|
|
}
|
|
|
|
uint get_btnCount() {
|
|
uint cnt = 0;
|
|
if(addHookButton !is null)
|
|
cnt += 1;
|
|
if(editButton !is null)
|
|
cnt += 1;
|
|
cnt += addBlockButtons.length;
|
|
cnt += addFieldButtons.length;
|
|
return cnt;
|
|
}
|
|
|
|
void updateAbsolutePosition() {
|
|
int blockOff = 0;
|
|
if(cast<BlockEditor>(parent) is null) {
|
|
size = vec2i(parent.size.width-20, needHeight);
|
|
blockOff = -30;
|
|
}
|
|
|
|
int y = text !is null && label.visible ? 44 : 0;
|
|
if(expanded) {
|
|
for(uint i = 0, cnt = fields.length; i < cnt; ++i) {
|
|
auto@ fld = fields[i].elem;
|
|
int h = fld.needHeight;
|
|
fld.size = vec2i(size.width, h);
|
|
fld.position = vec2i(0, y);
|
|
y += h;
|
|
}
|
|
|
|
for(uint i = 0, cnt = blocks.length; i < cnt; ++i) {
|
|
auto@ blk = blocks[i];
|
|
int h = blk.needHeight;
|
|
blk.size = vec2i(size.width-blockOff-30, h);
|
|
blk.position = vec2i(blockOff+30, y);
|
|
y += h;
|
|
}
|
|
|
|
for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
|
|
auto@ fld = hooks[i].elem;
|
|
int h = fld.needHeight;
|
|
fld.size = vec2i(size.width, h);
|
|
fld.position = vec2i(0, y);
|
|
y += h;
|
|
}
|
|
|
|
if(btnCount != 0) {
|
|
int btnWidth = min(220, size.width/min(btnCount,6));
|
|
int btnOff = (size.width-(min(btnCount,6) * btnWidth)) / 2;
|
|
int btnOrig = btnOff;
|
|
uint n = 0;
|
|
if(editButton !is null) {
|
|
editButton.size = vec2i(btnWidth, 36);
|
|
editButton.position = vec2i(btnOff, y+4);
|
|
n += 1;
|
|
y += 44;
|
|
btnOff = btnOrig;
|
|
}
|
|
if(addHookButton !is null) {
|
|
addHookButton.size = vec2i(btnWidth, 36);
|
|
addHookButton.position = vec2i(btnOff, y+4);
|
|
btnOff += btnWidth + 8;
|
|
n += 1;
|
|
if(n % 6 == 0) { btnOff = btnOrig; y += 44; }
|
|
}
|
|
for(uint i = 0, cnt = addFieldButtons.length; i < cnt; ++i) {
|
|
addFieldButtons[i].size = vec2i(btnWidth, 36);
|
|
addFieldButtons[i].position = vec2i(btnOff, y+4);
|
|
btnOff += btnWidth + 8;
|
|
n += 1;
|
|
if(n % 6 == 0) { btnOff = btnOrig; y += 44; }
|
|
}
|
|
for(uint i = 0, cnt = addBlockButtons.length; i < cnt; ++i) {
|
|
addBlockButtons[i].size = vec2i(btnWidth, 36);
|
|
addBlockButtons[i].position = vec2i(btnOff, y+4);
|
|
btnOff += btnWidth + 8;
|
|
n += 1;
|
|
if(n % 6 == 0) { btnOff = btnOrig; y += 44; }
|
|
}
|
|
}
|
|
}
|
|
|
|
if(Parent !is null) {
|
|
if(Alignment !is null) {
|
|
Position = Alignment.resolve(Parent.updatePosition.size);
|
|
ClipRect = recti(vec2i(), Position.size);
|
|
}
|
|
|
|
AbsolutePosition = Position + Parent.updatePosition.topLeft;
|
|
AbsoluteClipRect = (ClipRect + AbsolutePosition.topLeft).clipAgainst(Parent.absoluteClipRect);
|
|
}
|
|
else {
|
|
if(Alignment !is null) {
|
|
Position = Alignment.resolve(screenSize);
|
|
ClipRect = recti(vec2i(), Position.size);
|
|
}
|
|
|
|
AbsolutePosition = Position;
|
|
AbsoluteClipRect = ClipRect + Position.topLeft;
|
|
}
|
|
|
|
if(noClip)
|
|
AbsoluteClipRect = AbsolutePosition;
|
|
|
|
if(expanded) {
|
|
uint cCnt = Children.length();
|
|
for(uint i = 0; i != cCnt; ++i)
|
|
Children[i].updateAbsolutePosition();
|
|
}
|
|
else if(removeButton !is null) {
|
|
label.updateAbsolutePosition();
|
|
text.updateAbsolutePosition();
|
|
removeButton.updateAbsolutePosition();
|
|
}
|
|
}
|
|
|
|
void draw() {
|
|
if(text !is null && label.visible)
|
|
skin.draw(SS_HorizBar, SF_Normal, recti_area(AbsolutePosition.topLeft, vec2i(size.width, 44)));
|
|
if(btnCount != 0 && expanded) {
|
|
int bH = (btnCount/6+1)*44;
|
|
skin.draw(SS_PlainBox, SF_Normal, recti_area(vec2i(AbsolutePosition.topLeft.x, AbsolutePosition.botRight.y-bH), vec2i(size.width, bH)));
|
|
}
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
class EditorTab : Tab, IInputDialogCallback, QuestionDialogCallback {
|
|
GuiPanel@ editPanel;
|
|
BlockEditor@ editor;
|
|
FileDesc baseFile;
|
|
|
|
GuiPanel@ filePanel;
|
|
FileFolder@ files;
|
|
|
|
GuiButton@ newFile;
|
|
GuiButton@ deleteFile;
|
|
GuiButton@ duplicateFile;
|
|
|
|
string folder;
|
|
string loadedFile;
|
|
FileDef@ type;
|
|
bool duplicate = false;
|
|
|
|
EditorTab(const string& folder, FileDef@ type) {
|
|
this.folder = folder;
|
|
@this.type = type;
|
|
super();
|
|
title = folder;
|
|
initCompletions();
|
|
|
|
int y = 12;
|
|
if(type.defaultBlock.doc.length != 0) {
|
|
GuiMarkupText txt(this, recti_area(312,12,900,100));
|
|
txt.text = type.defaultBlock.doc;
|
|
txt.updateAbsolutePosition();
|
|
y += txt.size.height+8;
|
|
}
|
|
|
|
@editPanel = GuiPanel(this, Alignment(Left+300, Top+y, Right, Bottom));
|
|
|
|
@filePanel = GuiPanel(this, Alignment(Left, Top, Left+300, Bottom-36));
|
|
@files = FileFolder(filePanel, recti());
|
|
files.load(folder, extension=".txt");
|
|
|
|
@newFile = GuiButton(this, Alignment(Left, Bottom-36, Left+100, Bottom), "New");
|
|
newFile.setIcon(icons::Create);
|
|
newFile.color = colors::Green;
|
|
|
|
@duplicateFile = GuiButton(this, Alignment(Left+100, Bottom-36, Left+200, Bottom), "Duplicate");
|
|
duplicateFile.setIcon(icons::Export);
|
|
duplicateFile.disabled = true;
|
|
duplicateFile.color = Color(0x0080ffff);
|
|
|
|
@deleteFile = GuiButton(this, Alignment(Left+200, Bottom-36, Left+300, Bottom), "Delete");
|
|
deleteFile.setIcon(icons::Delete);
|
|
deleteFile.color = colors::Red;
|
|
deleteFile.disabled = true;
|
|
|
|
updateAbsolutePosition();
|
|
}
|
|
|
|
Color get_activeColor() {
|
|
return Color(0xd482ffff);
|
|
}
|
|
|
|
Color get_inactiveColor() {
|
|
return Color(0xa800ffff);
|
|
}
|
|
|
|
Color get_seperatorColor() {
|
|
return Color(0x75488dff);
|
|
}
|
|
|
|
Sprite get_icon() {
|
|
return icons::Paint;
|
|
}
|
|
|
|
void ensureFile(const string& path) {
|
|
string dir = path_up(path);
|
|
array<string> folders;
|
|
while(!fileExists(dir) && dir.length != 0) {
|
|
folders.insertLast(dir);
|
|
dir = path_up(dir);
|
|
}
|
|
for(int i = int(folders.length-1); i >= 0; --i)
|
|
makeDirectory(folders[i]);
|
|
}
|
|
|
|
void checkEmptyDirectory(const string& path) {
|
|
string dir = path;
|
|
while(path_inside(topMod.abspath, dir) && topMod.abspath != dir) {
|
|
if(isDirectory(dir)) {
|
|
FileList list(dir, "*", false, false);
|
|
if(list.length != 0)
|
|
break;
|
|
::deleteFile(dir);
|
|
}
|
|
dir = path_up(dir);
|
|
}
|
|
}
|
|
|
|
void inputCallback(InputDialog@ dialog, bool accepted) {
|
|
if(accepted) {
|
|
loadedFile = path_join(folder, dialog.getTextInput(0));
|
|
if(!loadedFile.endswith(".txt"))
|
|
loadedFile += ".txt";
|
|
title = getBasename(loadedFile);
|
|
|
|
{
|
|
string path = path_join(topMod.abspath, loadedFile);
|
|
ensureFile(path);
|
|
if(duplicate) {
|
|
for(uint i = 0, cnt = editor.blocks.length; i < cnt; ++i) {
|
|
if(editor.blocks[i].text.text.length != 0)
|
|
editor.blocks[i].text.text = "DUPLICATE_"+editor.blocks[i].text.text;
|
|
}
|
|
editor.commit();
|
|
editor.file.save(path);
|
|
}
|
|
else {
|
|
WriteFile file(path);
|
|
}
|
|
}
|
|
|
|
files.load(folder, extension=".txt");
|
|
files.select(loadedFile);
|
|
}
|
|
}
|
|
void changeCallback(InputDialog@ dialog) {}
|
|
|
|
void questionCallback(QuestionDialog@ dialog, int answer) {
|
|
if(answer == QA_Yes) {
|
|
string path = path_join(topMod.abspath, loadedFile);
|
|
if(fileExists(path)) {
|
|
::deleteFile(path);
|
|
checkEmptyDirectory(path);
|
|
}
|
|
deleteFile.disabled = true;
|
|
duplicateFile.disabled = true;
|
|
if(editor !is null) {
|
|
editor.remove();
|
|
@editor = null;
|
|
}
|
|
type.onChange();
|
|
files.load(folder, extension=".txt");
|
|
}
|
|
}
|
|
|
|
void updateRevertButton() {
|
|
deleteFile.disabled = loadedFile.length == 0 || !fileExists(path_join(topMod.abspath, loadedFile));
|
|
if(currentMod !is topMod && fileExists(path_join(currentMod.abspath, loadedFile))) {
|
|
deleteFile.text = "Revert";
|
|
deleteFile.color = Color(0xff8000ff);
|
|
setMarkupTooltip(deleteFile, "Revert the selected file back to the version from the base game.");
|
|
}
|
|
else {
|
|
deleteFile.text = "Delete";
|
|
deleteFile.color = Color(0xff8000ff);
|
|
setMarkupTooltip(deleteFile, "Delete this file completely from the game.");
|
|
}
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& evt) override {
|
|
if(evt.type == GUI_Confirmed) {
|
|
if(evt.caller is files) {
|
|
setGuiFocus(this);
|
|
loadedFile = files.getSelection().basePath;
|
|
title = getBasename(loadedFile);
|
|
if(editor !is null)
|
|
editor.remove();
|
|
@editor = BlockEditor(editPanel);
|
|
editor.parse(resolve(loadedFile), type);
|
|
baseFile.load(path_join(currentMod.abspath, loadedFile));
|
|
editPanel.updateAbsolutePosition();
|
|
duplicateFile.disabled = false;
|
|
updateRevertButton();
|
|
}
|
|
else if(editor !is null) {
|
|
editor.commit();
|
|
string path = path_join(topMod.abspath, loadedFile);
|
|
bool existed = fileExists(path);
|
|
if(baseFile.exists && topMod !is baseMod && baseFile == editor.file) {
|
|
if(existed) {
|
|
::deleteFile(path);
|
|
checkEmptyDirectory(path);
|
|
existed = false;
|
|
}
|
|
}
|
|
else {
|
|
ensureFile(path);
|
|
editor.file.save(path);
|
|
}
|
|
type.onChange();
|
|
editPanel.updateAbsolutePosition();
|
|
if(!existed) {
|
|
files.load(folder, extension=".txt");
|
|
files.select(loadedFile, bubble=false);
|
|
}
|
|
updateRevertButton();
|
|
}
|
|
}
|
|
if(evt.type == GUI_Changed && cast<BlockEditor>(evt.caller) !is null) {
|
|
editPanel.updateAbsolutePosition();
|
|
return true;
|
|
}
|
|
if(evt.type == GUI_Clicked) {
|
|
if(evt.caller is newFile) {
|
|
string defname;
|
|
auto@ sel = files.getSelection();
|
|
if(sel !is null) {
|
|
defname = path_up(sel.basePath.substr(folder.length+1));
|
|
if(defname.length != 0)
|
|
defname = path_join(defname, "");
|
|
}
|
|
|
|
duplicate = false;
|
|
InputDialog@ dialog = InputDialog(this, this);
|
|
dialog.addTitle("Create File");
|
|
dialog.accept.text = "Create";
|
|
dialog.addTextInput("Filename", defname);
|
|
|
|
addDialog(dialog);
|
|
dialog.focusInput();
|
|
return true;
|
|
}
|
|
else if(evt.caller is duplicateFile) {
|
|
string defname;
|
|
auto@ sel = files.getSelection();
|
|
if(sel !is null) {
|
|
defname = path_up(sel.basePath.substr(folder.length+1));
|
|
if(defname.length != 0)
|
|
defname = path_join(defname, "");
|
|
}
|
|
|
|
duplicate = true;
|
|
InputDialog@ dialog = InputDialog(this, this);
|
|
dialog.addTitle("Duplicate File");
|
|
dialog.accept.text = "Duplicate";
|
|
dialog.addTextInput("Filename", defname);
|
|
|
|
addDialog(dialog);
|
|
dialog.focusInput();
|
|
return true;
|
|
}
|
|
else if(evt.caller is deleteFile) {
|
|
question("Are you sure you wish to delete "+loadedFile+" from the mod? This cannot be undone.\n\nIf the file consisted of changes to a base mod file, deleting the file from your mod will revert the changes back to the original version.", this);
|
|
return true;
|
|
}
|
|
}
|
|
return Tab::onGuiEvent(evt);
|
|
}
|
|
|
|
void draw() {
|
|
skin.draw(SS_DesignOverviewBG, SF_Normal, AbsolutePosition);
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
Tab@ createEditorTab(const string& folder, FileDef@ type) {
|
|
return EditorTab(folder, type);
|
|
}
|
|
|
|
Tab@ createEditorTab(const string& file) {
|
|
string folder;
|
|
FileDef@ type;
|
|
for(uint i = 0, cnt = fileFolders.length; i < cnt; ++i) {
|
|
if(path_inside(fileFolders[i], file)) {
|
|
folder = fileFolders[i];
|
|
@type = cast<FileDef>(getClass(fileTypes[i]).create());
|
|
break;
|
|
}
|
|
}
|
|
if(type is null)
|
|
return null;
|
|
EditorTab tab(folder, type);
|
|
tab.files.select(file);
|
|
return tab;
|
|
}
|
|
|
|
array<string> fileClasses = {"statuses", "abilities", "anomalies", "artifacts", "influence", "research", "resources", "buildings", "biomes", "creeps", "orbitals", "traits", "subsystems", "effectors", "materials", "sounds", "constructions", "random_events", "cargo", "attitudes"};
|
|
array<string> fileFolders = {"data/statuses", "data/abilities", "data/anomalies", "data/artifacts", "data/influence", "data/research", "data/resources", "data/buildings", "data/biomes", "data/creeps", "data/orbitals", "data/traits", "data/subsystems", "data/effectors", "data/materials", "data/sounds", "data/constructions", "data/random_events", "data/cargo", "data/attitudes"};
|
|
array<string> fileTypes = {"StatusFile", "AbilityFile", "AnomalyFile", "ArtifactFile", "InfluenceFile", "ResearchFile", "ResourceFile", "BuildingFile", "BiomeFile", "CreepFile", "OrbitalFile", "TraitFile", "SubsystemFile", "EffectorFile", "MaterialFile", "SoundFile", "ConstructionFile", "EventFile", "CargoFile", "AttitudeFile"};
|
|
|
|
class ModEditorCommand : ConsoleCommand {
|
|
void execute(const string& args) {
|
|
int found = -1;
|
|
string check = args.trimmed();
|
|
for(uint i = 0, cnt = fileClasses.length; i < cnt; ++i) {
|
|
if(fileClasses[i].equals_nocase(check)) {
|
|
found = int(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(found == -1) {
|
|
print("Usage: mod_editor <class>\nSpecify one of the following classes of data files to edit:\n");
|
|
for(uint i = 0, cnt = fileClasses.length; i < cnt; ++i) {
|
|
print(" "+fileClasses[i]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
auto@ tab = createEditorTab(fileFolders[found], cast<FileDef>(getClass(fileTypes[found]).create()));
|
|
newTab(tab);
|
|
switchToTab(tab);
|
|
}
|
|
};
|
|
|
|
bool canEditFile(const string& basePath) {
|
|
if(!basePath.endswith(".txt"))
|
|
return false;
|
|
for(uint i = 0, cnt = fileFolders.length; i < cnt; ++i) {
|
|
if(path_inside(fileFolders[i], basePath)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
string getLocaleFile(IGuiElement@ elem) {
|
|
for(uint i = 0, cnt = tabCount; i < cnt; ++i) {
|
|
auto@ tab = cast<EditorTab>(tabs[i]);
|
|
if(tab !is null) {
|
|
if(elem.isChildOf(tab)) {
|
|
return tab.type.localeFile;
|
|
}
|
|
}
|
|
|
|
}
|
|
auto@ tab = cast<EditorTab>(ActiveTab);
|
|
if(tab !is null)
|
|
return tab.type.localeFile;
|
|
return "misc.txt";
|
|
}
|
|
|
|
void init() {
|
|
addConsoleCommand("mod_editor", ModEditorCommand());
|
|
|
|
/*auto@ tab = createEditorTab("data/subsystems", SubsystemFile());*/
|
|
/*newTab(tab);*/
|
|
/*switchToTab(tab);*/
|
|
}
|
|
|
|
void fillTargetsFromTab(Field@ sourceField, TargetChooser@ fld) {
|
|
auto@ tab = cast<EditorTab>(ActiveTab);
|
|
if(tab !is null) {
|
|
if(tab.editor !is null)
|
|
tab.editor.fillTargets(sourceField, fld);
|
|
}
|
|
}
|