C++ childCount函数代码示例

BasketListViewItem* BasketListViewItem::lastChild()
{
    int count = childCount();
    if (count <= 0)
        return 0;
    return (BasketListViewItem*)(child(count - 1));
}

bool ObjectItem::isContain(ObjectItem **ppRet, QPoint &pos, int frame, bool bChild, bool bCheckFlag)
{
    if (bChild)
    {
        for (int i = childCount() - 1; i >= 0; i--)
        {
            if (child(i)->isContain(ppRet, pos, frame, true))
            {
                return true;
            }
        }
    }

    if (bCheckFlag)
    {
        int flag = data(Qt::CheckStateRole).toInt();
        if (!(flag & kState_Disp) || (flag & kState_Lock))
        {   // 非表示
            return false;
        }
    }

    bool valid;
    FrameData d = getDisplayFrameData(frame, &valid);
    if (valid && isContain(d, pos, getDisplayMatrix(frame)))
    {
        *ppRet = this;
        return true;
    }
    return false;
}

int EventBrowser::FindEvent(QTreeWidgetItem *parent, QString filter, uint32_t after, bool forward)
{
	if(parent == NULL) return -1;

	for(int i = forward ? 0 : parent->childCount() - 1;
			i >= 0 && i < parent->childCount();
			i += forward ? 1 : -1)
	{
		auto n = parent->child(i);

		uint eid = n->data(COL_EID, Qt::UserRole).toUInt();

		bool matchesAfter = (forward && eid > after) || (!forward && eid < after);

		if(matchesAfter)
		{
			QString name = n->text(COL_NAME);
			if(name.contains(filter, Qt::CaseInsensitive))
				return (int)eid;
		}

		if(n->childCount() > 0)
		{
			int found = FindEvent(n, filter, after, forward);

			if(found > 0)
				return found;
		}
	}

	return -1;
}

bool SCgCommandSelectedObjectMove::mergeWith (const QUndoCommand* command)
{
    if (command->id() != id() || childCount() || command->childCount())
        return false;

    const SCgCommandSelectedObjectMove* c = static_cast<const SCgCommandSelectedObjectMove*>(command);
    if(mUndoInfo.keys() != c->mUndoInfo.keys())
        return false;

    qreal maxManhattanLength = 0;

    SCgScene::ObjectUndoInfo::ConstIterator const_it = c->mUndoInfo.begin();
    while(const_it != c->mUndoInfo.end())
    {
        QPointF offset = const_it.value().second.second - const_it.value().first.second;
        if(offset.manhattanLength() > maxManhattanLength)
            maxManhattanLength = offset.manhattanLength();
        ++const_it;
    }

    if(maxManhattanLength > 35)
        return false;

    SCgScene::ObjectUndoInfo::iterator it = mUndoInfo.begin();
    while(it != mUndoInfo.end())
    {
        it.value().second = c->mUndoInfo.value(it.key()).second;
        ++it;
    }
    return true;
}

KcmTreeItem *KcmTreeItem::child(const int row)
{
    if(childCount() > row) {
        return m_children.value(row);
    }
    return NULL;
}

/*! \reimp */
int QAccessibleWidget::childAt(int x, int y) const
{
    QWidget *w = widget();
    if (!w->isVisible())
        return -1;
    QPoint gp = w->mapToGlobal(QPoint(0, 0));
    if (!QRect(gp.x(), gp.y(), w->width(), w->height()).contains(x, y))
        return -1;

    QWidgetList list = childWidgets(w);
    int ccount = childCount();

    // a complex child
    if (list.size() < ccount) {
        for (int i = 1; i <= ccount; ++i) {
            if (rect(i).contains(x, y))
                return i;
        }
        return 0;
    }

    QPoint rp = w->mapFromGlobal(QPoint(x, y));
    for (int i = 0; i<list.size(); ++i) {
        QWidget *child = list.at(i);
        if (!child->isWindow() && !child->isHidden() && child->geometry().contains(rp)) {
            return i + 1;
        }
    }
    return 0;
}

void QgsLegendLayer::changeSymbologySettings( const QgsMapLayer* theMapLayer,
    const SymbologyList& newSymbologyItems )
{
  if ( !theMapLayer )
  {
    return;
  }

  QgsLegendSymbologyItem* theSymbologyItem = 0;

  //remove the symbology items under the legend layer
  for ( int i = childCount(); i >= 0; --i )
  {
    theSymbologyItem = dynamic_cast<QgsLegendSymbologyItem *>( child( i ) );
    if ( theSymbologyItem )
    {
      delete takeChild( i );
    }
  }

  //add the new symbology items
  int childposition = 0; //position to insert the items
  for ( SymbologyList::const_iterator it = newSymbologyItems.begin(); it != newSymbologyItems.end(); ++it )
  {
    QgsLegendSymbologyItem* theItem = new QgsLegendSymbologyItem( it->second.width(), it->second.height() );
    theItem->setText( 0, it->first );
    theItem->setIcon( 0, QIcon( it->second ) );
    insertChild( childposition, theItem );

    ++childposition;
  }

}

