GuiInstanceRepresentation.cpp

#include "GuiInstanceRepresentation.h" #include "GuiInstanceLoader.h"

#include "InstanceQuery/GuiInstanceQuery.h"

#include "../Resources/GuiParserManager.h"

namespace

{

namespace

presentation

{

using

namespace

collections

;

using

namespace

parsing

;

using

namespace

parsing

xml

;

using

namespace

templates

;

using

namespace

stream

;

/*********************************************************************** GuiValueRepr ***********************************************************************/

void

GuiValueRepr

CloneBody

(

Ptr

GuiValueRepr

repr

) {

repr

fromStyle

;

repr

tagPosition

; }

/*********************************************************************** GuiTextRepr ***********************************************************************/

Ptr

GuiValueRepr

GuiTextRepr

Clone

() {

auto

repr

MakePtr

GuiTextRepr

>();

GuiValueRepr

CloneBody

(

repr

);

repr

text

;

return

repr

; }

void

GuiTextRepr

FillXml

(

Ptr

parsing

xml

XmlElement

xml

) {

fromStyle

) {

auto

xmlText

MakePtr

XmlText

>();

xmlText

content

value

text

;

xml

subNodes

Add

(

xmlText

); } }

/*********************************************************************** GuiAttSetterRepr ***********************************************************************/

void

GuiAttSetterRepr

CloneBody

(

Ptr

GuiAttSetterRepr

repr

) {

GuiValueRepr

CloneBody

(

repr

);

FOREACH_INDEXER(GlobalStringKey, name, index, setters.Keys())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

GlobalStringKey

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

setters

Keys

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

GlobalStringKey

name

;

__foreach_iterator__

(

name

);

index

++)

{

auto

src

setters

Values

()

[

index

];

auto

dst

MakePtr

SetterValue

>();

dst

binding

src

binding

;

dst

attPosition

src

attPosition

;

FOREACH(Ptr<GuiValueRepr>, value, src->values)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiValueRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

src

values

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiValueRepr

value

;

__foreach_iterator__

(

value

);)

{

dst

values

Add

(

value

Clone

()); }

repr

setters

Add

(

name

dst

); }

FOREACH_INDEXER(GlobalStringKey, name, index, eventHandlers.Keys())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

GlobalStringKey

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

eventHandlers

Keys

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

GlobalStringKey

name

;

__foreach_iterator__

(

name

);

index

++)

{

auto

src

eventHandlers

Values

()

[

index

];

auto

dst

MakePtr

EventValue

>();

dst

binding

src

binding

;

dst

value

src

value

;

dst

fromStyle

src

fromStyle

;

dst

attPosition

src

attPosition

;

dst

valuePosition

src

valuePosition

;

repr

eventHandlers

Add

(

name

dst

); }

FOREACH_INDEXER(GlobalStringKey, name, index, environmentVariables.Keys())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

GlobalStringKey

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

environmentVariables

Keys

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

GlobalStringKey

name

;

__foreach_iterator__

(

name

);

index

++)

{

auto

src

environmentVariables

Values

()

[

index

];

auto

dst

MakePtr

EnvVarValue

>();

dst

value

src

value

;

dst

fromStyle

src

fromStyle

;

dst

attPosition

src

attPosition

;

dst

valuePosition

src

valuePosition

;

repr

environmentVariables

Add

(

name

dst

); }

repr

instanceName

; }

Ptr

GuiValueRepr

GuiAttSetterRepr

Clone

() {

auto

repr

MakePtr

GuiAttSetterRepr

>();

GuiAttSetterRepr

CloneBody

(

repr

);

repr

fromStyle

;

return

repr

; }

void

GuiAttSetterRepr

FillXml

(

Ptr

parsing

xml

XmlElement

xml

) {

fromStyle

) {

(

instanceName

GlobalStringKey

Empty

) {

auto

attName

MakePtr

XmlAttribute

>();

attName

name

value

L"ref.Name"

;

attName

value

instanceName

ToString

();

xml

attributes

Add

(

attName

); }

for

(

vint

;

setters

Count

();

++) {

auto

key

setters

Keys

()

[

];

auto

value

setters

Values

()

[

];

(

key

GlobalStringKey

Empty

) {

FOREACH(Ptr<GuiValueRepr>, repr, value->values)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiValueRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

value

values

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiValueRepr

repr

;

__foreach_iterator__

(

repr

);)

{

repr

FillXml

(

xml

); } }

else

(

From

(

value

values

).Any([](

Ptr

GuiValueRepr

value

) {

return

value

fromStyle

; })) {

bool

containsElement

From

(

value

values

) .Any([](

Ptr

GuiValueRepr

value

) {

return

value

fromStyle

&& !

value

Cast

GuiTextRepr

>(); });

(

containsElement

) {

auto

xmlProp

MakePtr

XmlElement

>();

xmlProp

name

value

L"att."

key

ToString

();

(

value

binding

GlobalStringKey

Empty

) {

xmlProp

name

value

L"-"

value

binding

ToString

(); }

FOREACH(Ptr<GuiValueRepr>, repr, value->values)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiValueRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

value

values

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiValueRepr

repr

;

__foreach_iterator__

(

repr

);)

{

repr

Cast

GuiTextRepr

>()) {

repr

FillXml

(

xmlProp

); } }

xml

subNodes

Add

(

xmlProp

); }

