private void TE_TextChanged(object sender, EventArgs e)
{
toolTipService.RemoveAll();
textMarkerService.RemoveAll(delegate(ITextMarker marker) { return(true); });
var textEditor = sender as TextEditor;
var text = textEditor.Text;
var tuple = Controller.Check(text);
Errors = tuple.Item2;
tree = tuple.Item1;
Debug.WriteLine("\n");
Errors.ForEach((VoltaCompilerError error) => {
int offset = textEditor.Document.GetOffset(error.Line, error.Column);
ITextMarker marker = textMarkerService.Create(offset, 0);
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.MarkerColor = Colors.Red;
toolTipService.CreateErrorToolTip(error, marker as TextMarker);
});
OnErrorListUpdated?.Invoke(Errors);
if (e != null)
{
CodeFile.HasUnsavedChanges = true;
}
}
private object EvaluateExpression(string expressionText)
{
object result = null;
_textMarkerService.RemoveAll(IsSelected);
if (!string.IsNullOrWhiteSpace(expressionText))
{
Expression expression = new Expression(expressionText, this.Options);
try
{
result = expression.Evaluate(this.Variables.Where(v => !string.IsNullOrWhiteSpace(v.Name)).ToDictionary(v => v.Name, v => v.TypedValue));
}
catch (ExpressiveException ee)
{
//if (ee.InnerException is MissingTokenException)
//{
// var mte = (MissingTokenException)ee.InnerException;
// ITextMarker marker = textMarkerService.Create(mte.StartOffset, mte.Length);
// marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
// marker.MarkerColor = Colors.Red;
//}
result = ee.Message;
}
catch (Exception ex)
{
result = ex.Message;
}
}
return(result);
}
public void RemoveMarkers()
{
ITextMarkerService markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService;
if (markerService != null)
{
markerService.RemoveAll(IsXPathNodeTextMarker);
}
}
private void MenuItem_Click(object sender, RoutedEventArgs e)
{
try
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Net.Http.dll");
//parameters.ReferencedAssemblies.Add("PresentationFramework.dll");
//parameters.ReferencedAssemblies.Add("PresentationCore.dll");
//parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("FacebookIDE.exe");
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
CompilerResults results = provider.CompileAssemblyFromSource(parameters, editor.Document.Text);
ErrorList.Clear();
textMarkerService.RemoveAll(m => true);
if (results.Errors.Count > 0)
{
foreach (CompilerError err in results.Errors)
{
ErrorList.Add(err);
var line = editor.Document.GetLineByNumber(err.Line);
ITextMarker marker = textMarkerService.Create(line.Offset + err.Column, line.Length);
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.MarkerColor = Colors.Red;
}
return;
}
Assembly assembly = results.CompiledAssembly;
Type program = assembly.GetType("Script");
var method = program.GetMethod("GetSeries");
var method2 = program.GetMethod("GetCollection");
var instance = assembly.CreateInstance("Script");
method.Invoke(instance, null);
SeriesCollection s = (SeriesCollection)method2.Invoke(instance, null);
chart.Series = s;
tab_control.SelectedIndex = 1;
}
catch (TargetInvocationException tie)
{
MessageBox.Show(tie.Message + "\r\n\r\n" + tie.InnerException.Message, "Script Error", MessageBoxButton.OK, MessageBoxImage.Error);;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Removes all markers from the given view content or text editor.
/// </summary>
public static void RemoveMarkers(IServiceProvider serviceProvider)
{
ITextMarkerService markerService = serviceProvider.GetService(typeof(ITextMarkerService)) as ITextMarkerService;
if (markerService != null)
{
markerService.RemoveAll(IsXPathNodeTextMarker);
}
}
/// <summary>
/// Removes all CodeCoverageMarkers from the marker strategy.
/// </summary>
public void RemoveMarkers(IDocument document)
{
ITextMarkerService markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService;
if (markerService != null)
{
markerService.RemoveAll(IsCodeCoverageTextMarker);
}
}
public async Task Analizar()
{
await Task.Yield();
this.Analizando = true;
if (this.Documento.TextLength > 0)
{
var lineas = this.Documento.Lines.Select(x => new Tuple <string, DocumentLine>(this.Documento.GetText(x), x)).ToList();
//Thread th = new Thread(() =>
//{
this.Errores.Resultados.Clear();
try
{
this.Analizador =
new AnalizadorLexico(this.Documento, this.Errores);
this.Analizador.Analizar(lineas);
if (this.Analizador.EsValido)
{
this.Analizador =
new AnalizadorSintactico((AnalizadorLexico)this.Analizador, this.Documento, this.Errores);
this.Analizador.Analizar();
if (this.Analizador.EsValido)
{
}
}
Application.Current?.Dispatcher?.Invoke(() =>
{
TextMarkerService.RemoveAll(m => true);
foreach (var ex in this.Errores.Resultados.Where(x => x.Linea != null && !x.Linea.IsDeleted && x.Linea.LineNumber >= 0))
{
if (ex.EsAdvertencia)
{
ResaltarError(ex.Linea, System.Windows.Media.Colors.Olive);
}
else
{
ResaltarError(ex.Linea, System.Windows.Media.Colors.Red);
}
}
});
}
catch (Exception) { }
this.Analizando = false;
//});
//th.SetApartmentState(ApartmentState.STA);
//th.Priority = ThreadPriority.Lowest;
//th.Start();
}
else
{
this.Analizando = false;
}
}
void ParseInformationUpdated(object sender, ICSharpCode.SharpDevelop.Parser.ParseInformationEventArgs e)
{
if (!e.FileName.Equals(textView.Document.FileName))
{
return;
}
ITextMarkerService markerService = textView.GetService <ITextMarkerService>();
if (markerService == null)
{
return;
}
markerService.RemoveAll(m => m.Tag is Error);
foreach (Error error in e.NewUnresolvedFile.Errors)
{
var offset = textView.Document.GetOffset(error.Region.Begin);
var endOffset = textView.Document.GetOffset(error.Region.End);
int length = endOffset - offset;
if (length < 2)
{
// marker should be at least 2 characters long, but take care that we don't make
// it longer than the document
length = Math.Min(2, textView.Document.TextLength - offset);
}
var marker = markerService.Create(offset, length);
switch (error.ErrorType)
{
case ErrorType.Unknown:
marker.MarkerColor = Colors.Blue;
break;
case ErrorType.Error:
marker.MarkerColor = Colors.Red;
break;
case ErrorType.Warning:
marker.MarkerColor = Colors.Orange;
break;
default:
throw new ArgumentOutOfRangeException();
}
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.ToolTip = error.Message;
marker.Tag = error;
}
}
private void ParseRQL()
{
_textMarkerService.RemoveAll(m => true);
_errorListener.Reset();
var inputStream = new CaseInsensitiveInputStream(CodeEditor.Text);
_lexer.SetInputStream(inputStream);
_parser.SetInputStream(new CommonTokenStream(_lexer));
_parser.query();
var errors = _errorListener.Errors.Aggregate(new StringBuilder(), (sb, err) =>
sb.AppendLine(err.ToString().Replace("\\n", " ")
.Replace("\\r", " ")
.Replace("\\t", " "))).ToString();
AddSquigglies();
Errors.Text = errors;
}
private void RunButton_Click(object sender, RoutedEventArgs e)
{
textMarkerService.RemoveAll(m => true);
try
{
ConsoleTextBox.Foreground = Brushes.Black;
ConsoleTextBox.Clear();
jsExecutor.Execute(textEditor.Text);
}
catch (JavascriptException ex)
{
ConsoleTextBox.Foreground = Brushes.Red;
ConsoleTextBox.AppendText($"line {ex.Line} col {ex.StartColumn}: {ex.Message}");
var lineIndex = FindIndex(ex.Line - 1);
ITextMarker marker = textMarkerService.Create(lineIndex + ex.StartColumn, ex.EndColumn - ex.StartColumn);
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.MarkerColor = Colors.Red;
}
}
private async void AnalyzeCodeSyntax()
{
dispatcherTimer.Stop();
try
{
foldingStretegy.UpdateFoldings(foldingManager, _editor.Document);
var errorService = ErrorService.GetService();
errorService.Clear();
var d = await CodeAnalysisService.LoadDocument(_editor.Document.Text).GetDiagnosticsAsync();
var s = d.Select(x =>
{
var cd = new CompilationDiagnostic(x);
var line = _editor.Document.GetLineByOffset(x.Location.SourceSpan.Start);
cd.Line = line.LineNumber;
cd.Column = line.Length;
return(cd);
});
errorService.AddRange(s);
textMarkerService.RemoveAll(m => true);
foreach (var item in d)
{
var span = item.Location.SourceSpan;
ITextMarker m = textMarkerService.Create(span.Start, span.Length);
m.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
m.MarkerColor = item.Severity == DiagnosticSeverity.Error ? Colors.Red : Colors.LightGreen;
m.ToolTip = item.ToString();
}
}
catch { }
}
public void RemoveAllErrorMarks()
{
textMarkerService.RemoveAll((m) => (ResolverMarkerType)m.Tag == ResolverMarkerType.Error);
}
void ClearErrors() => _textMarkerService.RemoveAll(m => true);
void RemoveAllErrorHighlight()
{
textMarkerService.RemoveAll(m => true);
//tbErrorList.Text = "";
lbErrorList.Items.Clear();
}
void RemoveAllClick(object sender, RoutedEventArgs e)
{
textMarkerService.RemoveAll(m => true);
}
void OnRemoved(object sender, TaskEventArgs e)
{
markerService.RemoveAll(marker => marker.Tag == e.Task);
}
/// <summary>
/// Render the current EPL formular
/// </summary>
public void Render()
{
if (eplFormular == null)
{
eplFormular = new EPLFormular(this, editor.Text);
eplFormular.Processor = Processor;
}
errors.Clear();
eplFormular.Load(editor.Text);
textMarkerService.RemoveAll(m => true);
labelCanvas.Children.Clear();
renderGrid.Children.Clear();
renderGrid.Children.Add(labelCanvas);
generatedEPLEditor.Text = eplFormular.GetEPLCode();
// Render
var dpiXProperty = typeof(SystemParameters).GetProperty("DpiX", BindingFlags.NonPublic | BindingFlags.Static);
int dpiX = (int)dpiXProperty.GetValue(null, null);
var dpiYProperty = typeof(SystemParameters).GetProperty("DpiX", BindingFlags.NonPublic | BindingFlags.Static);
int dpiY = (int)dpiXProperty.GetValue(null, null);
Tuple <double, double> relativePosition = new Tuple <double, double>(0, 0);
Tuple <double, double> absoltePosition = new Tuple <double, double>(0, 0);
// Label size
double labelHeightPx = UnitHelper.CmToPx(1.9, dpiX);
double labelWidthPx = UnitHelper.CmToPx(5.7, dpiY);
double printerWidthPx = UnitHelper.CmToPx(10, dpiX);
foreach (var command in eplFormular.Commands)
{
if (command is RCommand)
{
double _x = 0;
double _y = 0;
if (double.TryParse((command as RCommand).P1, out _x) && double.TryParse((command as RCommand).P2, out _y))
{
relativePosition = new Tuple <double, double>(UnitHelper.DotToPixel(8, _x, dpiX), UnitHelper.DotToPixel(8, _y, dpiY));
absoltePosition = new Tuple <double, double>
(
relativePosition.Item1,
relativePosition.Item2 + 5
);
}
}
else if (command is LabelHeightCommand)
{
if (double.TryParse(((LabelHeightCommand)command).P1, out labelHeightPx))
{
labelHeightPx = UnitHelper.DotToPixel(8, (int)labelHeightPx, dpiY);
SetLabelPrinterSizePixel(printerWidthPx, labelHeightPx, labelWidthPx);
absoltePosition = new Tuple <double, double>
(
((printerWidthPx / 2) - (labelWidthPx / 2)),
relativePosition.Item2 + 5
);
}
}
else if (command is LabelWidthCommand)
{
if (double.TryParse(((LabelWidthCommand)command).P1, out labelWidthPx))
{
labelWidthPx = UnitHelper.DotToPixel(8, (int)labelWidthPx, dpiX);
SetLabelPrinterSizePixel(printerWidthPx, labelWidthPx, labelHeightPx);
absoltePosition = new Tuple <double, double>
(
((printerWidthPx / 2) - (labelWidthPx / 2)),
relativePosition.Item2 + 5
);
}
}
else
{
var uiFactory = UIControlFactory.Get(command.GetType());
if (uiFactory != null)
{
// Render on UI
uiFactory.Render(this.renderGrid, eplFormular, command, absoltePosition, dpiX, dpiY);
}
}
}
}
