Partage
  • Partager sur Facebook
  • Partager sur Twitter

[GTK] Problème avec les boutons...

...et une image de fond

betteraves
    12 novembre 2007 à 20:16:23

    Salut à tous :) ,

    J'apprends actuellement à utiliser la librairie GTK+ et pour appliquer mes connaissances, j'ai décider de créer un petit encrypteur de fichier ; j'ai créé quelques menus, deux boutons (compresser et décompresser) ainsi qu'une barre du statut de l'encryptage. J'ai essayé de mettre une image de fond et j'ai donc trouvé une technique sur internet pour le faire (j'avoue que je n'ai compris que l'idée générale et que c'est du copié collé :euh: ); cette technique marche mais mes boutons ne s'affichent plus >_<

    Voici mon code :
    1. #include <stdlib.h>
    2. #include <gtk/gtk.h>
    3. #include "menu.h"
    4. void pression_aide(GtkWidget *widget, gpointer data);
    5. void a_propos_de(GtkWidget *widget, gpointer data);
    6. void pression_ouvrir(GtkWidget *widget, gpointer data);
    7. gboolean fond_ecran_expose(GtkWidget *pWindow, GdkEventExpose *event, gpointer user_data);
    8. void fond_ecran_set(GtkWidget *pWindow, gpointer user_data);
    9. int main(int argc,char **argv)
    10. {
    11.         GtkWidget * fenetre_principale = NULL;
    12.         GtkWidget * barre_menu = NULL;
    13.         GtkWidget * menu_fichier = NULL;
    14.         GtkWidget * fermer = NULL;
    15.         GtkWidget * ouvrir = NULL;
    16.         GtkWidget * menuaide = NULL;
    17.         GtkWidget * aide = NULL;
    18.         GtkWidget * a_propos = NULL;
    19.         GtkWidget * box_verticale = NULL;
    20.         GtkWidget * box_horizontale = NULL;
    21.         GtkWidget * bouton_compresser = NULL;
    22.         GtkWidget * bouton_decompresser = NULL;
    23.         GtkWidget * barre_progression = NULL;
    24.         GdkPixbuf *pixbuf_fond=NULL;
    25.         GdkPixmap *pixmap_fond=NULL;
    26.         gtk_init(&argc,&argv);
    27.         fenetre_principale = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    28.         gtk_window_set_title(GTK_WINDOW(fenetre_principale), "Crypteur de fichiers 1.5");
    29.         pixbuf_fond = gdk_pixbuf_new_from_file_at_size("cadena.jpg", 220, 330, NULL);
    30.         if (pixbuf_fond)
    31.         {
    32.                 //Création d'un GdkPixmap vierge
    33.                 pixmap_fond=gdk_pixmap_new(fenetre_principale->window, gdk_pixbuf_get_width(pixbuf_fond), gdk_pixbuf_get_height(pixbuf_fond), gdk_visual_get_system()->depth);
    34.                 //copie du GdkPixbuf dans le GdkPixmap.
    35.                 gdk_draw_pixbuf(pixmap_fond, fenetre_principale->style-> fg_gc[GTK_WIDGET_STATE (fenetre_principale)], pixbuf_fond,0,0,0,0, gdk_pixbuf_get_width(pixbuf_fond), gdk_pixbuf_get_height(pixbuf_fond), gdk_visual_get_system()->depth,0,0);
    36.                 //Supression du GdkPixbuf qui ne sert plus à rien
    37.                 g_object_unref(pixbuf_fond);
    38.         }
    39.         box_verticale = gtk_vbox_new(FALSE, 0);
    40.         gtk_container_add(GTK_CONTAINER(fenetre_principale), box_verticale);
    41.         barre_menu = creer_barre_menu(box_verticale);
    42.         menu_fichier = creer_menu(fenetre_principale, "Fichier", barre_menu);
    43.         ouvrir = creer_item_interieur(menu_fichier, "Ouvrir");
    44.         fermer = creer_item_interieur(menu_fichier, "Fermer");
    45.         menuaide = creer_menu(fenetre_principale, "?", barre_menu);
    46.         aide = creer_item_interieur(menuaide, "Aide");
    47.         a_propos = creer_item_interieur(menuaide, "A propos de ...");
    48.         barre_progression = gtk_progress_bar_new();
    49.         gtk_box_pack_start(GTK_BOX(box_verticale), barre_progression, FALSE, FALSE, 20);
    50.         box_horizontale = gtk_hbox_new(FALSE, 0);
    51.         gtk_box_pack_start(GTK_BOX(box_verticale), box_horizontale, FALSE, FALSE, 0);
    52.         bouton_compresser = gtk_button_new_with_label("Compresser");
    53.         bouton_decompresser = gtk_button_new_with_label("Décompresser");
    54.         gtk_box_pack_start(GTK_BOX(box_horizontale), bouton_compresser, FALSE, FALSE, 10);
    55.         gtk_box_pack_start(GTK_BOX(box_horizontale), bouton_decompresser, FALSE, FALSE, 10);
    56.         g_signal_connect(G_OBJECT(fenetre_principale), "realize", G_CALLBACK(fond_ecran_set), pixmap_fond);
    57.         g_signal_connect(G_OBJECT(fenetre_principale), "expose-event", G_CALLBACK(fond_ecran_expose), pixmap_fond);
    58.         g_signal_connect(G_OBJECT(fenetre_principale), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
    59.         g_signal_connect(G_OBJECT(fermer), "activate", G_CALLBACK(gtk_main_quit), NULL);
    60.         g_signal_connect(G_OBJECT(a_propos), "activate", G_CALLBACK(a_propos_de), (GtkWidget*) fenetre_principale);
    61.         g_signal_connect(G_OBJECT(aide), "activate", G_CALLBACK(pression_aide), (GtkWidget*) fenetre_principale);
    62.         g_signal_connect(G_OBJECT(ouvrir), "activate", G_CALLBACK(pression_ouvrir), (GtkWidget*) fenetre_principale);
    63.         gtk_widget_show_all(fenetre_principale);
    64.         gtk_main();
    65.         return EXIT_SUCCESS;
    66. }
    67. void pression_aide(GtkWidget *widget, gpointer data)
    68. {
    69.         GtkWidget * aide = NULL;
    70.         aide = gtk_message_dialog_new(GTK_WINDOW(data), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "[à taper]");
    71.         gtk_dialog_run(GTK_DIALOG(aide));
    72.         gtk_widget_destroy(aide);
    73. }
    74. void a_propos_de(GtkWidget *widget, gpointer data)
    75. {
    76.         GtkWidget * a_propos = NULL;
    77.         a_propos = gtk_message_dialog_new(GTK_WINDOW(data), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "Encrypteur/decrypteur\n\nRéalisé par niko\nMail : nikotenis83@gmail.com");
    78.         gtk_dialog_run(GTK_DIALOG(a_propos));
    79.         gtk_widget_destroy(a_propos);
    80. }
    81. void pression_ouvrir(GtkWidget *widget, gpointer data)
    82. {
    83.         GtkWidget * choisir_fichier = NULL;
    84.         gchar *chemin;
    85.         GtkWidget * fenetre_principale = NULL;
    86.         fenetre_principale = GTK_WIDGET(data);
    87.         choisir_fichier = gtk_file_chooser_dialog_new("Ouvrir...", GTK_WINDOW(fenetre_principale), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
    88.         gtk_window_set_modal(GTK_WINDOW(choisir_fichier), TRUE);
    89.         switch(gtk_dialog_run(GTK_DIALOG(choisir_fichier)))
    90.         {
    91.                 case GTK_RESPONSE_OK:
    92.                         chemin = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(choisir_fichier));
    93.                         gtk_widget_destroy(choisir_fichier);
    94.                 break;
    95.                 case GTK_RESPONSE_CANCEL:
    96.                         gtk_widget_destroy(choisir_fichier);
    97.                 break;
    98.                 default:
    99.                 gtk_widget_destroy(choisir_fichier);
    100.                 break;
    101.         }
    102. }
    103. void fond_ecran_set(GtkWidget *pWindow, gpointer user_data)
    104. {
    105.         GdkPixmap *pixmap_fond=(GdkPixmap*) user_data;
    106.         if (pixmap_fond)
    107.         {
    108.                 gdk_window_set_back_pixmap (pWindow->window, pixmap_fond, FALSE);
    109.         }
    110. }
    111. gboolean fond_ecran_expose(GtkWidget *pWindow, GdkEventExpose *event, gpointer user_data)
    112. {
    113.         GdkPixmap *pixmap_fond=(GdkPixmap*) user_data;
    114.         if (pixmap_fond)
    115.         {
    116.                 gdk_window_set_back_pixmap (pWindow->window, pixmap_fond, FALSE);
    117.                 return TRUE;
    118.         }
    119.         return FALSE;
    120. }


    PS: je me suis créé une petite (vraiment petite) libraire pour créer des menus donc demandez si vous voulez le code mais je ne pense pas que ce soit nécessaire ^^
    • Partager sur Facebook
    • Partager sur Twitter
    Bbar
      12 novembre 2007 à 22:15:14

      en regardant rapidement le code il y a une fonction qui me dérange un peu, c'est
      "fgtkWidget* = creer_item_interieur(gtkWidget*, gchar);".
      ça vient d'où ? o_O
      • Partager sur Facebook
      • Partager sur Twitter
      betteraves
        13 novembre 2007 à 17:18:17

        Comme je l'ai dis en PS, j'ai créé une petite librairie permetant de créer des menus plus facilement ; cette fonction vient de là :)
        • Partager sur Facebook
        • Partager sur Twitter
        betteraves
        Gambit2099
          14 novembre 2007 à 19:44:13

          Citation : betteraves

          Comme je l'ai dis en PS, j'ai créé une petite librairie permetant de créer des menus plus facilement ; cette fonction vient de là :)



          Tu l'as incluse dans le projet ?!
          • Partager sur Facebook
          • Partager sur Twitter
          www.juliandropsit.com
          betteraves
            14 novembre 2007 à 19:57:21

            Oui quand même, j'ai dit que se sont les boutons qui posent problème.
            De plus je compile avec gcc donc je l'inclue dans ma ligne de compilation.
            • Partager sur Facebook
            • Partager sur Twitter
            betteraves
            betteraves
              16 novembre 2007 à 20:54:50

              Up, quelqu'un connaîtrait-il un site spécialisé en gtk sur lequel j'aurais la réponse à ma question? (ou au moins la poser sur un forum)
              • Partager sur Facebook
              • Partager sur Twitter
              Gambit2099
              betteraves
                17 novembre 2007 à 10:04:06

                Ok merci beaucoup je viens de poster sur developpez ;)
                • Partager sur Facebook
                • Partager sur Twitter
                betteraves
                aurek
                  18 novembre 2007 à 10:32:10

                  Serait-il possible d'avoir quelque chose que l'on puisse compiler ?
                  • Partager sur Facebook
                  • Partager sur Twitter
                  betteraves
                    18 novembre 2007 à 13:34:43

                    ok, j'ai continué le code depuis et j'ai créé des nouveaux fichiers :
                    main.c
                    1. #include <stdlib.h>
                    2. #include <stdio.h>
                    3. #include <string.h>
                    4. #include <gtk/gtk.h>
                    5. #include "menu.h"
                    6. #include "fonctions.h"
                    7. int main(int argc,char **argv)
                    8. {
                    9.         GtkWidget * fenetre_principale = NULL;
                    10.         GtkWidget * barre_menu = NULL;
                    11.         GtkWidget * menu_fichier = NULL;
                    12.         GtkWidget * fermer = NULL;
                    13.         GtkWidget * ouvrir = NULL;
                    14.         GtkWidget * menuaide = NULL;
                    15.         GtkWidget * aide = NULL;
                    16.         GtkWidget * a_propos = NULL;
                    17.         GtkWidget * box_verticale = NULL;
                    18.         GtkWidget * box_horizontale = NULL;
                    19.         GtkWidget * bouton_compresser = NULL;
                    20.         GtkWidget * bouton_decompresser = NULL;
                    21.         GtkWidget * barre_progression = NULL;
                    22.         GdkPixbuf *pixbuf_fond=NULL;
                    23.         GdkPixmap *pixmap_fond=NULL;
                    24.         gchar *chemin = "";
                    25.         gtk_init(&argc,&argv);
                    26.         fenetre_principale = gtk_window_new(GTK_WINDOW_TOPLEVEL);
                    27.         gtk_window_set_title(GTK_WINDOW(fenetre_principale), "Crypteur de fichiers 1.5");
                    28.         gtk_window_set_icon_from_file(GTK_WINDOW(fenetre_principale), "icone.png", NULL);
                    29.         box_verticale = gtk_vbox_new(FALSE, 0);
                    30.         gtk_container_add(GTK_CONTAINER(fenetre_principale), box_verticale);
                    31.         barre_menu = creer_barre_menu(box_verticale);
                    32.         menu_fichier = creer_menu(fenetre_principale, "Fichier", barre_menu);
                    33.         ouvrir = creer_item_interieur(menu_fichier, "Ouvrir");
                    34.         fermer = creer_item_interieur(menu_fichier, "Fermer");
                    35.         menuaide = creer_menu(fenetre_principale, "?", barre_menu);
                    36.         aide = creer_item_interieur(menuaide, "Aide");
                    37.         a_propos = creer_item_interieur(menuaide, "A propos de ...");
                    38.         pixbuf_fond = gdk_pixbuf_new_from_file_at_size("cadena.jpg", 220, 330, NULL);
                    39.         if (pixbuf_fond)
                    40.         {
                    41.                 //Création d'un GdkPixmap vierge
                    42.                 pixmap_fond=gdk_pixmap_new(fenetre_principale->window, gdk_pixbuf_get_width(pixbuf_fond), gdk_pixbuf_get_height(pixbuf_fond), gdk_visual_get_system()->depth);
                    43.                 //copie du GdkPixbuf dans le GdkPixmap.
                    44.                 gdk_draw_pixbuf(pixmap_fond, fenetre_principale->style-> fg_gc[GTK_WIDGET_STATE (fenetre_principale)], pixbuf_fond,0,0,0,0, gdk_pixbuf_get_width(pixbuf_fond), gdk_pixbuf_get_height(pixbuf_fond), gdk_visual_get_system()->depth,0,0);
                    45.                 //Supression du GdkPixbuf qui ne sert plus à rien
                    46.                 g_object_unref(pixbuf_fond);
                    47.         }
                    48.         barre_progression = gtk_progress_bar_new();
                    49.         gtk_box_pack_start(GTK_BOX(box_verticale), barre_progression, FALSE, FALSE, 20);
                    50.         box_horizontale = gtk_hbox_new(FALSE, 0);
                    51.         gtk_box_pack_start(GTK_BOX(box_verticale), box_horizontale, FALSE, FALSE, 0);
                    52.         bouton_compresser = gtk_button_new_with_label("Compresser");
                    53.         bouton_decompresser = gtk_button_new_with_label("Décompresser");
                    54.         gtk_box_pack_start(GTK_BOX(box_horizontale), bouton_compresser, FALSE, FALSE, 10);
                    55.         gtk_box_pack_start(GTK_BOX(box_horizontale), bouton_decompresser, FALSE, FALSE, 10);
                    56.         g_signal_connect(G_OBJECT(fenetre_principale), "realize", G_CALLBACK(fond_ecran_set), pixmap_fond);
                    57.         g_signal_connect(G_OBJECT(fenetre_principale), "expose-event", G_CALLBACK(fond_ecran_expose), pixmap_fond);
                    58.         g_signal_connect(G_OBJECT(fenetre_principale), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
                    59.         g_signal_connect(G_OBJECT(fermer), "activate", G_CALLBACK(gtk_main_quit), NULL);
                    60.         g_signal_connect(G_OBJECT(a_propos), "activate", G_CALLBACK(a_propos_de), (GtkWidget*) fenetre_principale);
                    61.         g_signal_connect(G_OBJECT(aide), "activate", G_CALLBACK(pression_aide), (GtkWidget*) fenetre_principale);
                    62.         g_signal_connect(G_OBJECT(ouvrir), "activate", G_CALLBACK(pression_ouvrir), &chemin);
                    63.         g_signal_connect(G_OBJECT(bouton_compresser), "clicked", G_CALLBACK(compresser), chemin);
                    64.         gtk_widget_show_all(fenetre_principale);
                    65.         gtk_main();
                    66.         return EXIT_SUCCESS;
                    67. }


                    fonctions.c
                    1. #include <stdlib.h>
                    2. #include <stdio.h>
                    3. #include <string.h>
                    4. #include <gtk/gtk.h>
                    5. void pression_aide(GtkWidget *widget, gpointer data)
                    6. {
                    7.         GtkWidget * aide = NULL;
                    8.         aide = gtk_message_dialog_new(GTK_WINDOW(data), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "[à taper]");
                    9.         gtk_dialog_run(GTK_DIALOG(aide));
                    10.         gtk_widget_destroy(aide);
                    11. }
                    12. void a_propos_de(GtkWidget *widget, gpointer data)
                    13. {
                    14.         GtkWidget * a_propos = NULL;
                    15.         a_propos = gtk_message_dialog_new(GTK_WINDOW(data), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "Encrypteur/decrypteur\n\nRéalisé par niko\nMail : nikotenis83@gmail.com");
                    16.         gtk_dialog_run(GTK_DIALOG(a_propos));
                    17.         gtk_widget_destroy(a_propos);
                    18. }
                    19. void pression_ouvrir(GtkWidget *widget, gpointer data)
                    20. {
                    21.         GtkWidget * choisir_fichier = NULL;
                    22.         gchar ** chemin = data;
                    23.         choisir_fichier = gtk_file_chooser_dialog_new("Ouvrir...", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
                    24.         gtk_window_set_modal(GTK_WINDOW(choisir_fichier), TRUE);
                    25.         switch(gtk_dialog_run(GTK_DIALOG(choisir_fichier)))
                    26.         {
                    27.                 case GTK_RESPONSE_OK:
                    28.                         *chemin = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(choisir_fichier));
                    29.                         gtk_widget_destroy(choisir_fichier);
                    30.                 break;
                    31.                 case GTK_RESPONSE_CANCEL:
                    32.                         gtk_widget_destroy(choisir_fichier);
                    33.                 break;
                    34.                 default:
                    35.                 gtk_widget_destroy(choisir_fichier);
                    36.                 break;
                    37.         }
                    38. }
                    39. void compresser(GtkWidget *widget, gpointer data)
                    40. {
                    41.         printf("debut de la fonction");
                    42.         int caractere_actuel = 0, caractere_crypte = 0, i = 1, j;
                    43.         FILE *original = NULL, *crypte = NULL;
                    44.         char clef[20] = "prout", nom[100] = "";
                    45.         gchar *chemin = (gchar*) data;
                    46.         printf("fin de l'initialisation des variables");
                    47.         for(j=0 ; i<100; i++)
                    48.         {
                    49.                 nom[i] = *chemin;
                    50.                 chemin++;
                    51.         }
                    52.         printf("fin de la boucle");    
                    53.         printf("chemin = %s", chemin);
                    54.         printf("nom = %s", nom);
                    55.         original = fopen(nom, "rb");
                    56.         if(original = NULL)
                    57.         {
                    58.                 fprintf(stderr, "Erreur d'ouverture du fichier %s\n", nom);    
                    59.                 exit(EXIT_FAILURE);
                    60.         }
                    61.         else
                    62.         {
                    63.                 crypte = fopen("crypted", "w");
                    64.                 if(crypte = NULL)
                    65.                 {
                    66.                         fprintf(stderr, "Erreur lors de la création du fichier crypté\n");    
                    67.                         exit(EXIT_FAILURE);
                    68.                 }
                    69.                 else
                    70.                 {              
                    71.                         while (caractere_actuel != EOF)
                    72.                         {
                    73.                                 caractere_actuel = fgetc(original);
                    74.                                 caractere_crypte = caractere_actuel ^ clef[i];
                    75.                                 fputc(caractere_crypte, crypte);
                    76.                                 i++;
                    77.                                 if(clef[i] == 0)
                    78.                                         i = 1;
                    79.                         }
                    80.                         fclose(crypte);
                    81.                 }
                    82.                 fclose(original);
                    83.         }
                    84. }
                    85. void fond_ecran_set(GtkWidget *fenetre_principale, gpointer user_data)
                    86. {
                    87.         GdkPixmap *pixmap_fond=(GdkPixmap*) user_data;
                    88.         if (pixmap_fond)
                    89.         {
                    90.                 gdk_window_set_back_pixmap (fenetre_principale->window, pixmap_fond, FALSE);
                    91.         }
                    92. }
                    93. gboolean fond_ecran_expose(GtkWidget *fenetre_principale, GdkEventExpose *event, gpointer user_data)
                    94. {
                    95.         GdkPixmap *pixmap_fond=(GdkPixmap*) user_data;
                    96.         if (pixmap_fond)
                    97.         {
                    98.                 gdk_window_set_back_pixmap (fenetre_principale->window, pixmap_fond, FALSE);
                    99.                 return TRUE;
                    100.         }
                    101.         return FALSE;
                    102. }


                    fonctions.h
                    1. void pression_aide(GtkWidget *widget, gpointer data);
                    2. void a_propos_de(GtkWidget *widget, gpointer data);
                    3. void pression_ouvrir(GtkWidget *widget, gpointer data);
                    4. gboolean fond_ecran_expose(GtkWidget *pWindow, GdkEventExpose *event, gpointer user_data);
                    5. void fond_ecran_set(GtkWidget *pWindow, gpointer user_data);
                    6. void compresser(GtkWidget *widget, gpointer data);


                    menu.c
                    1. #include <stdlib.h>
                    2. #include <gtk/gtk.h>
                    3. GtkWidget * creer_menu(GtkWidget * fenetre, const gchar* nom, GtkWidget * barre_menu)
                    4. {
                    5.         GtkWidget * menu = NULL;
                    6.         GtkWidget * nom_menu = NULL;
                    7.         menu = gtk_menu_new();
                    8.         nom_menu = gtk_menu_item_new_with_label(nom);
                    9.         gtk_menu_item_set_submenu(GTK_MENU_ITEM(nom_menu), menu);
                    10.         gtk_menu_shell_append(GTK_MENU_SHELL(barre_menu), nom_menu);
                    11.         return menu;
                    12. }
                    13. GtkWidget * creer_item_interieur(GtkWidget * menu, const gchar* nom)
                    14. {
                    15.         GtkWidget * item_interieur = NULL;
                    16.         item_interieur = gtk_menu_item_new_with_label(nom);
                    17.         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_interieur);
                    18.         return item_interieur;
                    19. }
                    20. GtkWidget * creer_item_interieur_checkbox(GtkWidget * menu, const gchar* nom)
                    21. {
                    22.         GtkWidget * item_interieur = NULL;
                    23.         item_interieur = gtk_check_menu_item_new_with_label(nom);
                    24.         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_interieur);
                    25.         return item_interieur;
                    26. }
                    27. GtkWidget * creer_item_interieur_avec_image(GtkWidget * menu, const gchar* nom, const gchar* nom_image)
                    28. {
                    29.         GtkWidget * item_interieur = NULL;
                    30.         GtkWidget * image = NULL;
                    31.         image = gtk_image_new_from_file(nom_image);
                    32.         item_interieur = gtk_image_menu_item_new_with_label(nom);
                    33.         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item_interieur), image);
                    34.         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_interieur);
                    35.         return item_interieur;
                    36. }
                    37. GtkWidget * creer_barre_menu(GtkWidget * fenetre)
                    38. {
                    39.         GtkWidget * barre_menu = NULL;
                    40.         barre_menu = gtk_menu_bar_new();
                    41.         gtk_container_add(GTK_CONTAINER(fenetre), barre_menu);  
                    42.         return barre_menu;
                    43. }


                    menu.h
                    1. GtkWidget * creer_menu(GtkWidget * fenetre, const gchar* nom, GtkWidget * barre_menu);
                    2. GtkWidget * creer_item_interieur(GtkWidget * menu, const gchar* nom);
                    3. GtkWidget * creer_item_interieur_checkbox(GtkWidget * menu, const gchar* nom);
                    4. GtkWidget * creer_item_interieur_avec_image(GtkWidget * menu, const gchar* nom, const gchar* nom_image);
                    5. GtkWidget * creer_barre_menu(GtkWidget * fenetre);


                    Voilà ça fait beaucoup de code mais avec ça vous pouvez compiler ^^ il suffit juste de rajouter n'importe quelle image dans le dossier courant et l'appeler "cadena.jpg".
                    • Partager sur Facebook
                    • Partager sur Twitter
                    betteraves
                    betteraves
                      21 novembre 2007 à 14:07:33

                      dernier up desespéré ... si j'ai pas la réponse tant pis je ferais sans image de fond :(
                      • Partager sur Facebook
                      • Partager sur Twitter

                      [GTK] Problème avec les boutons...

                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                      × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                      • Editeur ●
                      • Markdown