/*! \reimp */
int QAccessibleApplication::navigate(RelationFlag relation, int entry,
                                     QAccessibleInterface **target) const
{
    if (!target)
        return -1;

    *target = 0;
    QObject *targetObject = 0;

    switch (relation) {
    case Self:
        targetObject = object();
        break;
    case Child:
        if (entry > 0 && entry <= childCount()) {
            const QWidgetList tlw(topLevelWidgets());
            if (tlw.count() >= entry)
                targetObject = tlw.at(entry-1);
        } else {
            return -1;
        }
        break;
    case FocusChild:
        targetObject = QApplication::activeWindow();
        break;
    default:
        break;
    }
    *target = QAccessible::queryAccessibleInterface(targetObject);
    return *target ? 0 : -1;
}

bool ObjectItem::validate(bool bRecv)
{
    int i;

    QList<unsigned short> frames;
    for (i = 0; i < m_frameDatas.size(); i++)
    {
        const FrameData &d = m_frameDatas.at(i);
        if (frames.contains(d.frame))
        {
            return false;
        }
        frames.append(d.frame);
    }

    if (bRecv)
    {
        for (i = 0; i < childCount(); i++)
        {
            if (!child(i)->validate(bRecv))
            {
                return false;
            }
        }
    }
    return true;
}

CharString NounShip::status() const
{
	CharString sTargetInfo;

	// team & ship type..
	sTargetInfo += CharString().format("%s - %s\n", teamName(), nounContext()->name() );
	// hull %
	sTargetInfo += CharString().format("Hull: %d%%\n", int( damageRatioInv() * 100) );

	int armor = 0, maxArmor = 0;
	int shield = 0, maxShield = 0;
	for(int i=0;i<childCount();i++)
	{
		BaseNode * pChild = child(i);
		if ( WidgetCast<GadgetShield>( pChild ) )
		{
			shield += ((GadgetShield *)pChild)->charge();
			maxShield += ((GadgetShield *)pChild)->maxCharge();
		}
		else if ( WidgetCast<GadgetArmor>( pChild ) )
		{
			armor += ((GadgetArmor *)pChild)->armor();
			maxArmor += ((GadgetArmor *)pChild)->maxArmor();
		}
	}

	if ( maxShield > 0 )
		sTargetInfo += CharString().format("Shield: %d%%\n", (shield * 100) / maxShield);
	if ( maxArmor > 0 )
		sTargetInfo += CharString().format("Armor: %d%%\n", (armor * 100) / maxArmor );

	return sTargetInfo;
}

void KACLListView::slotAddEntry()
{
    int allowedTypes = NamedUser | NamedGroup;
    if ( !m_hasMask )
        allowedTypes |= Mask;
    int allowedDefaultTypes = NamedUser | NamedGroup;
    if ( !findDefaultItemByType( Mask ) )
        allowedDefaultTypes |=  Mask;
    if ( !hasDefaultEntries() )
        allowedDefaultTypes |= User | Group;
    EditACLEntryDialog dlg( this, 0,
                            allowedUsers( false ), allowedGroups( false ),
                            allowedUsers( true ), allowedGroups( true ),
                            allowedTypes, allowedDefaultTypes, m_allowDefaults );
    dlg.exec();
    KACLListViewItem *item = dlg.item();
    if ( !item ) return; // canceled
    if ( item->type == Mask && !item->isDefault ) {
        m_hasMask = true;
        m_mask = item->value;
    }
    if ( item->isDefault && !hasDefaultEntries() ) {
        // first default entry, fill in what is needed
        if ( item->type != User ) {
            unsigned short v = findDefaultItemByType( User )->value;
            new KACLListViewItem( this, User, v, true );
        }
        if ( item->type != Group ) {
            unsigned short v = findDefaultItemByType( Group )->value;
            new KACLListViewItem( this, Group, v, true );
        }
        if ( item->type != Others ) {
            unsigned short v = findDefaultItemByType( Others )->value;
            new KACLListViewItem( this, Others, v, true );
        }
    }
    const KACLListViewItem *defaultMaskItem = findDefaultItemByType( Mask );
    if ( item->isDefault && !defaultMaskItem ) {
        unsigned short v = calculateMaskValue( true );
        new KACLListViewItem( this, Mask, v, true );
    }
    if ( !item->isDefault && !m_hasMask &&
            ( item->type == Group
              || item->type == NamedUser
              || item->type == NamedGroup ) ) {
        // auto-add a mask entry
        unsigned short v = calculateMaskValue( false );
        new KACLListViewItem( this, Mask, v, false );
        m_hasMask = true;
        m_mask = v;
    }
    calculateEffectiveRights();
    sort();
    setCurrentItem( item );
    // TQListView doesn't seem to emit, in this case, and we need to update 
    // the buttons...
    if ( childCount() == 1 ) 
        emit currentChanged( item );
}

void classSpecialColumns::setOpen( bool o )
{
    if ( o && !childCount() )
	{
		LoadColumns();
    }
    QListViewItem::setOpen( o );
}

const Object *Container::childAt(NPT_Ordinal index) const
{
	Object *child = NULL;
	if (index < childCount()) {
		child = *m_children.GetItem(index);
	}
	return child;
}

void classPrimaryKeys::setOpen( bool o )
{
    if ( o && !childCount() )
	{
		LoadColumns();
    }
    QListViewItem::setOpen( o );
}

void SpawnListItem::updateTitle(const QString& name)
{
    // update childcount in header
    QString temp;
    temp.sprintf("%s (%d)",
                 (const char*)name, childCount());
    setText(tSpawnColName, temp);
} // end if spawn should be in this category