C++ CountItems函数代码示例

int32
BListView::_CalcFirstSelected(int32 after)
{
    if (after >= CountItems())
        return -1;

    int32 count = CountItems();
    for (int32 i = after; i < count; i++) {
        if (ItemAt(i)->IsSelected())
            return i;
    }

    return -1;
}

	inline bool operator ==(const Selection& other)
		{
			if (other.CountItems() == CountItems()) {
				int32* items = Items();
				int32* otherItems = other.Items();
				for (int32 i = 0; i < CountItems(); i++) {
					if (items[i] != otherItems[i])
						return false;
					items++;
					otherItems++;
				}
				return true;
			} else
				return false;
		}

//------------------------------------------------------------------------------
void BMessageField::PrintToStream(const char* name) const
{
	int32 type = B_BENDIAN_TO_HOST_INT32(Type());
	printf("    entry %14s, type='%.4s', c=%2ld, ",
		   name, (char*)&type, CountItems());

	for (int32 i = 0; i < CountItems(); ++i)
	{
		if (i)
		{
			printf("                                            ");
		}
		PrintDataItem(i);
	}
}

	virtual void Entered()
	{
		_DeleteItems();

		if (fDirectory != NULL) {
			void* cookie;
			if (fDirectory->Open(&cookie, O_RDONLY) == B_OK) {
				Node* node;
				while (fDirectory->GetNextNode(cookie, &node) == B_OK) {
					BlacklistMenuItem* item = _CreateItem(node);
					node->Release();
					if (item == NULL)
						break;

					AddItem(item);

					item->UpdateBlacklisted();
				}
				fDirectory->Close(cookie);
			}

			SortItems(&BlacklistMenuItem::Less);
		}

		if (CountItems() > 0)
			AddSeparatorItem();
		AddItem(new(nothrow) MenuItem("Return to parent directory"));
	}

void NetListView::FrameResized(float width, float height)
{
	BListView::FrameResized(width, height);
	//Ensure the bevel on the right is drawn properly
	if(width < oldWidth)
		oldWidth = width;
	PushState();
	BRect invalRect(oldWidth, 0, oldWidth, height);
	ConvertFromParent(&invalRect);
	BRegion lineRegion(invalRect);
	ConstrainClippingRegion(&lineRegion);
	Draw(invalRect);
	oldWidth = width;
	PopState();
	
	//Do word wrapping
	BFont curFont;
	GetFont(&curFont);
	float itemWidth = Bounds().Width();
	float wrapWidth = (itemWidth - 6)/curFont.Size();
	for(int itemNum = 0; itemNum < CountItems(); itemNum++)
	{
		NetListItem* item = (NetListItem*)(Items()[itemNum]);
		item->SetWidth(itemWidth);
		item->CalcWordWrap(wrapWidth);
	}
	//DoForEach(UpdateItem, (void*)this);
	Invalidate();
	
	BListView::FrameResized(width, height);
}

void DraggableListView::MessageReceived(BMessage *message) {
	if (message->what != B_PULSE) {
		printf("DraggableListView:\n");
		message->PrintToStream();
		printf("\n");
	}
	switch(message->what) {
		case SM_DRAG_FILTER: {
			if (accepts_drags) {
				int32 item_count;
				type_code type_found;
				message->GetInfo("filter_name", &type_found, &item_count);
				int32 current_item = 0;
				char* text = NULL;
				int32 filter_id = 0;
				message->FindString("filter_name", current_item, &text);
				// Do add-filter stuff
				BMessage app_msg(SM_ADD_FILTER);
				app_msg.AddString("addon_name", text);
				app_msg.AddInt32("position", CountItems());
				BMessage reply;
				be_app_messenger.SendMessage(&app_msg, &reply);
				reply.FindInt32("filter_id", &filter_id);
				BStringItem *newItem = new FilterItem(text, filter_id);
				AddItem(newItem);
			}
			break;
		}
		default: {
			BListView::MessageReceived(message);
			break;
		}
	}
}

void
NetworkMenu::AttachedToWindow (void)
{
	if (CountItems())
	{
		BMenuItem *item (NULL);
		while ((item = RemoveItem((int32)0)) != NULL)
			delete item;
	}

	BMessage msg;
	BMessage *invoke (NULL);
	for (int32 i = 0; (msg = vision_app->GetNetwork (i)), !msg.HasBool ("error"); i++)
	{
		const char *name = msg.FindString ("name");
		invoke = new BMessage (fMsgConst);
		invoke->AddString ("network", name);
		BMenuItem *item (new BMenuItem(name, invoke));
		AddItem (item);
		if (!vision_app->CheckNetworkValid (name))
			item->SetEnabled (false);
	}
	SetTargetForItems (fTarget.Target(NULL));
	BMenu::AttachedToWindow();
}

IFWL_ListItem* CFWL_ListBox::CFWL_ListBoxDP::GetItem(IFWL_Widget* pWidget,
                                                     int32_t nIndex) {
  if (nIndex < 0 || nIndex >= CountItems(pWidget))
    return nullptr;

  return m_ItemArray[nIndex].get();
}

/***********************************************************
 * DeleteItem
 ***********************************************************/
