Position et mouvement de la souris sous windows

[theocrite]

Comment peut on récupérer la position et le mouvement du curseur de la souris sous windows CE embedded dans un programme C ?

Si quequ'un a la réponse, il me rend un gros service. J'en ai vraiment besoin.

[mogwai93]

#include <windows.h>

typedef struct POINTAPI{

X As Long

Y As Long

};

Long GetCursorPos (POINTAPI* lpPoint)

// Retourne la position du curseur de la souris dans une variable déclarée de type POINTAPI ...

Ca fonctionne sur Win98/Me/2000/XP

Mais pour windows CE embedded ???

#include <windows.h>

int STDCALL
WinMain (HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
{
   POINT pos; //espace pour loger les coordonnées
   GetCursorPos(&pos); //loge les coordonnées (x,y) de la position initiale de la souris

  // pos.x = coordonnées x de la souris 
  // pos.y = coordonnées y de la souris 

   return 0;
}

[theocrite]

Merci beaucoup Mogwai, c'est exactement ce que je cherchais. Reste à l'utiliser.

[XZombi]

Reste à voir si Windows CE va le supporter. Intéressant a savoir

[theocrite]

Ben on ne verra pas grand chose, finalement nous avons changé de direction (suite à un putch) : Comme nous avons besoin de 100% des cycles d'horloge pour un programme très gourmand, le mouvement et la position seront données en temps réel par une carte i2c placé entre la souris et le CPU.

Voila.

Merci quand même, ça me servira à moi perso.

[theocrite]

Sinon Theocrite tu en es ou avec ton post dans la rubrique programmation?

Voila où on en est pour le moment :

On a essayé de tester le GetCursorPos, mais le problème c'est que on arrive pas à afficher les positions. Dans embedded Vc++, on ne peut pas faire de C normal.

Il n'y a pas de main, mais un winmain(....) etc..

L'application "hello world" fournie est la plus compliquée que j'ai jamais vue.

On en est donc à chercher comment avoir un feedback, comment pouvoir afficher une chaine ou un nombre variable.

Si quelqu'un a un lien vers une doc EVC++, ou des info INterressantes, ça m'interresse.

[mogwai93]

Je ne connais pas embedded Vc++,

il a quoi de + ou de - par rapport à VC++ ?

pour afficher une valeur (chaine ou nombre)

si c'est un nombre faut le transformer en chaine...

tu peux faire une fenetre avec les ressources (fichier .rc)

tu fais un static

....
   LTEXT           "Texte:",IDC_STATIC,21,50,20,8 
   // Tu mets apres l'identifiant IDC_STATIC : Pos_X, Pos_Y, Taille_X, Taille_Y
....
#define IDC_STATIC .... // mettre une valeur non utilisée

puis dans le code, tu recuperes le static

et tu lui affectes ta valeur

je crois que c'est SetWindowText (HWND, Texte)

Si tu veux un exemple tout simple

dis-le et j'en mettrais un sur le forum

PS: c'est possible de voir le "Hello World" ?

[mogwai93]

Petit cadeau, voila le source (réduit au minimum) :

Testé avec DevC++

mais ca devrait fonctionner avec Visual C++

seul hic, ca ne recupere pas les coordonnees lorsque l'on est sur un bouton...

include.h

#define ID_BOITE    101 

#define IDD_DIALOG1 103 
#define IDC_QUIT    104 

#define IDC_STATIC  114
#define IDC_STATIC1 115
#define IDC_STATIC2 116

test.rc

#include <windows.h>
#include "include.h"


IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 312, 111
CAPTION "Bureau"
STYLE WS_POPUP | WS_CAPTION | WS_SYSMENU
FONT 8, "MS Sans Serif"
BEGIN
  GROUPBOX        "Application Window", ID_BOITE, 5, 7, 295, 80



  PUSHBUTTON      "&Quitter...", IDC_QUIT,   235, 90, 60, 15

   LTEXT           "",IDC_STATIC1, 20,45,20,8
   LTEXT           "",IDC_STATIC2, 20,55,20,8

   LTEXT           "X=",IDC_STATIC, 10,45,5,8
   LTEXT           "Y=",IDC_STATIC, 10,55,5,8
END

main.cpp

#include <windows.h>
#include "include.h"



BOOL CALLBACK DialogProc(  HWND hWnd,
       UINT message,
       WPARAM wParam, 
       LPARAM lParam  )
{
static POINT ptSouris;

int pos_x, pos_y;


   switch (message)
   {
       case WM_MOUSEMOVE :
               GetCursorPos (&ptSouris);

              // L'un ou l'autre : GetCursorPos ou LOWORD, HIWORD : c'est pareil
              //ptSouris.x = LOWORD (lParam);
              //ptSouris.y = HIWORD (lParam);
              
              pos_x = ptSouris.x;
              pos_y = ptSouris.y;
              SetDlgItemInt(hWnd, IDC_STATIC1, pos_x, true);
              SetDlgItemInt(hWnd, IDC_STATIC2, pos_y, true);
       break;
           
       case WM_CLOSE:
             EndDialog(hWnd,0);
       break;
 
       case WM_COMMAND:
               switch( wParam )
               {
                       case IDC_QUIT :
                               EndDialog(hWnd,0);
                       break;
               }
   }

   return false;
}


int WINAPI WinMain(  HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow )
{
   int i = DialogBox( hInstance,
                MAKEINTRESOURCE(IDD_DIALOG1),
                NULL,
                (DLGPROC)DialogProc );

   if( i == -1 ) MessageBox(NULL,"Une erreur inattendue est survenue.","TITRE",MB_OK|MB_ICONSTOP);

   return false;
}

[theocrite]

Oulala, tout ça.

Je vais voir ca en détail.

Pour code du hello world, je ne l'ai pas sous la main, donc je le posterais demain.

En tout cas merci beaucoup Mogwai

[theocrite]

Voila le hello world par défaut fourni avec le compilo. Il y a bien sûr la gestion d'une interface graphique pour Windows CE.

// hello_world.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "hello_world.h"
#include <commctrl.h>

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE  	hInst;  	// The current instance
HWND    hwndCB;  	// The command bar handle

// Forward declarations of functions included in this code module:
ATOM    MyRegisterClass	(HINSTANCE, LPTSTR);
BOOL    InitInstance	(HINSTANCE, int);
LRESULT CALLBACK	WndProc  	(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	About  	(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(	HINSTANCE hInstance,
   	HINSTANCE hPrevInstance,
   	LPTSTR    lpCmdLine,
   	int       nCmdShow)
{
MSG msg;
HACCEL hAccelTable;

// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow)) 
 return FALSE;

hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_HELLO_WORLD);
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0)) 
{
 if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
 {
 	TranslateMessage(&msg);
 	DispatchMessage(&msg);
 }
}

return msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    It is important to call this function so that the application 
//    will get 'well formed' small icons associated with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
WNDCLASS	wc;

   wc.style  	= CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc  = (WNDPROC) WndProc;
   wc.cbClsExtra  = 0;
   wc.cbWndExtra  = 0;
   wc.hInstance  = hInstance;
   wc.hIcon  	= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_HELLO_WORLD));
   wc.hCursor  	= 0;
   wc.hbrBackground	= (HBRUSH) GetStockObject(WHITE_BRUSH);
   wc.lpszMenuName  = 0;
   wc.lpszClassName	= szWindowClass;

