Salut à tous.

J'ai un problème pour calculer un défilement rapide dans une liste.

Lorsque je scroll, je conserve les paramètres du mouvement appliqué à la liste pour les envoyer à l'action qui gère le défilement rapide.

sXY pDepart (point de départ de mon mouvement)

sXY pFin (point de fin de mon mouvement)

unsigned long timeElapsed (temps en milli de mon mouvement)

Dans la fonction qui gère le défilement, je n'arrive pas à trouver un bon fonctionnement pour avoir un défilement rapide comme dans les listes sur téléphone.

J'ai cherché sans succès.

J'ai donc fait ceci, mais pas terrible.

//ici c'est pour déterminer le sens du mouvement appliqué

int xsens = (pFin.x < pDepart.x ? CMD_SCROLL_RIGHT : CMD_SCROLL_LEFT);

int ysens = (pFin.y < pDepart.y ? CMD_SCROLL_DOWN : CMD_SCROLL_UP);



//nombre de pixel par milliseconde de mon mouvement

double nbpix_par_milli_x = _max(1UL, abs(pFin.x - pDepart.x) / timeElapsed);

double nbpix_par_milli_y = _max(1UL, abs(pFin.y - pDepart.y) / timeElapsed);



ctimer timer;

while (TRUE)

{

	//vérif si le thread de l'action doit s'arrêter
	if (stop()) return;

	//temps écoulé depuis le dernier tour (temps de pause du thread + temps de rafraîchissement de la liste)
	unsigned long te = timer.timeElapsed();

	//remet le timer à 0
	timer.init();

	if (te)

	{
		//// "nombre de pixel par milli" x "le dernier temps écoulé en milli"
		long xdelta = (nbpix_par_milli_x * te);
		if (xdelta < 0) xdelta = 0;

		long ydelta = (nbpix_par_milli_y * te);
		if (ydelta < 0) ydelta = 0;
		////



		//à chaque tour de boucle, je ralentis le mouvement
		//donc c'est ici qu'il sait à quel moment arrêter le défilement
		if (!xdelta && !ydelta) return;

		//point avec les valeurs pour envoyer à la fonction de mon objet qui gère le scroll
		cpoint<int> delta_move;
		delta_move.x = (xsens == CMD_SCROLL_RIGHT ? -xdelta : xdelta);
		delta_move.y = (ysens == CMD_SCROLL_DOWN ? -ydelta : ydelta);


		BOOL ok;
		spinlock_ENTER(spinlock::app_invalidaterect);
		{
			//lock update (pour verrouiller la mise à jour de l'écran)
			__LU;		

			//fonction de l'objet qui va décaler les enfants en fonction de "delta_move"
			ok = getobjet()->gesture_scroll(delta_move, TRUE, 2);
		}
		spinlock_LEAVE(spinlock::app_invalidaterect);
		//

		//si l'objet a atteint la limite de son scroll on peut sortir
		if (!ok) return;
	}

	//met en pause le thread en pour 20 millisecondes
	thread_pause(20);

	//c'est surtout ici que je bloque, pour ralentir le défilement progressivement
	//si je détermine une valeur trop petite, la liste défilement trop longtemps
	//et au contraire, si je détermine une valeur plus grande, elle ne défile pas assez
	if (nbpix_par_milli_x) nbpix_par_milli_x -= ((nbpix_par_milli_x) / 100); 
	if (nbpix_par_milli_y) nbpix_par_milli_y -= ((nbpix_par_milli_y) / 100);

}

Si vous avez une idée ou une meilleur manière de procéder je suis preneur !

-
Edité par DarkCode 23 août 2017 à 5:22:08