Discussion :

[Captare]

Bonjour à tous,

Je suis en train de lire le tutoriel officiel de GTK+, et une nouvelle notion a fait son apparition que j'ai du mal à comprendre.
Je ne comprend pas très bien la différence entre une fonction callback "normal", et une fonction callback avec GdkEvent comme argument. Voici un code qui provient du tuto officiel :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
gint close_application( GtkWidget *widget,
                        GdkEvent  *event,
                        gpointer   data )
{
  gtk_main_quit ();
  return TRUE;
}
 
g_signal_connect_swapped (G_OBJECT (button), "clicked",
                              G_CALLBACK (close_application),
                              G_OBJECT (window));

Ici pourquoi faut il un GdkEvent en paramètre puisque le signal "clicked" ne fait pas partie de cette structure . Le code suivant devrait suffire, non ? (ou tout cas il fonctionne) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
gint close_application( GtkWidget *widget,
                        gpointer   data )
{
  gtk_main_quit ();
  return TRUE;
 
 
g_signal_connect_swapped (G_OBJECT (button), "clicked",
                              G_CALLBACK (close_application),
                              G_OBJECT (window));
}

Autre chose, comment empêcher un dialog de se fermer. Pas de problème vec une fenêtre, via "delete-event", mais impossible avec un dialog. J'ai regardé dans la doc et apparemment, le signal "delete-event" est désactivé lorsque le dialog est lancé (gtk_dialog_run). Quelqu'un a une solution ? Peut être que je peux forcer le signal ?

Dans mon programme j'ai une structure qui contient tous les éléments nécessaire au fonctionnement de la fenêtre principale. Je passe donc cette structure à des fonctions via un pointeur que j'ai alloué avec malloc, mais j'ai vu qu'il existait également g_malloc. Quelle différence existe il entre malloc et g_malloc ? Même si j'ai besoin de cette structure tout au long du programme faut il que je la free() , ou bien le système d'exploitation le fera quand le programme sera terminé (gtk_main_quit) ?

Derniere chose, je suis assez jeune (15 ans) et dans le tutoriel en anglais il y'a souvent un mot qui revient :"handler", qui signifierait poignée , quelqu'un peut m'expliquer ce que ce mot signifie ?


Merci à ceux qui prendront le temps de ma lire.

[gerald3d]

Une première réponse pour le signal "clicked". Effectivement, si le signal est celui pour un GtkButton, alors le prototype du Callback est inapproprié.
Pour aller plus loin, le prototype que tu donnes est aussi erroné. Voila celui indiqué par la documentation officielle :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
The "clicked" signal
 
void                user_function                      (GtkButton *button,
                                                        gpointer   user_data)      : Run First / Action
Emitted when the button has been activated (pressed and released).
 
button*:
 
the object that received the signal
user_data*:
 
user data set when the signal handler was connected.

[Captare]

Merci pour cette réponse.

Up pour les autres questions !

[gerald3d]

Une autre réponse à une autre question.

Si ton dialog est un GtkDialog, alors il hérite des GtkWindow. On peut donc utiliser la fonction suivante avant de lancer la boucle :

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
gtk_window_set_deletable ()
 
void                gtk_window_set_deletable            (GtkWindow *window,
                                                         gboolean setting);
By default, windows have a close button in the window frame. Some window managers allow GTK+ to disable this button. If you set the deletable property to FALSE using this function, GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible, so you should call it before calling gtk_window_show().
 
On Windows, this function always works, since there s no window manager policy involved.
 
window*:
 
a GtkWindow
setting*:
 
TRUE to decorate the window as deletable
Since 2.10

Tout ceci reste à tester bien sûr.
Si toutefois ca ne fonctionne pas, la documentation officielle nous dit :" If a dialog receives a delete event, the "response" signal will be emitted with a response ID of GTK_RESPONSE_DELETE_EVENT." Tu peux donc utiliser ce signal pour faire comme si l'utilisateur avait cliqué sur le bouton annuler de ton dialog (ou autre).

[Captare]

Merci t'es trop fort !

Le bouton, a bien disparu. J'ai encore un peu de mal à utiliser la documentation, je me suis juste limité à la page concernant les GtkDialogs.

Si ton dialog est un GtkDialog, alors il hérite des GtkWindow

Pourtant j'ai tout de même besoin d'utiliser la macro GTK_WINDOW, qui fait un cast. Sais tu pourquoi ?


Up pour les deux autres questions .

[gerald3d]

Un CAST, oui mais c'est un peu plus que ca quand même. La librairie Gtk+ est "pratiquement" une POO. Donc il est nécessaire de "caster" pour accéder au parent de l'objet.
Dans la documentation officielle tu as pour chaque type une hiérarchie des objets. Pense à toujours aller voir de ce côté. Bien souvent ton objet ne dispose pas de la fonction adéquate mais un de ses parents oui.

