C++ SetItem函数代码示例

void CNewHeaderCtrl::SetItemImage( int nItem, int nImage )
{
	// Save the image index
	m_mapImageIndex[nItem] = nImage;

	// Change the item to ownder drawn
	HD_ITEM hditem;

	hditem.mask = HDI_FORMAT;
	GetItem( nItem, &hditem );
	hditem.fmt |= HDF_OWNERDRAW;
	SetItem( nItem, &hditem );

	// Invalidate header control so that it gets redrawn
	Invalidate();
}

void FileCtrl::UpdateItem(const wxListItem &item)
{
   FileData *fd = (FileData*)GetItemData(item);
   wxCHECK_RET(fd, wxT("invalid filedata"));
   
   fd->ReadData();
   
   SetItemText(item, fd->GetFileName());
   SetItemImage(item, fd->GetImageId());
   
   if (GetWindowStyleFlag() & wxLC_REPORT)
   {
      for (int i = 1; i < FileData::FileList_Max; i++)
         SetItem( item.m_itemId, i, fd->GetEntry((FileData::fileListFieldType)i) );
   }
}

bool wxTreeCtrl::SetItemImage(long item, int image, int selImage)
{
    wxTreeItem info;

    info.m_mask = wxTREE_MASK_IMAGE;
    info.m_image = image;
    if ( selImage > -1)
    {
        info.m_selectedImage = selImage;
        info.m_mask |= wxTREE_MASK_SELECTED_IMAGE;
    }

    info.m_itemId = item;

    return SetItem(info);
}

void CSortHeaderCtrl::SetSortArrow( const int iSortColumn, const BOOL bSortAscending )
{
	m_iSortColumn = iSortColumn;
	m_bSortAscending = bSortAscending;

	// change the item to owner drawn.
	HD_ITEM hditem;

	hditem.mask = HDI_FORMAT;
	VERIFY( GetItem( iSortColumn, &hditem ) );
	hditem.fmt |= HDF_OWNERDRAW;
	VERIFY( SetItem( iSortColumn, &hditem ) );

	// invalidate the header control so it gets redrawn
	Invalidate();
}

//*****************************************************************************
//*
//*		SetItemText
//*
//*****************************************************************************
//	Set the text of an item
//	hItem		: Is the handle of the item
//	pText		: Is the new text of the item
//	nCol		: Is the column for the text (0=tree column)
//	Returns TRUE if the text was changed or FALSE if an error occurs
BOOL CTreeListCtrl::SetItemText(HTREEITEM hItem, LPCTSTR pText, int nCol) {
	TV_ITEM		sItem;


	ASSERT(::IsWindow(m_hWnd));

	sItem.mask				= TVIF_SUBITEM | TVIF_TEXT;
	sItem.hItem				= hItem;
	sItem.stateMask			= 0;
	sItem.pszText			= (LPTSTR)pText;
	sItem.cchTextMax		= (pText) ? 256 : 0;
	sItem.cChildren			= nCol;


	return SetItem(&sItem);
}

void EXWaitingTreeCtrl::ExpandItem(HTREEITEM hItem)
{
	if (m_hItemToPopulate == NULL)
		return;	// just expand, doesn't want new items

	ASSERT(hItem == m_hItemToPopulate);	// should never fail!!!

	if (m_bShowWaitMsg)
	{
		// display wait msg now, make sure it's visible
		SetRedraw();
		EnsureVisible(m_hItemMsg);
		UpdateWindow();
	}
	// setup animation thread, call PreAnimation
	StartAnimation();
	// draw icon
	if (m_bShowWaitMsg)
		DrawUserIcon();
	// delay redraw after populating
	SetRedraw(FALSE);
	// take a snapshot of the background
	TakeSnapshot();
	// del temporary item (wait msg still shown)
	DeleteItem(m_hItemMsg);
	// fill in with sub items
	BOOL bCheckChildren = PopulateItem(hItem);
	// clean up animation thread, call PostAnimation
	StopAnimation();
	// change parent to reflect current children number
	if (hItem != TVI_ROOT)
	{
		TVITEM item;
		item.hItem = hItem;
		item.mask = TVIF_HANDLE | TVIF_CHILDREN;
		item.cChildren = NeedsChildren(hItem) ? 0 : 1;
		if (bCheckChildren)
			SetItem(&item);
		else if (item.cChildren == 0)
			// restore item's plus button if no children inserted
			SetItemState(hItem, 0, TVIS_EXPANDED);
	}
	// clean up snapshot
	DestroySnapshot();
	// redraw now
	SetRedraw(TRUE);
}

