CWinApp::OnIdle
Remplacez cette fonction membre pour exécuter pendant le traitement des temps d'inactivité.
virtual BOOL OnIdle(
LONG lCount
);
Paramètres
- lCount
Un compteur incrémenté à chaque fois que OnIdle est appelé lorsque la file d'attente de messages de l'application est vide.Ce nombre est réinitialisé à 0 chaque fois qu'un message est considéré.Vous pouvez utiliser le paramètre d' lCount pour déterminer la durée relative à l'application a été inactive sans gérer un message.
Valeur de retour
Une valeur différente de zéro pour accepter plus de temps machine de traitement des temps d'inactivité ; 0 si plus de temps d'inactivité n'est requise.
Notes
OnIdle est appelé dans la boucle de message par défaut lorsque la file d'attente de messages de l'application est vide.Utilisez la substitution pour appeler vos propres tâches d'inactif- gestionnaire d'arrière-plan.
OnIdle doit retourner 0 pour indiquer qu'aucun machine temps de traitement des temps d'inactivité n'est requis.Le paramètre d' lCount est incrémenté à chaque fois que OnIdle est appelé lorsque la file d'attente de messages est vide et se réinitialise à 0 chaque fois qu'un nouveau message est traité.Vous pouvez appeler les différentes routines inactifs sur ce nombre.
Le code suivant résume la gestion des boucles inactives :
Si la boucle de message dans la bibliothèque MFC contrôle la file d'attente de messages et ne trouve pas de message en attente, elle appelle OnIdle de l'objet application et fournit 0 comme argument d' lCount .
OnIdle en exécute qui traite et retourne une valeur différente de zéro pour indiquer doivent être appelés à nouveau pour ce traitement davantage.
La boucle de message de la file d'attente de messages de nouveau.Si aucun message n'est en attente, elle appelle OnIdle de nouveau, incrémentant l'argument d' lCount .
Par la suite, OnIdle finit de traitement de toutes ses tâches inactives et retourne 0.Cela indique la boucle de message cesse d'appeler OnIdle jusqu'à ce que le message soit envoyée la file d'attente de messages, à laquelle le point le cycle inactif redémarre avec l'argument défini à 0.
N'exécutez pas les tâches longues pendant l' OnIdle parce que votre application ne peut pas traiter l'entrée d'utilisateur jusqu'à ce qu' OnIdle retourne.
[!REMARQUE]
L'implémentation par défaut d' OnIdle met à jour les objets interface utilisateur de commande tels que les éléments de menu et des boutons de barre d'outils, et elle exécute un nettoyage interne de structure de données.Par conséquent, si vous substituez OnIdle, vous devez appeler CWinApp::OnIdle avec lCount dans votre version substituée.Premier appel tout le traitement des temps d'inactivité de classe de base (autrement dit, jusqu'à la classe de base OnIdle retourne 0).Si vous devez exécuter le travail avant de traiter de classe de base se termine, examinez l'implémentation de la classe de base pour sélectionner lCount approprié pendant lequel exécuter votre travail.
Si vous ne souhaitez pas OnIdle à appeler chaque fois qu'un message est récupéré de la file d'attente de messages, vous pouvez substituer CWinThreadIsIdleMessage.Si une application a défini une minuterie très courte, ou si le système envoie le message de WM_SYSTIMER , puis OnIdle sera appelée à plusieurs reprises, et dégrade les performances.
Exemple
Les deux exemples suivants indiquent comment utiliser OnIdle.Le premier exemple traite deux tâches inactives à l'aide de l'argument d' lCount de classer les tâches.La première tâche est élevée, et vous devez le faire si possible.La deuxième tâche est moins importante et doit être effectuée uniquement lorsqu'il existe une longue pause dans les entrées d'utilisateur.Notez l'appel à la version de classe de base d' OnIdle.Le deuxième exemple gère un groupe de tâches inactives avec différentes priorités.
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
}
Second exemple
// 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;
}
Configuration requise
Header: afxwin.h