Virtual BOOL OnIdle ( LONG lCount );
Valore restituito
Diverso da zero per ricevere più tempo al trattamento minimo; 0 se non è più tempo di inattività è necessario.
Parametri
lCount
Un contatore incrementato ogni volta che OnIdle viene chiamato quando la coda di messaggi dell'applicazione è vuoto. Questo conteggio viene reimpostato su 0 ogni volta che viene elaborato un nuovo messaggio. È possibile utilizzare il parametro lCount per determinare il relativo periodo di tempo, che l'applicazione è stata inattiva senza l'elaborazione di un messaggio.
Osservazioni
Eseguire l'override di questa funzione membro per eseguire l'elaborazione in periodi di inattività. OnIdle viene chiamato nel ciclo di messaggi predefiniti quando la coda di messaggi dell'applicazione è vuoto. Utilizzare override per chiamare il proprio sfondo attività di gestore di idle.
O&nIdle deve restituire 0 per indicare che nessun tempo di inattività elaborazione è richiesto. Il parametro lCount viene incrementato ogni volta OnIdle viene chiamato quando il messagenbsp; coda è vuota e reimposta a 0 ogni volta che viene elaborato un nuovo messaggio. È possibile chiamare le routine di inattive diverse basate su questo conteggio.
Di seguito vengono riepilogate elaborazione ciclo idle:
OnIdle per l'oggetto application e forniture 0 come argomento lCount.OnIdleesegue alcuni trattamenti e restituisce un valore diverso da zero per indicare deve essere chiamato nuovamente per fare un'ulteriore elaborazione.OnIdle ancora una volta, incrementando l'argomento lCount.OnIdle termina l'elaborazione di tutti i suoi compiti inattivi e restituisce 0. Questo dice il ciclo di messaggi a smettere di chiamare OnIdle fino a quando il prossimo messaggio viene ricevuto dalla coda dei messaggi, al punto che il ciclo idle viene riavviato con l'argomento impostato tonbsp; 0.Non eseguire operazioni lunghe durante OnIdle perché l'applicazione non può elaborare l'input dell'utente, fino al ritorno di OnIdle.
&Notanbsp; L'implementazione predefinita di OnIdle aggiorna oggetti dell'interfaccia utente comando come voci di menu e pulsanti della barra degli strumenti, quindi esegue la pulitura di struttura dati interno. Pertanto, se si esegue l'override di OnIdle, deve chiamare CWinApp::OnIdle con l' lCount nella vostra versione sottoposta a override. Chiamare prima classe base tutto inattivo elaborazione (cioè, finché la classe di base OnIdle restituisce 0). Se avete bisogno di eseguire lavori prima del completamento dell'elaborazione della classe base, rivedere l'implementazione della classe base per selezionare la corretta lCount durante il quale a fare il vostro lavoro.
Esempio
Nei due esempi seguenti mostrano come utilizzare OnIdle. Il primo esempio elabora due compiti inattività utilizzando l'argomento lCount per impostare la priorità dei compiti. Il primo compito è alta priorità, e si dovrebbe farlo quando possibile. La seconda attività è meno importante e dovrebbe essere fatto solo quando vi è una lunga pausa in input dell'utente. Notare la chiamata alla classe base versione di OnIdle. Il secondo esempio gestisce un gruppo di attività idle con diverse priorità.
BOOL CMyApp::OnIdle(LO&NG lCount)
{
nbsp; BOOL bMore = CWinApp::OnIdle(lCount);
Se (lCount = = 0)
{
TRACE ("App inattivo per un breve periodo di time\n");
bMore = TRUE;
}
else if (lCount = = 10)
{
TRACE ("App inattivo per più tempo quantità di time\n");
bMore = TRUE;
}
else if (lCount = = 100)
{
TRACE ("App inattivo per quantità anche di più di time\n");
bMore = TRUE;
}
else if (lCount = = 1000)
{
TRACE ("App inattivo per abbastanza un lungo periodo di time\n");
/ / bMore non è impostato su TRUE, non è più necessario idle
/ / IMPORTANTE: bMore non è impostato su FALSE, dal momento che può CWinApp::OnIdle
/ / avere ulteriori compiti inattivi per completare.
}
return bMore;
/ / return TRUE finché c'è tutte le mansioni più inattive
}
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 CMyApp::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 FALSE;
}
Panoramica di CWinApp |nbsp; Membri della classe | Gerarchia Chart