else

{

FOREACH(Ptr<GuiValueRepr>, repr, value->values)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiValueRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

value

values

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiValueRepr

repr

;

__foreach_iterator__

(

repr

);)

{

(

auto

textRepr

repr

Cast

GuiTextRepr

>()) {

textRepr

fromStyle

) {

auto

att

MakePtr

XmlAttribute

>();

att

name

value

key

ToString

();

(

value

binding

GlobalStringKey

Empty

) {

att

name

value

L"-"

value

binding

ToString

(); }

att

value

textRepr

text

;

xml

attributes

Add

(

att

);

break

; } } } } } }

for

(

vint

;

eventHandlers

Count

();

++) {

auto

key

eventHandlers

Keys

()

[

];

auto

value

eventHandlers

Values

()

[

];

value

fromStyle

) {

auto

xmlEvent

MakePtr

XmlElement

>();

xmlEvent

name

value

L"ev."

key

ToString

();

(

value

binding

GlobalStringKey

Empty

) {

xmlEvent

name

value

L"-"

value

binding

ToString

(); }

xml

subNodes

Add

(

xmlEvent

);

auto

xmlText

MakePtr

XmlCData

>();

xmlText

content

value

;

xmlEvent

subNodes

Add

(

xmlText

); } }

for

(

vint

;

environmentVariables

Count

();

++) {

auto

key

environmentVariables

Keys

()

[

];

auto

value

environmentVariables

Values

()

[

];

value

fromStyle

) {

auto

xmlEnvVar

MakePtr

XmlElement

>();

xmlEnvVar

name

value

L"env."

key

ToString

();

xml

subNodes

Add

(

xmlEnvVar

);

auto

xmlText

MakePtr

XmlText

>();

xmlText

content

value

;

xmlEnvVar

subNodes

Add

(

xmlText

); } } } }

/*********************************************************************** GuiConstructorRepr ***********************************************************************/

Ptr

GuiValueRepr

GuiConstructorRepr

Clone

() {

auto

repr

MakePtr

GuiConstructorRepr

>();

GuiAttSetterRepr

CloneBody

(

repr

);

repr

fromStyle

;

repr

typeNamespace

;

repr

typeName

;

repr

styleName

;

return

repr

; }

void

GuiConstructorRepr

FillXml

(

Ptr

parsing

xml

XmlElement

xml

) {

fromStyle

) {

auto

xmlCtor

MakePtr

XmlElement

>();

(

typeNamespace

GlobalStringKey

Empty

) {

xmlCtor

name

value

typeName

ToString

(); }

else

{

xmlCtor

name

value

typeNamespace

ToString

() +

L":"

typeName

ToString

(); }

(

styleName

) {

auto

attStyle

MakePtr

XmlAttribute

>();

attStyle

name

value

L"ref.Style"

;

attStyle

value

styleName

Value

();

xml

attributes

Add

(

attStyle

); }

GuiAttSetterRepr

FillXml

(

xmlCtor

);

xml

subNodes

Add

(

xmlCtor

); } }

/*********************************************************************** GuiInstanceContext ***********************************************************************/

void

GuiInstanceContext

CollectDefaultAttributes

