CWinApp::OnIdle
Eseguire l'override della funzione membro per eseguire l'elaborazione di tempo di inattività.
virtual BOOL OnIdle(
LONG lCount
);
Parametri
- lCount
Un contatore incrementato ogni volta OnIdle viene chiamato quando la coda di messaggi dell'applicazione è vuota.Questo numero viene reimpostato su 0 quando un nuovo messaggio viene elaborato.È possibile utilizzare il parametro lCount per determinare la relativa durata che l'applicazione è stata inattiva senza elaborare un messaggio.
Valore restituito
Diverso da zero per ricevere più tempo di elaborazione inattiva, 0 se non di più tempo di inattività necessario.
Note
OnIdle viene chiamato il ciclo di messaggi predefinito quando la coda di messaggi dell'applicazione è vuota.Utilizzare l'override per chiamare le proprie attività in background di inattivo- gestore.
OnIdle deve restituire 0 per indicare che nessun tempo di elaborazione inattiva è obbligatorio.Il parametro lCount viene incrementato ogni volta OnIdle viene chiamato quando la coda di messaggi è vuota e bloccando a 0 quando un nuovo messaggio viene elaborata.È possibile chiamare una routine inattive diversi in base al conteggio.
L'esempio seguente vengono riepilogati l'elaborazione del ciclo inattivo:
Se il ciclo di messaggi della libreria MFC controlla la coda di messaggi e non individua messaggi in corso, chiama OnIdle per l'oggetto applicazione e fornisce 0 come argomento lCount.
OnIdle esegue un'elaborazione e che restituisce un valore diverso da zero per indicare che deve essere chiamato nuovamente per eseguire un'ulteriore elaborazione.
I controlli del ciclo di messaggi della coda di messaggi nuovamente.Se non esistono messaggi in corso, chiamare nuovamente OnIdle, incrementando l'argomento lCount.
Infine, OnIdle completa l'elaborazione tutte le relative attività inattive e restituisce 0.Ciò indica al ciclo di messaggi di interruzione di chiamare OnIdle fino a ricevere il messaggio successivo nella coda di messaggi, al momento del ciclo inattivo riavvio con l'argomento impostato su 0.
Non eseguire attività di lunga durata durante OnIdle perché l'applicazione non può più elaborare l'input utente finché restituzione OnIdle.
[!NOTA]
L'implementazione predefinita degli aggiornamenti OnIdle ordina gli oggetti dell'interfaccia utente come le voci di menu e pulsanti della barra degli strumenti ed esegue la pulitura interno della struttura dei dati.Pertanto, se si esegue l'override OnIdle, è necessario chiamare CWinApp::OnIdle con lCount nella versione sottoposta a override.Prima chiamata l'elaborazione di inattività della classe base (ovvero fino alla classe di base OnIdle restituisce 0).Se è necessario eseguire il lavoro prima dell'elaborazione della classe base completi, esaminare l'implementazione della classe base per selezionare lCount appropriato durante il quale eseguire il lavoro.
Se non si OnIdle da chiamare ogni volta che un messaggio viene recuperato dalla coda di messaggi, è possibile eseguire l'override CWinThreadIsIdleMessage.Se un'applicazione viene impostato da un timer di insufficiente, o se il sistema è inviando il messaggio WM_SYSTIMER, quindi OnIdle verrà chiamato ripetutamente e comporta una riduzione delle prestazioni.
Esempio
I due esempi seguenti viene mostrato come utilizzare OnIdle.Il primo esempio viene elaborato due attività inattive utilizzo dell'argomento lCount classificare in ordine di priorità le attività.La prima attività è con priorità alta e è necessario farlo quando possibile.La seconda attività è meno importante e deve essere eseguita solo quando esiste una pausa lunga l'input utente.Si noti la chiamata alla versione della classe base OnIdle.Nel secondo esempio gestisce un gruppo di attività inattive con diversi priorità.
BOOL CMyApp::OnIdle(LONG lCount)
{
BOOL bMore = CWinApp::OnIdle(lCount);
if (lCount == 0)
{
TRACE(_T("App idle for short period of time\n"));
bMore = TRUE;
}
else if (lCount == 10)
{
TRACE(_T("App idle for longer amount of time\n"));
bMore = TRUE;
}
else if (lCount == 100)
{
TRACE(_T("App idle for even longer amount of time\n"));
bMore = TRUE;
}
else if (lCount == 1000)
{
TRACE(_T("App idle for quite a long period of time\n"));
// bMore is not set to TRUE, no longer need idle
// IMPORTANT: bMore is not set to FALSE since CWinApp::OnIdle may
// have more idle tasks to complete.
}
return bMore;
// return TRUE as long as there are any more idle tasks
}
Secondo esempio
// In this example, four idle loop tasks are given various
// opportunities to run:
// Task1 is always given a chance to run during idle time, provided
// that no message has queued up while the framework was processing
// its own idle loop tasks (at lCount levels 0 and 1).
// Task2 is given a chance to run only if Task1 has already run,
// provided that no message has queued up while Task1 was running.
// Task3 and Task4 are given a chance to run only if both Task1 and
// Task2 have already run, and no message has queued up in the mean
// time. If Task3 gets its chance to run, then Task4 always gets
// a chance to run immediately after Task3.
BOOL CMyWinApp::OnIdle(LONG lCount)
{
// In this example, as in most applications, you should let the
// base class CWinApp::OnIdle complete its processing before you
// attempt any additional idle loop processing.
if (CWinApp::OnIdle(lCount))
return TRUE;
// The base class CWinApp::OnIdle reserves the lCount values 0
// and 1 for the framework's own idle processing. If you wish to
// share idle processing time at a peer level with the framework,
// then replace the above if-statement with a straight call to
// CWinApp::OnIdle; and then add a case statement for lCount value
// 0 and/or 1. Study the base class implementation first to
// understand how your idle loop tasks will compete with the
// framework's idle loop processing.
switch (lCount)
{
case 2:
Task1();
return TRUE; // next time give Task2 a chance
case 3:
Task2();
return TRUE; // next time give Task3 and Task4 a chance
case 4:
Task3();
Task4();
return FALSE; // cycle through the idle loop tasks again
}
return TRUE;
}
Requisiti
Header: afxwin.h