Problème de gestion d'un Timer

Bonjour,

J'ai un petit probl=E8me avec la gestion d'un Timer.

Je vous expose mon probl=E8me :
Je fais un WaitForMultipleObjects, puis je fais un SetWaitableTimer sur
un handle. Le probl=E8me c'est que je n'arrive pas =E0 faire un
ResetEvent sur le Handle =E0 qui j'ai fait mon SetWaitableTimer.
Pourtant je fais bien un CreateWaitableTimer en FALSE pour qu'il fasse
un ResetEvent automatiquement et j'ai aussi essay=E9 avec un TRUE.

Mon but :
Afficher un texte pendant un temps n secondes. Si j'envoi plusieurs
textes pendant ce temps n secondes, je stocke les messages suivants et
je les afficherai apr=E8s le temps n secondes, les uns apr=E8s les
autres.

Mais le r=E9sultat actuel :
J'affiche bien le premier texte pendant n secondes. Mais, si j'envoi
plusieurs textes pendant ce temps, les textes suivants arrivent apr=E8s
le temps n secondes (tout va bien juste qu'ici !!!!) mais, il arrive
tous en m=EAme temps.

voici mon code source:
Voici la fonction o=F9 je fais un waitformultipleobjects, un setwaitable

/--------------- DEBUT CODE ------------------/
void CDisplay::TimeDisplayProc(void* pThis)
{
CDisplay* pDis=3D(CDisplay*)pThis;

// Return code of waitformultipleobjects
DWORD l_dwWaitReturn;

// Define handle array to manage start of timer and stop of thread
HANDLE l_EventTab[3] =3D {0, 0, 0};

// Specifies when the state of the timer is to be set to signaled, in
100 nanosecond intervals.
LARGE_INTEGER liDueTime;

// Create a waitable timer
HANDLE l_TimerHandle =3D NULL;

l_TimerHandle =3D CreateWaitableTimer(0, FALSE, "TimeDisplayTimer");
if (!l_TimerHandle)
pDis->LogDebug(pDis->m_sPackage,
pDis->m_sComponent,
"TimeDisplayProc",
"l_TimerHandle failed",
__FILE__, __LINE__);

// Initialise event array
l_EventTab[0] =3D pDis->m_hStartTimer;
l_EventTab[1] =3D l_TimerHandle;
l_EventTab[2] =3D pDis->m_hEndTimeDisplayProc;

bool l_bRun =3D true;
while (l_bRun)
{
// Wait for the start of timer
l_dwWaitReturn =3D WaitForMultipleObjects(3, l_EventTab, FALSE,
INFINITE);

switch(l_dwWaitReturn)
{
case WAIT_OBJECT_0:
// Start timer
{
liDueTime.QuadPart =3D -15000000; // =3D15secondes

// Set a timer to wait for N seconds.
if (!SetWaitableTimer(l_EventTab[1],

&liDueTime,

0,

NULL,

NULL,

FALSE))
{
pDis->LogDebug(pDis->m_sPackage,

pDis->m_sComponent,

"TimeDisplayProc",

"SetWaitableTimer failed",

__FILE__, __LINE__);
}
pDis->m_bDisplayInProgress =3D true;
}
break;
case WAIT_OBJECT_0 + 1:
// Time is done
{
EnterCriticalSection(&pPID->m_critsecDataProtection);

if (!pDis->m_DisplayList.empty())
{
std::string stext =3D pDis->m_DisplayList.front().text;
int minTime =3D pDis->m_DisplayList.front().minDuration;
pDis->m_DisplayList.pop_front();

pDis->m_bDisplayInProgress =3D false;
pDis->_PrintText(stext, minTime);
}
else
pDis->m_bDisplayInProgress =3D true;

LeaveCriticalSection(&pDis->m_critsecDataProtection);
}
break;
case WAIT_OBJECT_0 + 2:
// End requested
{
l_bRun =3D false;
CloseHandle(pDis->m_hStartTimer);
CloseHandle(pDis->m_hEndTimeDisplayProc);
CloseHandle(l_TimerHandle);
}
break;
case WAIT_FAILED:
{
pDis->LogDebug(pPID->m_sPackage,

pPID->m_sComponent,

"TimeDisplayProc",

"WaitForMultipleObjects failed",

__FILE__, __LINE__);
}
break;
default:
break;
}
}
}
/--------------- FIN CODE -------------------/


Cette fonction permet d'afficher un texte ou sinon je stocke le texte
en attendant la fin du timer.
/-------------- DEBUT CODE -------------/
// Fonction pour l'affichage
FRESULT CDisplay::_PrintText(std::string sText, int uiTime)
{
EnterCriticalSection(&m_critsecDataProtection);
FRESULT err =3D ERROR_SUCCESS;

m_sDispInfo.text =3D sText.c_str();
m_sDispInfo.minDuration =3D -uiTime;

if (m_bDisplayInProgress)
m_DisplayList.push_back(m_sDispInfo);
else
{
err =3D m_DisplayLowLevel->PrintText(m_sDispInfo.text,
EXEC_DP_PRINTLC);
LogDebug(m_sPackage,
m_sComponent,
"_PrintText",
m_sDispInfo.text, __FILE__, __LINE__);

m_bDisplayInProgress =3D true;
SetEvent(m_hStartTimer);
}

LeaveCriticalSection(&m_critsecDataProtection);
return err;
}
/-------------- FIN CODE -------------------/