Evènements wx personnalisés dans C++

Version imprimable

31/07/2008, 17h13
Greg767

Evènements wx personnalisés dans C++

Hello,

J'ai un programme console écrit en C++ qui doit tourner en boucle et dedans j'ai créé une fenêtre wxWidgets, juste pour les tests. Ce que j'aimerais faire c'est que le programme C++ génère des évenements personnalisés pour la partie wxWidgets qui répondra à ces évènements.

J'ai pu tester la création d'un évènement "custom" en suivant ce tutorial:
http://wiki.wxwidgets.org/Custom_Events_Tutorial
Mais je ne sais pas quelle partie implémenter dans mon programme C++ pour qu'un évènement custom soit créé et que wxWidgets l'intercepte.

Pour l'instant je fais tourner mon programme C++ dans un MyFrame::OnIdle() évènement, mais je pense que je devrais utiliser wxThread. (<-- c'est off topic, je ne me suis pas encore familiarisé avec wxThread, je commencerai un autre post si jamais je n'arrive pas avec ça. Donc je n'attends pas des réponses concernant ceci)

J'espère que j'étais assez clair avec mon explication! :)
Merci à tous!

Greg

Pour lancer ton événement personnalisé, exemple:
Code:

1 2 3 4 wxCustomEvent tEvent( wxEVT_CUSTOM, GetId() ); tEvent.SetCustomParameter( mCustomParameter ); tEvent.SetEventObject( this ); ((WxCustomWindow*)TaFenetre)->GetEventHandler()->ProcessEvent( tEvent );
Pour traiter ton événement, dans la fenêtre.

Code:

ConnectEvent(-1,wxEVT_CUSTOM, wxCustomEventHandler(WxCustomWindow::CustomChangeHandler));

En clair: Pour tout les événements de type wxEVT_CUSTOM appeler WxCustomWindow::CustomChangeHandler

Merci pour ta réponse.
Je suis débutant en wx, donc j'aurais besoin de quelques éclaircissements.

D'où vient le type wxCustomEvent? Il faudrait créer une classe wxCustomEvent qui est dérivé de wxEvent?
Ensuite je n'ai pas compris cette méthode:

Code:

tEvent.SetCustomParameter( mCustomParameter );

Sinon je devrais placer ceci:
Code:

1 2 3 4 5 wxCustomEvent tEvent( wxEVT_CUSTOM, GetId() ); tEvent.SetCustomParameter( mCustomParameter ); tEvent.SetEventObject( this ); ((WxCustomWindow*)TaFenetre)->GetEventHandler()->ProcessEvent( tEvent );
dans ma fonction C++ et il est sensé créer l'évènenemt que j'intercepte dans TaFenetre avec le connect()?

Merci
Greg

Custom est à remplacer par le nom de ton événement dans mon post précédents.

En fait il y a 2 niveaux d'événements disponibles à ma connaissance dans les wxWidgets.

Le premier, redéfinir un type d'événement et réutiliser une class d'événement connue
Code:

1 2 3 4 5 6 7 8 //.h BEGIN_DECLARE_EVENT_TYPES() DECLARE_EXPORTED_EVENT_TYPE( WXMAKINGDLL_CUSTOM_EXPIMP, wxEVT_COMMAND_AMODIFIER, -1) END_DECLARE_EVENT_TYPES() //.cpp DEFINE_EVENT_TYPE(wxEVT_COMMAND_AMODIFIER)
Pour déclencher l'événement, par exemple on réutilise un type d’événement déjà défini comme wxCommandEvent
Code:

1 2 3 wxCommandEvent tEvent( wxEVT_COMMAND_AMODIFIER, GetId() ); tEvent.SetEventObject(this); GetEventHandler()->ProcessEvent( tEvent );
Le second plus complet,
Exemple on hérite de wxNotifyEvent
Code:

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 #ifdef WXMAKINGDLL_AMODIFIER #define WXDLLIMPEXP_AMODIFIER WXEXPORT #elif defined(WXUSINGDLL) #define WXDLLIMPEXP_AMODIFIER WXIMPORT #else // not making nor using DLL #define WXMAKINGDLL_AMODIFIER #define WXDLLIMPEXP_AMODIFIER #endif /*!----> // Ta classe event <--*/ class WXDLLIMPEXP_AMODIFIER wxCustomEvent: public wxNotifyEvent { public: /// A Constructor wxCustomEvent ( wxEventType commandType = wxEVT_NULL, int id = 0 ); /// A Destructor virtual ~ wxCustomEvent (); // Tu places tes fonctions protected: // Tu places tes variables };
Ensuite on utilise cet événement comme avec wxCommandEvent

Oui à la fin tu interceptes l’événement avec un "Connect"

Pour ceux qui seraient intéressés comment j'ai fait la création d'un évènement personnalisé, voilà mon exemple:

Le fichier d'entêtes de mon évènement wxCustomEvent.h :

Code:

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
 
#include <wx/wx.h>
 
DECLARE_EVENT_TYPE( wxEVT_CUSTOM_ACTION, -1 )
 
#define EVT_CUST(id, fn) \
    DECLARE_EVENT_TABLE_ENTRY( wxEVT_CUSTOM_ACTION, id, -1, \
    (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) \
    wxStaticCastEvent( wxCustomEventFunction, &fn ), (wxObject *) NULL ),
 