return RegisterClass(&wc);
}

//
//  FUNCTION: InitInstance(HANDLE, int)
//
//  PURPOSE: Saves instance handle and creates main window
//
//  COMMENTS:
//
//    In this function, we save the instance handle in a global variable and
//    create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND	hWnd;
TCHAR	szTitle[MAX_LOADSTRING];  	// The title bar text
TCHAR	szWindowClass[MAX_LOADSTRING];  // The window class name

hInst = hInstance;  // Store instance handle in our global variable
// Initialize global strings
LoadString(hInstance, IDC_HELLO_WORLD, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance, szWindowClass);

LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, ULL, hInstance, NULL);

if (!hWnd)	
 return FALSE;

ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
if (hwndCB)
 CommandBar_Show(hwndCB, TRUE);

return TRUE;
}

//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
int wmId,wmEvent;
PAINTSTRUCT ps;
TCHAR szHello[MAX_LOADSTRING];

switch (message) 
{
 case WM_COMMAND:
 	wmId    = LOWORD(wParam); 
 	wmEvent = HIWORD(wParam); 
 	// Parse the menu selections:
 	switch (wmId)
 	{
   case IDM_HELP_ABOUT:
      DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
      break;
   case IDM_FILE_EXIT:
      DestroyWindow(hWnd);
      break;
   default:
      return DefWindowProc(hWnd, message, wParam, lParam);
 	}
 	break;
 case WM_CREATE:
 	hwndCB = CommandBar_Create(hInst, hWnd, 1);  	
 	CommandBar_InsertMenubar(hwndCB, hInst, IDM_MENU, 0);
 	CommandBar_AddAdornments(hwndCB, 0, 0);
 	break;
 case WM_PAINT:
 	RECT rt;
 	hdc = BeginPaint(hWnd, &ps);
 	GetClientRect(hWnd, &rt);
 	LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
 	DrawText(hdc, szHello, _tcslen(szHello), &rt, 
   DT_SINGLELINE | DT_VCENTER | DT_CENTER);
 	EndPaint(hWnd, &ps);
 	break;
 case WM_DESTROY:
 	CommandBar_Destroy(hwndCB);
 	PostQuitMessage(0);
 	break;
 default:
 	return DefWindowProc(hWnd, message, wParam, lParam);
  }
  return 0;
}

