Logiciel de dessin sans les mfc mais ma fenetre ne reçoit pas les messages WM :cry:

**jbs106** · 26/04/2010, 22h02

Bonjour,

comme je l'ai précisé dans le titre, je souhaite réaliser une application de dessin, un SKETCHER avec les MFCs, je l'ai réalisé grace à un bouquain, le mien, je le nomme Drawer.

J'ai trouvé sur le net, une (autre) application structuré comme les mfc, sans les mfc(ce que je souhaitai!) mais qui ne possede pas d'objet Application..

Dans mon application, j'ai un objet Programme contenant le hinstance, un objet TMainFrame contenant l'objets Drawer (qui est sensé être l'objet doc et view mais pour le moment je simplifie) dans lequel je souhaite dessiner et normalement les objet de barre d'outil...

Mes soucis:
- les messages n'arrivent pas jusqu'à la fenetre de dessin comme dans le logiciel paint.
- si je force l'envoie de message de TMainFrame, mon application bug un peu...

Je pense avoir besoin d'une brillante explication, d'une lumière, d'un petit cour

merci de vous attardez sur ma demande

je vous joins mes sources.

**3DArchi** · 27/04/2010, 07h36

Salut,
Peux-tu détailler ton problème ? Car là, c'est un peu brut de fonderie.

**jbs106** · 27/04/2010, 10h03

j'ai un fichier Window.h de la GNU qui m'offre quelque fonctionnalité de base pour mes controles..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#ifndef WINDOW_CONTROL_H
#define WINDOW_CONTROL_H
 
class Window
{
public:
	Window(){}
	virtual ~Window() {};
	virtual void init(HWND hSelf, HWND parent){_hSelf= hSelf;_hParent=parent;}
	virtual void destroy() = 0;
	virtual void display(bool toShow = true) const {::ShowWindow(_hSelf, toShow?SW_SHOW:SW_HIDE);};
	virtual void reSizeTo(RECT & rc) // should NEVER be const !!!
	{ 	::MoveWindow(_hSelf, rc.left, rc.top, rc.right, rc.bottom, TRUE);
		redraw();
	};
 
	virtual void reSizeToWH(RECT & rc) // should NEVER be const !!!
	{ 	::MoveWindow(_hSelf, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, TRUE);
		redraw();
	};
 
	virtual void redraw(bool forceUpdate = false) const
	{	::InvalidateRect(_hSelf, NULL, TRUE);
		if (forceUpdate)	::UpdateWindow(_hSelf);
	};
 
    virtual void getClientRect(RECT & rc)		const	{	::GetClientRect		(_hSelf, &rc);	};
	virtual void getWindowRect(RECT & rc)		const	{	::GetWindowRect	(_hSelf, &rc);	};
	virtual int getWidth()	const {	RECT rc;	GetClientRect(_hSelf, &rc);	return (rc.right - rc.left);	};
	virtual int getHeight() const {	RECT rc;	GetClientRect(_hSelf, &rc);
	if (::IsWindowVisible(_hSelf) == TRUE)	return (rc.bottom - rc.top);	return 0;	};
 
	virtual bool isVisible	()	const	{ 	return (::IsWindowVisible(_hSelf)?true:false);	};
	inline HWND getHSelf	()	const	{	return _hSelf;	};	//assert(_hSelf);
	inline HWND getHParent	()	const	{	return _hParent;};
	void getFocus() const {		::SetFocus(_hSelf);	};
protected:
 
	HWND _hParent;
	HWND _hSelf;
};
 
#endif //WINDOW_CONTROL_H

une class programme permettant le démarrage de mon programme...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
#ifndef PROGRAMME_H
#define PROGRAMME_H
class TMainFrame;
class Programme
{
public:
 
	~Programme(){}
	Programme();
	WPARAM Run();
	BOOL Init(HINSTANCE hInst,int nCmdShow);
	void SetCmdShow(int nCmdShow){_nCmdShow=nCmdShow;};
	inline HINSTANCE GetHInst() const {return _hInst;};
	inline TMainFrame* GetMainFrame(){return _pMainFrame;}
	inline TCHAR* GetAppTitle(){return _szTitle;}
private:
	TMainFrame* _pMainFrame;
	int _nCmdShow;
	HINSTANCE _hInst;
	HINSTANCE _hPrevInst;
	LPSTR _lpCmdLine;
	TCHAR _szTitle[MAX_LOADSTRING];
	TCHAR _szWindowClass[MAX_LOADSTRING];
	HACCEL _hAccelTable;
 
};
#endif

et son fichier cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 
#include "stdafx.h"
 
Programme::Programme()
{
	this->_hInst=NULL;
	this->_hAccelTable=NULL;
	this->_hPrevInst=NULL;
	this->_lpCmdLine=NULL;
	this->_pMainFrame=NULL;
	this->_nCmdShow=NULL;
	LoadString(_hInst, IDS_APP_TITLE, _szTitle, MAX_LOADSTRING);
	LoadString(_hInst, IDS_DRAWER, _szWindowClass, MAX_LOADSTRING);
 
}
BOOL Programme::Init(HINSTANCE hInst,int nCmdShow)
{
	_hInst = hInst;
	if (!_hInst){::MessageBox(NULL, TEXT("_hInst == NULL"), TEXT("class Window"), MB_OK);throw int(1999);}
 
	this->_pMainFrame = new TMainFrame();	// création fenêtre principale
	if(!this->_pMainFrame->Create(this))
		return FALSE;
	ShowWindow(this->_pMainFrame->getHSelf(), nCmdShow);
	UpdateWindow(this->_pMainFrame->getHSelf());
	return TRUE;	// initialisation réussie
}
 
 
WPARAM Programme::Run()
{	
	MSG _msg;
	_hAccelTable = LoadAccelerators(_hInst, MAKEINTRESOURCE(IDR_DRAWER));
 
	while (GetMessage(&_msg, NULL, 0, 0))	// Boucle de messages principale*:
	{
		if (!TranslateAccelerator(_msg.hwnd, _hAccelTable, &_msg))
		{
			TranslateMessage(&_msg);
			DispatchMessage(&_msg);
		}
	}
	return (int) _msg.wParam;
}

la classe TMAINFRAME

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#ifndef MAINFRAME_H_INCLUDED
#define MAINFRAME_H_INCLUDED
class Drawer;
class TMainFrame:public Window
{
 
protected :
 
	Programme* _pApp;
	Drawer* _pDrawer;
	void destroy(){}
public :
	// constructeur, destructeur
	TMainFrame();
	~TMainFrame();
 
	BOOL Create(Programme*);
	inline Drawer*		GetDrawer()		{	return _pDrawer	;}
	inline Programme*	GetProgramme()	{	return _pApp	;}
 
protected :
	static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
	LRESULT MsgCreate	(HWND, WPARAM, LPARAM);	// WM_CREATE
	LRESULT MsgClose	(WPARAM, LPARAM);		// WM_CLOSE
	LRESULT MsgDestroy	(WPARAM, LPARAM);		// WM_DESTROY
	LRESULT MsgSetFocus	(WPARAM, LPARAM);		// WM_SETFOCUS
	LRESULT MsgCommand	(WPARAM, LPARAM);		// WM_COMMAND
	void CmdFileQuit		();		// "Fichier->Quitter"
};
#endif	// MAINFRAME_H_INCLUDED

son fichier cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include "stdafx.h"
 
TMainFrame::TMainFrame()
{
	_hSelf			= NULL;
	this->_hParent	= NULL;
	this->_pApp		= NULL;
	this->_pDrawer	= new Drawer();
}
 
TMainFrame::~TMainFrame(){	delete _pDrawer;}
 
BOOL TMainFrame::Create(Programme* aApp)
{
	this->_pApp = aApp;
	// classe de fenêtre
	TCHAR szWndClass[] = _T("Drawer_MainFrame");
 
	// initialisation classe de fenêtre
	WNDCLASS wc;
 
	ZeroMemory(&wc, sizeof(WNDCLASS));
	wc.style			= CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc		= WndProc;
	wc.hInstance		= this->_pApp->GetHInst();
	wc.hIcon			= LoadIcon(this->_pApp->GetHInst(), MAKEINTRESOURCE(IDI_DRAWER));
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.lpszMenuName		= MAKEINTRESOURCE(IDR_DRAWER);
	wc.lpszClassName	= szWndClass;
	wc.hbrBackground = NULL;
	// enregistrement classe de fenêtre
	if(!RegisterClass(&wc))
		return FALSE;
 
	// création fenêtre principale
	this->_hSelf = CreateWindowEx(0, szWndClass, this->_pApp->GetAppTitle(), WS_OVERLAPPEDWINDOW,
							CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
							NULL, NULL, this->_pApp->GetHInst(), this);
 
	return (_hSelf != NULL);
}
 
LRESULT CALLBACK TMainFrame::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	// affecter l'objet TMainFrame lors de la création de la fenêtre, contenu dans la 
	// structure CREATESTRUCT pointée par lParam
	if(msg == WM_CREATE)
	{
		LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam;
		SetWindowLong(hWnd, GWL_USERDATA, (LONG)lpcs->lpCreateParams);
	}
 
	// récupération objet TMainFrame associé à la fenêtre
	TMainFrame* pWnd = (TMainFrame*) GetWindowLong(hWnd, GWL_USERDATA);
	if(!pWnd)
		return DefWindowProc(hWnd, msg, wParam, lParam);
	switch(msg)
	{
		case WM_SETFOCUS	: return pWnd->MsgSetFocus	(wParam, lParam);
		case WM_CREATE		: return pWnd->MsgCreate	(hWnd, wParam, lParam);
		case WM_CLOSE		: return pWnd->MsgClose		(wParam, lParam);
		case WM_DESTROY		: return pWnd->MsgDestroy	(wParam, lParam);
		case WM_COMMAND		: return pWnd->MsgCommand	(wParam, lParam);
		default				: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
 
 
}
LRESULT TMainFrame::MsgCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
{	this->_hSelf=hWnd;
	this->_pDrawer->Create(this);
 
	ShowWindow(this->_pDrawer->getHSelf(), SW_SHOW);
	return 0;
}
 
LRESULT TMainFrame::MsgClose(WPARAM wParam, LPARAM lParam)
{
	DestroyWindow(_hSelf);
	return 0;
}
LRESULT TMainFrame::MsgSetFocus(WPARAM wParam, LPARAM lParam)
{	this->_pDrawer->getFocus();
 
	return 0;
}
 
LRESULT TMainFrame::MsgDestroy(WPARAM wParam, LPARAM lParam)
{
	PostQuitMessage(0);
	return 0;
}
 
 
LRESULT TMainFrame::MsgCommand(WPARAM wParam, LPARAM lParam)
{
	// on laisse la vue de la zone cliente commencer par traiter la commande
	if(SendMessage(this->_pDrawer->getHSelf(), WM_COMMAND, wParam, lParam))
		return TRUE;
 
	int nIDCtl = LOWORD(wParam);	// en fonction de la commande
	switch(nIDCtl)
	{
		case IDM_EXIT					: CmdFileQuit		();			break;
		default : return FALSE;
	}
	return TRUE;// la commande a été traitée
}
void TMainFrame::CmdFileQuit(){	SendMessage(_hSelf, WM_CLOSE, 0, 0);}

et enfin ma class drawer me servant pour le moment de document et de vue:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#ifndef DRAWER_H
#define DRAWER_H
class CElement;
 
class Drawer:public Window
{
protected :
	TMainFrame* _pTMainFrame;
 
public :
	Drawer(){}
	~Drawer(){}
	BOOL Create(TMainFrame* pMainFrame);
protected :
	static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
	LRESULT MsgMouseMove	(WPARAM, LPARAM);	// WM_MOUSEMOVE
	void destroy(){}
protected:
};
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
// Drawer.cpp*: définit le point d'entrée pour l'application.
//
 
#include "stdafx.h"
 
 
BOOL Drawer::Create(TMainFrame* pMainFrame)
{
	// classe de fenêtre
	TCHAR szWndClass[]	= _T("Paint_ChildView");
 
	// initialisation classe de fenêtre
	WNDCLASS wc;
	ZeroMemory(&wc, sizeof(WNDCLASS));
	wc.style			= CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc		= WndProc;
	wc.hInstance		= pMainFrame->GetProgramme()->GetHInst();
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.lpszClassName	= szWndClass;
 
	// enregistrement classe de fenêtre
	if(!RegisterClass(&wc))
		return FALSE;
	this->_hParent = pMainFrame->getHSelf();
 
	_hSelf = CreateWindowEx(0, szWndClass, NULL, WS_CHILD,
							0, 0, 0, 0, pMainFrame->getHSelf(), NULL, pMainFrame->GetProgramme()->GetHInst(), this);
 
	return (_hSelf != NULL);
}
 
LRESULT CALLBACK Drawer::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	// affecter l'objet Drawer lors de la création de la vue, contenu dans la 
	// structure CREATESTRUCT pointée par lParam
	if(msg == WM_CREATE)
	{
		LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam;
		SetWindowLong(hWnd, GWL_USERDATA, (LONG)lpcs->lpCreateParams);
	}
 
	// récupération objet Drawer associé à la fenêtre
	Drawer* pWnd = (Drawer*) GetWindowLong(hWnd, GWL_USERDATA);
	if(!pWnd)
		return DefWindowProc(hWnd, msg, wParam, lParam);
 
	// en fonction du message
	switch(msg)
	{
		case WM_MOUSEMOVE	: return pWnd->MsgMouseMove		(wParam, lParam);
		default : return FALSE;
	}
}
 
 
LRESULT Drawer::MsgMouseMove	(WPARAM wParam, LPARAM lParam)
{
	POINT point;
	PAINTSTRUCT ps;
	HDC hdc= BeginPaint(_hSelf,&ps);
	TCHAR bf2[5];
	TCHAR bf1[5];
	GetCursorPos(&point);
	ScreenToClient(_hSelf,&point);
	_itow_s(point.x,bf1,5,10);
	_itow_s(point.y,bf2,5,10);
	TCHAR aText[MAX_LOADSTRING] =TEXT("Coordonnée cliente :");
	wcscat(aText,bf1);
	wcscat(aText,TEXT(","));
	wcscat(aText,bf2);
	SetWindowText(this->getHParent(),aText);
	MoveToEx(hdc,0,0,NULL);
	LineTo(hdc,point.x,point.y);
	EndPaint(this->getHSelf(), &ps);
	return 0;
 
}
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
	Programme Apps;
	if(Apps.Init(hInstance,nCmdShow))
		return Apps.Run();
	else return 0;
 
 }

