begin process at 2010 02 10 09:34:58
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Périphériques

 > FAIRE GLISSER LA SOURIS

FAIRE GLISSER LA SOURIS


 Information sur la source

Note :
3 / 10 - par 1 personne
3,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Périphériques Classé sous :souris, commande, gestion, périphérique, blague Niveau :Débutant Date de création :06/03/2008 Vu / téléchargé :4 977 / 228

Auteur : shorzy

Ecrire un message privé
Commentaire sur cette source (22)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
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 ;-)

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip Source avec une capture DOUBLE BUFFERING (MFC)

 Sources de la même categorie

Source avec Zip Source avec une capture [DEV-C++] GESTION DU PORT PARALLÈLE par victorcoasne
Source avec Zip COMMUNICATION RS232 VIA PORT COM par MadMax1024
Source avec Zip Source avec une capture EXTINCTION ET REDEMARRAGE DE VOTRE MONITEUR À UNE HEURE PRÉC... par Yost
ÉTEINDRE ECRAN SOUS WINDOWS par kiki67100
Source avec Zip DRIVERS POUR AFFICHEUR LCD (2X16) ET CLAVIER MATRICIEL 12 TO... par CodeStaler

 Sources en rapport avec celle ci

GESTIONNAIRE DE BIBLIOTHEQUE par eishtein
Source avec Zip Source avec une capture RÉARRANGER LES LIGNES D'UNE LISTVIEW À LA SOURIS (WIN32 API) par racpp
Source avec Zip CACHER LES CURSEURS SYSTÈME (WIN32 API) par racpp
Source avec Zip Source avec une capture [DEV-C++] GESTION DU PORT PARALLÈLE par victorcoasne
Source avec Zip Source avec une capture CAPTURE ECRAN POUVANT CIBLER UNE ZONE par xbabilone

Commentaires et avis

Commentaire de BruNews le 06/03/2008 16:03:14 administrateur CS

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

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...

Commentaire de BruNews le 06/03/2008 16:37:30 administrateur CS

int ou long c'est idem 4 octets.

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^^

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.

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...

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.

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++

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++

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

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.

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 ;) )

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.

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 !!!

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 ;) )

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.

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

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.

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 ;)

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.

Commentaire de roidec le 10/03/2008 21:52:06

salut
bon travail amigo continue

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


Discussions en rapport avec ce code source dans le forum

Gestion de la souris sous DOS avec Dev c++ [ par ceric35 ] Existe t-il un moyen en c sous dos de controler la souris???...au moins de connaitre ses coordonnéeset les évenements de clic.merci. gestion de la souris [ par Adeon ] salut !je n'arrive pas a trouver comment gerer la souris en mode textpourais je avoir un petit exemple qui fasse en quelques lignes "si le curseur est Gestion des événement OpenGL [ par theidiot ] Je connais bien glutMouseFunc(); et glutMotionFunc(); pour paramètrer callback x et y. Le problème c'est qu'il faut peser sur le boutton de la souris SDL : gestion de la molette de la souris ? [ par eplanet ] Bonjour à tous, est-ce que quelqu'un saurait quel est l'événement qui gère la molette de la souris avec SDL, et comment on l'utilise...Merci beaucoup. Gestion d'un périphérique MIDI [ par RV2931 ] Bonjour,J'aurai voulu savoir si quelqu'un a déjà programmer une application qui utilisait un périphérique MIDI in/out ?? existe-t-il un driver standar Gestion de la souris sous Borland c++Builder [ par Thanatos ] Bonjour,Quelqu'un connaitrait-il la façon d'utiliser la souris ( gestion de la position et des clics) sous Borland C++Builder 5.5 ? Et quelles librair gestion de la souris dans une fenêtre OpenGL [ par philmus ] salut, je commence à écrire des petits pgs OpenGL; maintenant, je doit gérer l'entrée (clavier et souris) pour interagir avec l'utilisateur. Le pb Gestion de la souris OpenGL SANS GLUT [ par Xentor ] Comment faire pour connaitre le déplacement de la souris sans utiliser Glut ? (Savoir si on la déplace en haut, à gauche, etc...) J'ai fait plusieurs [VC++]Gestion du tps en C++ [ par Asarnil ] Voila , je cherche comment gerer le temps de maniere efficace en C++ .La j'ai fait un test qui fait avancer un 0 sur une ligne le pron c'est que meme Position de la souris. [ par Colombus ] Bonjour, Dans un projet MFC j'ouvre un bitmap; Je voudrais par la suite, "uniquement" après clic sur un bouton pouvoir avec la souris cliquer sur un p


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,154 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales