OGRErr OGR_SRSNode::applyRemapper( const char *pszNode, char **papszSrcValues, char **papszDstValues, int nStepSize, int bChildOfHit ) { int i; /* -------------------------------------------------------------------- */ /* Scan for value, and replace if our parent was a "hit". */ /* -------------------------------------------------------------------- */ if( bChildOfHit || pszNode == NULL ) { for( i = 0; papszSrcValues[i] != NULL; i += nStepSize ) { if( EQUAL(papszSrcValues[i],pszValue) && ! EQUAL(papszDstValues[i],"") ) { SetValue( papszDstValues[i] ); break; } } } /* -------------------------------------------------------------------- */ /* Are the the target node? */ /* -------------------------------------------------------------------- */ if( pszNode != NULL ) bChildOfHit = EQUAL(pszValue,pszNode); /* -------------------------------------------------------------------- */ /* Recurse */ /* -------------------------------------------------------------------- */ for( i = 0; i < GetChildCount(); i++ ) { GetChild(i)->applyRemapper( pszNode, papszSrcValues, papszDstValues, nStepSize, bChildOfHit ); } return OGRERR_NONE; }
// Write the List in OOGL format. int GeomList::Save(char *indent, IoDataStream *s) { const char *INDENT = indent ? indent : ""; s->PrintF("%sLIST", INDENT); if (mpName) { s->PrintF(" # %s", mpName); } s->PrintF("\n"); int i, n = GetChildCount(); char buffer[1024], *NEWINDENT; if (indent) { sprintf(buffer, "%s ", indent); NEWINDENT = buffer; } else { NEWINDENT = NULL; } for (i = 0; i < n; i++) { s->PrintF("%s{\n", INDENT); mGeomList[i]->Save(NEWINDENT, s); s->PrintF("%s}\n", INDENT); } return !s->error(); }
bool StorageCollectionSparePool::BuildYourValueSet(){ U32 i; StorageElement *pElement; DesignatorId id; // collect your size m_capacity = 0; for( i = 0; i < GetChildCount(); i++ ){ pElement = (StorageElement *)GetChild( i ); m_capacity += pElement->GetCapacity(); } StorageCollection::BuildYourValueSet(); AddGenericValue( (char *)&m_dedicatedHostId, sizeof(m_dedicatedHostId), SSAPI_STORAGE_COLL_SPAREPOOL_FID_HOST_ID ); return true; }
JBoolean JNamedTreeNode::FindNamedChild ( const JCharacter* name, const JNamedTreeNode** node ) const { const JSize count = GetChildCount(); for (JIndex i=1; i<=count; i++) { *node = GetNamedChild(i); if ((**node).GetName() == name) { return kJTrue; } } *node = NULL; return kJFalse; }
JBoolean JFSFileTreeNodeBase::Update ( const JBoolean force, JFSFileTreeNodeBase** updateNode ) { JBoolean changed = kJFalse; const JSize count = GetChildCount(); for (JIndex i=1; i<=count; i++) { JFSFileTreeNodeBase* node = dynamic_cast<JFSFileTreeNodeBase*>(GetChild(i)); assert (node != NULL); if (node->Update(force, updateNode)) { changed = kJTrue; } } return changed; }
std::ostream & TKTry:: Release(std::ostream & s) const { DoLabel(s); // try must have braces switch (GetChildCount()) { case 2: { // try-finally s << "try"; Token & what = GetFirstChild(); // Add braces if (what.GetType() == TokenType::TO_BRACE_O) { what.Release(s); } else { s << '{'; what.Release(s); s << '}'; } s << "finally"; Token & final = GetChild(1); // Add braces if (final.GetType() == TokenType::TO_BRACE_O) { final.Release(s); } else { s << '{'; final.Release(s); s << '}'; }
ECode ShortcutAndWidgetContainer::OnLayout( /* [in] */ Boolean changed, /* [in] */ Int32 l, /* [in] */ Int32 t, /* [in] */ Int32 r, /* [in] */ Int32 b) { Int32 count; GetChildCount(&count); for (Int32 i = 0; i < count; i++) { AutoPtr<IView> child; ViewGroup::GetChildAt(i, (IView**)&child); Int32 visibility; child->GetVisibility(&visibility); if (visibility != GONE) { AutoPtr<IViewGroupLayoutParams> params; child->GetLayoutParams((IViewGroupLayoutParams**)¶ms); AutoPtr<CellLayout::LayoutParams> lp = (CellLayout::LayoutParams*)IObject::Probe(params); Int32 childLeft = lp->mX; Int32 childTop = lp->mY; child->Layout(childLeft, childTop, childLeft + lp->mWidth, childTop + lp->mHeight); if (lp->mDropped) { lp->mDropped = FALSE; AutoPtr<ArrayOf<Int32> > cellXY = mTmpCellXY; GetLocationOnScreen(cellXY); AutoPtr<IBinder> token; GetWindowToken((IBinder**)&token); mWallpaperManager->SendWallpaperCommand(token, IWallpaperManager::COMMAND_DROP, (*cellXY)[0] + childLeft + lp->mWidth / 2, (*cellXY)[1] + childTop + lp->mHeight / 2, 0, NULL); } } } return NOERROR; }
void QuadTreeNode::AddMesh(QuadTreeMesh *new_mesh, int depth) { size_t meshes_size = meshes.size(); // If we have reached the last level of the quad tree, add the mesh and return if(depth == 0) { meshes.push_back(new_mesh); return; } // If this node has no meshes or children, go ahead and add the mesh to it if(GetChildCount() == 0 && meshes_size < QUADTREE_TARGET_LEAF_SIZE) { meshes.push_back(new_mesh); return; } // If there are already meshes at this node, add it anyway if it's close enough to the first one if(meshes_size > 0) { D3DXVECTOR3 diff = new_mesh->sphere.center - meshes[0]->sphere.center; if(D3DXVec3Length(&diff) <= QUADTREE_MIN_DIST) { meshes.push_back(new_mesh); return; } } // Push down the new mesh and the existing ones PushDown(new_mesh, depth); for (size_t i = 0; i != meshes_size; ++i) PushDown(meshes[i], depth); // Clear mesh list meshes.clear(); }
void IconMerger::CheckOverflow( /* [in] */ Int32 width) { if (mMoreView == NULL) return; Int32 N = GetChildCount(); Int32 visibleChildren = 0, visibility; for (Int32 i = 0; i < N; i++) { AutoPtr<IView> childView = GetChildAt(i); childView->GetVisibility(&visibility); if (visibility != IView::GONE) visibleChildren++; } mMoreView->GetVisibility(&visibility); Boolean overflowShown = (visibility == IView::VISIBLE); // let's assume we have one more slot if the more icon is already showing if (overflowShown) visibleChildren--; Boolean moreRequired = visibleChildren * mIconSize > width; if (moreRequired != overflowShown) { AutoPtr<IRunnable> runnable = new SetVisibilityRunnable(moreRequired, this); Post(runnable); } }
int OGR_SRSNode::NeedsQuoting() const { // non-terminals are never quoted. if( GetChildCount() != 0 ) return FALSE; // As per bugzilla bug 201, the OGC spec says the authority code // needs to be quoted even though it appears well behaved. if( poParent != NULL && EQUAL(poParent->GetValue(),"AUTHORITY") ) return TRUE; // As per bugzilla bug 294, the OGC spec says the direction // values for the AXIS keywords should *not* be quoted. if( poParent != NULL && EQUAL(poParent->GetValue(),"AXIS") && this != poParent->GetChild(0) ) return FALSE; // Strings starting with e or E are not valid numeric values, so they // need quoting, like in AXIS["E",EAST] if( (pszValue[0] == 'e' || pszValue[0] == 'E') ) return TRUE; // Non-numeric tokens are generally quoted while clean numeric values // are generally not. for( int i = 0; pszValue[i] != '\0'; i++ ) { if( (pszValue[i] < '0' || pszValue[i] > '9') && pszValue[i] != '.' && pszValue[i] != '-' && pszValue[i] != '+' && pszValue[i] != 'e' && pszValue[i] != 'E' ) return TRUE; } return FALSE; }
void StorageElementArray::ReportYourUnderlyingDevices( Container &devices ){ SList tempContainer; StorageElement *pElement; U32 index; DesignatorId *pId; devices.RemoveAll(); for( index = 0 ; index < GetChildCount(); index++ ){ // request a list for every child pElement = (StorageElement *)GetChild( index ); pElement->ReportYourUnderlyingDevices( tempContainer ); // move ids into the main vector while( tempContainer.Count() ){ tempContainer.GetAt( (CONTAINER_ELEMENT &)pId, 0 ); tempContainer.RemoveAt( 0 ); devices.Add( (CONTAINER_ELEMENT) pId ); } } }
void CCWidget::MultiplySize(float byIDLWidth, float byIDLHeight, float byCurrWidth, float byCurrHeight){ if(GetIDLRect().w>0 && GetIDLRect().h>0) { m_Rect.x = int(m_IDLRect.x * byIDLWidth +0.5f); m_Rect.w = int(m_IDLRect.w * byIDLWidth +0.5f); m_Rect.y = int(m_IDLRect.y * byIDLHeight +0.5f); m_Rect.h = int(m_IDLRect.h * byIDLHeight +0.5f); } else { m_Rect.x = int(m_Rect.x * byCurrWidth +0.5f); m_Rect.w = int(m_Rect.w * byCurrWidth +0.5f); m_Rect.y = int(m_Rect.y * byCurrHeight +0.5f); m_Rect.h = int(m_Rect.h * byCurrHeight +0.5f); } SetBoundsAlignment( GetBoundsAlignment(), -1, -1); int n = GetChildCount(); for( int i = 0; i < n; ++i) { GetChild(i)->MultiplySize(byIDLWidth, byIDLHeight, byCurrWidth, byCurrHeight); } }
bool QuadTreeNode::Optimize() { //Call this function on each child for(size_t i = 0; i < 4; ++i) { QuadTreeNode *old_child = children[i]; if(old_child && old_child->Optimize()) { //This child has only one child of its own so it should be removed //First get the child QuadTreeNode *new_child = 0; for(size_t j = 0; j < 4; ++j) { new_child = old_child->children[j]; if(new_child) { old_child->children[j] = 0; break; } } // Replace this child with its child children[i] = new_child; // old_child dealloc handled when MemoryPool is flushed } } // Report number of children remaining in this node to calling function after optimization is complete if(GetChildCount() == 1) { // This node should be removed return true; } return false; }
long CXmlUtil::FindElement(XMLDOMElementPtr& outEle, const XMLDOMElementPtr& parent, const wchar_t* pszElement, const wchar_t* pszField, const wchar_t* value) { NL(value); XMLDOMElementPtr ele; long nCount = GetChildCount(parent, pszElement); long i; outEle = NULL; for (i = nCount - 1; i >= 0; i--) { if (GetChild(ele, parent, pszElement, i) && _wcsicmp(GetField(ele, pszField).c_str(), value) == 0) { outEle = ele; break; } } return i; }
//----------------------------------------------------------------------------- // Purpose: Removes all instances of a given object from this node. // Input : pObject - //----------------------------------------------------------------------------- CCullTreeNode *CCullTreeNode::FindCullTreeObjectRecurse(CMapClass *pObject) { for (int i = 0; i < m_Objects.Count(); i++) { CMapClass *pCurrent = m_Objects[i]; if (pCurrent == pObject) { return(this); } } int nChildCount = GetChildCount(); for (int nChild = 0; nChild < nChildCount; nChild++) { CCullTreeNode *pChild = GetCullTreeChild(nChild); CCullTreeNode *pFound = pChild->FindCullTreeObjectRecurse(pObject); if (pFound != NULL) { return(pFound); } } return(NULL); }
ECode ShortcutAndWidgetContainer::DispatchDraw( /* [in] */ ICanvas* canvas) { //@SuppressWarnings("all") // suppress dead code warning const Boolean debug = FALSE; if (debug) { // Debug drawing for hit space AutoPtr<IPaint> p; CPaint::New((IPaint**)&p); p->SetColor(0x6600FF00); Int32 count; GetChildCount(&count); for (Int32 i = count - 1; i >= 0; i--) { AutoPtr<IView> child; ViewGroup::GetChildAt(i, (IView**)&child); AutoPtr<IViewGroupLayoutParams> params; child->GetLayoutParams((IViewGroupLayoutParams**)¶ms); AutoPtr<CellLayout::LayoutParams> lp = (CellLayout::LayoutParams*)IObject::Probe(params); canvas->DrawRect(lp->mX, lp->mY, lp->mX + lp->mWidth, lp->mY + lp->mHeight, p); } } return ViewGroup::DispatchDraw(canvas); }
void CHudChatFilterPanel::SetVisible(bool state) { if ( state == true ) { for (int i = 0; i < GetChildCount(); i++) { CHudChatFilterCheckButton *pButton = dynamic_cast < CHudChatFilterCheckButton * > ( GetChild(i) ); if ( pButton ) { if ( cl_chatfilters.GetInt() & pButton->GetFilterFlag() ) { pButton->SetSelected( true ); } else { pButton->SetSelected( false ); } } } } BaseClass::SetVisible( state ); }
bool nsLineBox::CachedIsEmpty() { if (mFlags.mDirty) { return IsEmpty(); } if (mFlags.mEmptyCacheValid) { return mFlags.mEmptyCacheState; } bool result; if (IsBlock()) { result = mFirstChild->CachedIsEmpty(); } else { PRInt32 n; nsIFrame *kid; result = true; for (n = GetChildCount(), kid = mFirstChild; n > 0; --n, kid = kid->GetNextSibling()) { if (!kid->CachedIsEmpty()) { result = false; break; } } if (HasBullet()) { result = false; } } mFlags.mEmptyCacheValid = true; mFlags.mEmptyCacheState = result; return result; }
wxObject* wxsGridBagSizer::OnBuildPreview(wxWindow* Parent,long Flags) { wxWindow* NewParent = Parent; if ( !(Flags & pfExact) ) { NewParent = new wxsSizerPreview(Parent); } wxGridBagSizer* Sizer = OnBuildSizerPreview(NewParent); int Count = GetChildCount(); for ( int i=0; i<Count; i++ ) { wxsItem* Child = GetChild(i); wxsGridBagSizerExtra* _Extra = (wxsGridBagSizerExtra*)GetChildExtra(i); // Reset span in case of wrong values if (_Extra->colspan < 1) _Extra->colspan = 1; if (_Extra->rowspan < 1) _Extra->rowspan = 1; // How many rows / cols ? int nbRows = 0; int nbCols = 0; for (int j = 0 ; j < Count ; j++) { wxsGridBagSizerExtra* ExtraRows = (wxsGridBagSizerExtra*)GetChildExtra(j); if (nbRows < ExtraRows->row + ExtraRows->rowspan) nbRows = ExtraRows->row + ExtraRows->rowspan; if (nbCols < ExtraRows->col + ExtraRows->colspan) nbCols = ExtraRows->col + ExtraRows->colspan; } // Set the position in the sizer in case of wrong values if (_Extra->col < 0 && _Extra->row < 0) { _Extra->col = 0; _Extra->row = nbRows; } if (_Extra->col < 0) _Extra->col = nbCols; if (_Extra->row < 0) _Extra->row = nbRows; // We pass either Parent passed to current BuildPreview function // or pointer to additional parent currently created wxObject* ChildPreview = Child->BuildPreview(NewParent,Flags); if ( !ChildPreview ) continue; wxSizer* ChildAsSizer = wxDynamicCast(ChildPreview,wxSizer); wxWindow* ChildAsWindow = wxDynamicCast(ChildPreview,wxWindow); wxGBSizerItem* ChildAsItem = wxDynamicCast(ChildPreview,wxGBSizerItem); if ( ChildAsSizer ) { Sizer->Add(ChildAsSizer, wxGBPosition(_Extra->row, _Extra->col), wxGBSpan(_Extra->rowspan, _Extra->colspan), wxsSizerFlagsProperty::GetWxFlags(_Extra->Flags), _Extra->Border.GetPixels(Parent)); } else if ( ChildAsWindow ) { Sizer->Add(ChildAsWindow, wxGBPosition(_Extra->row, _Extra->col), wxGBSpan(_Extra->rowspan, _Extra->colspan), wxsSizerFlagsProperty::GetWxFlags(_Extra->Flags), _Extra->Border.GetPixels(Parent)); } else if ( ChildAsItem ) { ChildAsItem->SetProportion(_Extra->Proportion); ChildAsItem->SetFlag(wxsSizerFlagsProperty::GetWxFlags(_Extra->Flags)); ChildAsItem->SetBorder(_Extra->Border.GetPixels(Parent)); ChildAsItem->SetSpan(wxGBSpan(_Extra->rowspan, _Extra->colspan)); ChildAsItem->SetPos(wxGBPosition(_Extra->row, _Extra->col)); Sizer->Add(ChildAsItem); } } if ( !(Flags & pfExact) ) { NewParent->SetSizer(Sizer); if ( !GetChildCount() ) { // Setting custom size for childless sizer to prevent // zero-size items NewParent->SetInitialSize(wxSize(20,20)); NewParent->SetSizeHints(20,20); NewParent->SetSize(wxSize(20,20)); } else { Sizer->Fit(NewParent); Sizer->SetSizeHints(NewParent); } return NewParent; } return Sizer; }
void Control::MeasureChildren(Size availableSize) const { for (size_t i = 0; i < GetChildCount(); i++) { GetChild(i)->Measure(availableSize); } }
/* readonly attribute long anchors; */ NS_IMETHODIMP nsHTMLImageMapAccessible::GetAnchors(PRInt32 *aAnchors) { return GetChildCount(aAnchors); }
bool MFrame::OnShow() { if(GetChildCount()>0) GetChild(0)->SetFocus(); return true; }
wxObject* wxsDialog::OnBuildPreview(wxWindow* Parent,long Flags) { wxWindow* NewItem = 0; wxDialog* Dlg = 0; // In case of frame and dialog when in "Exact" mode, we do not create // new object, but use Parent and call Create for it. if ( Flags & pfExact ) { Dlg = wxDynamicCast(Parent,wxDialog); if ( Dlg ) { Dlg->Create(0,GetId(),Title,wxDefaultPosition,wxDefaultSize,Style()); Dlg->SetClientSize(Size(wxTheApp->GetTopWindow())); Dlg->Move(Pos(wxTheApp->GetTopWindow())); } NewItem = Dlg; SetupWindow(NewItem,Flags); AddChildrenPreview(NewItem,Flags); if ( Centered ) { Dlg->Centre(); } } else { NewItem = new wxsGridPanel(Parent,GetId(),wxPoint(0,0),Size(Parent),0); NewItem->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); SetupWindow(NewItem,Flags); AddChildrenPreview(NewItem,Flags); // wxPanel tends to behave very strange when it has children and no sizer, // we have to manually resize it's content if ( !GetChildCount() || GetChild(0)->GetType()!=wxsTSizer ) { wxSize NewSize = Size(Parent); if ( !NewSize.IsFullySpecified() ) { NewSize.SetDefaults(wxSize(400,450)); NewItem->SetSize(NewSize); #if wxCHECK_VERSION(2,8,0) NewItem->SetInitialSize(NewSize); #else NewItem->SetBestFittingSize(NewSize); #endif if ( GetChildCount() == 1 ) { // If there's only one child it's size gets dialog's size wxWindow* ChildPreview = wxDynamicCast(GetChild(0)->GetLastPreview(),wxWindow); if ( ChildPreview ) { ChildPreview->SetSize(0,0,NewItem->GetClientSize().GetWidth(),NewItem->GetClientSize().GetHeight()); } } } else { NewItem->SetSize(NewSize); #if wxCHECK_VERSION(2,8,0) NewItem->SetInitialSize(NewSize); #else NewItem->SetBestFittingSize(NewSize); #endif } } } return NewItem; }
PRUint32 nsHTMLImageMapAccessible::AnchorCount() { return GetChildCount(); }
void GUIcontrol::Process() { if(visible) { if(GetChildCount() == 0) { if(PointInBox(mouseX, mouseY, GetPosX(), GetPosY(), GetPatternWidth(), GetPatternHeight())) { GUIMessage temp_message; if(GetPatternCount() > 1) SetCurrentPattern(1); //temp_message.from = GetGID(); //temp_message.a1 = MOUSE_OVER; //temp_message.a2 = 0; if(mouse[0]) { _pressed = true; //mouse[0] = false; if(GetPatternCount() > 1) { SetCurrentPattern(2); _pos_dx = 1; _pos_dy = 1; if(_caption) { _caption_dx = 1; _caption_dy = 1; } } } else { _pos_dx = 0; _pos_dy = 0; if(_caption) { _caption_dx = 0; _caption_dy = 0; } if(_pressed) { _pressed = false; temp_message.from = GetGID(); temp_message.a1 = MOUSE_LEFT_CLICKED; temp_message.a2 = 0; temp_message.solved = false; SendMessage(temp_message); } } } else { if(GetCurrentPattern() != 0) SetCurrentPattern(0); } } } }
void CFormulaNode::Recalculate_VerticalCenter( const SizeFde &sz ) { RealFde vc = sz.height() / 2.0; switch( getAlignmentType() ) { case FBtnChildPos::Child: if( getAlignmentValue() >= 1 && (getAlignmentValue() - 1) < getGraphPrimNumber() ) { const RectFde& _t = getGraphPrimitivePositionRect( getAlignmentValue() - 1 ); vc = (_t.top() + _t.bottom()) / 2.0; } break; case FBtnChildPos::Child_Average: if( getAlignmentValue() >= 1 && (getAlignmentValue() - 1) < getGraphPrimNumber() ) { vc = 0.0; for( long i = 0; i <= getAlignmentValue() - 1; i++ ) { const RectFde& _t = getGraphPrimitivePositionRect( i ); vc += _t.top() + _t.bottom(); } vc = vc / (getAlignmentValue() * 2.0); } break; case FBtnChildPos::MSPACE_Exact_HeightDepth: case FBtnChildPos::Frame: if( (getAlignmentValue() - 1) >= 0 && (getAlignmentValue() - 1) < GetChildCount() ) { CNode *pNode = GetChild( getAlignmentValue() - 1 ); if( pNode ) vc = pNode->GetPosition().y() + pNode->GetVerticalCenter(); } break; case FBtnChildPos::Frame_Blank_Average: { CNode *pNodeFirst = GetFirstChild(); CNode *pNodeLast = GetLastChild(); if( pNodeFirst != NULL && pNodeLast != NULL ) { vc = (pNodeFirst->GetPosition().y() + pNodeFirst->GetSize().height() + pNodeLast->GetPosition().y()) / 2.0; } } break; case FBtnChildPos::Half: break; case FBtnChildPos::TableAxis: if( (getAlignmentValue() - 1) >= 0 && (getAlignmentValue() - 1) < GetChildCount() ) { CNode *pNode = GetChild( getAlignmentValue() - 1 ); if( pNode ) vc = pNode->GetPosition().y() + pNode->GetSize().height() / 2.0; } break; case FBtnChildPos::TableCenter2Baseline: case FBtnChildPos::TableTop2Baseline: case FBtnChildPos::TableBottom2Baseline: { RealFde asc = ::getCurrentDefaultAscent( GetLevel() ); RealFde h = ::getCurrentDefaultSize( GetLevel() ).height(); vc = getAscent( sz ) - asc + h - asc / 2.0; } break; default: break; } SetVerticalCenter( vc ); }
OGRErr OGR_SRSNode::FixupOrdering() { int i; /* -------------------------------------------------------------------- */ /* Recurse ordering children. */ /* -------------------------------------------------------------------- */ for( i = 0; i < GetChildCount(); i++ ) GetChild(i)->FixupOrdering(); if( GetChildCount() < 3 ) return OGRERR_NONE; /* -------------------------------------------------------------------- */ /* Is this a node for which an ordering rule exists? */ /* -------------------------------------------------------------------- */ const char * const * papszRule = NULL; for( i = 0; apszOrderingRules[i] != NULL; i++ ) { if( EQUAL(apszOrderingRules[i][0],pszValue) ) { papszRule = apszOrderingRules[i] + 1; break; } } if( papszRule == NULL ) return OGRERR_NONE; /* -------------------------------------------------------------------- */ /* If we have a rule, apply it. We create an array */ /* (panChildPr) with the priority code for each child (derived */ /* from the rule) and we then bubble sort based on this. */ /* -------------------------------------------------------------------- */ int *panChildKey = (int *) CPLCalloc(sizeof(int),GetChildCount()); for( i = 1; i < GetChildCount(); i++ ) { panChildKey[i] = CSLFindString( (char**) papszRule, GetChild(i)->GetValue() ); if( panChildKey[i] == -1 ) { CPLDebug( "OGRSpatialReference", "Found unexpected key %s when trying to order SRS nodes.", GetChild(i)->GetValue() ); } } /* -------------------------------------------------------------------- */ /* Sort - Note we don't try to do anything with the first child */ /* which we assume is a name string. */ /* -------------------------------------------------------------------- */ int j, bChange = TRUE; for( i = 1; bChange && i < GetChildCount()-1; i++ ) { bChange = FALSE; for( j = 1; j < GetChildCount()-i; j++ ) { if( panChildKey[j] == -1 || panChildKey[j+1] == -1 ) continue; if( panChildKey[j] > panChildKey[j+1] ) { OGR_SRSNode *poTemp = papoChildNodes[j]; int nKeyTemp = panChildKey[j]; papoChildNodes[j] = papoChildNodes[j+1]; papoChildNodes[j+1] = poTemp; nKeyTemp = panChildKey[j]; panChildKey[j] = panChildKey[j+1]; panChildKey[j+1] = nKeyTemp; bChange = TRUE; } } } CPLFree( panChildKey ); return OGRERR_NONE; }
void CParentNode::iterateNodeTree_ToWidth( NODE_TREE_ITERATOR call_back, void *arg ) { call_back( this, arg ); for( long i = 0; i < GetChildCount(); i++ ) GetChild( i )->iterateNodeTree_ToWidth( call_back, arg ); }
int CFormulaNode::RunCalc() { if( !getCalc() ) { if( getCalcButtonID().length() ) setMissButton(); return 0; } if( !getCalc()->isPositionRunExist() ) return 0; QVector<RealFde> frames_ltrb; frames_ltrb.fill( 0.0, 4 * GetChildCount() ); QVector<RealFde> frames_margin_ltrb; frames_margin_ltrb.fill( 0.0, 4 * GetChildCount() ); QVector<RealFde> primitive_ltrb; primitive_ltrb.fill( 0.0, 4 * GetChildCount() ); long i; CNode *pCurNode = GetFirstChild(); if( pCurNode->GetType() != NODE_FRAME ) return 0; for( i = 0; i < GetChildCount() && pCurNode; pCurNode = pCurNode->GetNext(), i++ ) { frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] = pCurNode->GetPosition().x(); frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] = pCurNode->GetPosition().y(); frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] = pCurNode->GetPosition().x() + pCurNode->GetSize().width(); frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] = pCurNode->GetPosition().y() + pCurNode->GetSize().height(); frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] = ((CFrameNode*) pCurNode)->getLeftIndent(); frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] = ((CFrameNode*) pCurNode)->getTopIndent(); frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] = ((CFrameNode*) pCurNode)->getRightIndent(); frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] = ((CFrameNode*) pCurNode)->getBottomIndent(); } for( i = 0; i < getGraphPrimNumber(); i++ ) { primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 0 ) ); primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 1 ) ); primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 2 ) ); primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 3 ) ); } UseBtnCalc_InitByThisSize( *getCalc() ); int ret = getCalc()->PositionRun( frames_ltrb, frames_margin_ltrb, primitive_ltrb ); // reset parent margins UseBtnCalc_ChangeThisMargin( *getCalc() ); for( i = 0; i < getGraphPrimNumber(); i++ ) { if( getCalc()->isFormulaTypeGraphics( i ) ) { setGraphPrimitivePositionCoord( i, SVG_NodeTemplate_Parameter_Left, primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] ); setGraphPrimitivePositionCoord( i, SVG_NodeTemplate_Parameter_Top, primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] ); setGraphPrimitivePositionCoord( i, SVG_NodeTemplate_Parameter_Right, primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] ); setGraphPrimitivePositionCoord( i, SVG_NodeTemplate_Parameter_Bottom, primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] ); } } if( ret ) { pCurNode = GetFirstChild(); i = 0; while( pCurNode ) { ((CFrameNode*) pCurNode)->setLeftIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] ); ((CFrameNode*) pCurNode)->setTopIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] ); ((CFrameNode*) pCurNode)->setRightIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] ); ((CFrameNode*) pCurNode)->setBottomIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] ); pCurNode = pCurNode->GetNext(); i++; } RecalculateSizeChild(); } return ret; }
void CParentNode::cleanSpareAutodetect() { for( long no = 0; no < GetChildCount(); no++ ) GetChild( no )->cleanSpareAutodetect(); }