J'ai simplifié au maximum, les messages ne transite pas par mon drawer alors que je sais que c'est possible... mais c'est certain qu'il me manque quelque chose...

**Médinoc** · 27/04/2010, 17h17

Déjà, je pense que WndProc ne devrait pas être dans Drawer, mais dans Window, et appeler une fonction virtuelle quand pWnd n'est pas nul.

Aussi, tu devrais utiliser GetWindowLongPtr().

**jbs106** · 27/04/2010, 19h27

Je souhaite avoir un MainFrame comme dans les MFC et un modèle Vue/Document (que je regroupe) dans mon Drawer, Window sert à stocker le HANDLE de ma fenetre et quelques fonctions utilent pour le developpement de mon application.

Je n'arrive pas à faire transiter mes messages "naturellement" vers les evenement utilisateur comme l'application paint.

Si je force à travers le MainFrame, ça bug, je n'ai plus d'accès au menu à part si je clique hors application et que je renvoie le focus. Ce n'est pas terrible.

Je pense que mes WNDPROCs sont bien placés, je ne suis pas un professionnel, Je comprend vite mais faut m'expliquer longtemps

**Médinoc** · 28/04/2010, 11h19

Le code simplifié que tu as posté, est-ce celui du Drawer.zip ou est-ce celui du Paint.zip?

Logiciel de dessin sans les mfc mais ma fenetre ne reçoit pas les messages WM :cry:

C++

Vue hybride

Discussions similaires

Partager

Partager