Problem mit FastColoredTextBox

  • VB.NET

Es gibt 22 Antworten in diesem Thema. Der letzte Beitrag () ist von nafets3646.

    Problem mit FastColoredTextBox

    Hallo liebe Community,
    Heute belästige ich euch mit einem/mehreren Problemen mit der FastColoredTextBox. Für diese habe ich ein eigenes kleines Verwaltungssystem geschrieben, welches eigentlich auch schon ziemlich gut funktioniert. Hier die Klassen, welche ich erstellt habe:
    Highlighter

    VB.NET-Quellcode

    1. Imports System.Text.RegularExpressions
    2. Imports FastColoredTextBoxNS
    4. Public Class Highlighter
    6. ''' <summary>
    7. ''' Erstellt einen neuen Highlighter
    8. ''' </summary>
    9. Public Sub New()
    10. Me.TextStyle = New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle)
    11. End Sub
    13. ''' <summary>
    14. ''' Erstellt einen neuen Highlighter
    15. ''' </summary>
    16. ''' <param name="regexpattern">Der RegexPattern nach dem gesucht werden soll</param>
    17. ''' <param name="regexoptions">Die zu verwendenden RegexOptions</param>
    18. ''' <param name="color">Die neue Farbe des gematchten Texts</param>
    19. ''' <param name="backgroundcolor">Die neue Hintergrundfarbe des gematchten Texts</param>
    20. ''' <param name="fontstyle">Die Schrifteigenschaften des gematchten Texts</param>
    21. Public Sub New(regexpattern As String, regexoptions As RegexOptions, color As Color, backgroundcolor As Color, fontstyle As FontStyle)
    22. Me.RegexPattern = regexpattern
    23. Me.RegexOptions = regexoptions
    24. Me.Color = color
    25. Me.BackgroundColor = backgroundcolor
    26. Me.FontStyle = fontstyle
    27. Me.TextStyle = New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle)
    28. End Sub
    30. ''' <summary>
    31. ''' Erstellt einen neuen Highlighter
    32. ''' </summary>
    33. ''' <param name="name">Der Name des Highlighters</param>
    34. ''' <param name="regexpattern">Der RegexPattern nach dem gesucht werden soll</param>
    35. ''' <param name="regexoptions">Die zu verwendenden RegexOptions</param>
    36. ''' <param name="color">Die neue Farbe des gematchten Texts</param>
    37. ''' <param name="backgroundcolor">Die neue Hintergrundfarbe des gematchten Texts</param>
    38. ''' <param name="fontstyle">Die Schrifteigenschaften des gematchten Texts</param>
    39. Public Sub New(name As String, regexpattern As String, regexoptions As RegexOptions, color As Color, backgroundcolor As Color, fontstyle As FontStyle)
    40. Me.Name = name
    41. Me.RegexPattern = regexpattern
    42. Me.RegexOptions = regexoptions
    43. Me.Color = color
    44. Me.BackgroundColor = backgroundcolor
    45. Me.FontStyle = fontstyle
    46. Me.TextStyle = New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle)
    47. End Sub
    49. ''' <summary>
    50. ''' Erstellt einen neuen Highlighter
    51. ''' </summary>
    52. ''' <param name="name">Der Name des Highlighters</param>
    53. ''' <param name="keywordstomatch">Die KeyWords, welche gematcht werden sollen</param>
    54. ''' <param name="regexoptions">Die zu verwendenden RegexOptions</param>
    55. ''' <param name="color">Die neue Farbe des gematchten Texts</param>
    56. ''' <param name="backgroundcolor">Die neue Hintergrundfarbe des gematchten Texts</param>
    57. ''' <param name="fontstyle">Die Schrifteigenschaften des gematchten Texts</param>
    58. Public Sub New(name As String, keywordstomatch As IEnumerable(Of String), regexoptions As RegexOptions, color As Color, backgroundcolor As Color, fontstyle As FontStyle)
    59. Me.Name = name
    60. Me.RegexPattern = String.Join("|", keywordstomatch)
    61. Me.RegexOptions = regexoptions
    62. Me.Color = color
    63. Me.BackgroundColor = backgroundcolor
    64. Me.FontStyle = fontstyle
    65. Me.TextStyle = New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle)
    66. End Sub
    68. ''' <summary>
    69. ''' Erstellt einen neuen Highlighter
    70. ''' </summary>
    71. ''' <param name="keywordstomatch">Die KeyWords, welche gematcht werden sollen</param>
    72. ''' <param name="regexoptions">Die zu verwendenden RegexOptions</param>
    73. ''' <param name="color">Die neue Farbe des gematchten Texts</param>
    74. ''' <param name="backgroundcolor">Die neue Hintergrundfarbe des gematchten Texts</param>
    75. ''' <param name="fontstyle">Die Schrifteigenschaften des gematchten Texts</param>
    76. Public Sub New(keywordstomatch As IEnumerable(Of String), regexoptions As RegexOptions, color As Color, backgroundcolor As Color, fontstyle As FontStyle)
    77. Me.RegexPattern = String.Join("|", keywordstomatch)
    78. Me.RegexOptions = regexoptions
    79. Me.Color = color
    80. Me.BackgroundColor = backgroundcolor
    81. Me.FontStyle = fontstyle
    82. Me.TextStyle = New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle)
    83. End Sub
    85. ''' <summary>
    86. ''' Der Name des Highlighters
    87. ''' </summary>
    88. Public Property Name As String = "Highlighter"
    90. ''' <summary>
    91. ''' Der RegexPattern nach dem gesucht werden soll
    92. ''' </summary>
    93. Public Property RegexPattern As String = "."
    95. ''' <summary>
    96. ''' Die zu verwendenden RegexOptions
    97. ''' </summary>
    98. Public Property RegexOptions As RegexOptions = RegexOptions.None
    100. ''' <summary>
    101. ''' Die neue Farbe des gematchten Texts
    102. ''' </summary>
    103. Public Property Color As Color = Color.Black
    105. ''' <summary>
    106. ''' Die neue Hintergrundfarbe des gematchten Texts
    107. ''' </summary>
    108. Public Property BackgroundColor As Color = Color.Transparent
    110. ''' <summary>
    111. ''' Die Schrifteigenschaften des gematchten Texts
    112. ''' </summary>
    113. Public Property FontStyle As FontStyle = Drawing.FontStyle.Regular
    115. ''' <summary>
    116. ''' Führt die ClearStyle-Methode für eine Range aus
    117. ''' </summary>
    118. Public Sub ClearStyle(range As FastColoredTextBoxNS.Range)
    119. range.ClearStyle(New TextStyle(New SolidBrush(Me.Color), New SolidBrush(Me.BackgroundColor), Me.FontStyle))
    120. End Sub
    122. ''' <summary>
    123. ''' Der TextStyle, welcher angewendet wird
    124. ''' </summary>
    125. Private Property TextStyle As TextStyle
    127. ''' <summary>
    128. ''' Führt die SetStyle-Methode für eine Range aus
    129. ''' </summary>
    130. Public Sub SetStyle(ByRef range As FastColoredTextBoxNS.Range)
    131. range.SetStyle(Me.TextStyle, Me.RegexPattern, Me.RegexOptions)
    132. End Sub
    134. End Class
    138. ''' <summary>
    139. ''' Eine Auflistung mehrerer Highlighters
    140. ''' </summary>
    141. ''' <remarks></remarks>
    142. Public Class HighlighterCollection
    143. Inherits List(Of Highlighter)
    145. ''' <summary>
    146. ''' Erstellt eine neue HighlighterCollection
    147. ''' </summary>
    148. Public Sub New()
    149. Me.Capacity = 16
    150. End Sub
    152. ''' <summary>
    153. ''' Erstellt eine neue HighlighterCollection
    154. ''' </summary>
    155. ''' <param name="standardhighlighter">Der Name des StandardHighlighters</param>
    156. ''' <remarks></remarks>
    157. Public Sub New(standardhighlighter As String)
    158. Me.Capacity = 16
    159. Me.StandardHighlighter = standardhighlighter
    160. End Sub
    162. ''' <summary>
    163. ''' Der Name des StandardHighlighters, er wird für die Methode ClearStyle verwendet
    164. ''' </summary>
    165. Public Property StandardHighlighter As String = ""
    167. ''' <summary>
    168. ''' Sucht einen Highlighter nach seinem Namen und gibt den ersten Fund zurück
    169. ''' </summary>
    170. ''' <param name="name">Der Name des zu suchenden Highlighters</param>
    171. Public Function GetByName(name As String) As Highlighter
    172. For Each Highlighter As Highlighter In Me
    173. If Highlighter.Name = name Then Return Highlighter
    174. Next
    175. Throw New KeyNotFoundException("Es konnte kein übereinstimmender Highlighter gefunden werden")
    176. End Function
    178. ''' <summary>
    179. ''' Setzt alle verfügbaren Styles für die angegebene Range
    180. ''' </summary>
    181. ''' <param name="range">Der Bereich, auf den die Styles angewendet werden sollen</param>
    182. Public Sub SetStyle(range As FastColoredTextBoxNS.Range)
    183. For Each Highlighter As Highlighter In Me
    184. If Highlighter.Name <> Me.StandardHighlighter Then Highlighter.SetStyle(range)
    185. Next
    186. End Sub
    188. ''' <summary>
    189. ''' Setzt den Standardstyle für die angegebene Range
    190. ''' </summary>
    191. ''' <param name="range">Der Bereich, auf den der Style angewendet werden soll</param>
    192. Public Sub ClearStyle(range As FastColoredTextBoxNS.Range)
    193. Me.GetByName(StandardHighlighter).ClearStyle(range)
    194. End Sub
    196. ''' <summary>
    197. ''' Kombiniert die Funktion der Methoden <see cref="ClearStyle">ClearStyle</see> und <see cref="SetStyle">SetStyle</see>
    198. ''' </summary>
    199. ''' <param name="range">Der Bereich, auf den die Styles angewendet werden sollen</param>
    200. Public Sub Apply(range As FastColoredTextBoxNS.Range)
    201. Me.GetByName(StandardHighlighter).ClearStyle(range)
    202. For Each Highlighter As Highlighter In Me
    203. If Highlighter.Name <> Me.StandardHighlighter Then Highlighter.SetStyle(range)
    204. Next
    205. End Sub
    207. End Class

    FoldingMarker

    VB.NET-Quellcode

    1. Imports System.Text.RegularExpressions
    2. Imports FastColoredTextBoxNS
    4. Public Class FoldingMarker
    6. ''' <summary>
    7. ''' Erstellt einen neuen FoldingMarker
    8. ''' </summary>
    9. ''' <param name="startmarker">Der Startmarker</param>
    10. ''' <param name="endmarker">Der Endmarker</param>
    11. Public Sub New(startmarker As String, endmarker As String)
    12. Me.StartMarker = startmarker
    13. Me.EndMarker = endmarker
    14. End Sub
    16. ''' <summary>
    17. ''' Erstellt einen neuen FoldingMarker
    18. ''' </summary>
    19. ''' <param name="name">Der Name des FoldingMarkers</param>
    20. ''' <param name="startmarker">Der Startmarker</param>
    21. ''' <param name="endmarker">Der Endmarker</param>
    22. Public Sub New(name As String, startmarker As String, endmarker As String)
    23. Me.Name = name
    24. Me.StartMarker = startmarker
    25. Me.EndMarker = endmarker
    26. End Sub
    28. ''' <summary>
    29. ''' Der Name des FoldingMarkers
    30. ''' </summary>
    31. Public Property Name As String = "FoldingMarker"
    33. ''' <summary>
    34. ''' Der Startmarker
    35. ''' </summary>
    36. Public Property StartMarker As String = ""
    38. ''' <summary>
    39. ''' Der Endmarker
    40. ''' </summary>
    41. Public Property EndMarker As String = ""
    43. ''' <summary>
    44. ''' Wendet den FoldingMarker auf die angegebene Range an
    45. ''' </summary>
    46. ''' <param name="range">Der Bereich, auf den der FoldingMarker angewendet werden soll</param>
    47. ''' <remarks></remarks>
    48. Public Sub Apply(range As FastColoredTextBoxNS.Range)
    49. range.SetFoldingMarkers(Me.StartMarker, Me.EndMarker)
    50. End Sub
    52. End Class
    56. ''' <summary>
    57. ''' Eine Auflistung mehrerer FoldingMarkers
    58. ''' </summary>
    59. ''' <remarks></remarks>
    60. Public Class FoldingMarkerCollection
    61. Inherits List(Of FoldingMarker)
    63. ''' <summary>
    64. ''' Erstellt eine neue FoldingMarkerCollection
    65. ''' </summary>
    66. Public Sub New()
    67. 'Me.Capacity = 16
    68. End Sub
    70. ''' <summary>
    71. ''' Sucht einen FoldingMarker nach seinem Namen und gibt den ersten Fund zurück
    72. ''' </summary>
    73. ''' <param name="name">Der Name des zu suchenden FoldingMarkers</param>
    74. Public Function GetByName(name As String) As FoldingMarker
    75. For Each FoldingMarker As FoldingMarker In Me
    76. If FoldingMarker.Name = name Then Return FoldingMarker
    77. Next
    78. Throw New KeyNotFoundException("Es konnte kein übereinstimmender FoldingMarker gefunden werden")
    79. End Function
    81. ''' <summary>
    82. ''' Wendet alle FoldingMarkers auf die angegebene Range an
    83. ''' </summary>
    84. ''' <param name="range">Der Bereich, auf den die Styles angewendet werden sollen</param>
    85. Public Sub Apply(range As FastColoredTextBoxNS.Range)
    86. For Each FoldingMarker As FoldingMarker In Me
    87. FoldingMarker.Apply(range)
    88. Next
    89. End Sub
    91. End Class

    Und so hatte ich vor, es umzusetzen:
    TIBASICCodeEditor

    VB.NET-Quellcode

    1. Imports FastColoredTextBoxNS
    2. Imports System.Text.RegularExpressions
    4. Public Class TIBASICCodeEditor
    5. Inherits FastColoredTextBox
    7. Public Sub New()
    8. Me.HighlightingRangeType = FastColoredTextBoxNS.HighlightingRangeType.AllTextRange
    9. Me.CommentPrefix = "'"
    10. End Sub
    12. Private Highlighters As New HighlighterCollection("Standard") From { _
    13. New Highlighter("Kommentar", "'.*$", RegexOptions.None, Color.Green, Color.Transparent, FontStyle.Regular), _
    14. New Highlighter("Strings", "\"".*\""", RegexOptions.None, Color.Firebrick, Color.Transparent, FontStyle.Regular), _
    15. New Highlighter("Blaue KeyWords", {"Input", "For", "If", "End", "While", "Repeat", "Input", "Prompt", "Disp", "Then", "Pause", "Lbl", "Goto", "IS>", "DS<", "Menu", "Output", "getKey"}, RegexOptions.None, Color.Blue, Color.Transparent, FontStyle.Regular), _
    16. New Highlighter("Hellblaue KeyWords", {"Str[0-9]", "Pic[0-9]", "GDB[0-9]", "Y[0-9]", "L[1-6]"}, RegexOptions.None, Color.DodgerBlue, Color.Transparent, FontStyle.Regular), _
    17. New Highlighter("Zahlen", "[0-9]*", RegexOptions.None, Color.Orange, Color.Transparent, FontStyle.Regular), _
    18. New Highlighter("Standard", ".*", RegexOptions.Multiline Or RegexOptions.Singleline, Color.Black, Color.Transparent, FontStyle.Regular) _
    19. } 'Die Anwendung erfolgt von unten nach oben
    22. Private FoldingMarkers As New FoldingMarkerCollection From { _
    23. New FoldingMarker("If", "End"), _
    24. New FoldingMarker("For(.*)", "End"), _
    25. New FoldingMarker("While", "End"), _
    26. New FoldingMarker("Repeat", "End") _
    27. }
    29. Private Sub FastColoredTextBox_TextChanged(sender As Object, e As FastColoredTextBoxNS.TextChangedEventArgs) Handles Me.TextChanged
    30. Highlighters.Apply(e.ChangedRange) 'Alle Highlighter anwenden
    31. FoldingMarkers.Apply(e.ChangedRange) 'Alle FoldingMarker anwenden
    32. End Sub
    34. End Class

    Nun treten bei diesem Code ein paar Probleme auf:
    1. Die Markierungen, bei denen sich die Codeabschnitte zusammenfalten lassen sollten, funktionieren nicht richtig (falsche Zuordnung)
    2. Beim Einfügen von Codeausschnitten funktioniert die Formatierung nicht richtig
    3. Kommentare werden, wenn der Apostroph (') gelöscht wird, zumindest von der Formatierung her nicht entfernt

    Hoffe, ihr könnt mir bei meinen Problemen helfen, vielen Dank für alle Antworten im Voraus :).

    PS: Bitte entschuldigt den schlechten Codingstil bei den Klassen, die waren nur sozusagen ein Prototyp ;).

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nafets3646“ ()

    Nachtrag

    Hatte noch vergessen, dazuzuschreiben, was das überhaupt für Code ist etc. und weil der vorherige Post durch diesen Nachtrag über 15'000 Zeichen hätte, hänge ich ihn einfach mal als zweiten Post hintendran.

    Der Code sieht beispielsweise so aus:

    Brainfuck-Quellcode

    1. Prompt X
    2. X / 3.6 -> X
    3. Disp "="
    4. Disp X
    5. Disp "Meter pro Sekunde"
    6. If X = 10 : Then
    7. ClrHome
    8. Disp "----------------"
    9. Input "Anzahl ", Y
    10. For(Z, 1, Y, 1)
    11. Disp "AWESOME"
    12. End
    13. Pause
    14. ClrHome
    15. 1 -> A
    16. Repeat A >= 25
    17. randInt(1, 10) -> X
    18. round(tan(sin(x)) / 3, 3) -> X
    19. round(A + X, 2) -> A
    20. Disp A
    21. End
    22. Disp "lol"
    23. End

    Dieser Code funktioniert beispielsweise vom Syntax-Highlighting her perfekt, allerdings ordnet er das letzte End nicht zu. Fürs Verständnis: Der Code würde in VB ungefähr so aussehen:

    VB.NET-Quellcode

    1. '...
    2. If X = 10 Then
    3. '...
    4. For Z As Integer = 1 To Y Step 1
    5. '...
    6. Next
    7. '...
    8. Do Until A >= 25
    9. '...
    10. Loop
    11. '...
    12. End If

    Die Kommentare werden wie in VB.NET mit einem Apostroph gekennzeichnet.

    @sonne75
    Ich habe es dir mal gekennzeichnet:
    Falsch (so ists momentan):

    Richtig (so sollte es sein):

    Die roten Linien kennzeichnen den Anfang und das Ende eines Zusammenklappbaren Blockes, wie man sehen kann wird der erste If-Block zum ersten End-Block zugeordnet, obwohl er zum letzten zugeordnet werden sollte.

    @sonne75
    Macht leider keinen Unterschied.

    @All
    Ich habe nochmal den Versuch gestartet, das Control von Grund auf neu zu programmieren, die Kommentare scheinen zu funktionieren, allerdings klappt das mit den FoldingMarkern immer noch nicht:
    Code

    VB.NET-Quellcode

    1. Option Strict On
    3. Imports FastColoredTextBoxNS
    4. Imports System.Text.RegularExpressions
    6. Public Class NewTIBASICCodEditor
    7. Inherits FastColoredTextBox
    9. Private CommentStyle As Style = New TextStyle(Brushes.Green, Brushes.Transparent, FontStyle.Regular)
    10. Private CommentRegex As String = "\'.*$"
    11. Private StringStyle As Style = New TextStyle(Brushes.Firebrick, Brushes.Transparent, FontStyle.Regular)
    12. Private StringRegex As String = "\"".*\"""
    13. Private BlueKeyWordStyle As Style = New TextStyle(Brushes.Blue, Brushes.Transparent, FontStyle.Regular)
    14. Private BlueKeyWordRegex As String = String.Join("|", {"Input", "For", "If", "End", "While", "Repeat", "Input", "Prompt", "Disp", "Then", "Pause", "Lbl", "Goto", "IS>", "DS<", "Menu", "Output", "getKey"})
    15. Private LightBlueKeyWordStyle As Style = New TextStyle(Brushes.DodgerBlue, Brushes.Transparent, FontStyle.Regular)
    16. Private LightBlueKeyWordRegex As String = String.Join("|", {"Str[0-9]", "Pic[0-9]", "GDB[0-9]", "Y[0-9]", "L[1-6]"})
    17. Private NumberStyle As Style = New TextStyle(Brushes.Orange, Brushes.Transparent, FontStyle.Regular)
    18. Private NumberRegex As String = "[0-9]*"
    20. Private Sub NewTIBASICCodEditor_TextChanged(sender As Object, e As TextChangedEventArgs) Handles Me.TextChanged
    21. Dim Range As Range = e.ChangedRange
    23. 'Alle Styles löschen
    24. Range.ClearStyle(CommentStyle)
    25. Range.ClearStyle(StringStyle)
    26. Range.ClearStyle(BlueKeyWordStyle)
    27. Range.ClearStyle(LightBlueKeyWordStyle)
    28. Range.ClearStyle(NumberStyle)
    30. 'Styles anwenden
    31. Range.SetStyle(CommentStyle, CommentRegex)
    32. Range.SetStyle(StringStyle, StringRegex)
    33. Range.SetStyle(BlueKeyWordStyle, BlueKeyWordRegex)
    34. Range.SetStyle(LightBlueKeyWordStyle, LightBlueKeyWordRegex)
    35. Range.SetStyle(NumberStyle, NumberRegex)
    39. 'FoldingMarkers definieren
    40. Range.ClearFoldingMarkers()
    42. 'Versuch 1, funktioniert nicht
    43. Range.SetFoldingMarkers("If", "End")
    44. Range.SetFoldingMarkers("For", "End")
    45. Range.SetFoldingMarkers("While", "End")
    46. Range.SetFoldingMarkers("Repeat", "End")
    48. 'Versuch 2, funktioniert auch nicht
    49. 'Range.SetFoldingMarkers("If.*End", RegexOptions.Singleline)
    50. 'Range.SetFoldingMarkers("For.*End", RegexOptions.Singleline)
    51. 'Range.SetFoldingMarkers("While.*End", RegexOptions.Singleline)
    52. 'Range.SetFoldingMarkers("Repeat.*End", RegexOptions.Singleline)
    55. 'Versuch 3, funktioniert auch nicht
    56. 'Range.SetFoldingMarkers(String.Format("{0}.*{1}", String.Join("|", {"If", "For", "While", "Repeat"}), "End"), RegexOptions.Singleline Or RegexOptions.Multiline)
    60. End Sub
    62. End Class

    Fass einfach alle FoldingMarker Befehle zusammen.
    Also anstatt der 4 einzelnen, einen großen.
    Dann sieht es soaus, und funktioniert auch.

    VB.NET-Quellcode

    1. New FoldingMarker("(If|For|While|Repeat)", "End")

    //EDIT: Zuerst falsches Bild angehängt.

    @FlashTek
    Das habe ich auch in meinem neuen Versuch gemacht (heißt dort Versuch 3), das funktioniert aber ebenfalls nicht.

    //EDIT:
    Achso, hatte es etwas anders gemacht, deine Methode funktioniert perfekt :thumbup:. Danke für den Tipp :).
    Habe es so gemacht, finde ich etwas einfacher zu Warten:

    VB.NET-Quellcode

    1. Range.SetFoldingMarkers(String.Format("({0})", String.Join("|", {"If", "For", "While", "Repeat"})), "End")

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nafets3646“ ()

    @nafets3646: Liest du dir eigentlich durch, was ich poste? Du sollst einfach nur SetFoldingMarkers aufrufen - dann übergibst du das Start-Pattern ("If|For|While|Repeat") und das End-Pattern ("End"). Fertig.
    //Edit: Hat sich jetzt ja durch deinen Edit erledigt ;)

    @FlashTek
    Edit vs. Edit (bei dir war der Code am Anfang gar nicht dabei, deshalb hatte ich das anders interpretiert :D).

    @All
    Noch ne kleine Frage: Weiß vielleicht jemand, wie man bei der FastColoredTextBox Fehler markieren kann, so wie in Visual Studio?

    Mein System ist momentan:
    TI-BASIC-Code -(wird umgewandelt in)> VB.NET-Code -(wird kompiliert mit)> vbc.exe -(wirft Fehler)> Fehlerliste
    Die in der Fehlerliste angezeigten Fehler will ich nun zuordnen (hab ich schon geschafft) und dann in der TextBox markieren.

    nafets3646 schrieb:

    Die in der Fehlerliste angezeigten Fehler will ich nun zuordnen (hab ich schon geschafft) und dann in der TextBox markieren.


    @sonne75:
    Hat er doch schon und ich weiß dass er das geschafft hat, weil ich ebenfalls in diesem Projekt involviert bin ;)

    Will nicht schon wieder eine Antwort erstellen deswegen @sonne75: Es geht eben um das oben gezeigte colorieren der ausgelesenen Zeilen mit der Fastcolored Textbox ;)

    8-) faxe1008 8-)

Facebook
Telefonspende