(

Ptr

GuiResourceItem

resource

GuiAttSetterRepr

ValueList

values

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

(

auto

parser

GetParserManager

()->

GetParser

ElementName

L"INSTANCE-ELEMENT-NAME"

)) {

// test if there is only one text value in the xml

(

xml

subNodes

Count

() ==

) {

(

Ptr

XmlText

text

xml

subNodes

[

Cast

XmlText

>()) {

Ptr

GuiTextRepr

value

new

GuiTextRepr

;

value

text

content

value

;

value

tagPosition

{ {

resource

text

content

codeRange

start

};

values

Add

(

value

); }

else

(

Ptr

XmlCData

text

xml

subNodes

[

Cast

XmlCData

>()) {

Ptr

GuiTextRepr

value

new

GuiTextRepr

;

value

text

content

value

;

value

tagPosition

{ {

resource

text

content

codeRange

start

};

value

tagPosition

column

;

// <![CDATA[

values

Add

(

value

); } }

// collect default attributes

FOREACH(Ptr<XmlElement>, element, XmlGetElements(xml))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlElement

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

XmlGetElements

(

xml

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlElement

element

;

__foreach_iterator__

(

element

);)

{

(

auto

name

parser

->Parse({

resource

element

name

value

element

codeRange

start

errors

)) {

(

name

->IsCtorName()) {

// collect constructor values in the default attribute setter

auto

ctor

LoadCtor

(

resource

element

errors

);

(

ctor

) {

values

Add

(

ctor

); } }

else

name

->IsPropertyElementName() && !

name

->IsEventElementName()) {

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Unknown element name: \""

element

name

value

L"\"."

)); } } } } }

void

GuiInstanceContext

CollectAttributes

(

Ptr

GuiResourceItem

resource

GuiAttSetterRepr

SetteValuerMap

setters

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

(

auto

parser

GetParserManager

()->

GetParser

ElementName

L"INSTANCE-ELEMENT-NAME"

)) {

Ptr

GuiAttSetterRepr

SetterValue

defaultValue

new

GuiAttSetterRepr

SetterValue

;

// collect default attributes

CollectDefaultAttributes

(

resource

defaultValue

values

xml

errors

);

(

defaultValue

values

Count

() >

) {

setters

Add

(

GlobalStringKey

Empty

defaultValue

); }

// collect values

FOREACH(Ptr<XmlElement>, element, XmlGetElements(xml))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlElement

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

XmlGetElements

(

xml

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlElement

element

;

__foreach_iterator__

(

element

);)

{

(

auto

name

parser

->Parse({

resource

element

name

value

element

name

codeRange

start

errors

)) {

(

name

->IsPropertyElementName()) {

// collect a value as a new attribute setter

(

setters

Keys

().

Contains

(

GlobalStringKey

Get

(

name

->name))) {

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Duplicated property \""

name

->name +

L"\"."

)); }

else

{

Ptr

GuiAttSetterRepr

SetterValue

new

GuiAttSetterRepr

SetterValue

;

binding

GlobalStringKey

Get

(

name

->binding);

attPosition

{ {

resource

element

codeRange

start

};

(

name

->binding ==

L"set"

) {

// if the binding is "set", it means that this element is a complete setter element

Ptr

GuiAttSetterRepr

setter

new

GuiAttSetterRepr

;

FillAttSetter

(

resource

setter

element

errors

);

values

Add

(

setter

); }

else

{

// if the binding is not "set", then this is a single-value attribute or a colection attribute

// fill all data into this attribute

CollectDefaultAttributes

(

resource

values

element

errors

); }

(

values

Count

() >

) {

setters

Add

(

GlobalStringKey

Get

(

name

->name),

); } } } } } } }

void

GuiInstanceContext

CollectEvents

(

Ptr

GuiResourceItem

resource

GuiAttSetterRepr

EventHandlerMap

eventHandlers

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

(

auto

parser

GetParserManager

()->

GetParser

ElementName

L"INSTANCE-ELEMENT-NAME"

)) {

// collect values

FOREACH(Ptr<XmlElement>, element, XmlGetElements(xml))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlElement

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

XmlGetElements

(

xml

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlElement

element

;

__foreach_iterator__

(

element

);)

{

(

auto

name

parser

->Parse({

resource

element

name

value

element

name

codeRange

start

errors

)) {

(

name

->IsEventElementName()) {

// collect a value as an event setter

(

eventHandlers

Keys

().

Contains

(

GlobalStringKey

Get

(

name

->name))) {

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Duplicated event \""

name

->name +

L"\"."

)); }

else

{

// test if there is only one text value in the xml

(

element

subNodes

Count

() ==

) {

(

Ptr

XmlText

text

element

subNodes

[

Cast

XmlText

>()) {

auto

value

MakePtr

GuiAttSetterRepr

EventValue

>();

value

binding

GlobalStringKey

Get

(

name

->binding);

value

text

content

value

;

value

attPosition

{ {

resource

element

codeRange

start

};

value

valuePosition

{ {

resource

text

content

codeRange

start

};

eventHandlers

Add

(

GlobalStringKey

Get

(

name

->name),

value

);

(

text

content

codeRange

start

row

text

content

codeRange

end

row

) {

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Multiple lines script should be contained in a CDATA section."

)); }

goto

EVENT_SUCCESS; }

else

(

Ptr

XmlCData

text

element

subNodes

[

Cast

XmlCData

>()) {

auto

value

MakePtr

GuiAttSetterRepr

EventValue

>();

value

binding

GlobalStringKey

Get

(

name

->binding);

value

text

content

value

;

value

attPosition

{ {

resource

element

codeRange

start

};

value

valuePosition

{ {

resource

text

content

codeRange

start

};

value

valuePosition

column

;

// <![CDATA[

eventHandlers

Add

(

GlobalStringKey

Get

(

name

->name),

value

); }

goto

EVENT_SUCCESS; }

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Event script should be contained in a text or CDATA section."

)); EVENT_SUCCESS:; } } } } } }

void

GuiInstanceContext

FillAttSetter