void Client::ParseItems(string str)
{
	if (str.length() > 0)
	{
		std::vector<string> itemtokens;
		std::vector<string> tokens;
		boost::split(itemtokens, str, boost::is_any_of("|"));

		for (int i = 0; i < itemtokens.size(); ++i)
		{
			boost::split(tokens, itemtokens[i], boost::is_any_of(","));

			if (tokens.size() == 2)
				SetItem(tokens[0], _atoi64(tokens[1].c_str()));
		}
	}
}

void CDragDropTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
    CTreeCtrl::OnLButtonUp(nFlags, point);

    if (m_bDragging && m_pImageList != NULL)
    {
        // Stop the scroll timer if it's running.
        KillTimer(1);

        // Terminate the dragging operation and release the mouse.
        m_pImageList->DragLeave(this);
        m_pImageList->EndDrag();
        ::ReleaseCapture();
        m_bDragging = FALSE;
        SelectDropTarget(NULL);

        // Delete the image list created by CreateDragImage.
        delete m_pImageList;
        m_pImageList = NULL;

        // Get the HTREEITEM of the drop target and exit now if it's NULL.
        UINT nFlags;
        HTREEITEM hItem = HitTest(point, &nFlags);
        if (hItem == NULL)
            return;

        if (hItem == m_hDragItem)
            return;
        else if (hItem == GetParentItem(m_hDragItem))
            return;
        else if (IsChildOf(hItem, m_hDragItem))
            return;

        // Move the dragged item and its subitems (if any) to the drop point.
        MoveTree(hItem, m_hDragItem);

        // Mark the item as having children
        TVITEM tvItem;
        tvItem.mask = TVIF_CHILDREN | TVIF_HANDLE;
        tvItem.cChildren = 1;
        tvItem.hItem = hItem;
        SetItem(&tvItem);

        m_hDragItem = NULL;
    }
}

// Restores the entire list if the filter is empty
void wxAdvancedListCtrl::RestoreList()
{
    if (BackupItems.empty())
        return;

    DeleteAllItems();

    for (size_t x = 0; x < BackupItems.size(); ++x)
    {
        InsertItem(x, wxT(""));

        for (size_t y = 0; y < BackupItems[x].size(); ++y)
        {
            SetItem(BackupItems[x][y]);
        }
    }
}

/**
 * \brief Set the correct font for a required field.
 * \param i The line to change.
 * \param b Tell if the field has a value or not.
 */
void bf::item_field_edit::set_required_color( unsigned int i, bool b )
{
  wxListItem prop;
  prop.SetId(i);
  GetItem(prop);

  wxFont font( GetFont() );
  font.SetWeight( wxFONTWEIGHT_BOLD );
  prop.SetFont( font );

  if (b)
    prop.SetTextColour( *wxBLACK );
  else
    prop.SetTextColour( *wxRED );

  SetItem(prop);
} // item_field_edit::set_required_color()