void
HListView::DeleteItem(int32 index) {
	HListItem* item = cast_as(RemoveItem(index), HListItem);
	fPointerList.RemoveItem(item);
	delete item;

	HApp* app = cast_as(be_app, HApp);
	bool queue;

	int32 max_transfer;
	app->Prefs()->GetData("queue", &queue);
	app->Prefs()->GetData("max_transfer", &max_transfer);

	if (queue) {
		int32 num_task = max_transfer - CountDownloadingItems();
		if (num_task > 0) {
			int32 count = CountItems();
			HListItem** items = (HListItem**)Items();
			for (int32 i = 0; i < count; i++) {
				item = items[i];
				if (!item->IsStarted() && item->State() != T_FINISHED && item->State() != T_NOTFOUND) {
					item->Start();
					num_task--;
				}
				if (num_task <= 0)
					break;
			}
		}
	}
}

void ArpOutlineListView::ComputeDimens(ArpDimens& cur_dimens)
{
	float min_w=0, min_h=0;
	float pref_w=0, pref_h=0;
	
	int32 num = CountItems();
	int32 max_num = 4;
	for( int32 i=0; i<num; i++ ) {
		BListItem* item = ItemAt(i);
		if( item ) {
			item->Update(this,BasicFont());
			float w = item->Width();
			float h = item->Height();
			min_h = max(min_h,h);
			pref_w = max(pref_w,w);
			if( max_num > 0 ) pref_h += h;
			max_num--;
		}
	}
	pref_h+=2;
	float fw = BasicFont()->StringWidth("WWWW");
	font_height fhs;
	BasicFont()->GetHeight(&fhs);
	float fh = fhs.ascent+fhs.descent+fhs.leading;
	min_w = max(min_w,fw);
	min_h = max(min_h,fh);
	pref_w = max(pref_w,min_w);
	pref_h = max(pref_h,min_h);
	
	cur_dimens.X().SetTo(0, min_w, pref_w, ArpAnySize, 0);
	cur_dimens.Y().SetTo(0, min_h, pref_h, ArpAnySize, 0);
}

bool
BrowsingHistory::_AddItem(const BrowsingHistoryItem& item, bool internal)
{
	int32 count = CountItems();
	int32 insertionIndex = count;
	for (int32 i = 0; i < count; i++) {
		BrowsingHistoryItem* existingItem
			= reinterpret_cast<BrowsingHistoryItem*>(
			fHistoryItems.ItemAtFast(i));
		if (item.URL() == existingItem->URL()) {
			if (!internal) {
				existingItem->Invoked();
				_SaveSettings();
			}
			return true;
		}
		if (item < *existingItem)
			insertionIndex = i;
	}
	BrowsingHistoryItem* newItem = new(std::nothrow) BrowsingHistoryItem(item);
	if (!newItem || !fHistoryItems.AddItem(newItem, insertionIndex)) {
		delete newItem;
		return false;
	}

	if (!internal) {
		newItem->Invoked();
		_SaveSettings();
	}

	return true;
}

void
BListView::_RescanSelection(int32 from, int32 to)
{
	if (from > to) {
		int32 tmp = from;
		from = to;
		to = tmp;
	}

	from = max_c(0, from);
	to = min_c(to, CountItems() - 1);

	if (fAnchorIndex != -1) {
		if (fAnchorIndex == from)
			fAnchorIndex = to;
		else if (fAnchorIndex == to)
			fAnchorIndex = from;
	}

	for (int32 i = from; i <= to; i++) {
		if (ItemAt(i)->IsSelected()) {
			fFirstSelected = i;
			break;
		}
	}

	if (fFirstSelected > from)
		from = fFirstSelected;

	fLastSelected = fFirstSelected;
	for (int32 i = from; i <= to; i++) {
		if (ItemAt(i)->IsSelected())
			fLastSelected = i;
	}
}

bool ColumnListView::AddList(BList* newItems)
{
	if(fHierarchical)
		return AddListPrivate(newItems,fFullItemList.CountItems());
	else
		return AddListPrivate(newItems,CountItems());
}

bool ColumnListView::AddItem(CLVListItem* item)
{
	if(fHierarchical)
		return AddItemPrivate(item,fFullItemList.CountItems());
	else
		return AddItemPrivate(item,CountItems());
}

int32 QueryMenu::QueryThread()
{
	BAutolock lock(fQueryLock);

	if (!lock.IsLocked())
		return B_ERROR;

	// Begin resolving query
	fCancelQuery = false;
	fQuery->Fetch();

	// Build Menu
	entry_ref ref;
	node_ref node;
	while (fQuery->GetNextRef(&ref) == B_OK && !fCancelQuery)
	{
		BEntry entry(&ref);
		entry.GetNodeRef(&node);
		EntryCreated(ref, node.node);
	}

	// Remove the group separator if there are no groups or no items without groups
	BMenuItem *item;
	if (dynamic_cast<BSeparatorItem *>(item = ItemAt(0)) != NULL)
		RemoveItem(item);
	else if (dynamic_cast<BSeparatorItem *>(item = ItemAt(CountItems() - 1)) != NULL)
		RemoveItem(item);

	return B_OK;
}