virtual BOOL OnIdle ( longa lCount );
Valor de retorno
Diferente de zero para receber mais tempo ocioso de processamento; 0 se não há mais tempo ocioso é necessária.
Parâmetros
lCount
Um contador incrementado sempre que OnIdle é chamado quando fila de mensagem do aplicativo está vazia. Esta contagem é Redefinir como 0 sempre que uma Novo mensagem é processada. Você pode usar o parâmetro lCount para determinar o comprimento relativo de tempo que o aplicativo ficou ocioso sem processar uma mensagem.
Observações
Substituir esta função de membro para executar o processamento de tempo inativo. OnIdle é chamado no loop de mensagem padrão quando a fila de mensagem do aplicativo está vazia. Use sua Substituir para chamar seu próprio fundo tarefas ocioso-manipulador.
OnIdle deve retornar 0 para indicar que nenhum tempo de processamento ocioso é necessário. O parâmetro lCount é incrementado sempre que OnIdle é chamado quando o messagenbsp; a fila está vazia e redefine como 0 sempre que uma &Novo mensagem é processada. Você pode chamar suas rotinas de ociosas diferentes baseadas esta contagem.
O seguinte resume o processamento de loop ocioso:
OnIdle para o objeto application e suprimentos 0 como o argumento lCount.OnIdleexecuta algum processamento e retorna um valor diferente de zero para indicar que ele deve ser chamado novamente para fazer processamento adicional.OnIdle novamente, incrementando o argumento lCount.OnIdle termina o processamento de todas as suas tarefas ociosas e retornará 0. Isso informa o loop de mensagem para parar de chamar OnIdle até a próxima mensagem é recebida da fila de mensagens, em que ponto do ciclo ocioso é reiniciado com o argumento definido tonbsp; 0.Não execute tarefas demoradas durante OnIdle porque seu aplicativo não é possível processar a entrada do usuário até que OnIdle retorne.
&Notanbsp; A implementação padrão do OnIdle atualiza objetos de interface do usuário de comando, como itens de menu e botões da barra de ferramentas, e ele executa limpeza de estrutura de dados internos. Portanto, se você substituir OnIdle, você deve chamar CWinApp::OnIdle com o lCount em sua versão substituída. Primeiro chamar a classe base de tudo processamento ocioso (ou seja, até que OnIdle a classe base retorna 0). Se você precisar executar o trabalho antes do processamento de classe base é concluída, revise a implementação de classe base para selecionar o apropriado lCount durante os quais a fazer seu trabalho.
Exemplo
Os dois exemplos a seguir mostram como usar OnIdle. O primeiro exemplo processa duas tarefas ociosas usando o argumento lCount 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 apenas quando houver uma pausa longa na entrada do usuário. Observe a chamada para a versão de classe base do OnIdle. O segundo exemplo gerencia um grupo de tarefas ociosas com prioridades diferentes.
BOOL CMyApp::OnIdle(LO&NG lCount)
{
nbsp; BOOL bMore = CWinApp::OnIdle(lCount);
se (lCount = = 0)
{
RASTREAMENTO ("App ocioso por um período curto do time\n");
bMore = TRUE;
}
else if (lCount = = 10)
{
RASTREAMENTO ("App ocioso por mais tempo quantidade do time\n");
bMore = TRUE;
}
else if (lCount = = 100)
{
RASTREAMENTO ("App ocioso por quantidade ainda maior de time\n");
bMore = TRUE;
}
else if (lCount = = 1000)
{
RASTREAMENTO ("App inactivo durante bastante tempo do time\n");
/ / bMore não estiver definido para TRUE, não precisa mais ocioso
/ / IMPORTANTE: bMore não é definida como FALSE, uma vez que pode CWinApp::OnIdle
/ / tem mais tarefas ociosas para concluir.
}
retornar bMore;
/ / return TRUE enquanto não há nenhuma tarefa mais ociosa
}
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 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;
}
Visão geral de CWinApp |nbsp; Membros de classe | Gráfico de hierarquia