BOOL CObjectClassStatistics::EnumDataSources (HPROJECT hPr, BOOL, UINT_PTR *pData)
{
// Namen der Datenquelle besorgen
char cbBuffer[_MAX_PATH];

	DEX_GetDataSourceShortName(hPr, cbBuffer);

// Icon der Datenquelle besorgen
DWORD dwBmp = IMG_DATASOURCE;

	{
	__Interface<ITRiASConnection> Conn;

		if (DEX_GetDataSourcePtr(hPr, *Conn.ppv())) {
		__Interface<ITRiASDatabase> DBase;

			if (SUCCEEDED(Conn -> get_Database (DBase.ppi()))) {
				USES_CONVERSION;

			CComBSTR bstrProgID;		// ProgID des TRiAS-DataBase-TargetObjektes

				if (SUCCEEDED(DBase -> get_Type (&bstrProgID))) {
				__Interface<ITRiASDataServerRegEntries> Entries(CLSID_TRiASDataServerRegEntries);
				__Interface<ITRiASDataServerRegEntry> Entry;

					if (SUCCEEDED(Entries -> FindFromServerProgID (bstrProgID, Entry.ppi()))) 
						Entry -> get_ToolboxBitmap32 ((LONG *)&dwBmp);
				}
			}
		}
	}

// Item in Baum einhängen und mit dummy [+] versehen
	_ASSERTE(0 <= dwBmp && dwBmp < _countof(g_cbBmps));

HTREEITEM hRoot = *reinterpret_cast<HTREEITEM *>(pData);
HTREEITEM hItem = InsertItem(cbBuffer, g_cbBmps[dwBmp], g_cbBmps[dwBmp], hRoot, TVI_LAST);
TV_ITEM tvi;

	tvi.mask = TVIF_HANDLE|TVIF_CHILDREN|TVIF_PARAM;
	tvi.hItem = hItem;
	tvi.cChildren = 1;
	tvi.lParam = reinterpret_cast<LPARAM>(new CDataSourceItemCallback(hPr, hItem));
	SetItem(&tvi);
	return TRUE;
}

void LstOdaSrvDetails::InsertHeader(const wxString &Name, 
                                    const wxColor *NameColor,
                                    const wxColor *NameBGColor)
{
    wxListItem ListItem;
    
    ListItem.SetMask(wxLIST_MASK_TEXT);
    
    // Name Column
    ListItem.SetText(Name);
    ListItem.SetColumn(srvdetails_field_name);
    ListItem.SetId(InsertItem(GetItemCount(), ListItem.GetText()));

    ListItem.SetBackgroundColour(*NameBGColor);
    ListItem.SetTextColour(*NameColor);
    SetItem(ListItem);
}

void CKadContactListCtrl::UpdateContact(int iItem, const Kademlia::CContact* contact, bool bLocalize)
{
	CString id;
	if (!bLocalize) // update the following fields only if really needed (it's quite expensive to always update them)
	{
		contact->getClientID(&id);
		SetItemText(iItem,colID,id);

		id.Format(_T("%i"),contact->getType());
		SetItemText(iItem,colType,id);

		contact->getDistance(&id);
		SetItemText(iItem,colDistance,id);

		SetItem(iItem,0,LVIF_IMAGE,0,contact->getType()>4?4:contact->getType(),0,0,0,0);
	}
}

void CUISpinText::SetCurrentValue(){
	xr_token* tok = GetOptToken();

	while (tok->name){
		AddItem_(tok->name, tok->id);
		tok++;
	}
	xr_string val = GetOptTokenValue();

	for (u32 i = 0; i < m_list.size(); i++)
		if (val == m_list[i]._orig.c_str())
		{
			m_curItem	= i;
			break;
		}

	SetItem();
}

void CListProcess::Select(long ndx, bool bSelect)
{
  GetInfo(m_itm,ndx);
  long nState = m_itm.GetState();
  if(bSelect != !!(nState & wxLIST_STATE_SELECTED))
  {
    if(bSelect)
    {
      nState |= wxLIST_STATE_SELECTED;
    }
    else
    {
      nState ^= wxLIST_STATE_SELECTED;
    }
    m_itm.SetState(nState);
    SetItem(m_itm);
  }
}