protected override void OnUpdateSyntax(ContentChangedEventArgs e)
{
var parser = new AchievementScriptParser();
_parsedContent = parser.Parse(Tokenizer.CreateTokenizer(e.Content));
if (e.IsAborted)
{
return;
}
var interpreter = new AchievementScriptInterpreter();
interpreter.Run(_parsedContent, out _scope);
if (e.IsAborted)
{
return;
}
ServiceRepository.Instance.FindService <IBackgroundWorkerService>().InvokeOnUiThread(() =>
{
ErrorsToolWindow.References.Clear();
foreach (var error in _parsedContent.Errors)
{
string message = error.Message;
var innerError = error;
if (innerError.InnerError != null)
{
do
{
innerError = innerError.InnerError;
} while (innerError.InnerError != null);
if (error.Line != innerError.Line || error.Column != innerError.Column)
{
message += String.Format(" (called from {0}:{1})", error.Line, error.Column);
}
}
ErrorsToolWindow.References.Add(new CodeReferenceViewModel
{
StartLine = innerError.Line,
StartColumn = innerError.Column,
EndLine = innerError.EndLine,
EndColumn = innerError.EndColumn,
Message = message
});
}
});
if (e.IsAborted)
{
return;
}
if (e.IsWhitespaceOnlyChange)
{
return;
}
// wait a short while before updating the editor list
ServiceRepository.Instance.FindService <ITimerService>().Schedule(() =>
{
if (e.IsAborted)
{
return;
}
_owner.PopulateEditorList(interpreter);
}, TimeSpan.FromMilliseconds(700));
base.OnUpdateSyntax(e);
}
private void LoadGame(int gameId, string raCacheDirectory)
{
_game = new GameViewModel(GameId.Value.GetValueOrDefault(), "", raCacheDirectory);
_game.PopulateEditorList(null);
DialogTitle = "New Script - " + _game.Title;
_achievements.Clear();
_ticketNotes.Clear();
_memoryItems.Clear();
MemoryAddresses.Rows.Clear();
var unofficialAchievements = new List <DumpAchievementItem>();
foreach (var achievement in _game.Editors.OfType <GeneratedAchievementViewModel>())
{
AchievementViewModel source = achievement.Core;
if (source.Achievement == null)
{
source = achievement.Unofficial;
if (source.Achievement == null)
{
continue;
}
}
var dumpAchievement = new DumpAchievementItem(achievement.Id, source.Title.Text);
if (achievement.Core.Achievement == null)
{
dumpAchievement.IsUnofficial = true;
unofficialAchievements.Add(dumpAchievement);
}
else
{
_achievements.Add(dumpAchievement);
}
foreach (var group in source.RequirementGroups)
{
foreach (var requirement in group.Requirements)
{
if (requirement.Requirement == null)
{
continue;
}
if (requirement.Requirement.Left != null && requirement.Requirement.Left.IsMemoryReference)
{
var memoryItem = AddMemoryAddress(requirement.Requirement.Left);
if (memoryItem != null && !dumpAchievement.MemoryAddresses.Contains(memoryItem))
{
dumpAchievement.MemoryAddresses.Add(memoryItem);
}
}
if (requirement.Requirement.Right != null && requirement.Requirement.Right.IsMemoryReference)
{
var memoryItem = AddMemoryAddress(requirement.Requirement.Right);
if (memoryItem != null && !dumpAchievement.MemoryAddresses.Contains(memoryItem))
{
dumpAchievement.MemoryAddresses.Add(memoryItem);
}
}
}
}
dumpAchievement.IsSelected = true;
dumpAchievement.PropertyChanged += DumpAchievement_PropertyChanged;
}
foreach (var unofficialAchievement in unofficialAchievements)
{
_achievements.Add(unofficialAchievement);
}
foreach (var kvp in _game.Notes)
{
FieldSize size = FieldSize.Byte;
Token token = new Token(kvp.Value, 0, kvp.Value.Length);
if (token.Contains("16-bit", StringComparison.OrdinalIgnoreCase) ||
token.Contains("16 bit", StringComparison.OrdinalIgnoreCase))
{
size = FieldSize.Word;
}
else if (token.Contains("32-bit", StringComparison.OrdinalIgnoreCase) ||
token.Contains("32 bit", StringComparison.OrdinalIgnoreCase))
{
size = FieldSize.DWord;
}
AddMemoryAddress(new Field {
Size = size, Type = FieldType.MemoryAddress, Value = (uint)kvp.Key
});
}
if (_achievements.Count == 0)
{
SelectedCodeNotesFilter = CodeNoteFilter.All;
}
UpdateMemoryGrid();
IsGameLoaded = true;
GameId.IsEnabled = false;
if (_achievements.Count > 0)
{
ServiceRepository.Instance.FindService <IBackgroundWorkerService>().RunAsync(MergeOpenTickets);
}
}
protected override void OnUpdateSyntax(ContentChangedEventArgs e)
{
bool needsUpdate = false;
// parse immediately so we can update the syntax highlighting
var tokenizer = Tokenizer.CreateTokenizer(e.Content);
if (_parsedContent == null || e.Type == ContentChangeType.Refresh)
{
_parsedContent = new ExpressionGroupCollection();
_parsedContent.Scope = new InterpreterScope(AchievementScriptInterpreter.GetGlobalScope());
_parsedContent.Scope.Context = new AchievementScriptContext();
lock (_parsedContent)
{
_parsedContent.Parse(tokenizer);
needsUpdate = true;
}
}
else if (e.Type == ContentChangeType.Update)
{
lock (_parsedContent)
{
needsUpdate = _parsedContent.Update(tokenizer, e.AffectedLines);
}
if (!needsUpdate && !e.IsAborted)
{
UpdateErrorList();
}
}
if (needsUpdate && !e.IsAborted)
{
// running the script can take a lot of time, push that work onto a background thread and show progress bar
UpdateProgress(1, 0);
// make sure to at least show the script file in the editor list
if (!_owner.Editors.Any())
{
_owner.PopulateEditorList(null);
}
ServiceRepository.Instance.FindService <IBackgroundWorkerService>().RunAsync(() =>
{
if (!e.IsAborted)
{
// run the script
var callback = new ScriptInterpreterCallback(this, e);
var interpreter = new AchievementScriptInterpreter();
bool hadErrors, hasErrors;
lock (_parsedContent)
{
hadErrors = _parsedContent.HasEvaluationErrors;
hasErrors = !interpreter.Run(_parsedContent, callback);
}
if (!e.IsAborted)
{
UpdateProgress(100, 0);
// if any errors were added or removed, update the highlighting
if (hasErrors != hadErrors)
{
UpdateSyntaxHighlighting(e);
}
// report any errors
UpdateErrorList();
if (!e.IsAborted)
{
// update the editor list
_owner.PopulateEditorList(interpreter);
}
}
}
// make sure the progress bar is hidden
UpdateProgress(0, 0);
});
}
base.OnUpdateSyntax(e);
}
