begin process at 2008 08 08 21:41:43
1 223 607 membres
365 nouveaux aujourd'hui
14 230 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

FAIRE GLISSER LA SOURIS


Information sur la source

Description

Bonjour.

Cette Source pourrait faire partie d'une Blague :
Une fois le Programme Lancé, votre Souris Glissera
au Moindre de vos Déplacements.
Pire, Arrivé au Bord de l'Ecran, la Souris Reapparaît
à l'autre Bout, et Continue de Glisser.


La Source vous donne l'Occasion de voir les Fonctions Windows
permettant de Manipuler la Souris.

Source

  • /*******************************************************************
  • *** Petit Programme "Chiant" Faisant "Glisser" le Mulot ***
  • *** Comme s'il Etait dans l'Espace...(Sans Frottement) ***
  • *** De plus en Sortant de l'Ecran la Souris apparait ***
  • *** à l'Autre Bout ***
  • *** /!\ /!\ ***
  • *** Il Faudra Fermer le Programme pour Arrêter le Cauchemard ***
  • ********************************************************************/
  • // *********************************************************************************************
  • // Déclaration des Entêtes *********************************************************************
  • // *********************************************************************************************
  • #include <windows.h>
  • #include <iostream.h>
  • #include <stdio.h>
  • // *********************************************************************************************
  • // Déclaration des Fonctions *******************************************************************
  • // *********************************************************************************************
  • Deplacement(POINT &PointAncien , POINT &PointRecent);
  • // *********************************************************************************************
  • // Programme Principal *************************************************************************
  • // *********************************************************************************************
  • int main()
  • {
  • //******************************** Création des Variable Locale ********************************
  • // Stockage des Coordonnées à l'Instant t1,t2,t3
  • POINT P1,P2;
  • // ******************************* Fin de Création des Variables Locale ************************
  • // Obtient la Position du Curseur à l'instant t1
  • GetCursorPos(&P1);
  • // On Rends "Explicitement" la main à Windows
  • Sleep(8);
  • //*************************************** Boucle Infini ****************************************
  • do
  • {
  • // Stockage des Coordonées de P2(t2)
  • GetCursorPos(&P2);
  • // Fait Glisser la Souris (Selon de Déplacement Observé entre t1 et t2)
  • Deplacement(P1 , P2);
  • // On Rends "Explicitement" la main à Windows
  • Sleep(8);
  • // Stockage des Coordonées de P1(t1)
  • GetCursorPos(&P1);
  • // Fait Glisser la Souris (Selon de Déplacement Observé entre t2 et t3)
  • Deplacement(P2 , P1);
  • Sleep(8);
  • }while(1);
  • //************************************** Fin Boucle Infini *************************************
  • return 0;
  • } // fin de main
  • // **************************************************
  • // * *
  • // * Fonction Gérant les Déplacements de la Souris *
  • // * --------------------------------------------- *
  • // * *
  • // * *
  • // * Des Ajustements sont Effectuer pour Permettre *
  • // * à la Souris d'Apparaître de l'Autre côté de *
  • // * l'Ecran Lorsque l'on Dépasse du Cadre *
  • // * *
  • // **************************************************
  • Deplacement(POINT &P1 , POINT &P2)
  • {
  • // Stockage des Coordonnées à l'Instant t1,t2,t3
  • long x1=0,y1=0 ,x2=0,y2=0,x3,y3;
  • // Stockage des Coordonnées MAX de l'Ecran
  • POINT Ecran = {GetSystemMetrics(SM_CXSCREEN)-1, GetSystemMetrics(SM_CYSCREEN)-1};
  • // Stockage du Vecteur de Déplacement
  • POINT Delta;
  • // Calcul du Vecteur de Déplacement
  • Delta.x = (P2.x-P1.x);
  • Delta.y = (P2.y-P1.y);
  • // Récupération des Données
  • x1=P1.x;
  • y1=P1.y;
  • x2=P2.x;
  • y2=P2.y;
  • // Prévoit le Prochain Déplacement
  • // (Sans l'Effectuer car il y aura peut être des Ajustements à faire)
  • x3=x2+Delta.x;
  • y3=y2+Delta.y;
  • // Tester le Dépassement Droite-Gauche (Axe x)
  • if ( (x3>=(Ecran.x)) || (x3<=0) )
  • {
  • // Changer les Prévisions en Cas de Dépassement en Positif (Vers la Gauche)
  • if ( x3>=(Ecran.x) )
  • {
  • x3=(0+Delta.x) - (Ecran.x-x2);
  • x2=0 - (Ecran.x-x2);
  • }
  • // Changer les Prévisions en Cas de Dépassement en Négatif (Vers la Droite)
  • if ( x3<=0 )
  • {
  • x3=Ecran.x+Delta.x+x2;
  • x2=Ecran.x+x2;
  • }
  • } // Fin du Test (Axe x)
  • // Tester le Dépassement Haut-Bas (Axe y)
  • if( (y3>=Ecran.y) || (y3<=0) )
  • {
  • // Changer les Prévisions en Cas de Dépassement en Positif (Vers le Haut)
  • if ( y3>=Ecran.y )
  • {
  • y3=(0+(Delta.y)) - (Ecran.y-y2);
  • y2=0 - (Ecran.y-y2);
  • }
  • // Changer les Prévisions en Cas de Dépassement en Négatif (Vers le Bas)
  • if ( y3<=0 )
  • {
  • y3=Ecran.y+(Delta.y)+y2;
  • y2=Ecran.y+y2;
  • }
  • } // Fin du Test (Axe y)
  • // On Réenregistre P2 car il servira pour le Prochain Déplacement
  • P2.x=x2;
  • P2.y=y2;
  • // Effectue le Déplacement (Si Besoin, des Ajustements ont été faits depuis les Prévisions)
  • SetCursorPos(x3,y3);
  • Sleep (8);
  • } // Fin de Deplacement
