GuiGraphicsSharedSizeComposition.cpp

#include "GuiGraphicsSharedSizeComposition.h"

namespace

{

namespace

presentation

{

namespace

compositions

{

using

namespace

reflection

description

;

using

namespace

collections

;

using

namespace

controls

;

using

namespace

elements

;

/*********************************************************************** GuiSharedSizeItemComposition ***********************************************************************/

void

GuiSharedSizeItemComposition

Update

() {

(

parentRoot

) {

parentRoot

ForceCalculateSizeImmediately

(); }

InvokeOnCompositionStateChanged

(); }

void

GuiSharedSizeItemComposition

OnParentLineChanged

() {

GuiBoundsComposition

OnParentLineChanged

();

(

parentRoot

) {

parentRoot

childItems

Remove

(

this

);

parentRoot

nullptr

; }

auto

current

GetParent

();

while

(

current

) {

(

auto

item

dynamic_cast

GuiSharedSizeItemComposition

*>(

current

)) {

break

; }

else

(

auto

root

dynamic_cast

GuiSharedSizeRootComposition

*>(

current

)) {

parentRoot

root

;

break

; }

current

GetParent

(); }

(

parentRoot

) {

parentRoot

childItems

Add

(

this

);

Size

minSize

;

(

sharedWidth

) {

vint

index

parentRoot

itemWidths

Keys

().

IndexOf

(

group

);

(

index

!= -

) {

minSize

parentRoot

itemWidths

Values

()

[

index

]; } }

(

sharedHeight

) {

vint

index

parentRoot

itemHeights

Keys

().

IndexOf

(

group

);

(

index

!= -

) {

minSize

parentRoot

itemHeights

Values

()

[

index

]; } }

SetPreferredMinSize

(

minSize

); } }

GuiSharedSizeItemComposition

() {

SetMinSizeLimitation

(

GuiGraphicsComposition

LimitToElementAndChildren

); }

GuiSharedSizeItemComposition

() { }

const

WString

GuiSharedSizeItemComposition

GetGroup

() {

return

group

; }

void

GuiSharedSizeItemComposition

SetGroup

(

const

WString

value

) {

(

group

value

) {

group

value

;

Update

(); } }

bool

GuiSharedSizeItemComposition

GetSharedWidth

() {

return

sharedWidth

; }

void

GuiSharedSizeItemComposition

SetSharedWidth

(

bool

value

) {

(

sharedWidth

value

) {

sharedWidth

value

;

Update

(); } }

bool

GuiSharedSizeItemComposition

GetSharedHeight

() {

return

sharedHeight

; }

void

GuiSharedSizeItemComposition

SetSharedHeight

(

bool

value

) {

(

sharedHeight

value

) {

sharedHeight

value

;

Update

(); } }

/*********************************************************************** GuiSharedSizeRootComposition ***********************************************************************/

void

GuiSharedSizeRootComposition

AddSizeComponent

(

collections

Dictionary

WString

vint

sizes

const

WString

group

vint

sizeComponent

) {

vint

index

sizes

Keys

().

IndexOf

(

group

);

(

index

== -

) {

sizes

Add

(

group

sizeComponent

); }

else

(

sizes

Values

().

Get

(

index

) <

sizeComponent

) {

sizes

Set

(

group

sizeComponent

); } }

void

GuiSharedSizeRootComposition

CollectSizes

(

collections

Dictionary

WString

vint

widths

collections

Dictionary

WString

vint

heights

) {

FOREACH(GuiSharedSizeItemComposition*, item, childItems)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

GuiSharedSizeItemComposition

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

childItems

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

GuiSharedSizeItemComposition

item

;

__foreach_iterator__

(

item

);)

{

auto

group

item

GetGroup

();

auto

minSize

item

GetPreferredMinSize

();

item

SetPreferredMinSize

(

Size

(

));

auto

size

item

GetPreferredBounds

().

GetSize

();

(

item

GetSharedWidth

()) {

AddSizeComponent

(

widths

group

size

); }

(

item

GetSharedHeight

()) {

AddSizeComponent

(

heights

group

size

); }

item

SetPreferredMinSize

(

minSize

); } }

void

GuiSharedSizeRootComposition

AlignSizes

(

collections

Dictionary

WString

vint

widths

collections

Dictionary

WString

vint

heights

) {

FOREACH(GuiSharedSizeItemComposition*, item, childItems)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

GuiSharedSizeItemComposition

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

childItems

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

GuiSharedSizeItemComposition

item

;

__foreach_iterator__

(

item

);)

{

auto

group

item

GetGroup

();

auto

size

item

GetPreferredMinSize

();

(

item

GetSharedWidth

()) {

size

widths

[

group

]; }

(

item

GetSharedHeight

()) {

size

heights

[

group

]; }

item

SetPreferredMinSize

(

size

); } }

GuiSharedSizeRootComposition

() { }

GuiSharedSizeRootComposition

() { }

void

GuiSharedSizeRootComposition

ForceCalculateSizeImmediately

() {

itemWidths

Clear

();

itemHeights

Clear

();

CollectSizes

(

itemWidths

itemHeights

);

AlignSizes

(

itemWidths

itemHeights

);

GuiBoundsComposition

ForceCalculateSizeImmediately

(); }

Rect

GuiSharedSizeRootComposition

GetBounds

() {

Dictionary

WString

vint

widths

heights

;

CollectSizes

(

widths

heights

);

bool

minSizeModified

CompareEnumerable

(

itemWidths

widths

) !=

CompareEnumerable

(

itemHeights

heights

) !=

;

(

minSizeModified

) {

CopyFrom

(

itemWidths

widths

);

CopyFrom

(

itemHeights

heights

);

AlignSizes

(

itemWidths

itemHeights

);

GuiBoundsComposition

ForceCalculateSizeImmediately

(); }

return

GuiBoundsComposition

GetBounds

(); } } } }