[gerald3d]

Réponse à une autre question. g_malloc ou malloc ? Je dirai bonnet blanc, blanc bonnet. Cependant la doc. officielle précise qu'il faut utiliser g_free(); avec g_malloc();. Si tu mélanges un malloc avec un g_free ou inversement il semblerait que cela puisse poser certains problèmes.
Je pense que ces fonctions existent dans la glib pour permettre la portabilités des projets. Comment fait-on une allocation sous Windows, Mac? Si tu utilises g_malloc tu pourras utiliser ton code tel quel quelque soit le système d'exploitation.

[Captare]

Merci pour tes réponses.

Up pour mes autres questions (structure, et traduction).

[gerald3d]

Normalement le système d'exploitation doit libérer toute allocation lors de l'arrêt de l'application. Maintenant, est-ce toujours vrai? Je suis loin d'être un spécialiste en la matière pour te donner une réponse ferme et définitive.
De toute façon, il est quand même bien d'avoir "ses affaires rangées". Donc par principe si tu alloues dans le tas, libères avant de quitter. J'ajouterai que lorsque tu alloues dans le tas au milieu de ton programme n'attends pas la fin pour libérer si tu n'en as plus besoin avant. Au moins ton programme utilises de mémoire au mieux le système fonctionne.

[Captare]

Merci de ta réponse.

Up pour ma dernière question.

[gerald3d]

Il faut traduire handler par "gestionnaire".

[liberforce]

Normalement le système d'exploitation doit libérer toute allocation lors de l'arrêt de l'application. Maintenant, est-ce toujours vrai? Je suis loin d'être un spécialiste en la matière pour te donner une réponse ferme et définitive.

Oui, c'est toujours vrai. Le noyau de l'OS ne peut autoriser une application à lui voler de la mémoire indéfiniment si celle ci a été tuée.

De toute façon, il est quand même bien d'avoir "ses affaires rangées". Donc par principe si tu alloues dans le tas, libères avant de quitter. J'ajouterai que lorsque tu alloues dans le tas au milieu de ton programme n'attends pas la fin pour libérer si tu n'en as plus besoin avant. Au moins ton programme utilises de mémoire au mieux le système fonctionne.

Effectivement, une bonne règle à respecter est de libérer la mémoire quand on n'en a plus besoin, et si on ne compte pas s'en resservir prochainement. Exemple de consommation mémoire en respectant ces règles avec l'outil massif de valgrind (document un peu vieux mais les concepts sont toujours d'actualité.

[Captare]

Merci pour vos réponses à tous les deux .

[Captare]

Re bonjour à tous,

J'ai encore une petite question. Dans mon code j'ai :

Code :

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

 game->button[i] = gtk_button_new_with_label(alpha);

qui se trouve dans une boucle, exécuté 26 fois. Donc à la sortie j'ai 26 boutons.
A ce moment les bouton ne sont pas liés à une callback . Ensuite j'appelle la fonction : display_table_callback, qui va associer la callback à ces boutons.

Code :

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

1
2
3
4
5
6
7
8
9
void display_table_callback(GAME *game, GCallback callback)
{
    int i = 0;
    while (i < 26)
    {
        o[i] = g_signal_connect(G_OBJECT(game->button[i]), "clicked", G_CALLBACK(callback), game);
        i++;
    }
}

Bon rien de sorcier. Le problème c'est que j'aimerais associer à tous mes boutons une autre callback. Je pense qu'il faudrait donc que je déconnecte tous mes boutons de la callback envoyé par display_table_callback puis les reconnecter via cette dernière fonction avec une callback en paramètre différente, seulement je n'y arrive pas. Dans la doc il y'a cette fonction g_signal_handlers_disconnect, mais impossible de déconnecter mon signal .

Pouvez vous m'aider ?

Merci à ceux qui prendront le temps de me lire .

[Captare]

Si quelqu'un désire plus de précisions pour mon problème, n'hésiter pas .

[gerald3d]

Tu veux deux callback par bouton ou bien supprimer le premier pour en mettre un autre?

[Captare]

Merci de ta réponse !

Je voudrais supprimer la première callback puis en assigner une deuxième (différente bien sûr) .

[gerald3d]

Je suis d'accord avec toi. La seule fonction que je vois est bien la

Code :

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

void g_signal_handler_disconnect(gpointer instance,  gulong handler_id);

Maintenant si tu conserves les handler_id de chaque connexion tu n'arrives pas à les supprimer?
Aurais-tu un bout de code pour voir?

[Captare]

Oui, mais je pense que ça coince au niveau du paramètre gpointer instance. D'ailleurs je ne le comprends pas. Peux tu me l'expliquer ? Pour le second pas de problème.

[gerald3d]

Il correspond au pointeur de l'objet auquel est attaché le signal.