class wxCustomEvent: public wxCommandEvent
{
public:
    wxCustomEvent( wxWindow* win = (wxWindow*) NULL );
	~wxCustomEvent();
 
    // required for sending with wxPostEvent()
    virtual wxEvent *Clone() const
		{ return new wxCustomEvent(*this); };
 
	DECLARE_DYNAMIC_CLASS(wxCustomEvent)
 
};
 
typedef void (wxEvtHandler::*wxCustomEventFunction)(wxCustomEvent&);

Mon programme C++ est constitué d'un fichier d'entêtes et d'un fichier mon_app.cpp, donc dans le fichier mon_app.h se trouve, entre autres,:

Code:

#include "wxCustomEvent.h"

Ensuite dans le fichier mon_app.cpp de mon programme j'implémente ce qui était dans le wxCustomEvent.h, donc:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
const wxEventType wxEVT_CUSTOM_ACTION = wxNewEventType();
IMPLEMENT_DYNAMIC_CLASS(wxCustomEvent, wxCommandEvent)
 
wxCustomEvent::wxCustomEvent(wxWindow* win)
{
	SetEventType(wxEVT_CUSTOM_ACTION);
	SetEventObject(win);
}
//Destructor
wxCustomEvent::~wxCustomEvent()
{
 
}

Ensuite j'ai un fichier main.h et main.cpp. Dans le main.h je définis la classe pour mon frame et de mon thread.

main.h, juste ce qui concerne le frame et thread:

Code:

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
 
#include "mon_app.h"
#include <wx/wx.h>
 
#define ID_APP_QUIT 1
#define ID_CHG_TITRE 2
 
class TMyApp : public wxApp
{
public:
    virtual bool OnInit();
};
 
// La classe MyThread est une classe dérivé de wxThread
class MyThread: public wxThread
{
public :
        // Contructeur de la classe
	MyThread():wxThread(wxTHREAD_DETACHED)
	{}
 
    // Méthode virtuelle, c'est dans cette méthode que l'on place 
    // les calculs qui peuvent être long. Attention, cette méthode 
    // ne doit jamais être appelée directement.
	void* Entry();
};
 
class TMyFrame : public wxFrame
{
public:
    TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                                           long style = wxDEFAULT_FRAME_STYLE);
    void OnQuit(wxCommandEvent& event);
    void OnChgTitre(wxCommandEvent& event);
    void OnCustEvent(wxCustomEvent& event);
    void sendEvent();
    MyThread* thread;
private:
    wxButton *MonBouton;
    wxButton *MonBouton2;
 
DECLARE_EVENT_TABLE()
};

main.cpp:

Code:

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
 
#include "main.h"
 
MonApp myapp;		// mon programme
TMyFrame *frame;
bool running = true;
 
IMPLEMENT_APP(TMyApp)
 
bool TMyApp::OnInit()
{
    frame = new TMyFrame( "Hello Event World", 
         wxPoint(50,50), wxSize(450,340) );
    frame->Show(TRUE);
    SetTopWindow(frame);
    return TRUE;
} 
 
void* MyThread::Entry()
{	
	while(running){
                myapp.action();
                //Pour l'instant j'ai une variable d'état dans mon appl. et je lance
                //l'évènement en fonction de ceci.
                //Mais cela va changer et l'évènement sera lancé directement
                // de l'appli.
		if(myapp.getEventState()) frame->sendEvent();
	}
	// Cette instruction est indispensable si l'on veut 
	// pouvoir arrêter le processus en cours de route.
    // Grosso-modo, à ce moment, c'est ici que la "tache"
    // vérifie que personne ne lui a demandé de se stopper.
	TestDestroy();
	return 0;
}
 
TMyFrame::TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                        long style) : wxFrame(NULL, -1, title, pos, size, style)
{
  SetIcon(wxICON(monicone));
  SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
  MonBouton = new wxButton(this,ID_CHG_TITRE,_("Chgt Titre"), wxPoint(20,20),
                                                                 wxDefaultSize);
  MonBouton2 = new wxButton(this,ID_APP_QUIT,_("Quitter"), wxPoint(20,60),
                                                                 wxDefaultSize);
 
 
  // Création du thread.
  thread = new MyThread();
  thread->Create();
  thread->Run();
}
 
void TMyFrame::sendEvent()
{
    wxCustomEvent my_event(this);
    ProcessEvent(my_event);
 
}
 
void TMyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{	
	running = false;
       Close(true);
 
}
 
void TMyFrame::OnChgTitre(wxCommandEvent& WXUNUSED(event))
{
    SetTitle(_("Nouveau Titre"));
}
 
void TMyFrame::OnCustEvent(wxCustomEvent& event)
{
	wxMessageBox(_("Evènement réussi!"), wxOK|wxICON_INFORMATION, this);
 
//Puisque c'est aussi un console application j'ai encore:
int main(int argc, char **argv)
{
 
...
 
return WinMain(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), SW_SHOWNORMAL);
}
 
BEGIN_EVENT_TABLE(TMyFrame, wxFrame)
    EVT_BUTTON(ID_APP_QUIT,  TMyFrame::OnQuit)
    EVT_BUTTON(ID_CHG_TITRE,  TMyFrame::OnChgTitre)
    EVT_CUST(wxID_ANY, TMyFrame::OnCustEvent)
END_EVENT_TABLE()

Voilà c'est tout.