GuiLanguageColorizer.cpp

#include "GuiLanguageColorizer.h"

#include "../../Templates/GuiThemeStyleFactory.h"

namespace

{

namespace

presentation

{

namespace

controls

{

using

namespace

elements

;

using

namespace

parsing

;

using

namespace

parsing

tabling

;

using

namespace

collections

;

using

namespace

theme

;

/*********************************************************************** GuiGrammarColorizer ***********************************************************************/

void

GuiGrammarColorizer

OnParsingFinishedAsync

(

const

RepeatingParsingOutput

output

) {

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

context

output

;

OnContextFinishedAsync

(

context

); }

RestartColorizer

(); }

void

GuiGrammarColorizer

OnContextFinishedAsync

(

const

RepeatingParsingOutput

context

) { }

void

GuiGrammarColorizer

Attach

(

elements

GuiColorizedTextElement

_element

SpinLock

_elementModifyLock

compositions

GuiGraphicsComposition

_ownerComposition

vuint

editVersion

) {

GuiTextBoxRegexColorizer

Attach

(

_element

_elementModifyLock

_ownerComposition

editVersion

);

RepeatingParsingExecutor

CallbackBase

Attach

(

_element

_elementModifyLock

_ownerComposition

editVersion

); }

void

GuiGrammarColorizer

Detach

() {

GuiTextBoxRegexColorizer

Detach

();

RepeatingParsingExecutor

CallbackBase

Detach

();

(

element

elementModifyLock

) {

parsingExecutor

EnsureTaskFinished

();

StopColorizer

(

false

); } }

void

GuiGrammarColorizer

TextEditPreview

(

TextEditPreviewStruct

arguments

) {

GuiTextBoxRegexColorizer

TextEditPreview

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextEditPreview

(

arguments

); }

void

GuiGrammarColorizer

TextEditNotify

(

const

TextEditNotifyStruct

arguments

) {

GuiTextBoxRegexColorizer

TextEditNotify

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextEditNotify

(

arguments

); }

void

GuiGrammarColorizer

TextCaretChanged

(

const

TextCaretChangedStruct

arguments

) {

GuiTextBoxRegexColorizer

TextCaretChanged

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextCaretChanged

(

arguments

); }

void

GuiGrammarColorizer

TextEditFinished

(

vuint

editVersion

) {

GuiTextBoxRegexColorizer

TextEditFinished

(

editVersion

);

RepeatingParsingExecutor

CallbackBase

TextEditFinished

(

editVersion

); }

void

GuiGrammarColorizer

OnSemanticColorize

(

SemanticColorizeContext

context

const

RepeatingParsingOutput

input

) {

(

auto

analyzer

parsingExecutor

GetAnalyzer

()) {

auto

semanticId

analyzer

GetSemanticIdForTokenAsync

(

context

input

);

(

semanticId

!=-

) {

context

semanticId

; } } }

void

GuiGrammarColorizer

EnsureColorizerFinished

() {

parsingExecutor

EnsureTaskFinished

();

StopColorizerForever

();

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

context

RepeatingParsingOutput

(); } }

GuiGrammarColorizer

(

Ptr

RepeatingParsingExecutor

_parsingExecutor

) :

RepeatingParsingExecutor

CallbackBase

(

_parsingExecutor

) {

parsingExecutor

AttachCallback

(

this

);

BeginSetColors

(); }

GuiGrammarColorizer

(

Ptr

parsing

tabling

ParsingGeneralParser

_grammarParser

const

WString

_grammarRule

) :

RepeatingParsingExecutor

CallbackBase

(

new

RepeatingParsingExecutor

(

_grammarParser

_grammarRule

)) {

parsingExecutor

AttachCallback

(

this

);

BeginSetColors

(); }

GuiGrammarColorizer

() {

EnsureColorizerFinished

();

parsingExecutor

DetachCallback

(

this

); }

void

GuiGrammarColorizer

BeginSetColors

() {

ClearTokens

();

colorSettings

Clear

();

text

ColorEntry

entry

; {

entry

normal

text

Color

(

);

entry

normal

background

Color

(

);

entry

selectedFocused

text

Color

(

255

);

entry

selectedFocused

background

Color

(

153

255

);

entry

selectedUnfocused

text

Color

(

255

);

entry

selectedUnfocused

background

Color

(

153

255

); }

SetDefaultColor

(

entry

);

colorSettings

Add

(

L"Default"

entry

); }

const

collections

SortedList

WString

GuiGrammarColorizer

GetColorNames

() {

return

colorSettings

Keys

(); }

GuiGrammarColorizer

ColorEntry

GuiGrammarColorizer

GetColor

(

const

WString

name

) {

vint

index

colorSettings

Keys

().

IndexOf

(

name

);

return

index

==-

GetDefaultColor

():

colorSettings

Values

().

Get

(

index

); }

void

GuiGrammarColorizer

SetColor

(

const

WString

name

const

ColorEntry

entry

) {

colorSettings

Set

(

name

entry

); }

void

GuiGrammarColorizer

SetColor

(

const

WString

name

const

Color

color

) {

text

ColorEntry

entry

GetDefaultColor

();

entry

normal

text

color

;

SetColor

(

name

entry

); }

void

GuiGrammarColorizer

EndSetColors

() {

SortedList

WString

tokenColors

;

Ptr

ParsingTable

table

parsingExecutor

GetParser

()

GetTable

();

semanticColorMap

Clear

();

vint

tokenCount

table

GetTokenCount

();

for

(

vint

token

ParsingTable

UserTokenStart

;

token

tokenCount

;

token

++) {

const

ParsingTable

TokenInfo

tokenInfo

table

GetTokenInfo

(

token

);

const

RepeatingParsingExecutor

TokenMetaData

parsingExecutor

GetTokenMetaData

(

token

ParsingTable

UserTokenStart

);

(

defaultColorIndex

==-

) {

AddToken

(

tokenInfo

regex

GetDefaultColor

()); }

else

{

WString

name

parsingExecutor

GetSemanticName

(

defaultColorIndex

);

vint

color

AddToken

(

tokenInfo

regex

GetColor

(

name

));

semanticColorMap

Set

(

defaultColorIndex

color

);

tokenColors

Add

(

name

); } }

FOREACH_INDEXER(WString, color, index, colorSettings.Keys())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

colorSettings

Keys

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

color

;

__foreach_iterator__

(

color

);

index

++)

{

tokenColors

Contains

(

color

)) {

vint

semanticId

parsingExecutor

GetSemanticId

(

color

);

(

semanticId

!=-

) {

vint

tokenId

AddExtraToken

(

colorSettings

Values

().

Get

(

index

));

vint

color

tokenId

tokenCount

ParsingTable

UserTokenStart

;

semanticColorMap

Set

(

semanticId

color

); } } }