/*******************************************************************
***		Petit Programme "Chiant" Faisant "Glisser" le Mulot		 ***
***		Comme s'il Etait dans l'Espace...(Sans Frottement)		 ***
***		De plus en Sortant de l'Ecran la Souris apparait		 ***
***		à l'Autre Bout											 ***
***		/!\													/!\	 ***
***		Il Faudra Fermer le Programme pour Arrêter le Cauchemard ***
********************************************************************/








// *********************************************************************************************
// Déclaration des Entêtes *********************************************************************
// *********************************************************************************************

#include <windows.h>
#include <iostream.h>
#include <stdio.h>


// *********************************************************************************************
// Déclaration des Fonctions *******************************************************************
// *********************************************************************************************

Deplacement(POINT &PointAncien , POINT &PointRecent);


















// *********************************************************************************************
// Programme Principal *************************************************************************
// *********************************************************************************************


int main()
{



//******************************** Création des Variable Locale ********************************

	// Stockage des Coordonnées à l'Instant t1,t2,t3
	POINT P1,P2;

// ******************************* Fin de Création des Variables Locale ************************







	// Obtient la Position du Curseur à l'instant t1
	GetCursorPos(&P1);

	// On Rends "Explicitement" la main à Windows
	Sleep(8);


//*************************************** Boucle Infini ****************************************
	do
	{
		// Stockage des Coordonées de P2(t2)
		GetCursorPos(&P2);

		// Fait Glisser la Souris (Selon de Déplacement Observé entre t1 et t2)
		Deplacement(P1 , P2);

		// On Rends "Explicitement" la main à Windows
		Sleep(8);

		// Stockage des Coordonées de P1(t1)
		GetCursorPos(&P1);

		// Fait Glisser la Souris (Selon de Déplacement Observé entre t2 et t3)
		Deplacement(P2 , P1);

		Sleep(8);

	}while(1);
//************************************** Fin Boucle Infini *************************************
		
	
	return 0;
}	// fin de main



















// **************************************************
// *												*
// * Fonction Gérant les Déplacements de la Souris	*
// * ---------------------------------------------	*
// *												*
// *												*
// * Des Ajustements sont Effectuer pour Permettre	*
// * à la Souris d'Apparaître de l'Autre côté de	*
// * l'Ecran Lorsque l'on Dépasse du Cadre			*
// *												*
// **************************************************




