protected static void FireRecordDeleted(object sender, BaseRecord rec)
{
if (!HoldUpdates && RecordDeleted != null)
{
RecordDeleted(sender, new RecordChangeEventArgs(rec));
}
}
protected static void FireRecordListUpdate(object sender, BaseRecord rec)
{
if (!HoldUpdates && ChildListChanged != null)
{
ChildListChanged(sender, new RecordChangeEventArgs(rec));
}
}
private bool findDuplicateFormIDs(BaseRecord tn, Dictionary <uint, Record> ids)
{
if (tn is Record)
{
var r2 = (Record)tn;
if (ids.ContainsKey(r2.FormID))
{
PluginTree.SelectedRecord = tn;
MessageBox.Show("Record duplicates " + (ids[r2.FormID]).DescriptiveName);
ids.Clear();
return(true);
}
else
{
ids.Add(r2.FormID, r2);
}
}
else
{
foreach (BaseRecord tn2 in tn.Records)
{
findDuplicateFormIDs(tn2, ids);
}
}
return(false);
}
public static Plugin GetPluginFromNode(BaseRecord node)
{
BaseRecord tn = node;
if (tn is Plugin) return (Plugin)tn;
while (!(tn is Plugin) && tn != null) tn = tn.Parent;
if (tn != null) return tn as Plugin;
return null;
}
public override void InsertRecord(int idx, BaseRecord br)
{
var r = br as Plugin;
r.Parent = this;
if (idx < 0 || idx > pluginList.Count)
idx = pluginList.Count;
pluginList.Insert(idx, r);
FireRecordListUpdate(this, null);
}
private bool IsNonConformingRecord(BaseRecord tn)
{
if (tn is Record)
{
var r = tn as Record;
return(r != null && !r.MatchRecordStructureToRecord());
}
return(false);
}
public override void InsertRecord(int idx, BaseRecord br)
{
var sr = br as SubRecord;
if (sr == null)
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Records can only hold Subrecords.");
sr.Parent = this;
SubRecords.Insert(idx, sr);
}
public override void AddRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null)
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Groups can only hold records or other groups.");
r.Parent = this;
records.Add(r);
FireRecordListUpdate(this, this);
}
internal bool findNonConformingRecordIncremental(BaseRecord tn, bool forward, bool wrapAround)
{
var node = IncrementalSearch(tn, false, forward, wrapAround, IsNonConformingRecord);
if (node != null)
{
PluginTree.SelectedRecord = node;
}
return(node != null);
}
public override bool DeleteRecord(BaseRecord br)
{
var sr = br as SubRecord;
if (sr == null)
{
return(false);
}
return(SubRecords.Remove(sr));
}
public override bool DeleteRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null) return false;
bool ok = records.Remove(r);
if (ok) r.Parent = null;
FireRecordListUpdate(this, this);
FireRecordDeleted(this, r);
return ok;
}
public override void AddRecord(BaseRecord br)
{
var p = br as Plugin;
if (p != null)
{
p.Parent = this;
pluginList.Add(p);
}
FireRecordListUpdate(this, null);
}
public override bool DeleteRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null) return false;
bool result = records.Remove(r);
if (result) r.Parent = null;
InvalidateCache();
FireRecordDeleted(this, r);
FireRecordListUpdate(this, this);
return result;
}
public override void AddRecord(BaseRecord br)
{
var p = br as Plugin;
if (p != null)
{
p.Parent = this;
pluginList.Add(p);
}
FireRecordListUpdate(this, null);
}
public override void AddRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null)
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Plugins can only hold Groups or Records.");
r.Parent = this;
records.Add(r);
InvalidateCache();
FireRecordListUpdate(this, this);
}
public override bool DeleteRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null) return false;
bool result = records.Remove(r);
if (result) r.Parent = null;
InvalidateCache();
FireRecordDeleted(this, r);
FireRecordListUpdate(this, this);
return result;
}
public override bool DeleteRecord(BaseRecord br)
{
var p = br as Plugin;
if (p != null)
{
p.Parent = null;
bool ok = pluginList.Remove(p);
FireRecordListUpdate(this, this);
return ok;
}
return false;
}
public override void InsertRecord(int idx, BaseRecord br)
{
var r = br as Plugin;
r.Parent = this;
if (idx < 0 || idx > pluginList.Count)
{
idx = pluginList.Count;
}
pluginList.Insert(idx, r);
FireRecordListUpdate(this, null);
}
public SearchSettings()
{
type = SearchType.EditorID;
startNode = null;
text = null;
first = true;
partial = true;
forward = true;
wrapAround = true;
updateFunc = null;
rectype = null;
}
public override void InsertRecord(int idx, BaseRecord br)
{
var sr = br as SubRecord;
if (sr == null)
{
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Records can only hold Subrecords.");
}
sr.Parent = this;
SubRecords.Insert(idx, sr);
}
public override void InsertRecord(int idx, BaseRecord br)
{
var r = br as Rec;
if (r == null)
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Groups can only hold records or other groups.");
r.Parent = this;
if (idx < 0 || idx > records.Count)
idx = records.Count;
records.Insert(idx, r);
FireRecordListUpdate(this, this);
}
public override void AddRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null)
{
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Groups can only hold records or other groups.");
}
r.Parent = this;
records.Add(r);
FireRecordListUpdate(this, this);
}
public override void InsertRecord(int idx, BaseRecord br)
{
var r = br as Rec;
if (r == null)
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Plugins can only hold Groups or Records.");
r.Parent = this;
if (idx < 0 || idx > records.Count)
idx = records.Count;
records.Insert(idx, r);
InvalidateCache();
FireRecordListUpdate(this, this);
}
public override bool DeleteRecord(BaseRecord br)
{
var p = br as Plugin;
if (p != null)
{
p.Parent = null;
bool ok = pluginList.Remove(p);
FireRecordListUpdate(this, this);
return(ok);
}
return(false);
}
public Plugin GetPlugin()
{
BaseRecord tn = this.Parent;
while (!(tn is Plugin) && tn != null)
{
tn = tn.Parent;
}
if (tn != null)
{
return(tn as Plugin);
}
return(null);
}
public static void giveBaseRecordNewFormID(BaseRecord rec, bool updateReference, ref uint formCount, ref uint refCount)
{
if (rec is Record)
{
giveRecordNewFormID((Record)rec, updateReference, ref formCount, ref refCount);
}
else if (rec is GroupRecord)
{
foreach (BaseRecord rec2 in ((GroupRecord)rec).Records)
{
giveBaseRecordNewFormID(rec2, updateReference, ref formCount, ref refCount);
}
}
}
public override bool DeleteRecord(BaseRecord br)
{
var r = br as Rec;
if (r == null)
{
return(false);
}
bool ok = records.Remove(r);
if (ok)
{
r.Parent = null;
}
FireRecordListUpdate(this, this);
FireRecordDeleted(this, r);
return(ok);
}
public override void InsertRecord(int idx, BaseRecord br)
{
var r = br as Rec;
if (r == null)
{
throw new TESParserException("Record to add was not of the correct type." +
Environment.NewLine + "Groups can only hold records or other groups.");
}
r.Parent = this;
if (idx < 0 || idx > records.Count)
{
idx = records.Count;
}
records.Insert(idx, r);
FireRecordListUpdate(this, this);
}
internal BaseRecord IncrementalSearch(BaseRecord tn, bool first, bool forward, bool wrapAround,
Predicate <BaseRecord> searchFunc)
{
using (var itr = new RecursiveRecordIterator(tn, forward))
{
BaseRecord startNode = null;
Debug.Assert(tn.Equals(itr.Current));
bool keep = first;
do
{
do
{
tn = itr.Current;
if (keep && searchFunc(tn))
{
return(tn);
}
keep = true;
if (startNode == null)
{
startNode = tn;
}
else if (startNode.Equals(tn))
{
return(null);
}
} while (itr.MoveNext());
if (!wrapAround)
{
break;
}
itr.Push(PluginList.All.Records[0] as BaseRecord);
itr.Reset();
wrapAround = false;// multipass protection
} while (itr.MoveNext());
}
return(null);
}
private bool findDuplicateFormIDs(BaseRecord tn, Dictionary<uint, Record> ids)
{
if (tn is Record)
{
var r2 = (Record)tn;
if (ids.ContainsKey(r2.FormID))
{
PluginTree.SelectedRecord = tn;
MessageBox.Show("Record duplicates " + (ids[r2.FormID]).DescriptiveName);
ids.Clear();
return true;
}
else
{
ids.Add(r2.FormID, r2);
}
}
else
{
foreach (BaseRecord tn2 in tn.Records) findDuplicateFormIDs(tn2, ids);
}
return false;
}
public static void giveBaseRecordNewFormID(BaseRecord rec, bool updateReference)
{
uint formCount = 0, refCount = 0;
giveBaseRecordNewFormID(rec, updateReference, ref formCount, ref refCount);
}
/// <summary>
/// UpdateMainTextforTH
/// </summary>
/// <param name="rec"></param>
public void UpdateMainTextForTH(BaseRecord rec)
{
UpdateMainText(rec);
}
public virtual void InsertRecord(int index, BaseRecord br)
{
AddRecord(br);
}
public override int IndexOf(BaseRecord br)
{
return(records.IndexOf(br as Rec));
}
public virtual int IndexOf(BaseRecord br)
{
return(-1);
}
public abstract bool DeleteRecord(BaseRecord br);
public abstract void AddRecord(BaseRecord br);
public virtual void InsertRecord(int index, BaseRecord br)
{
AddRecord(br);
}
public abstract bool DeleteRecord(BaseRecord br);
public RecordChangeEventArgs(BaseRecord rec)
{
record = rec;
}
public virtual int IndexOf(BaseRecord br)
{
return -1;
}
public static int CopyRecordsTo(BaseRecord[] src, IGroupRecord dst)
{
int count = 0;
if (src != null && dst != null)
{
if (dst is Plugin)
{
var dstRec = src.Where(x => !LooseGroups.Contains(x.Name)).Select(x => x.Clone()).ToArray();
if (dstRec.All(x => x is Record))
{
// put records into appropriate groups
var groups = dst.Records.OfType<GroupRecord>();
var lookup = dstRec.GroupBy(r => r.Name).Select(g => new {key = g.Key, value = g.ToArray()})
.ToLookup(k => k.key, v => v.value);
foreach (var kvp in lookup)
{
if (LooseGroups.Contains(kvp.Key))
{
dst.AddRecords(dstRec);
}
else
{
var gr = groups.FirstOrDefault(x => x.ContentsType == kvp.Key);
if (gr == null)
{
gr = new GroupRecord(kvp.Key);
dst.AddRecord(gr);
}
foreach (var list in kvp)
gr.AddRecords(list);
}
}
}
else
{
dst.AddRecords(dstRec);
}
// handle loose groups by creating copy of parent groups
foreach (var srcRec in src.Where(x => LooseGroups.Contains(x.Name)))
{
var dstnodes = new Stack<BaseRecord>();
dstnodes.Push(srcRec.Clone(recursive: true));
for (var n = srcRec.Parent; n is GroupRecord; n = n.Parent)
dstnodes.Push(n.Clone(recursive: false));
var par = dst as IGroupRecord;
foreach (var baseRecord in dstnodes)
{
if (par == null) break;
if (baseRecord is GroupRecord)
{
var gr = baseRecord as GroupRecord;
var pargr = par.Records.OfType<GroupRecord>().FirstOrDefault(x => x.IsEquivalent(gr));
if (pargr != null)
{
par = pargr;
continue;
}
}
par.AddRecord(baseRecord);
par = baseRecord as IGroupRecord;
}
count += dstnodes.Count;
}
}
else
{
var dstRec = src.Select(x => x.Clone()).ToArray();
dst.AddRecords(dstRec);
count += dstRec.Count();
}
}
return count;
}
protected static void FireRecordListUpdate(object sender, BaseRecord rec)
{
if (!HoldUpdates && ChildListChanged != null)
{
ChildListChanged(sender, new RecordChangeEventArgs(rec));
}
}
private void BackgroundIncrementalSearch(BaseRecord start, bool forward)
{
float totalNodes = PluginList.All.Enumerate(x => x != null).Count();
if (totalNodes == 0)
{
toolStripIncrInvalidRecStatus.Text = "No Plugins Loaded";
toolStripIncrInvalidRecStatus.ForeColor = Color.Maroon;
if (!Properties.Settings.Default.NoWindowsSounds)
{
SystemSounds.Beep.Play();
}
return;
}
int prevCount = 0;
float currentCount = 0.0f;
BaseRecord foundNode = null;
toolStripIncrFindStatus.Text = "";
// Grab selected node before searching as it can only be accessed from UI thread
if (start == null)
{
start = PluginTree.SelectedRecord != null ? PluginTree.SelectedRecord : PluginTree.TopRecord;
}
Predicate <BaseRecord> updateFunc = n =>
{
if (IsBackroundProcessCanceled()) // returning true will stop it
{
return(true);
}
var counter = (int)(++currentCount / totalNodes * 100.0f);
if (counter != prevCount)
{
prevCount = counter;
if (counter % 10 == 0)
{
UpdateBackgroundProgress(counter);
}
}
return(false);
};
var searchContext = new SearchSettings();
var item = toolStripIncrFindType.SelectedItem as ComboHelper <SearchType, string>;
searchContext.startNode = start;
searchContext.type = item.Key;
searchContext.text = toolStripIncrFindText.Text;
searchContext.partial = !toolStripIncrFindExact.Checked;
searchContext.wrapAround = toolStripIncrFindWrapAround.Checked;
searchContext.first = toolStripIncrFindText.Tag == null ? true : (bool)toolStripIncrFindText.Tag;
searchContext.rectype = toolStripIncrFindTypeFilter.SelectedItem as string;
searchContext.forward = forward;
searchContext.updateFunc = updateFunc;
// exclude null text searches except for when type is specified
if (searchContext.type != SearchType.TypeEditorIdSearch && string.IsNullOrEmpty(searchContext.text))
{
if (!Properties.Settings.Default.NoWindowsSounds)
{
SystemSounds.Beep.Play();
}
toolStripIncrFind.Focus();
toolStripIncrFindText.Select();
toolStripIncrFindText.Focus();
return;
}
StartBackgroundWork(
() => { foundNode = PerformSearch(searchContext); }
, () =>
{
if (IsBackroundProcessCanceled())
{
toolStripIncrFindStatus.Text = "Search Canceled";
toolStripIncrFindStatus.ForeColor = Color.Black;
}
else
{
if (foundNode != null)
{
toolStripIncrFindStatus.Text = "Match Found";
toolStripIncrFindStatus.ForeColor = Color.Black;
PluginTree.SelectedRecord = foundNode;
toolStripIncrFindText.Tag = false;
}
else
{
toolStripIncrFindText.Tag = true;
toolStripIncrFindStatus.Text = "No Matches Found";
toolStripIncrFindStatus.ForeColor = Color.Maroon;
if (!Properties.Settings.Default.NoWindowsSounds)
{
SystemSounds.Beep.Play();
}
}
toolStripIncrFind.Focus();
toolStripIncrFindText.Select();
toolStripIncrFindText.Focus();
}
}
);
}
public RecordChangeEventArgs(BaseRecord rec)
{
record = rec;
}
public override int IndexOf(BaseRecord br)
{
return(pluginList.IndexOf(br as Plugin));
}
public override int IndexOf(BaseRecord br)
{
return records.IndexOf(br as Rec);
}
public override int IndexOf(BaseRecord br)
{
return pluginList.IndexOf(br as Plugin);
}
public override bool DeleteRecord(BaseRecord br)
{
var sr = br as SubRecord;
if (sr == null) return false;
return SubRecords.Remove(sr);
}
protected static void FireRecordDeleted(object sender, BaseRecord rec)
{
if (!HoldUpdates && RecordDeleted != null)
{
RecordDeleted(sender, new RecordChangeEventArgs(rec));
}
}
public abstract void AddRecord(BaseRecord br);