// Mesage handler for the About box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
RECT rt, r1;
int DlgWidth, DlgHeight;	// dialog width and height in pixel units
int NewPosX, NewPosY;

switch (message)
{
 case WM_INITDIALOG:
 	// trying to center the About dialog
 	if (GetWindowRect(hDlg, &rt1)) {
   GetClientRect(GetParent(hDlg), &rt);
   DlgWidth	= rt1.right - rt1.left;
   DlgHeight	= rt1.bottom - rt1.top;
   NewPosX  = (rt.right - rt.left - DlgWidth)/2;
   NewPosY  = (rt.bottom - rt.top - DlgHeight)/2;
   
   // if the About box is larger than the physical screen 
   if (NewPosX < 0) NewPosX = 0;
   if (NewPosY < 0) NewPosY = 0;
   SetWindowPos(hDlg, 0, NewPosX, NewPosY,
   	0, 0, SWP_NOZORDER | SWP_NOSIZE);
 	}
 	return TRUE;

 case WM_COMMAND:
 	if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
 	{
   EndDialog(hDlg, LOWORD(wParam));
   return TRUE;
 	}
 	break;
}
   return FALSE;
}

Le "print" se trouve dans l'une des dernière lignes :

LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);

DrawText(hdc, szHello, _tcslen(szHello), &rt,

DT_SINGLELINE | DT_VCENTER | DT_CENTER);

IDS_HELLO est un integer qui désigne la place de la chaine de caractère "hello world" dans une sorte de registre.

Et quand on essaye de compiler quelque chose comme ça :

#include <stdio.h>

int main(void)
{
       printf("C'est du C normal\n");
       return 0;
}

Voici le résultat obtenu :

Deleting intermediate files and output files for project 'C_normal - Win32 (WCE SH3) Debug'.

--------------------Configuration: C_normal - Win32 (WCE SH3) Debug--------------------

Compiling...

Cnorm.c

Linking...

corelibc.lib(pegwmain.obj) : error LNK2019: unresolved external symbol _WinMain referenced in function _WinMainCRTStartup

SH3Dbg/C_normal.exe : fatal error LNK1120: 1 unresolved externals

Error executing link.exe.

C_normal.exe - 2 error(s), 0 warning(s)

[theocrite]

Et évidement, impossible de trouver une doc potable sur eVC++.

o_O

[mogwai93]

j'ai regardé rapidement,

mais on ne peut pas compiler, il manque un fichier ressources

mais on peut facilement le reproduire

"le sorte de registres" que tu dis

et un fichier ressources dans lequel tu peux mettre :

- des images

- des menus

- des chaines de caracteres

- des fenetres

- .....

C'est vrai, que l'on peut epurer ce code :

enlever le menu et sa gestion....

sinon, le code execute une fenetre et place "hello world" au centre de la fenetre

quelle que soit sa taille

c'est la bloc WM_PAINT qui est appelée, à chaque réaffichage de la fenetre (lors du focus, ou d'un redimensionnement)

ici, le texte est affiché en utilisant le GDC de Windows (affichage graphique)

Sinon , les 2 méthodes MyRegisterClass et InitInstance

font à peu pres la même chose que mon code :

appel à DialogBox + fichier ressource (zone IDDDIALOG1)

leur code est plus long, mais tu peux mieux gerer les objets

mais tout depend de ce que tu veux faire....

avec leur méthode, c'est faisable, mais c'est bcp plus dur... c'est un choix à faire

si t'as des questions....

[mogwai93]

Voila un lien (avec un peu d'info, mais tres peu)

http://www.codeppc.com/evc/index.htm