Deplacement(POINT &P1 , POINT &P2)
{


// Stockage des Coordonnées à l'Instant t1,t2,t3
	long x1=0,y1=0 ,x2=0,y2=0,x3,y3;

// Stockage des Coordonnées MAX de l'Ecran
	POINT Ecran = {GetSystemMetrics(SM_CXSCREEN)-1, GetSystemMetrics(SM_CYSCREEN)-1};

// Stockage du Vecteur de Déplacement
	POINT Delta;

// Calcul du Vecteur de Déplacement
	Delta.x = (P2.x-P1.x);
	Delta.y = (P2.y-P1.y);


// Récupération des Données
	x1=P1.x;
	y1=P1.y;

	x2=P2.x;
	y2=P2.y;


// Prévoit le Prochain Déplacement
// (Sans l'Effectuer car il y aura peut être des Ajustements à faire)
	x3=x2+Delta.x;
	y3=y2+Delta.y;


	// Tester le Dépassement Droite-Gauche (Axe x)
	if ( (x3>=(Ecran.x)) || (x3<=0) )
	{


		// Changer les Prévisions en Cas de Dépassement en Positif (Vers la Gauche)
		if ( x3>=(Ecran.x) )
		 {
			x3=(0+Delta.x) - (Ecran.x-x2);
			x2=0 - (Ecran.x-x2);
		 }


		// Changer les Prévisions en Cas de Dépassement en Négatif (Vers la Droite)
		if ( x3<=0 )
		{
			x3=Ecran.x+Delta.x+x2;
			x2=Ecran.x+x2;
		 }
			
	}	// Fin du Test (Axe x)




	// Tester le Dépassement Haut-Bas (Axe y)
	if( (y3>=Ecran.y) ||  (y3<=0) ) 
	{


		// Changer les Prévisions en Cas de Dépassement en Positif (Vers le Haut)
		 if ( y3>=Ecran.y )
		 {
			y3=(0+(Delta.y)) - (Ecran.y-y2);
			y2=0 - (Ecran.y-y2);
		 }



		 // Changer les Prévisions en Cas de Dépassement en Négatif (Vers le Bas)
		 if ( y3<=0 )
		 {

			y3=Ecran.y+(Delta.y)+y2;
			y2=Ecran.y+y2;
		 }

	}	// Fin du Test (Axe y)


// On Réenregistre P2 car il servira pour le Prochain Déplacement
	P2.x=x2;
	P2.y=y2;


// Effectue le Déplacement (Si Besoin, des Ajustements ont été faits depuis les Prévisions)
	SetCursorPos(x3,y3);

	Sleep (8);


}	// Fin de Deplacement

Conclusion

                     !!! ATTENTION !!!
!!! A LIRE AVANT DE LANCER LE PROGRAMME !!!

Pour Stopper le Mouvement de la Souris, il faudra Fermé le programme.
Cela ce fait en Fermant la Fenêtre DOS : "Souris_Glisse.exe" .

Comme la Souris sera (Pour les Moins Doués) Incontrôlable, vous pouvez

utiliser ALT+ENTREE  pour Fermer le Programme.

Si vous avez perdu le Focus sur l'Application (En cliquant n'import où !!)
Il faudra dabord faire ALT+TAB pour retourner sur "Souris_Glisse.exe" .


