Discussion :

[Rniamo]

bonjour,

j'essaye d'apprendre le gtkmm mais j'ai un petit soucis, comment je ferme l'application (signal delete-event ?) ? où est-ce que je passe des arguments aux callback ?

voici le code (tout dans le main pour tester pour le moment) :

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
 
#include <iostream>
#include <gtkmm.h>
 
using namespace std;
using namespace Gtk;
 
void on_button_clicked()
{
    cout << "Appui sur le bouton" << endl;
}
 
 
int main(int argc, char *argv[])
{
	Main kit(argc, argv);
 
	Window window;
	window.set_size_request(320, 240);
 
	Gtk::Frame frame;
	window.add(frame);
	frame.set_label(" - frame - ");
	frame.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	frame.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
 
	VBox vbox(true,0);
	frame.add(vbox);
 
	Button bouton("bouton");
	vbox.pack_start(bouton,true,true,0);
	bouton.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
 
	Button bouton2("bouton");
	vbox.pack_start(bouton2,true,true,0);
	bouton2.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
 
	window.show_all();
 
	kit.run();
 
	return 0;
}

[Anium]

Pour fermer t'as fenêtre principale, il suffit d'appeler la méthode hide() de Window.

Sinon, moi je lance une fenêtre principale de cette manière :

Code :

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

1
2
3
 
Gtk::Window window;
Gtk::Main::run(window);

Ce qui permet de quitter l'application quand la fenêtre est détruite.

Si c'est dans ta méthode on_button_clicked() que tu veux fermer ta fenêtre, le plus simple et de créer ta classe fenêtre dérivée de Gtk::Window. Tu n'auras qu'à faire ceci :

Code :

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

bouton.signal_clicked().connect(sigc::ptr_fun(&MaWindow::on_button_clicked));

et ton callback :

Code :

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

1
2
3
4
5
void MaWindow::on_button_clicked()
{
    cout << "Appui sur le bouton" << endl;
    hide();
}

Sinon il faut passer un argument avec sigc::bind.

[Rniamo]

j'ai modifié mon code :

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
/* g++ -o gtkmm gtkmm.cc `pkg-config gtkmm-2.4 --cflags --libs` */
 
#include <iostream>
#include <gtkmm.h>
 
using namespace std;
using namespace Gtk;
 
class Fenetre : public Window
{
	private :
 
		Window window;
 
		static void on_button_clicked()
		{
		    cout << "Appui sur le bouton" << endl;
		}	
 
	public :
		Fenetre()
		{
			window.set_size_request(320, 240);
 
			VBox vbox(true,0);
			window.add(vbox);
 
			Button bouton("bouton");
			vbox.pack_start(bouton,true,true,0);
			bouton.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
		}
 
		void montrer()
		{
			window.show_all();
		}
 
		~Fenetre()
		{
		}
};
 
int main(int argc, char *argv[])
{
	Main kit(argc, argv);
 
	Fenetre fen;
	fen.montrer();
 
	Main::run(fen);
 
	return EXIT_SUCCESS;
}

Concernant la fermeture ça marche, pour les arguments, je voudrait passé une autre classe que celle de ma fenêtre, c'est possible ?

Enfin en passant ma fenêtre à Gtk::Main::run(), j'ai l'impression que le constructeur ne sert à rien.

Enfin dans cette version du code, je n'ai plus le contenu de ma fenêtre.

[Anium]

Ta méthode on_button_clicked n'a pas besoin d'être déclarée static, à moins que tu ne veuille l'appeler sans créer d'instance.

Tu n'as pas besoin de déclarer un autre widget Window puisque ta classe hérite des propriétés de Window.

Utilise la méthode show_all_children() pour afficher tous tes widgets en récursif.

De plus ton bouton est déclaré en local, dans ton constructeur, il sera donc détruit à la fin de ton constructeur.

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
/* g++ -o gtkmm gtkmm.cc `pkg-config gtkmm-2.4 --cflags --libs` */
 
#include <iostream>
#include <gtkmm.h>
 
using namespace std;
using namespace Gtk;
 
class Fenetre : public Window
{
	private :
                Button m_button;
		void on_button_clicked()
		{
		    cout << "Appui sur le bouton" << endl;
		}	
 
	public :
		Fenetre():m_button("bouton")
		{
			set_size_request(320, 240);
 
			VBox vbox(true,0);
			add(vbox);
 
			vbox.pack_start(bouton,true,true,0);
			bouton.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
                        show_all_children();
		}
 
		~Fenetre()
		{
		}
};
 
int main(int argc, char *argv[])
{
	Main kit(argc, argv);
 
	Fenetre fen;
	Main::run(fen);
 
	return EXIT_SUCCESS;
}

pour les arguments, je voudrait passé une autre classe que celle de ma fenêtre, c'est possible ?

Que veux-tu faire exactement ?

Enfin, je te conseil de séparer tes déclarations de ton implémentation (.h .cpp).

[Rniamo]

j'ai le code (ça doit être à peu prés le même que celui d'Anium) :

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
/* g++ -o gtkmm gtkmm.cc `pkg-config gtkmm-2.4 --cflags --libs` */
 
#include <iostream>
#include <gtkmm.h>
 
using namespace std;
using namespace Gtk;
 
class Fenetre : public Window
{
	private :
		Button bouton;
 
		static void on_button_clicked()
		{
		    cout << "Appui sur le bouton" << endl;
		}	
 
	public :
		Fenetre() : bouton("click me !")
		{
			set_size_request(320, 240);
 
			VBox vbox(true,0);
			add(vbox);
 
			vbox.pack_start(bouton,true,true,0);
			bouton.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
		}
 
		void montrer()
		{
			show_all_children();
		}
 
		~Fenetre()
		{
		}
};
 
int main(int argc, char *argv[])
{
	Main kit(argc, argv);
 
	Fenetre fen;
	fen.montrer();
 
	Main::run(fen);
 
	return EXIT_SUCCESS;
}

Toujours le problème du bouton qui n'apparait pas.

Concernant le passage par paramètre, je voudrait par exemple passé une structure déclaré dans le main (elle passerait via le constructeur de Fenetre() puis les méthodes).

ma méthode est static parce que sinon :

Code :

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

erreur: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say «&Fenetre::on_button_clicked»

Enfin concernant les .hpp ... ce code est juste pour apprendre les quelques base donc un .cc suffit pour le moment.

[Anium]

Ton bouton n'apparait pas parce que ta VBox est en local aussi, il faut la déclarer en dehors de ton constructeur, comme pour ton bouton.

Sinon, en enlevant ton static et en mettant

Code :

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

bouton.signal_clicked().connect(sigc::ptr_fun(&Fenetre::on_button_clicked));

Ça ne résout pas le problème ?

Pour ton passage par paramètre, tu peux bien sur passer n'importe quoi par le constructeur, ou même par une méthode set qui initialisera un champs privé de ta classe.

Code :

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

1
2
3
void Fenetre::set_value(Type value){
   m_value = value;
}

Tu pourras déclarer ce champs dans ton .h de ta classe et ainsi tes méthodes pourront y accéder.

Par contre, si tu compte modifier ce champs et qu'il le soit aussi dans ton main, il faudra le passer soit par référence, soit par pointeur.