Discussion :

[zerbynette]

Bonjour à Tous,

j'ai un souci qui m'intrigue beaucoup.
Dans mon projet, j'ai créé une première classe dérivant de wxEvtHandler avec une classe dérivant de wxCommandEvent afin de personnaliser l'event associé. Le nouveau type d'event est déclaré avec la macro "DECLARE_EVENT_TABLE_ENTRY(...)", le handler déclaré avec "DECLARE_EVENT_TABLE()" et l'event est associé à une fonction avec "BEGIN_EVENT_TABLE(myHandler, wxEvtHandler)" et "EVT_MYFIRSTEVENT(wxID_ANY, myHandler::OnFirstEvent)"

Dans le constructeur de myHandler, j'appelle "SetEvtHandlerEnabled(true);"

Tous les events envoyés par "wxPostEvent(myHandlerPointer, event);" sont bien reçus et traités par OnFirstEvent().

Par la suite, je crée une autre classe dérivant de wxEvtHandler avec une autre classe dérivant de wxCommandEvent. Et la fonction associée est déclarée de la même manière.

Je décide donc d'envoyer des events par wxPostEvent() : RIEN dans le traitement de l'event.
je tente AddPendingEvent() : RIEN.
Par contre, avec le debugger, je vois bien la queue de message s'allonger (wxEvtHandler.m_pendingEvents.wxObjectList.wxListBase.m_count s'incrémente à chaque appel à wxPostEvent ou AddPendingEvent)

Et, quand je tente ProcessEvent(): Mes events sont traités comme voulus dans la fonction associée à l'event.

Je ne comprends pas pourquoi avec le 1er handler, je peux envoyer mes messages par wxPostEvent et qu'avec le second non. Je souhaite conserver le principe de queue de message et j'ai lu que ProcessEvent était comme appeler directement la fonction associée.

Quelqu'un a-t-il déjà été confronté à ce type de problème?

Merci de votre aide.

[3DArchi]

Salut,
Peux-tu montrer les déclarations des 2 classes et la façon dont tu envois ?

[zerbynette]

Bonjour,

la premiere classe d'event est:

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
 
//Create a new event constant - see initialization in .cpp
extern const wxEventType wxEVT_PROXY_NOTIF_EVT;
 
class ProxyNotifEvent : public wxCommandEvent{
private:
	eController m_CTBID; 		//!< block controller ID
	eNotifEventMsk m_EVTMSK; 	//!< notification event mask
 
 
public:
	ProxyNotifEvent( wxEventType commandType = wxEVT_PROXY_NOTIF_EVT, int id = 0  )
			:   wxCommandEvent(commandType, id){};
	ProxyNotifEvent(eController ctbId, eNotifEventMsk EvtMsk);
	ProxyNotifEvent( const ProxyNotifEvent &event );
 
	virtual wxEvent *Clone() const
		{ return new ProxyNotifEvent(*this); };
 
	// Setters and Getters
	eController getCTBID() const;
	eNotifEventMsk getEVTMSK() const;
	void setCTBID(eController ctbId);
	void setEVTMSK(eNotifEventMsk evtMsk);
};
 
//Provide event table information
typedef void (wxEvtHandler::*ProxyNotifEventFunction)(ProxyNotifEvent &);
 
 
//Declare event table entry code
// it may also be convenient to define an event table macro for this event type
#define EVT_PROXY_NOTIFY(id, fn) \
    DECLARE_EVENT_TABLE_ENTRY( \
    		wxEVT_PROXY_NOTIF_EVT, id, wxID_ANY, \
        (wxObjectEventFunction)(wxEventFunction) \
        (wxCommandEventFunction) wxStaticCastEvent( \
        		ProxyNotifEventFunction, &fn ), (wxObject *) NULL ),

et le .cpp commence par:

Code :

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

const wxEventType wxEVT_PROXY_NOTIF_EVT = wxNewEventType();

et je l'envoie ainsi:

Code :

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

1
2
3
4
5
 
ProxyNotifEvent event;
event.setCTBID(m_CtlBlock->getID());
event.setEVTMSK(eNotifEvtMsk_STATE);
wxPostEvent(m_pProxyNotifEvtHandler, event);

la 2e classe est:

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
 
