Verwenden von Virtual List-View-Steuerelementen
In diesem Thema wird veranschaulicht, wie Sie mit Steuerelementen für virtuelle Listenansichten arbeiten. Die begleitenden C++-Codebeispiele zeigen, wie Sie Benachrichtigungen zu Steuerelementen für virtuelle Listenansichten verarbeiten, den Cache optimieren und ein Element aus dem Cache abrufen.
- Wichtige Informationen
- Verarbeiten von Benachrichtigungscodes für virtuelle List-View-Steuerelemente
- Optimieren des Caches
- Abrufen eines Elements aus dem Cache
- Zugehörige Themen
Hinweis
Der Beispielcode in diesem Abschnitt setzt voraus, dass der Cache ein dynamisch zugeordnetes Array von anwendungsdefinierten Strukturen ist. Die Struktur wird im folgenden C++-Codebeispiel definiert.
struct RndItem
{
int iIcon; // Bitmap assigned to this item.
UINT state; // Item state value.
TCHAR Title[BUFFER_SIZE]; // BUFFER_SIZE is a user-defined macro value.
TCHAR SubText1[BUFFER_SIZE]; // Text for the label of the first sub-item.
TCHAR SubText2[BUFFER_SIZE]; // Text for the label of the second item.
};
Wichtige Informationen
Technologien
Voraussetzungen
- C/C++
- Programmierung der Windows-Benutzeroberfläche
Anweisungen
Verarbeiten von Benachrichtigungscodes für virtuelle List-View-Steuerelemente
Zusätzlich zu den Benachrichtigungscodes, die von anderen Listenansichtssteuerelementen gesendet werden, können virtuelle Listenansichtssteuerelemente auch die LVN_ODCACHEHINT und LVN_ODFINDITEM Benachrichtigungscodes senden.
Diese anwendungsdefinierte Funktion verarbeitet Benachrichtigungsmeldungen, die häufig von einem virtuellen Listenansichtssteuerelement gesendet werden.
LRESULT OnNotify(HWND hwnd, NMHDR* pnmhdr)
{
HRESULT hr;
LRESULT lrt = FALSE;
switch (pnmhdr->code)
{
case LVN_GETDISPINFO:
{
RndItem rndItem;
NMLVDISPINFO* plvdi = (NMLVDISPINFO*) pnmhdr;
if (-1 == plvdi->item.iItem)
{
OutputDebugString(TEXT("LVOWNER: Request for -1 item?\n"));
DebugBreak();
}
// Retrieve information for item at index iItem.
RetrieveItem( &rndItem, plvdi->item.iItem );
if(plvdi->item.mask & LVIF_STATE)
{
// Fill in the state information.
plvdi->item.state |= rndItem.state;
}
if(plvdi->item.mask & LVIF_IMAGE)
{
// Fill in the image information.
plvdi->item.iImage = rndItem.iIcon;
}
if(plvdi->item.mask & LVIF_TEXT)
{
// Fill in the text information.
switch (plvdi->item.iSubItem)
{
case 0:
// Copy the main item text.
hr = StringCchCopy(plvdi->item.pszText, MAX_COUNT, rndItem.Title);
if(FAILED(hr))
{
// Insert error handling code here. MAX_COUNT
// is a user-defined value. You must not enter
// more characters than specified by MAX_COUNT or
// the text will be truncated.
}
break;
case 1:
// Copy SubItem1 text.
hr = StringCchCopy( plvdi->item.pszText, MAX_COUNT, rndItem.SubText1);
if(FAILED(hr))
{
// Insert error handling code here. MAX_COUNT
// is a user-defined value. You must not enter
// more characters than specified by MAX_COUNT or
// the text will be truncated..
}
break;
case 2:
// Copy SubItem2 text.
hr = StringCchCopy(plvdi->item.pszText, MAX_COUNT, rndItem.SubText2);
if(FAILED(hr))
{
// Insert error handling code here. MAX_COUNT
// is a user-defined value. You must not enter
// more characters than specified by MAX_COUNT or
// the text will be truncated..
}
break;
default:
break;
}
}
lrt = FALSE;
break;
}
case LVN_ODCACHEHINT:
{
NMLVCACHEHINT* pcachehint = (NMLVCACHEHINT*) pnmhdr;
// Load the cache with the recommended range.
PrepCache( pcachehint->iFrom, pcachehint->iTo );
break;
}
case LVN_ODFINDITEM:
{
LPNMLVFINDITEM pnmfi = NULL;
pnmfi = (LPNMLVFINDITEM)pnmhdr;
// Call a user-defined function that finds the index according to
// LVFINDINFO (which is embedded in the LPNMLVFINDITEM structure).
// If nothing is found, then set the return value to -1.
break;
}
default:
break;
} // End Switch block.
return(lrt);
}
Optimieren des Caches
Ein virtuelles Listenansichtssteuerelement sendet eine LVN_ODCACHEHINT Benachrichtigung, wenn sich der Inhalt des Anzeigebereichs geändert hat. Die Nachricht enthält Informationen zum Bereich der elemente, die zwischengespeichert werden sollen. Nach Dem Empfang der Benachrichtigungsnachricht muss Ihre Anwendung darauf vorbereitet sein, den Cache mit Elementinformationen für den angeforderten Bereich zu laden, damit die Informationen sofort verfügbar sind, wenn eine LVN_GETDISPINFO Benachrichtigungsnachricht gesendet wird.
Im folgenden C++-Codebeispiel akzeptiert die anwendungsdefinierte Funktion den Bereich von Elementen für den Cache, der von einem virtuellen Listenansichtssteuerelement gesendet wird. Es führt eine Überprüfung durch, um festzustellen, ob der angeforderte Bereich von Elementen noch nicht zwischengespeichert ist, und ordnet dann den erforderlichen globalen Arbeitsspeicher zu und füllt den Cache bei Bedarf.
void PrepCache(int iFrom, int iTo)
{
/* Global Variables
* g_priCache[ ]: the main cache.
* g_iCache: the index of the first item in the main cache.
* g_cCache: the count of items in the main cache.
*
* g_priEndCache[ ]: the cache of items at the end of the list.
* g_iEndCache: the index of the first item in the end cache.
* g_cEndCache: the count of items in the end cache.
*/
// Local Variables
int i;
BOOL fOLFrom = FALSE;
BOOL fOLTo = FALSE;
// Check to see if this is the end cache.
if ((iTo == g_cCache - 1) && ((iTo - iFrom) < 30)) // 30 entries wide.
{
// Check to see if this is a portion of the current end cache.
if ((g_cCache) && (iFrom >= g_iEndCache) && (iFrom < g_iEndCache+g_cEndCache))
return;
// If it is a part of current end cache, no loading is necessary.
// This is a new end cache. Free the old memory.
if ( g_priEndCache )
GlobalFree( g_priEndCache );
// Set the index and count values for the new end cache,
// and then retrieve the memory.
g_iEndCache = iFrom;
g_cEndCache = (iTo - iFrom + 1);
g_priEndCache = (RndItem *)GlobalAlloc(GPTR, sizeof(RndItem) * g_cEndCache);
if (! g_priEndCache)
{
// TODO: Out of memory. Perform error handling.
}
// Loop to fill the cache with the recommended items.
for (i=0; i<g_cEndCache; i++)
{
// TODO: Call a function that accesses item information and
// fills a cache element.
}
}
else
{
// It is not a member of the current end cache.
// Try the primary cache instead.
// Check to see if iFrom is within the primary cache.
if ((g_cCache) && (iFrom >= g_iCache) && (iFrom < g_iCache+g_cCache))
fOLFrom = TRUE;
// Check to see if iTo is within the primary cache.
if ((g_cCache) && (iTo >= g_iCache) && (iTo <= g_iCache+g_cCache))
fOLTo = TRUE;
// do nothing if both iFrom and iTo are within the current cache.
if (fOLFrom && fOLTo)
return;
// Enlarge the cache size rather than make it specific to this hint.
if (fOLFrom)
iFrom = g_iCache;
else if (fOLTo)
iTo = g_iCache + g_cCache;
// A new primary cache is needed. Free the old primary cache.
if ( g_priCache )
GlobalFree( g_priCache );
// Set the index and count values for the new primary cache,
// and then retrieve the memory.
g_iCache = iFrom;
g_cCache = (iTo - iFrom + 1);
g_priCache = (RndItem *)GlobalAlloc( GPTR, sizeof( RndItem ) * g_cCache );
if (!g_priCache)
{
// TODO: Out of memory. Do error handling.
}
// Loop to fill the cache with the recommended items.
for (i=0; i<g_cCache; i++)
{
// TODO: Call a function that accesses item information
// and fills a cache element.
}
}
}
Abrufen eines Elements aus dem Cache
Diese Beispielfunktion akzeptiert zwei Parameter: die Adresse der anwendungsdefinierten Struktur und einen ganzzahligen Wert, der den Index des Elements in der Liste darstellt. Es überprüft den Indexwert, um zu ermitteln, ob das gewünschte Element zwischengespeichert wird. Wenn dies der Grund ist, wird der Zeiger, der an die Funktion übergeben wurde, auf einen Speicherort im Cache festgelegt. Wenn sich das Element nicht im Standard- oder Endcache befindet, müssen die Elementinformationen manuell gefunden werden.
void RetrieveItem( RndItem * prndItem, int index )
{
// Global Variables
// g_priCache[ ]: the main cache.
// g_iCache: the index of the first item in the main cache.
// c_cCache: the count of items in the main cache.
//
// g_priEndCache[ ]: the cache of items at the end of the list.
// g_iEndCache: the index of the first item in the end cache.
// g_cEndCache: the count of items in the end cache.
//
// Check to see if the item is in the main cache.
if ((index >= g_iCache) && (index < g_iCache + g_cCache))
*prndItem = g_priCache[index-g_iCache];
// If it is not in the main cache, then check to see if
// the item is in the end area cache.
else if ((index >= g_iEndCache) && (index < g_iEndCache + g_cEndCache))
*prndItem = g_priEndCache[index-g_iEndCache];
else
{
// The item is not in either cache.
// Therefore, retrieve the item information manually.
}
}
Bemerkungen
Eine Liste der Fensternachrichten, die von einem Listenansichtssteuerelement verarbeitet werden, finden Sie unter Standard List-View Nachrichtenverarbeitung.
Vollständiges Beispiel
Zugehörige Themen