Setup

(); }

void

GuiGrammarColorizer

ColorizeTokenContextSensitive

(

vint

lineIndex

const

wchar_t

text

vint

start

vint

length

vint

token

vint

contextState

) {

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

ParsingTreeObject

node

context

node

Obj

();

(

node

token

!=-

parsingExecutor

GetTokenMetaData

(

token

hasContextColor

) {

ParsingTextPos

pos

(

lineIndex

start

);

SemanticColorizeContext

scContext

;

(

SemanticColorizeContext

RetriveContext

(

scContext

pos

node

parsingExecutor

Obj

())) {

const

RepeatingParsingExecutor

FieldMetaData

parsingExecutor

GetFieldMetaData

(

scContext

type

scContext

field

);

vint

semantic

colorIndex

;

scContext

semanticId

;

(

scContext

acceptableSemanticIds

) {

OnSemanticColorize

(

scContext

context

);

(

semantics

Contains

(

scContext

semanticId

)) {

semantic

scContext

semanticId

; } }

(

semantic

!=-

) {

vint

index

semanticColorMap

Keys

().

IndexOf

(

semantic

);

(

index

!=-

) {

token

semanticColorMap

Values

()

[

index

]; } } } } } }

Ptr

RepeatingParsingExecutor

GuiGrammarColorizer

GetParsingExecutor

() {

return

parsingExecutor

; } } } }