void ofxFlashDisplayObjectContainer :: swapChildrenAt ( int index1, int index2 )
{
if( index1 == index2 )
return;
ofxFlashDisplayObject* child1 = getChildAt( index1 );
ofxFlashDisplayObject* child2 = getChildAt( index2 );
if( child1 == NULL || child2 == NULL )
return;
if( index2 > index1 )
{
children.erase( children.begin() + index2 );
children.erase( children.begin() + index1 );
}
else
{
children.erase( children.begin() + index1 );
children.erase( children.begin() + index2 );
}
if( index1 < index2 )
{
children.insert( children.begin() + index1, child2 );
children.insert( children.begin() + index2, child1 );
}
else
{
children.insert( children.begin() + index2, child1 );
children.insert( children.begin() + index1, child2 );
}
}
MythGenericTree* MythGenericTree::getSelectedChild(bool onlyVisible) const
{
MythGenericTree *selectedChild = NULL;
if (m_selected_subnode)
selectedChild = m_selected_subnode;
else if (onlyVisible)
selectedChild = getVisibleChildAt(0);
else
selectedChild = getChildAt(0);
return selectedChild;
}
MythGenericTree* MythGenericTree::findLeaf()
{
if (m_subnodes->count() > 0)
{
if (m_currentOrderingIndex == -1)
return m_subnodes->first()->findLeaf();
MythGenericTree *first_child = getChildAt(0);
return first_child->findLeaf();
}
return this;
}
bool RandomAccessVerificationAndOptimizationOperator::validateChildren(){
// all it's children must be RandomAccessNodes
for(unsigned i = 0 ; i < getChildrenCount() ; i++){
PhysicalPlanOptimizationNode * child = getChildAt(i);
PhysicalPlanNodeType childType = child->getType();
switch (childType) {
case PhysicalPlanNode_RandomAccessTerm:
case PhysicalPlanNode_RandomAccessAnd:
case PhysicalPlanNode_RandomAccessOr:
case PhysicalPlanNode_RandomAccessNot:
case PhysicalPlanNode_RandomAccessGeo:
continue;
default:
return false;
}
}
return true;
}
bool SortByScoreOptimizationOperator::validateChildren(){
for(unsigned i = 0 ; i < getChildrenCount() ; i++){
PhysicalPlanOptimizationNode * child = getChildAt(i);
PhysicalPlanNodeType childType = child->getType();
switch (childType) {
case PhysicalPlanNode_RandomAccessTerm:
case PhysicalPlanNode_RandomAccessAnd:
case PhysicalPlanNode_RandomAccessOr:
case PhysicalPlanNode_RandomAccessNot:
case PhysicalPlanNode_RandomAccessGeo:
return false;
default:{
continue;
}
}
}
return true;
}
int CUITree::getTreeItemHeight()
{
int nHeight = 0;
// TreeItem 높이를 찾는다.
int n, nChild = getChildCount();
for (n = 0; n < nChild; ++n)
{
CUIBase* pChild = getChildAt(n);
if (pChild->getType() == eUI_CONTROL_TREEITEM)
{
nHeight = pChild->GetHeight();
break;
}
}
return nHeight;
}
bool UnionSortedByIDOptimizationOperator::validateChildren(){
for(unsigned i = 0 ; i < getChildrenCount() ; i++){
PhysicalPlanOptimizationNode * child = getChildAt(i);
PhysicalPlanNodeType childType = child->getType();
switch (childType) {
case PhysicalPlanNode_RandomAccessTerm:
case PhysicalPlanNode_RandomAccessAnd:
case PhysicalPlanNode_RandomAccessOr:
case PhysicalPlanNode_RandomAccessNot:
case PhysicalPlanNode_RandomAccessGeo:
case PhysicalPlanNode_UnionLowestLevelTermVirtualList:
case PhysicalPlanNode_GeoNearestNeighbor:
// this operator cannot have TVL as a child, TVL overhead is not needed for this operator
return false;
default:{
continue;
}
}
}
return true;
}
IntSize WrapPanel::simpleMeasure(const IntSize& _sizeAvailable)
{
IntSize result;
IntSize sizeAvailable = _sizeAvailable;
IntPoint currentPosition;
int maxLineHeight = 0;
bool hasAnyWidget = false;
size_t count = getChildCount();
for (size_t index = 0; index < count; ++ index)
{
Widget* child = getChildAt(index);
Panel::updateMeasure(child, sizeAvailable);
IntSize size = Panel::getDesiredSize(child);
if (((currentPosition.left + size.width) > sizeAvailable.width))
{
if (hasAnyWidget)
{
result.width = (std::max)(result.width, currentPosition.left - mSpacer.width);
currentPosition.left = 0;
currentPosition.top += maxLineHeight + mSpacer.height;
maxLineHeight = 0;
}
}
currentPosition.left += size.width + mSpacer.width;
maxLineHeight = (std::max)(maxLineHeight, size.height);
hasAnyWidget = true;
}
result.height = currentPosition.top + maxLineHeight;
result.width = (std::max)(result.width, currentPosition.left);
return result;
}
void WrapPanel::simpleArrange()
{
IntCoord coordAvailable(0, 0, getWidth(), getHeight());
IntPoint currentPosition = coordAvailable.point();
int maxLineHeight = 0;
bool hasAnyWidget = false;
size_t startLineIndex = 0;
size_t count = getChildCount();
for (size_t index = 0; index < count; ++ index)
{
Widget* child = getChildAt(index);
IntSize size = Panel::getDesiredSize(child);
if (((currentPosition.left + size.width) > coordAvailable.width))
{
if (hasAnyWidget)
{
alignChildLine(startLineIndex, index, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
currentPosition.left = 0;
currentPosition.top += maxLineHeight + mSpacer.height;
maxLineHeight = 0;
startLineIndex = index;
}
}
currentPosition.left += size.width + mSpacer.width;
maxLineHeight = (std::max)(size.height, maxLineHeight);
hasAnyWidget = true;
}
if (startLineIndex < count)
alignChildLine(startLineIndex, count, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
}
void WrapPanel::alignChildLine(size_t _startIndex, size_t _stopIndex, const IntCoord& _coordAvailable, int _lineWidth)
{
int left = _coordAvailable.left;
if (mContentAlign.isHCenter())
left = _coordAvailable.left + ((_coordAvailable.width - _lineWidth) / 2);
else if (mContentAlign.isRight())
left = _coordAvailable.left + (_coordAvailable.width - _lineWidth);
for (size_t index = _startIndex; index < _stopIndex; ++ index)
{
Widget* child = getChildAt(index);
IntSize size = Panel::getDesiredSize(child);
int top = _coordAvailable.top;
if (mContentAlign.isVCenter())
top = _coordAvailable.top + ((_coordAvailable.height - size.height) / 2);
else if (mContentAlign.isBottom())
top = _coordAvailable.top + (_coordAvailable.height - size.height);
Panel::updateArrange(child, IntCoord(left, top, size.width, size.height));
left += size.width + mSpacer.width;
}
}
void WrapPanel::floatArrange()
{
size_t count = getChildCount();
if (count == 0)
return;
Widget* child = getChildAt(0);
IntSize firstSize = Panel::getDesiredSize(child);
if (mSnapFloat.isRight())
Panel::updateArrange(child, IntCoord(getWidth() - firstSize.width, 0, firstSize.width, firstSize.height));
else
Panel::updateArrange(child, IntCoord(0, 0, firstSize.width, firstSize.height));
if (count == 1)
return;
IntCoord coordAvailable(0, 0, getWidth(), getHeight());
IntPoint currentPosition;
int maxLineHeight = 0;
bool hasAnyWidget = false;
size_t startLineIndex = 1;
for (size_t index = 1; index < count; ++ index)
{
bool floatBehaivoir = ((firstSize.height + mSpacer.height) > currentPosition.top);
if (floatBehaivoir)
{
if (mSnapFloat.isRight())
coordAvailable.left = 0;
else
coordAvailable.left = firstSize.width + mSpacer.width;
coordAvailable.width = getWidth() - (firstSize.width + mSpacer.width);
}
else
{
coordAvailable.left = 0;
coordAvailable.width = getWidth();
}
Widget* child = getChildAt(index);
IntSize size = Panel::getDesiredSize(child);
if ((currentPosition.left + size.width) > coordAvailable.width)
{
if (hasAnyWidget || floatBehaivoir)
{
alignChildLine(startLineIndex, index, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
currentPosition.left = 0;
currentPosition.top += maxLineHeight + mSpacer.height;
maxLineHeight = 0;
startLineIndex = index;
}
}
if (floatBehaivoir)
{
if (((currentPosition.left + size.width) > coordAvailable.width))
{
-- index;
continue;
}
}
currentPosition.left += size.width + mSpacer.width;
maxLineHeight = (std::max)(size.height, maxLineHeight);
hasAnyWidget = true;
}
if (startLineIndex < count)
alignChildLine(startLineIndex, count, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
}
IntSize WrapPanel::floatMeasure(const IntSize& _sizeAvailable)
{
IntSize result;
size_t count = getChildCount();
if (count == 0)
return result;
Widget* child = getChildAt(0);
Panel::updateMeasure(child, _sizeAvailable);
IntSize firstSize = Panel::getDesiredSize(child);
if (count == 1)
return firstSize;
IntSize sizeAvailable = _sizeAvailable;
IntPoint currentPosition;
int maxLineHeight = 0;
bool hasAnyWidget = false;
for (size_t index = 1; index < count; ++ index)
{
bool floatBehaivoir = ((firstSize.height + mSpacer.height) > currentPosition.top);
if (floatBehaivoir)
{
sizeAvailable.width = _sizeAvailable.width - (firstSize.width + mSpacer.width);
}
else
{
sizeAvailable.width = _sizeAvailable.width;
}
Widget* child = getChildAt(index);
Panel::updateMeasure(child, sizeAvailable);
IntSize size = Panel::getDesiredSize(child);
if ((currentPosition.left + size.width) > sizeAvailable.width)
{
if (hasAnyWidget || floatBehaivoir)
{
result.width = (std::max)(result.width, currentPosition.left - mSpacer.width);
currentPosition.left = 0;
currentPosition.top += maxLineHeight + mSpacer.height;
maxLineHeight = 0;
}
}
if (floatBehaivoir)
{
if (((currentPosition.left + size.width) > sizeAvailable.width))
{
-- index;
continue;
}
}
currentPosition.left += size.width + mSpacer.width;
maxLineHeight = (std::max)(maxLineHeight, size.height);
hasAnyWidget = true;
}
result.height = (std::max)(firstSize.height, currentPosition.top + maxLineHeight);
result.width = (std::max)(result.width, currentPosition.left);
return result;
}
void FrameLayout::onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int count = getChildCount();
const bool measureMatchParentChildren =
MeasureSpec::getMode(widthMeasureSpec) != MeasureSpec::EXACTLY ||
MeasureSpec::getMode(heightMeasureSpec) != MeasureSpec::EXACTLY;
m_matchParentChildren.clear();
int maxHeight = 0;
int maxWidth = 0;
int childState = 0;
for (int i = 0; i < count; i++) {
shared_ptr<View> child = getChildAt(i);
if (m_measureAllChildren || child->getVisibility() != View::GONE) {
measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
FrameLayoutParams *lp = static_cast<FrameLayoutParams*>(child->getLayoutParams());
maxWidth = std::max(maxWidth, child->getMeasuredWidth() + lp->leftMargin + lp->rightMargin);
maxHeight = std::max(maxHeight, child->getMeasuredHeight() + lp->topMargin + lp->bottomMargin);
childState = combineMeasuredStates(childState, child->getMeasuredState());
if (measureMatchParentChildren) {
if (lp->width == LayoutParams::MATCH_PARENT ||
lp->height == LayoutParams::MATCH_PARENT) {
m_matchParentChildren.push_back(child);
}
}
}
}
// Account for padding too
maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();
// Check against our minimum height and width
maxHeight = std::max(maxHeight, getSuggestedMinimumHeight());
maxWidth = std::max(maxWidth, getSuggestedMinimumWidth());
// Check against our foreground's minimum height and width
/*const Drawable drawable = getForeground();
if (drawable != null) {
maxHeight = std::max(maxHeight, drawable.getMinimumHeight());
maxWidth = std::max(maxWidth, drawable.getMinimumWidth());
}*/
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
resolveSizeAndState(maxHeight, heightMeasureSpec,
childState << MEASURED_HEIGHT_STATE_SHIFT));
count = m_matchParentChildren.size();
if (count > 1) {
for (int i = 0; i < count; i++) {
shared_ptr<View> child = m_matchParentChildren[i];
MarginLayoutParams *lp = static_cast<MarginLayoutParams*>(child->getLayoutParams());
int childWidthMeasureSpec;
int childHeightMeasureSpec;
if (lp->width == LayoutParams::MATCH_PARENT) {
childWidthMeasureSpec = MeasureSpec::makeMeasureSpec(getMeasuredWidth() -
getPaddingLeftWithForeground() - getPaddingRightWithForeground() -
lp->leftMargin - lp->rightMargin,
MeasureSpec::EXACTLY);
} else {
childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
lp->leftMargin + lp->rightMargin,
lp->width);
}
if (lp->height == LayoutParams::MATCH_PARENT) {
childHeightMeasureSpec = MeasureSpec::makeMeasureSpec(getMeasuredHeight() -
getPaddingTopWithForeground() - getPaddingBottomWithForeground() -
lp->topMargin - lp->bottomMargin,
MeasureSpec::EXACTLY);
} else {
childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
lp->topMargin + lp->bottomMargin,
lp->height);
}
child->measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
}
}
void FrameLayout::onLayout(bool changed, int left, int top, int right, int bottom) {
CCLOG("onLayout(%s) %d, %d, %d, %d", m_id.c_str(), left, top, right, bottom);
const int count = getChildCount();
const int parentLeft = getPaddingLeftWithForeground();
const int parentRight = right - left - getPaddingRightWithForeground();
const int parentTop = getPaddingTopWithForeground();
const int parentBottom = bottom - top - getPaddingBottomWithForeground();
m_foregroundBoundsChanged = true;
for (int i = 0; i < count; i++) {
shared_ptr<View> child = getChildAt(i);
if (child->getVisibility() != View::GONE) {
FrameLayoutParams *lp = static_cast<FrameLayoutParams*>(child->getLayoutParams());
const int width = child->getMeasuredWidth();
const int height = child->getMeasuredHeight();
int childLeft;
int childTop;
int gravity = lp->gravity;
if (gravity == -1) {
gravity = DEFAULT_CHILD_GRAVITY;
}
const int layoutDirection = getLayoutDirection();
const int absoluteGravity = Gravity::getAbsoluteGravity(gravity, layoutDirection);
const int verticalGravity = gravity & Gravity::VERTICAL_GRAVITY_MASK;
switch (absoluteGravity & Gravity::HORIZONTAL_GRAVITY_MASK) {
case Gravity::LEFT:
childLeft = parentLeft + lp->leftMargin;
break;
case Gravity::CENTER_HORIZONTAL:
childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
lp->leftMargin - lp->rightMargin;
break;
case Gravity::RIGHT:
childLeft = parentRight - width - lp->rightMargin;
break;
default:
childLeft = parentLeft + lp->leftMargin;
}
switch (verticalGravity) {
case Gravity::TOP:
childTop = parentTop + lp->topMargin;
break;
case Gravity::CENTER_VERTICAL:
childTop = parentTop + (parentBottom - parentTop - height) / 2 +
lp->topMargin - lp->bottomMargin;
break;
case Gravity::BOTTOM:
childTop = parentBottom - height - lp->bottomMargin;
break;
default:
childTop = parentTop + lp->topMargin;
}
child->layout(childLeft, childTop, childLeft + width, childTop + height);
}
}
}
