CWinApp::OnIdle
Substitua esta função de membro para executar o processamento de time ocioso.
virtual BOOL OnIdle(
LONG lCount
);
Parâmetros
- lCount
Um contador incrementado cada time OnIdle é chamado quando a fila de mensagens do aplicativo está vazia. Essa contagem é redefinida como 0, cada time uma nova mensagem é processada.Você pode usar o lCount parâmetro para determinar o período de time em que o aplicativo ficar ocioso sem processamento de uma mensagem relativo.
Valor de retorno
Nonzero para receber mais time de processamento ocioso; 0 se não há mais time ocioso for necessária.
Comentários
OnIdle é chamado no loop de mensagem padrão quando a fila de mensagens do aplicativo está vazia. Use sua substituir para telefonar suas próprias tarefas em segundo plano do manipulador de ociosidade.
OnIdle deve retornar 0 para indicar que não é necessário nenhum time ocioso do processamento. The lCount parâmetro é incrementado cada vez OnIdle é chamado quando a fila de mensagens está vazia e redefine como 0, sempre que uma nova mensagem é processada. Você pode telefonar suas rotinas de ociosidade diferentes com base nessa contagem.
A seguir resume o processamento de loop ocioso:
Se o loop de mensagem a biblioteca Microsoft Foundation classe verifica a fila de mensagens e localiza não há mensagens pendentes, ele chama OnIdle para o objeto de aplicativo e fontes 0 sistema autônomo o lCount argumento.
OnIdle executa algum processamento e retorna um valor diferente de zero para indicar que ele deve ser chamado novamente para fazer processamento adicional.
O loop de mensagens verifica a fila de mensagens novamente.Se não há mensagens estão pendentes, ele chama OnIdle novamente, incrementando a lCount argumento.
Eventualmente, OnIdle terminar de processar todas as tarefas ociosas e retornará 0. Isso faz com que o loop de mensagem para interromper a chamada OnIdle até que seja recebida a próxima mensagem da fila de mensagens, no ponto em que o ciclo ocioso é reiniciado com o argumento conjunto como 0.
Não realize tarefas demoradas durante OnIdle porque o aplicativo não pode processar a entrada do usuário até que OnIdle Retorna.
.gif "Observação") Observação: |
|---|
A implementação padrão de OnIdle atualizações de objetos da interface do usuário, sistema autônomo itens de menu e botões da barra de ferramentas de comando e ele executa a limpeza de estrutura de dados interno. Portanto, se você substituir OnIdle, você deve telefonar CWinApp::OnIdle com o lCount em sua versão de substituição. Primeiro chamar processamento ocioso todos classe de base (ou seja, até a base de classe OnIdle Retorna 0). Se você precisar realizar o trabalho antes de concluir o processamento da classe base, analise a implementação da classe de base para selecionar o correto lCount durante o qual trabalhar. |
Se você não quiser OnIdle a ser chamado sempre que uma mensagem é recuperada da fila de mensagens, você pode substituir o CWinThreadIsIdleMessage.Se um aplicativo definiu um timer muito curto, ou se o sistema está enviando o WM_SYSTIMER mensagem de e OnIdle será chamado várias vezes e prejudicar o desempenho.
Exemplo
Os dois exemplos a seguir mostram como usar OnIdle. O primeiro exemplo processa duas tarefas ociosas usando o lCount argumento para priorizar as tarefas. A primeira tarefa é de alta prioridade e você deve fazê-lo sempre que possível.A segunda tarefa é menos importante e deve ser feita somente quando há uma longa pausar na entrada do usuário.Observe a telefonar para a versão de classe base da OnIdle. O segundo exemplo gerencia um agrupar de tarefas ociosas com prioridades diferentes.
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
}
Exemplo da segundo
// 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;
}
Requisitos
Cabeçalho: afxwin.h