CWinApp::OnIdle
Publicado: abril de 2016
Substituir essa função de membro para executar o processamento de tempo ocioso.
Sintaxe
virtual BOOL OnIdle(
LONG lCount
);
Parâmetros
- lCount
Um contador incrementado cada vez que OnIdle é chamado quando a fila de mensagens do aplicativo está vazia. Esta contagem é redefinida como 0 sempre que uma nova mensagem é processada. Você pode usar o parâmetro de lCount para determinar o período de tempo que relativo o aplicativo foi ocioso sem processar uma mensagem.
Valor de retorno
Diferente de zero para receber mais tempo de processamento ociosos; 0 se não mais tempo ocioso é necessário.
Comentários
OnIdle é chamado no loop de mensagem padrão quando a fila de mensagens do aplicativo está vazia. Use a substituição para chamar suas próprias tarefas de plano de fundo do quietude- manipulador.
OnIdle deve retornar 0 para indicar que nenhuma hora de processamento ocioso é necessária. O parâmetro de lCount é incrementado cada vez que OnIdle é chamado quando a fila de mensagens está vazia e redefina a 0 uma nova mensagem é processada cada vez. Você pode chamar suas rotinas ociosos diferentes com base em esta contagem.
O exemplo a seguir resume o processamento ocioso do loop:
Se o loop de mensagem na biblioteca de classes da Microsoft foundation verifica a fila de mensagens e não encontra nenhuma mensagem pendente, chama OnIdle para o objeto do aplicativo e fornece 0 como o argumento de lCount .
OnIdle executa qualquer processamento e retorna um valor diferente de zero para indicar que deve ser chamado novamente para fazer processamento adicional.
As verificações de loop de mensagem a fila de mensagens novamente. Se nenhuma mensagem está pendente, chama OnIdle novamente, incremento do argumento lCount .
Se houver, OnIdle termina o processamento todas as suas tarefas ociosos e retorna 0. Isso informa o loop de mensagens para parar de chamar OnIdle até que a seguinte mensagem ser recebida de fila de mensagens, no ponto no ciclo ocioso reinicia com o argumento definido como 0.
Não executar tarefas longas durante OnIdle porque seu aplicativo não pode processar a entrada do usuário até que OnIdle retorna.
Dica
A implementação padrão de atualizações de OnIdle de objetos de interface do usuário como itens de menu e botões da barra de ferramentas, e realiza a limpeza interna da estrutura de dados.Portanto, se você substituir OnIdle, você deve chamar CWinApp::OnIdle com lCount na sua versão sobrecarregada.A primeira chamada qualquer processamento de ociosa da classe base (isto é, até a classe base OnIdle retorna 0).Se você precisa realizar o trabalho antes que o processamento da classe base terminar, revise a implementação da classe base para selecionar lCount durante que apropriado para tornar seu trabalho.
Se você não deseja OnIdle a ser chamado sempre que uma mensagem é recuperada de fila de mensagens, você pode substituir CWinThreadIsIdleMessage. Se um aplicativo tiver definido um timer muito tempo, ou se o sistema é enviando a mensagem de WM_SYSTIMER , então OnIdle será chamada repetidamente, e prejudica o desempenho.
Exemplo
Os seguintes exemplos mostram como usar OnIdle. O primeiro exemplo processa duas tarefas ociosos usando o argumento de lCount priorizar para tarefas. A primeira tarefa é prioridade, e você deve fazê-lo sempre que possível. A segunda tarefa é menos importante e deve ser feita apenas quando há uma pausa longa na entrada do usuário. Observe a chamada à versão da classe base de OnIdle. O segundo exemplo gerencia um grupo de tarefas ociosos prioridades com 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
}
Segundo exemplo
// 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