PS:
Essayer de Faire un Dessin sur Paint ;-)
Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

  • signaler à un administrateur
    Commentaire de BruNews le 06/03/2008 16:03:14 administrateur CS

    POINT Ecran, c'était à calculer 1 seule fois dans le main().

  • signaler à un administrateur
    Commentaire de lynxtyle le 06/03/2008 16:27:57 3/10

    Je dirai une de plus !

    Je vais commencer par les bon point (sinon on va dire que je suis méchant si je débarque directement par ce qui va pas^^) :
    - le code est bien commenté

    Maintenant voilà quelques conseils d'amélioration :
    - revois un peu la mise en page car pour un autre code exemple c'est pas joli (moins de grand saut et rester constant dans les espaces)
    - par commodité on préfère mettre les fonctions avant le main ou dans une source séparé rajouté avec un include en entête (ainsi quand on lit le code on sait ce que fait la fonction avant de la voir appeler... c'est une commodité)
    - rajouter une sortie correcte au programme (histoire de donner un sens à ton "return 0;" final^^) jors rajouter dans la boucle :
    "if (GetAsyncKeyState(VK_SPACE)&0x8000)
    drapeau = 0;
    }while(drapeau == 1);"
    pour sortir quand on appuit sur la touche espace
    - rajouter un type à tes fonctions ça aussi serait pas mal... ça compilerai plus facilement je pense^^ jors :
    "void Deplacement(POINT &P1 , POINT &P2)"
    - pourquoi utiliser des long? un int suffit pas pour tes variables? d'ailleur tes variables manquent d'imagination... au minimum un tableau aurai était plus joli^^... et tu aurais pu réduire le code avec des boucles^^

    Enfin bon je suis plutot déçu... rien de nouveau et beaucoup de pire... j'espère revoir ce code mais après correction...

  • signaler à un administrateur
    Commentaire de BruNews le 06/03/2008 16:37:30 administrateur CS

    int ou long c'est idem 4 octets.

  • signaler à un administrateur
    Commentaire de lynxtyle le 06/03/2008 16:51:55

    c'est pas tout à fait exacte : la place occupée en mémoire par les types entiers n'est pas spécifiée, toutefois la taille du type short et int est d'au moins 2 octets, celle du type long d'au moins 4 octets...
    les types d'entiers à taille définie ont été introduits dans le ANSI C99 par l'intermédiaire du fichier en-tête stdint.h qui n'est pas utilisé ici...
    donc en clair suivant le réglage du compilateur le int peut faire gagner 2 octets par variable... c'est pas énorme mais bon vive l'optimisation^^

  • signaler à un administrateur
    Commentaire de BruNews le 06/03/2008 17:07:04 administrateur CS

    Si on mettait le 'unt' à 2 octets ce ne serait pas une optimisation mais une nuisance surtout en terme de perfs.
    Ce code est pour Window qui a fort heureusement et définitivement (comme les autres acteurs majeurs) exclu C99 de ses compilos, int et long resteront à 4 octets.

  • signaler à un administrateur
    Commentaire de lynxtyle le 06/03/2008 17:58:20

    Désolé d'être aussi pointilleu mais je suis souvant sur des systèmes atypiques... et un int à 2 octets n'est pas forcément une nuisance (quand tu n'as qu'une 100aine d'octets^^)... et pareil utiliser stdint.h peut être sympa sur les nouvelles machines avec N=64bits... vu que le short correspond à un long et le long à un long long... (donc configurer le int à 2 octets resterait très interessant dans ce cas...)

    Mais bon on s'éloigne beaucoup du sujet là ^^ pour en revenir à la source on aurait même pu mettre un short et faire un petit tableau à deux dimentions Positions[1][2]... ça aurait était très sympa : Positions[0][] pour les X, Positions[1][] pour les Y... avec quelques boucles ça aurait été un code court qui aurai eu un intêret algorithmique... là je trouve que ça ne fait qu'un code de plus sur la gestion de la souris... J'espère le voir évoluer...

  • signaler à un administrateur
    Commentaire de BruNews le 06/03/2008 18:04:04 administrateur CS

    Pour conclure (sur PC Windows) int et long toujours à 4 octets sur 64 bits et restera même si on arrive aux 128 bits.

  • signaler à un administrateur
    Commentaire de shorzy le 06/03/2008 19:05:21

    Salut, je vous remercie de vos Commentaires.
    Pour vous dire, j'ai utilisé des long car, d'après ce que j'ai vu :
    windows.h utilise la Structure POINT formé de deux LONG,
    Les LONG étant des long.
    Pour le Code...
    ---
    J'ai déplacé certaines Parties pour vous rendre le Prgm le plus Digeste possible,
    Effectivement, je n'aurais pas du Déplacer POINT Ecran comme le Signal "BruNews"
    ---
    Merci à lynxtyle, Appuyer sur VK_SPACE j'y avais pensé mais je ne savais pas comment faire.
    ---
    Voila, pour la mise en page dsl c'est un Copier-Coller de MS_C++

  • signaler à un administrateur
    Commentaire de shorzy le 06/03/2008 19:07:33

    Salut, je vous remercie de vos Commentaires.
    Pour vous dire, j'ai utilisé des long car, d'après ce que j'ai vu :
    windows.h utilise la Structure POINT formé de deux LONG,
    Les LONG étant des long.
    Pour le Code...
    ---
    J'ai déplacé certaines Parties pour vous rendre le Prgm le plus Digeste possible,
    Effectivement, je n'aurais pas du Déplacer POINT Ecran comme le Signal "BruNews"
    ---
    Merci à lynxtyle, Appuyer sur VK_SPACE j'y avais pensé mais je ne savais pas comment faire.
    ---
    Voila, pour la mise en page dsl c'est un Copier-Coller de MS_C++

  • signaler à un administrateur
    Commentaire de BruNews le 06/03/2008 19:14:49 administrateur CS

    Dans VS, menu tools options:
    Text Editor, All Languages, Tabs
    - smart COCHER
    - Tab size : 2
    Indent size : 2
    insert spaces COCHER

  • signaler à un administrateur
    Commentaire de DeAtHCrAsH le 07/03/2008 09:48:11

    Quote :
    // On Rends "Explicitement" la main à Windows
    Sleep(8);
    => ce n'est pas tout a fait vrai, en fait tu mets juste le thread principal de ton appli en attente. Windows garde toujours la main sur les allocations mémoires et la gestion des threads.

  • signaler à un administrateur
    Commentaire de _dune2_ le 07/03/2008 17:37:41

    BruNews : "Pour conclure (sur PC Windows) int et long toujours à 4 octets sur 64 bits et restera même si on arrive aux 128 bits."

    Mouhahahaaaa ! vive les optimisations de windows (dixi BruNews : "Si on mettait le 'unt' à 2 octets ce ne serait pas une optimisation mais une nuisance surtout en terme de perfs.
    Ce code est pour Window qui a fort heureusement et définitivement (comme les autres acteurs majeurs) exclu C99 de ses compilos, int et long resteront à 4 octets.").

    Moi je ne sais pas pour windows, mais sous unix :
    ===========================================
    #include <stdio.h>

    main() {
      printf("sizeof(int)  : %d\n",sizeof(int));
      printf("sizeof(long) : %d\n",sizeof(long));
      return;
    }
    ===========================================

    - compilation et execution sur une machine 32bits :

    cku@encelade:~/test$ uname -m
    i686
    cku@encelade:~/test$ ./toto
    sizeof(int)  : 4
    sizeof(long) : 4

    - compilation et execution sur une machine 64bits :

    cku@ambre:~/test$ uname -m
    x86_64
    cku@ambre:~/test$ ./toto
    sizeof(int)  : 4
    sizeof(long) : 8

    ... J'attend impatiemment l'arrivée des 128bits sous unix (et tous systèmes POSIX) ;) pas vous ?

    ++dune2 (sans rancune ;) )

  • signaler à un administrateur
    Commentaire de BruNews le 07/03/2008 18:04:11 administrateur CS

    Je me réjouis chaque jour de ne pas être sous un système qui me changera mes identifiants quand je change la plateforme cible.
    *((long*) p) = 0xFFFFFFFF;
    Je sais que j'adresse 4 octets que je compile WIN32 ou WIN64.
    Vraiment sans rancune aucune, bien au contraire.

  • signaler à un administrateur
    Commentaire de shorzy le 07/03/2008 18:08:45

    Pour Répondre à DeAtHCrAsH
    -----
    // On Rends "Explicitement" la main à Windows
    Sleep(8);
    -----
    Si je ne met pas cette Ligne, La Souris se comporte très Différement
    de ce qui est Voulu par le Programme:

    Si entre 2 Relevés de Position je ne met pas Sleep()
    Alors le Premier Relevé=le Deuxième relevé
    Malgrés que sur Windows la Souris est Bougé...

    J'ai fais Différents Tests:
    Sur Certain, la Souris 'Clignote' autour de sa position au lieu de se Déplacer !!!

  • signaler à un administrateur
    Commentaire de _dune2_ le 07/03/2008 18:09:43

    Oui mais au moins j'ai le choix :
    - utiliser un "int" pour rester en 32bits.
    - utiliser un "long" pour utiliser une pleine échelle de registres.

    De plus, le "long" permet de faire des conversions entre pointeurs et variables, car les pointeurs sont en 64bits. Comment faire un calcul de pointeur si tu n'as pas de type correspondant à sa taille ?

    Personnellement, je prefère avoir le choix, et c'est sous la responsabilité du codeur de faire le bon choix ;)

    ++dune2 (l'échange d'experience forme la connaissance ;) )

  • signaler à un administrateur
    Commentaire de BruNews le 07/03/2008 18:18:23 administrateur CS

    Tu dois bien penser qu'on a tous les types qu'il faut pour manipuler pointeurs et faire de l'adressage, __int64, UINT64, DWORD_PTR, etc...
    Tout ce qui est pointeur (*ptr) est automatiquement sur 64 bits quand je compile en 64, tout va bon. Les types simples sont par contre immuables, ça garantit la pérennité du code.

  • signaler à un administrateur
    Commentaire de _dune2_ le 07/03/2008 18:24:40

    Je trouve tout de même que la multiplication des types de variables n'est pas une solution qui va vers une simplification ...

    Quelle est la différence entre "int" et "long" sous windows alors ?? Pourquoi avoir 2 types identiques ?

    Si c'est pour avoir une pérénnité du code, je l'assure en utilisant tout simplement "int" pour des variables à taille immuable et "long" lorsque je souhaite avoir une variable de taille adapté à l'archi (essentiellement dans le cadre de calculs sur des pointeurs).

    ++dune2

  • signaler à un administrateur
    Commentaire de BruNews le 07/03/2008 18:31:17 administrateur CS

    'long' était passé de 2 à 4 quand on est passé du 16 au 32 et on a été nombreux à trouver que c'était le souk pour l'existant. La décision avait alors été prise que tous les types primaires ne bougeraient plus.
    En prog Win on a les types Win évolutifs à employer, du genre INT_PTR. C'est une habitude à avoir, rien de plus.

  • signaler à un administrateur
    Commentaire de _dune2_ le 07/03/2008 18:35:25

    Pour conclure : (je ne veux pas non plus que la source devienne un lieu de débat)
    On est donc d'accord que c'est une habitude de codage ;)
    Mais je ne pense pas qu'on puisse parler d'optimisation à ce stade ;)

  • signaler à un administrateur
    Commentaire de BruNews le 07/03/2008 18:39:39 administrateur CS

    L'accès à une adresse alignée en est assurément une, c'était le but de la remarque.

  • signaler à un administrateur
    Commentaire de roidec le 10/03/2008 21:52:06

    salut
    bon travail amigo continue

  • signaler à un administrateur
    Commentaire de LeFauve42 le 11/03/2008 11:46:38

    Si ca n'a pas change, le type "int" est suppose etre un entier da la taille native de la plateforme.
    Cela a des quelquefois eu des consequences rigolotes. Par exemple sur les premieres versions d'OSF/1 sur DEC ALPHA, les long etaient toujours en 32 bits mais les int etaient en 64...
    L'arrivee des "long long" a un peu calme les choses, mais j'avoue que je prefere les "pseudo types" genre __int16 ou __int64. Au moins, on sait vraiment ce qu'on va avoir et on n'a pas de surprises (sauf que la plupart des plateformes ne les reconnaissent pas... Quite a normaliser quelque chose, pourquoi ne pas choisir ce genre de notations ?).
    A l'epoque (au millenaire dernier :op) je faisais du portage de SUN vers DEC, et j'en ai [...] des vertes et des pas mures avec ces histoires de tailles :o)

Ajouter un commentaire

Pub



Appels d'offres

CalendriCode

Août 2008
LMMJVSD
    123
45678910
11121314151617
18192021222324
25262728293031

Téléchargements

Logiciels à télécharger sur le même thème :

Boutique

Boutique de goodies CodeS-SourceS