(

Ptr

GuiResourceItem

resource

Ptr

GuiAttSetterRepr

setter

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

(

auto

parser

GetParserManager

()->

GetParser

ElementName

L"INSTANCE-ELEMENT-NAME"

)) {

setter

tagPosition

{ {

resource

xml

codeRange

start

};

// collect attributes as setters

FOREACH(Ptr<XmlAttribute>, att, xml->attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

xml

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

(

auto

name

parser

->Parse({

resource

att

name

value

att

name

codeRange

start

errors

)) {

(

name

->IsReferenceAttributeName()) {

// collect reference attributes

(

name

->name ==

L"Name"

) {

setter

instanceName

GlobalStringKey

Get

(

att

value

); } }

else

(

name

->IsEnvironmentAttributeName()) {

// collect environment variables

(

setter

environmentVariables

Keys

().

Contains

(

GlobalStringKey

Get

(

name

->name))) {

errors

Add

(

GuiResourceError

({ {

resource

att

name

codeRange

start

L"Duplicated environment variable \""

name

->name +

L"\"."

)); }

else

{

auto

value

MakePtr

GuiAttSetterRepr

EnvVarValue

>();

value

att

value

;

value

attPosition

{ {

resource

att

codeRange

start

};

value

valuePosition

{ {

resource

att

value

codeRange

start

};

value

valuePosition

column

;

setter

environmentVariables

Add

(

GlobalStringKey

Get

(

name

->name),

value

); } }

else

(

name

->IsPropertyAttributeName()) {

// collect attributes setters

(

setter

setters

Keys

().

Contains

(

GlobalStringKey

Get

(

name

->name))) {

errors

Add

(

GuiResourceError

({ {

resource

att

name

codeRange

start

L"Duplicated property \""

name

->name +

L"\"."

)); }

else

{

auto

MakePtr

GuiAttSetterRepr

SetterValue

>();

binding

GlobalStringKey

Get

(

name

->binding);

attPosition

{ {

resource

att

codeRange

start

};

setter

setters

Add

(

GlobalStringKey

Get

(

name

->name),

);

Ptr

GuiTextRepr

value

new

GuiTextRepr

;

value

text

att

value

;

value

tagPosition

{ {

resource

att

value

codeRange

start

};

value

tagPosition

column

;

values

Add

(

value

); } }

else

(

name

->IsEventAttributeName()) {

// collect event setters

(

setter

eventHandlers

Keys

().

Contains

(

GlobalStringKey

Get

(

name

->name))) {

errors

Add

(

GuiResourceError

({ {

resource

att

name

codeRange

start

L"Duplicated event \""

name

->name +

L"\"."

)); }

else

{

auto

value

MakePtr

GuiAttSetterRepr

EventValue

>();

value

binding

GlobalStringKey

Get

(

name

->binding);

value

att

value

;

value

attPosition

{ {

resource

att

codeRange

start

};

value

valuePosition

{ {

resource

att

value

codeRange

start

};

value

valuePosition

column

;

setter

eventHandlers

Add

(

GlobalStringKey

Get

(

name

->name),

value

); } }

else

{

errors

Add

(

GuiResourceError

({ {

resource

att

name

codeRange

start

L"Unknown attribute name: \""

att

name

value

L"\"."

)); } } }

// collect attributes and events

CollectAttributes

(

resource

setter

setters

xml

errors

);

CollectEvents

(

resource

setter

eventHandlers

xml

errors

); } }

Ptr

GuiConstructorRepr

GuiInstanceContext

LoadCtor

(

Ptr

GuiResourceItem

resource

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

(

auto

parser

GetParserManager

()->

GetParser

ElementName

L"INSTANCE-ELEMENT-NAME"

)) {

(

auto

ctorName

parser

->Parse({

resource

xml

name

value

xml

name

codeRange

start

errors

)) {

(

ctorName

->IsCtorName()) {

Ptr

GuiConstructorRepr

ctor

new

GuiConstructorRepr

;

ctor

typeNamespace

GlobalStringKey

Get

(

ctorName

->namespaceName);

ctor

typeName

GlobalStringKey

Get

(

ctorName

->name);

// collect attributes as setters

FOREACH(Ptr<XmlAttribute>, att, xml->attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

xml

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

(

auto

attName

parser

->Parse({

resource

att

name

value

att

name

codeRange

start

errors

)) {

(

attName

->IsReferenceAttributeName()) {

(

attName

->name ==

L"Style"

) {

ctor

styleName

att

value

; } } } }

FillAttSetter

(

resource

ctor

xml

errors

);

return

ctor

; }

else

{

errors

Add

(

GuiResourceError

({ {

resource

xml

codeRange

start

L"Wrong constructor name \""

xml

name

value

L"\"."

)); } } }

return

; }

Ptr

GuiInstanceContext

LoadFromXml

(

Ptr

GuiResourceItem

resource

Ptr

parsing

xml

XmlDocument

xml

GuiResourceError

List

errors

) {

Ptr

GuiInstanceContext

context

new

GuiInstanceContext

;

context

tagPosition

{ {

resource

xml

rootElement

codeRange

start

};

(

xml

rootElement

name

value

L"Instance"

) {

(

auto

codeBehindAttr

XmlGetAttribute

(

xml

rootElement

L"ref.CodeBehind"

)) {

context

codeBehind

codeBehindAttr

->value.value ==

L"true"

; }

// load type name

(

auto

classAttr

XmlGetAttribute

(

xml

rootElement

L"ref.Class"

)) {

context

className

classAttr

->value.value;

context

classPosition

= { {

resource

classAttr

->codeRange.start }; }

// load style names

(

auto

styleAttr

XmlGetAttribute

(

xml

rootElement

L"ref.Styles"

)) {

SplitBySemicolon

(

styleAttr

->value.value,

context

stylePaths

);

context

stylePosition

= { {

resource

styleAttr

->codeRange.start }; }

// load namespaces

List

Ptr

XmlAttribute

namespaceAttributes

;

CopyFrom

(

namespaceAttributes

xml

rootElement

attributes

);

XmlGetAttribute

(

xml

rootElement

L"xmlns"

)) {

Ptr

XmlAttribute

att

new

XmlAttribute

;

att

name

value

L"xmlns"

;

att

value

L"presentation::controls::Gui*;"

L"presentation::elements::Gui*Element;"

L"presentation::compositions::Gui*Composition;"

L"presentation::compositions::Gui*;"

L"presentation::templates::Gui*;"

L"system::*;"

L"system::reflection::*;"

L"presentation::*;"

L"presentation::Gui*;"

L"presentation::controls::*;"

L"presentation::controls::list::*;"

L"presentation::controls::tree::*;"

L"presentation::elements::*;"

L"presentation::elements::Gui*;"

L"presentation::elements::text::*;"

L"presentation::compositions::*;"

L"presentation::templates::*;"

L"presentation::theme::*"

;

namespaceAttributes

Add

(

att

); }

FOREACH(Ptr<XmlAttribute>, att, namespaceAttributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

namespaceAttributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

// check if the attribute defines a namespace

WString

attName

att

name

value

;

(

attName

Length

() >=

attName

Left

(

) ==

L"xmlns"

) {

GlobalStringKey

;

(

attName

Length

() >

) {

(

attName

Left

(

) ==

L"xmlns:"

) {

GlobalStringKey

Get

(

attName

Sub

(

attName

Length

() -

)); }

else

{

continue

; } }

// create a data structure for the namespace

Ptr

NamespaceInfo

info

;

vint

index

context

namespaces

Keys

().

IndexOf

(

);

(

index

== -

) {

info

new

NamespaceInfo

;

info

name

;

info

attPosition

{ {

resource

att

codeRange

start

};

context

namespaces

Add

(

info

); }

else

{

info

context

namespaces

Values

()

[

index

]; }

// extract all patterns in the namespace, split the value by ';'

List

WString

patterns

;

SplitBySemicolon

(

att

value

patterns

);

FOREACH(WString, pattern, patterns)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

patterns

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

pattern

;

__foreach_iterator__

(

pattern

);)

{

// add the pattern to the namespace

Ptr

GuiInstanceNamespace

new

GuiInstanceNamespace

;

Pair<vint, vint> star = INVLOC.FindFirst(pattern, L"*", Locale::None);

Pair

vint

star

Locale

Invariant

().

FindFirst

(

pattern

L"*"

Locale

None

);

(

star

key

== -

) {

prefix

pattern

; }

else

{

prefix

pattern

Sub

(

star

key

);

postfix

pattern

Sub

(

star

key

star

value

pattern

Length

() -

star

key

star

value

); }

info

namespaces

Add

(

); } } }

// load instance

FOREACH(Ptr<XmlElement>, element, XmlGetElements(xml->rootElement))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlElement

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

XmlGetElements

(

xml

rootElement

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlElement

element

;

__foreach_iterator__

(

element

);)

{

(

element

name

value

L"ref.Parameter"

) {

auto

attName

XmlGetAttribute

(

element

L"Name"

);

auto

attClass

XmlGetAttribute

(

element

L"Class"

);

(

attName

attClass

) {

auto

parameter

MakePtr

GuiInstanceParameter

>();

parameter

name

GlobalStringKey

Get

(

attName

->value.value);

parameter

className

GlobalStringKey

Get

(

attClass

->value.value);

parameter

tagPosition

{ {

resource

element

codeRange

start

};

parameter

classPosition

= { {

resource

attClass

->value.codeRange.start };

parameter

classPosition

column

;

context

parameters

Add

(

parameter

); }

else

{

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"ref.Parameter requires the following attributes existing at the same time: Name, Class."

)); } }

else

(

element

name

value

L"ref.LocalizedStrings"

) {

auto

attName

XmlGetAttribute

(

element

L"Name"

);

auto

attClass

XmlGetAttribute

(

element

L"Class"

);

auto

attDefault

XmlGetAttribute

(

element

L"Default"

);

(

attName

attClass

) {

auto

localized

MakePtr

GuiInstanceLocalized

>();

localized

name

GlobalStringKey

Get

(

attName

->value.value);

localized

className

GlobalStringKey

Get

(

attClass

->value.value);

localized

tagPosition

{ {

resource

element

codeRange

start

};

localized

classPosition

= { {

resource

attClass

->value.codeRange.start };

localized

classPosition

column

;

(

attDefault

) {

localized

defaultStrings

attDefault

->value.value ==

L"true"

; }

context

localizeds

Add

(

localized

); }

else

{

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"ref.LocalizedStrings requires the following attributes existing at the same time: Name, Class."

)); } }

#define COLLECT_SCRIPT(NAME, SCRIPT, POSITION)\

(element->name.value == L"ref." #NAME)\

if (element->subNodes.Count() == 1)\

if (auto cdata = element->subNodes[0].Cast<XmlCData>())\

context->SCRIPT = cdata->content.value;\

context->POSITION = { {resource},cdata->codeRange.start };\

context->POSITION.column += 9; /* <![CDATA[ */\

goto NAME##_SCRIPT_SUCCESS;\

errors.Add(GuiResourceError({ {resource},element->codeRange.start }, L"Script should be contained in a CDATA section."));\

NAME##_SCRIPT_SUCCESS:;\

else if COLLECT_SCRIPT(Members, memberScript, memberPosition)

else

(

element

name

value

L"ref."

"Members"

) {

(

element

subNodes

Count

() ==

) {

(

auto

cdata

element

subNodes

[

Cast

XmlCData

>()) {

context

memberScript

cdata

content

value

;

context

memberPosition

{ {

resource

cdata

codeRange

start

};

context

memberPosition

column

;

goto

Members_SCRIPT_SUCCESS; } }

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Script should be contained in a CDATA section."

)); Members_SCRIPT_SUCCESS:; }

else if COLLECT_SCRIPT(Ctor, ctorScript, ctorPosition)

else

(

element

name

value

L"ref."

"Ctor"

) {

(

element

subNodes

Count

() ==

) {

(

auto

cdata

element

subNodes

[

Cast

XmlCData

>()) {

context

ctorScript

cdata

content

value

;

context

ctorPosition

{ {

resource

cdata

codeRange

start

};

context

ctorPosition

column

;

goto

Ctor_SCRIPT_SUCCESS; } }

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Script should be contained in a CDATA section."

)); Ctor_SCRIPT_SUCCESS:; }

else if COLLECT_SCRIPT(Dtor, dtorScript, dtorPosition)

else

(

element

name

value

L"ref."

"Dtor"

) {

(

element

subNodes

Count

() ==

) {

(

auto

cdata

element

subNodes

[

Cast

XmlCData

>()) {

context

dtorScript

cdata

content

value

;

context

dtorPosition

{ {

resource

cdata

codeRange

start

};

context

dtorPosition

column

;

goto

Dtor_SCRIPT_SUCCESS; } }

errors

Add

(

GuiResourceError

({ {

resource

element

codeRange

start

L"Script should be contained in a CDATA section."

)); Dtor_SCRIPT_SUCCESS:; }

#undef COLLECT_SCRIPT

else

context

instance

) {

context

instance

LoadCtor

(

resource

element

errors

); } } }

else

{

errors

Add

(

GuiResourceError

({ {

resource

xml

rootElement

codeRange

start

L"The root element of instance should be \"Instance\"."

)); }

return

context

instance

context

nullptr

; }

Ptr

parsing

xml

XmlDocument

GuiInstanceContext

SaveToXml

() {

auto

xmlInstance

MakePtr

XmlElement

>();

xmlInstance

name

value

L"Instance"

; {

auto

attCodeBehind

MakePtr

XmlAttribute

>();

attCodeBehind

name

value

L"ref.CodeBehind"

;

attCodeBehind

value

codeBehind

L"true"

L"false"

;

xmlInstance

attributes

Add

(

attCodeBehind

); }

auto

attClass

MakePtr

XmlAttribute

>();

attClass

name

value

L"ref.Class"

;

attClass

value

className

;

xmlInstance

attributes

Add

(

attClass

);

for

(

vint

;

namespaces

Count

();

++) {

auto

key

namespaces

Keys

()

[

];

auto

value

namespaces

Values

()

[

];

auto

xmlns

MakePtr

XmlAttribute

>();

xmlns

name

value

L"xmlns"

;

(

key

GlobalStringKey

Empty

) {

xmlns

name

value

L":"

key

ToString

(); }

xmlInstance

attributes

Add

(

xmlns

);

for

(

vint

;

value

namespaces

Count

();

++) {

auto

value

namespaces

[

];

(

) {

xmlns

value

L";"

; }

xmlns

value

prefix

L"*"

postfix

; } }

FOREACH(Ptr<GuiInstanceParameter>, parameter, parameters)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiInstanceParameter

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

parameters

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiInstanceParameter

parameter

;

__foreach_iterator__

(

parameter

);)

{

auto

xmlParameter

MakePtr

XmlElement

>();

xmlParameter

name

value

L"ref.Parameter"

;

xmlInstance

subNodes

Add

(

xmlParameter

);

auto

attName

MakePtr

XmlAttribute

>();

attName

name

value

L"Name"

;

attName

value

parameter

name

ToString

();

xmlParameter

attributes

Add

(

attName

);

auto

attClass

MakePtr

XmlAttribute

>();

attClass

name

value

L"Class"

;

attClass

value

parameter

className

ToString

();

xmlParameter

attributes

Add

(

attClass

); }

FOREACH(Ptr<GuiInstanceLocalized>, localized, localizeds)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiInstanceLocalized

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

localizeds

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiInstanceLocalized

localized

;

__foreach_iterator__

(

localized

);)

{

auto

xmlParameter

MakePtr

XmlElement

>();

xmlParameter

name

value

L"ref.LocalizedStrings"

;

xmlInstance

subNodes

Add

(

xmlParameter

);

auto

attName

MakePtr

XmlAttribute

>();

attName

name

value

L"Name"

;

attName

value

localized

name

ToString

();

xmlParameter

attributes

Add

(

attName

);

auto

attClass

MakePtr

XmlAttribute

>();

attClass

name

value

L"Class"

;

attClass

value

localized

className

ToString

();

xmlParameter

attributes

Add

(

attClass

);

auto

attDefault

MakePtr

XmlAttribute

>();

attDefault

name

value

L"Default"

;

attDefault

value

localized

defaultStrings

L"true"

L"false"

;

xmlParameter

attributes

Add

(

attDefault

); }

#define SERIALIZE_SCRIPT(NAME, SCRIPT)\

if (SCRIPT != L"")\

auto xmlScript = MakePtr<XmlElement>();\

xmlScript->name.value = L"ref." #NAME;\

xmlInstance->subNodes.Add(xmlScript);\

auto text = MakePtr<XmlCData>();\

text->content.value = SCRIPT;\

xmlScript->subNodes.Add(text);\

SERIALIZE_SCRIPT(Members, memberScript)

(

memberScript

L""

) {

auto

xmlScript

MakePtr

XmlElement

>();

xmlScript

name

value

L"ref."

"Members"

;

xmlInstance

subNodes

Add

(

xmlScript

);

auto

text

MakePtr

XmlCData

>();

text

content

value

memberScript

;

xmlScript

subNodes

Add

(

text

); }

SERIALIZE_SCRIPT(Ctpr, ctorScript)

(

ctorScript

L""

) {

auto

xmlScript

MakePtr

XmlElement

>();

xmlScript

name

value

L"ref."

"Ctpr"

;

xmlInstance

subNodes

Add

(

xmlScript

);

auto

text

MakePtr

XmlCData

>();

text

content

value

ctorScript

;

xmlScript

subNodes

Add

(

text

); }

SERIALIZE_SCRIPT(Dtor, dtorScript)

(

dtorScript

L""

) {

auto

xmlScript

MakePtr

XmlElement

>();

xmlScript

name

value

L"ref."

"Dtor"

;

xmlInstance

subNodes

Add

(

xmlScript

);

auto

text

MakePtr

XmlCData

>();

text

content

value

dtorScript

;

xmlScript

subNodes

Add

(

text

); }

#undef SERIALIZE_SCRIPT

(

stylePaths

Count

() >

) {

auto

attStyles

MakePtr

XmlAttribute

>();

attStyles

name

value

L"ref.Styles"

;

xmlInstance

attributes

Add

(

attStyles

);

for

(

vint

;

stylePaths

Count

();

++) {

(

) {

attStyles

value

L";"

; }

attStyles

value

stylePaths

[

]; } }

instance

FillXml

(

xmlInstance

);

auto

doc

MakePtr

XmlDocument

>();

doc

rootElement

xmlInstance

;

return

doc

; }

bool

GuiInstanceContext

ApplyStyles

(

Ptr

GuiResourceItem

resource

Ptr

GuiResourcePathResolver

resolver

GuiResourceError

List

errors

) {

appliedStyles

) {

appliedStyles

true

;

List

Ptr

GuiInstanceStyle

styles

;

FOREACH(WString, uri, stylePaths)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

stylePaths

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

uri

;

__foreach_iterator__

(

uri

);)

{

WString

protocol

path

;

(

IsResourceUrl

(

uri

protocol

path

)) {

(

auto

styleContext

resolver

ResolveResource

(

protocol

path

Cast

GuiInstanceStyleContext

>()) {

CopyFrom

(

styles

styleContext

styles

true

); }

else

{

errors

Add

(

GuiResourceError

({

resource

stylePosition

L"Failed to find the style referred in attribute \"ref.Styles\": \""

uri

L"\"."

)); } }

else

{

errors

Add

(

GuiResourceError

({

resource

stylePosition

L"Invalid path in attribute \"ref.Styles\": \""

uri

L"\"."

)); } }

FOREACH(Ptr<GuiInstanceStyle>, style, styles)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiInstanceStyle

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

styles

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiInstanceStyle

style

;

__foreach_iterator__

(

style

);)

{

List

Ptr

GuiConstructorRepr

output

;

ExecuteQuery

(

style

query

this

output

);

FOREACH(Ptr<GuiConstructorRepr>, ctor, output)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiConstructorRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

output

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiConstructorRepr

ctor

;

__foreach_iterator__

(

ctor

);)

{

ApplyStyle

(

style

ctor

); } }

return

true

; }

else

{

return

false

; } }

/*********************************************************************** GuiInstanceStyle ***********************************************************************/

namespace

visitors

{

class

SetStyleMarkVisitor

public

Object

public

GuiValueRepr

IVisitor

{

public

void

Visit

(

GuiTextRepr

repr

)

override

{

repr

fromStyle

true

; }

void

Visit

(

GuiAttSetterRepr

repr

)

override

{

repr

fromStyle

true

;

FOREACH(Ptr<GuiAttSetterRepr::SetterValue>, value, repr->setters.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiAttSetterRepr

SetterValue

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

repr

setters

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiAttSetterRepr

SetterValue

value

;

__foreach_iterator__

(

value

);)

{

FOREACH(Ptr<GuiValueRepr>, subValue, value->values)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiValueRepr

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

value

values

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiValueRepr

subValue

;

__foreach_iterator__

(

subValue

);)

{

subValue

(

this

); } }

FOREACH(Ptr<GuiAttSetterRepr::EventValue>, value, repr->eventHandlers.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiAttSetterRepr

EventValue

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

repr

eventHandlers

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiAttSetterRepr

EventValue

value

;

__foreach_iterator__

(

value

);)

{

value

fromStyle

true

; }

FOREACH(Ptr<GuiAttSetterRepr::EnvVarValue>, value, repr->environmentVariables.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiAttSetterRepr

EnvVarValue

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

repr

environmentVariables

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiAttSetterRepr

EnvVarValue

value

;

__foreach_iterator__

(

value

);)

{

value

fromStyle

true

; } }

void

Visit

(

GuiConstructorRepr

repr

)

override

{

Visit

((

GuiAttSetterRepr

repr

); } }; }

using

namespace

visitors

;

Ptr

GuiInstanceStyle

LoadFromXml

(

Ptr

GuiResourceItem

resource

Ptr

parsing

xml

XmlElement

xml

GuiResourceError

List

errors

) {

auto

style

MakePtr

GuiInstanceStyle

>();

(

auto

pathAttr

XmlGetAttribute

(

xml

L"ref.Path"

)) {

auto

position

pathAttr

->value.codeRange.start;

position

.column +=

;

auto

parser

GetParserManager

()->

GetParser

GuiIqQuery

L"INSTANCE-QUERY"

);

auto

query

parser

->Parse({

resource

pathAttr

->value.value,

position

errors

);

query

)

return

nullptr

;

style

query

; }

else

{

errors

Add

(

GuiResourceError

({ {

resource

xml

codeRange

start

L"Missing attribute \"ref.Path\" in <Style>."

)); }

style

setter

MakePtr

GuiAttSetterRepr

>();

GuiInstanceContext

FillAttSetter

(

resource

style

setter

xml

errors

);

SetStyleMarkVisitor

visitor

;

style

setter

visitor

);

return

style

; }

Ptr

parsing

xml

XmlElement

GuiInstanceStyle

SaveToXml

() {

auto

xmlStyle

MakePtr

XmlElement

>();

xmlStyle

name

value

L"Style"

;

auto

attPath

MakePtr

XmlAttribute

>();

attPath

name

value

L"ref.Path"

;

attPath

value

GenerateToStream

([&](

StreamWriter

writer

) {

GuiIqPrint

(

query

writer

); });

xmlStyle

attributes

Add

(

attPath

);

setter

FillXml

(

xmlStyle

);

return

xmlStyle

; }

/*********************************************************************** GuiInstanceStyleContext ***********************************************************************/

Ptr

GuiInstanceStyleContext

LoadFromXml

(

Ptr

GuiResourceItem

resource

Ptr

parsing

xml

XmlDocument

xml

GuiResourceError

List

errors

) {

auto

context

MakePtr

GuiInstanceStyleContext

>();

(

xml

rootElement

name

value

L"Styles"

) {

FOREACH(Ptr<XmlElement>, styleElement, XmlGetElements(xml->rootElement))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlElement

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

XmlGetElements

(

xml

rootElement

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlElement

styleElement

;

__foreach_iterator__

(

styleElement

);)

{

(

styleElement

name

value

L"Style"

) {

(

auto

style

GuiInstanceStyle

LoadFromXml

(

resource

styleElement

errors

)) {

context

styles

Add

(

style

); } }

else

{

errors

Add

(

GuiResourceError

({ {

resource

styleElement

codeRange

start

L"Unknown element in <Styles>: \""

styleElement

name

value

L"\"."

)); } } }

else

{

errors

Add

(

GuiResourceError

({ {

resource

xml

rootElement

codeRange

start

L"The root element of instance styles should be \"Styles\"."

)); }

return

context

; }

Ptr

parsing

xml

XmlDocument

GuiInstanceStyleContext

SaveToXml

() {

auto

xmlStyles

MakePtr

XmlElement

>();

xmlStyles

name

value

L"Styles"

;

FOREACH(Ptr<GuiInstanceStyle>, style, styles)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

GuiInstanceStyle

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

styles

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

GuiInstanceStyle

style

;

__foreach_iterator__

(

style

);)

{

xmlStyles

subNodes

Add

(

style

SaveToXml

()); }

auto

doc

MakePtr

XmlDocument

>();

doc

rootElement

xmlStyles

;

return

doc

; } } }