//Create a new event constant - see initialization in .cpp
extern const wxEventType wxEVT_SEQUENCER_EVT;
 
class SequencerEvent  : public wxCommandEvent{
private:
	eSeqEvtType m_evtType;
	unsigned int m_data;
 
 
public:
	SequencerEvent(wxEventType commandType = wxEVT_SEQUENCER_EVT, int id = 0  )
			:   wxCommandEvent(commandType, id){};
	SequencerEvent(eSeqEvtType evtType, unsigned int data);
	SequencerEvent( const SequencerEvent &event );
 
	virtual wxEvent *Clone() const
		{ return new SequencerEvent(*this); };
 
	// Setters and Getters
	eSeqEvtType getEvtType() const;
	unsigned int getData() const;
	void setEvtType(eSeqEvtType evtType);
	void setData(unsigned int data);
};
 
//Provide event table information
typedef void (wxEvtHandler::*SequencerEventFunction)(SequencerEvent &);
 
 
//Declare event table entry code
// it may also be convenient to define an event table macro for this event type
#define EVT_SEQUENCER(id, fn) \
    DECLARE_EVENT_TABLE_ENTRY( \
    		wxEVT_SEQUENCER_EVT, id, wxID_ANY, \
        (wxObjectEventFunction)(wxEventFunction) \
        (wxCommandEventFunction) wxStaticCastEvent( \
        		SequencerEventFunction, &fn ), (wxObject *) NULL ),

et le .cpp commence par:

Code :

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

1
2
 
const wxEventType wxEVT_SEQUENCER_EVT = wxNewEventType();

et je suis obligée de l'envoyer ainsi:

Code :

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

1
2
3
4
5
6
7
 
SequencerEvent event;
event.setEvtType(Seq_RecipeValidationStart);
event.setData(m_data);
m_pSequencerEvtHandler->ProcessEvent(event);
//wxPostEvent(m_pSequencerEvtHandler, event);
//wxPostEvent ajoute le message dans la queue mais le message n'estpas traité

pour les Handlers, dans les 2 cas, le .h est de la forme:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class myHandler: public wxEvtHandler {
public:
	myHandler();
	~myHandler();
 
	void OnEvent(myEvent & event);
 
private:
	DECLARE_EVENT_TABLE()
 
};

et le .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
 
// --------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// --------------------------------------------------------------------------
BEGIN_EVENT_TABLE(myHandler, wxEvtHandler)
EVT_SEQUENCER(wxID_ANY, myHandler::OnEvent) //ou EVT_PROXY_NOTIFY(wxID_ANY, myHandler::OnEvent)
END_EVENT_TABLE()
 
//...
myHandler::myHandler() {
//...
	SetEvtHandlerEnabled(true);
//...
}
 
myHandler::OnEvent(myEvent & event){
	std::cout << "a myEvent has arrived..." << std::endl;
}

Honnetement, dans le 2e cas, la fonction qui traite les event semble bien declarée car avec le ProcessEvent(), on y passe.

Merci pour ton aide.

[3DArchi]

Salut,
J'ai l'impression que tout à l'air bien 'branché' puisque les évènements arrivent à trouver leur chemin lorsque tu les envois par ProcessEvent.
Si la file des évènements postés ne diminue pas, je vois au moins une cause : tu postes des évènements mais tu ne rends jamais la main à la boucle de message. Serais-tu dans une fonction bloquante ? une boucle de traitement ? Si c'est le cas, peut être qu'une approche multithread s'impose.

[zerbynette]

Ce qui m'intrigue c'est que le reste du programme tourne très bien, même après avoir posté mes messages. Seule la queue de message s'allonge sans être vidée.

Je n'y connais rien en multithread, ta suggestion me fait très peur. Donc un thread à part pour le 2e handler?

En tout cas, merci pour ton aide, surtout pour me repondre à 7h du mat. Je t'en suis très reconnaissante.

[wxXav]

Hello

Afin de vérifier si la théorie de 3DArchi est la bonne (fonction bloquante), tu peux déjà essayer de placer quelques petits wxTheApp->Yield() dans les boucles qui sont le plus susceptibles de monopoliser les ressources CPU.

Tu peux également en mettre un après avoir posté l'event, mais le résultat est quasi-identique au fait d'appeler ProcessEvent

@+
Xav'