IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

GTK+ avec C & C++ Discussion :

Comportement de fenêtres GTK+ avec dessins


Sujet :

GTK+ avec C & C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Homme Profil pro
    Chercheur
    Inscrit en
    Mars 2009
    Messages
    61
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France

    Informations professionnelles :
    Activité : Chercheur

    Informations forums :
    Inscription : Mars 2009
    Messages : 61
    Par défaut Comportement de fenêtres GTK+ avec dessins
    Bonjour,

    je développe un programme Fortran90/C/Gtk+, à une certaine étape je dessine des courbes dans une GtkWindow en utilisant Cairo:
    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
     
    GtkWidget * info;
    cairo_t *cr;
    int i;
    int sizecurve;
    float curvetoprint[sizecurve];
     
    info = (GtkWidget *) gtk_builder_get_object (BuilderGtk, "RDFs");
    /* RDFs est une Windows décrite dans un fichier xml */
     
    cr = gdk_cairo_create(widget -> window);
    cairo_set_source_rgb(cr,  0, 0, 0);
    cairo_set_line_width (cr, 1.0);
     
    for (i=0; i < sizecurve-2; i++)
    {
    /* On place le tout dans une fenêtre 800x600 */
        cairo_move_to(cr, i*800/sizecurve, 600-50*curvetoprint[i]);
        cairo_line_to(cr, (i+1)*800/sizecurve, 600-50*curvetoprint[i+1]);
    }
     
    cairo_stroke(cr);
    cairo_destroy(cr);
    Tout cela fonctionne parfaitement seulement j'ai noté quelque chose de désagréable lors de l'exécution du programme.
    La courbe est tracée pas de soucis seulement quand je masque la fenêtre dans la barre des taches et que je la fait réapparaître son contenu a été effacé ...

    Une suggestion pour empêcher cela ?

    S.

  2. #2
    Expert confirmé
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    Février 2008
    Messages
    2 308
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : Février 2008
    Messages : 2 308
    Billets dans le blog
    5
    Par défaut
    2 solutions de principe :
    1. dessiner dans un bloc mémoire alloué. Ce bloc est affiché dans le Callback appelé par le signal "expose-event".
    2. Dessiner entièrement la courbe dans le callback appelé par le signal "expose-event". Pas terrible comme solution. Ralentissement de l'éxécution. Mais c'est la solution la plus simple à mettre en oeuvre.

  3. #3
    Membre confirmé
    Homme Profil pro
    Chercheur
    Inscrit en
    Mars 2009
    Messages
    61
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France

    Informations professionnelles :
    Activité : Chercheur

    Informations forums :
    Inscription : Mars 2009
    Messages : 61
    Par défaut
    Merci pour l'info je vais essayer de faire uniquement avec l'expose event.

    S.

  4. #4
    Futur Membre du Club
    Inscrit en
    Décembre 2010
    Messages
    5
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 5
    Par défaut
    pouvez M. Slookeur m'envouyé le code du programme permetant de dessiner n'imprte qu'elle courbes dans une GtkWindow en utilisant Cairo plz et merci d'avance

  5. #5
    Membre confirmé Avatar de Gamall
    Profil pro
    Étudiant ENSEA
    Inscrit en
    Août 2009
    Messages
    252
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant ENSEA

    Informations forums :
    Inscription : Août 2009
    Messages : 252
    Par défaut
    Citation Envoyé par gerald3d Voir le message
    2 solutions de principe :
    1. dessiner dans un bloc mémoire alloué. Ce bloc est affiché dans le Callback appelé par le signal "expose-event".
    2. Dessiner entièrement la courbe dans le callback appelé par le signal "expose-event". Pas terrible comme solution. Ralentissement de l'éxécution. Mais c'est la solution la plus simple à mettre en oeuvre.
    Pour le expose-event, j'ai remarqué qu'il n'est pas émis si le fenêtre est partiellement cachée. Du coup la partie qui était cachée est effacée lorsque la fenêtre réapparaît.

  6. #6
    Expert confirmé
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    Février 2008
    Messages
    2 308
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : Février 2008
    Messages : 2 308
    Billets dans le blog
    5
    Par défaut
    Je n'ai jamais rencontré ce genre de problème. Maintenant je n'ai jamais dessiné directement dans un GtkWindow. Mes dessins se sont toujours faits dans un GtkDrawingArea. Est-ce que ca fait une différence? Pas sûr...

  7. #7
    Futur Membre du Club
    Inscrit en
    Décembre 2010
    Messages
    5
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 5
    Par défaut
    oui oui mon fraire je veux seulement le code du programme qui dessine n'importe qu'elle courbe et merci

  8. #8
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    Citation Envoyé par reda91 Voir le message
    oui oui mon fraire je veux seulement le code du programme qui dessine n'importe qu'elle courbe et merci
    Merci de ne pas venir polluer le fil de discussion de quelqu'un d'autre. Si tu as des questions, ouvre ton propre fil de discussion.

  9. #9
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    Citation Envoyé par gerald3d Voir le message
    Je n'ai jamais rencontré ce genre de problème. Maintenant je n'ai jamais dessiné directement dans un GtkWindow. Mes dessins se sont toujours faits dans un GtkDrawingArea. Est-ce que ca fait une différence? Pas sûr...
    Je comprends mieux ta remarque. La manière de dessiner via cairo ne change pas, mais GtkWindow dessine automatiquement son contenu par défaut, et pas GtkDrawingArea...

  10. #10
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    Bon, je n'avais pas vu qu'il dessinait directement dans la GtkWindow. La solution est donc sans doute de dessiner dans une GtkDrawingArea insérée dans la GtkWindow (solution la plus propre), ou bien appeler gtk_widget_set_app_paintable sur la GtkWindow.

  11. #11
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    Citation Envoyé par artificier59 Voir le message
    Pour le expose-event, j'ai remarqué qu'il n'est pas émis si le fenêtre est partiellement cachée. Du coup la partie qui était cachée est effacée lorsque la fenêtre réapparaît.
    Je ne suis pas d'accord. L'expose-event est émis à chaque fois qu'il y a quelque chose à dessiner. Quand la fenêtre est à l'arrière plan et partiellement cachée, et qu'on la fait passer à l'avant plan, je suis à peu près certain qu'il est émis.

    @Gerald, dessiner dans un GtKDrawingArea ou un autre widgets, c'est pareil, cairo dessine de toute façon dans le GdkWindow associé au widget...

  12. #12
    Expert confirmé
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    Février 2008
    Messages
    2 308
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : Février 2008
    Messages : 2 308
    Billets dans le blog
    5
    Par défaut
    Citation Envoyé par liberforce Voir le message
    @Gerald, dessiner dans un GtKDrawingArea ou un autre widgets, c'est pareil, cairo dessine de toute façon dans le GdkWindow associé au widget...
    Oui tu as raison. +1

  13. #13
    Membre confirmé Avatar de Gamall
    Profil pro
    Étudiant ENSEA
    Inscrit en
    Août 2009
    Messages
    252
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant ENSEA

    Informations forums :
    Inscription : Août 2009
    Messages : 252
    Par défaut
    Citation Envoyé par liberforce Voir le message
    Je ne suis pas d'accord. L'expose-event est émis à chaque fois qu'il y a quelque chose à dessiner. Quand la fenêtre est à l'arrière plan et partiellement cachée, et qu'on la fait passer à l'avant plan, je suis à peu près certain qu'il est émis.
    Je viens de faire un petit test simple avec ce 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
    #include <gtk/gtk.h>
     
    gboolean expose_cb (GtkWidget *widget, GdkEventExpose *event)
    {
    	g_print ("Expose event emitted !\n");
     
    	return FALSE;
    }
     
    int
    main(int argc, char ** argv)
    {
    	GtkWidget *window;
    	GtkWidget *draw;
     
    	gtk_init (&argc, &argv);
     
    	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    	gtk_window_set_default_size (GTK_WINDOW(window), 320, 200);
    	g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
     
    	draw = gtk_drawing_area_new ();
    	g_signal_connect (draw, "expose-event", G_CALLBACK(expose_cb), NULL);
    	gtk_container_add (GTK_CONTAINER(window), draw);
     
    	gtk_widget_show_all (window);
     
    	gtk_main ();
     
    	return 0; 
    }
    J'ai mis une fenêtre en partie par dessus ce programme, et quand je clique sur cette fenêtre pour cacher le programme, puis que je re-clique sur le programme pour le remettre au premier plan, le signal n'est pas émis.
    Autre chose, quand je glisse la fenêtre (sans la relâcher) sous une autre ou sous le tableau de bord du bas (sous gnome), le signal n'est pas non plus émis.
    Du coup ben s'il y a un dessin dans la fenêtre, ben celui-ci est effacé


    Aussi, ce que je comprends pas, c'est pourquoi pour une fenêtre qui contient des widgets (boutons, barre de menu, etc...), qui est partiellement cachée comme je l'ai décris plus haut, les widgets ne s’effacent pas ?

  14. #14
    Expert confirmé
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    Février 2008
    Messages
    2 308
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : Février 2008
    Messages : 2 308
    Billets dans le blog
    5
    Par défaut
    Histoire d'être sûr. Ajoute le signal "GDK_EXPOSURE_MASK" avec la fonction gtk_widget_set_events (GtkWidget *widget, gint events); à ta GtkWindow* et retente l'expérience.

    Si on prend les GtkDrawingArea ils héritent bien des GtkWidgets mais ils n'écoutent pas tous les signaux de ces derniers. Il est possible que les GtkWindow n'écoutent pas le signal "GDK_EXPOSURE_MASK".

  15. #15
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    J'ai testé avec la même configuration mais en utilisant compiz à la place de metacity comme gestionnaire de fenêtre. Effectivement, il y a moins d'expose-event envoyés. Celui ci n'est en fait appelé que lorsque c'est nécessaire, à savoir quand le contenu à afficher va changer. C'est peut être à cause du compositeur, qui retraite les images avant de les afficher, ou peut être depuis la gestion de l'offscreen rendering... Je ne sais pas trop. Toujours est il que cela fonctionne comme du double buffering, Vu qu'on a déjà l'image de ce qu'il y a à afficher, si la fenêtre est recouverte par une autre puis découverte, pas besoin de tout redessiner, et donc pas besoin d'envoyer un expose-event: on réutilise juste ce qui a déjà été dessiné. C'est une différence de fonctionnement, mais le résultat est identique.

    Citation Envoyé par Slookeur Voir le message
    La courbe est tracée pas de soucis seulement quand je masque la fenêtre dans la barre des taches et que je la fait réapparaître son contenu a été effacé ...
    J'ai un exemple de code cairo que j'avais déjà posté ici (cairo-plot), et il fonctionne très bien, il n'y a pas ton bug... Et c'est juste une GtkDrawingArea dans laquelle je dessine...

    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
    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
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    #include <gtk/gtk.h>
    #include <math.h>
    #include <cairo.h>
     
    #define WIDTH   640
    #define HEIGHT  480
     
    #define ZOOM_X  100.0
    #define ZOOM_Y  100.0
     
     
    gfloat f (gfloat x)
    {
    	return 0.03 * pow (x, 3);
    }
     
    static gboolean
    on_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
    {
    	cairo_t *cr = gdk_cairo_create (widget->window);
    	GdkRectangle da;            /* Dimensions de la GtkDrawingArea */
    	gdouble dx = 5.0, dy = 5.0; /* Nombre de pixels entre chaque point calculé */
    	gdouble i, clip_x1 = 0.0, clip_y1 = 0.0, clip_x2 = 0.0, clip_y2 = 0.0;
    	gint unused = 0;
     
    	/* On définit la zone de clipping, cela correspond à la zone à 
    	 * raffraîchir. En ne dessinant que le strict nécessaire, on dessinera 
    	 * plus rapidement */
    	cairo_rectangle (cr, 
    			event->area.x, 
    			event->area.y, 
    			event->area.width, 
    			event->area.height);
    	cairo_clip (cr);
     
    	/* On détermine les dimensions de la GtkDrawingArea */
    	gdk_window_get_geometry (widget->window, 
    			&da.x, 
    			&da.y, 
    			&da.width, 
    			&da.height, 
    			&unused);
     
    	/* On dessine un fond noir */
    	cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
    	cairo_paint (cr);
     
    	/* On change la matrice de transformation. C'est comme un changement 
    	 * de repère en mathématiques. On centre d'abord l'origine du repère.
    	 * Ensuite on change son échelle */
    	cairo_translate (cr, da.width / 2, da.height / 2);
    	cairo_scale (cr, ZOOM_X, -ZOOM_Y);  
     
    	/* On détermine les points à calculer (c'est à dire ceux se trouvant 
    	 * dans la zone de clipping) */
    	cairo_device_to_user_distance (cr, &dx, &dy);
    	cairo_clip_extents (cr, &clip_x1, &clip_y1, &clip_x2, &clip_y2);
    	cairo_set_line_width (cr, dx);
     
    	/* On dessine les axes */
    	cairo_set_source_rgb (cr, 0.0, 1.0, 0.0);
    	cairo_move_to (cr, clip_x1, 0.0);
    	cairo_line_to (cr, clip_x2, 0.0);
    	cairo_move_to (cr, 0.0, clip_y1);
    	cairo_line_to (cr, 0.0, clip_y2);
    	cairo_stroke (cr);
     
    	/* On rajoute les points de la coube en les reliant par une droite */
    	for (i = clip_x1; i < clip_x2; i += dx)
    		cairo_line_to (cr, i, f (i));
     
    	/* On dessine la courbe */
    	cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6);
    	cairo_stroke (cr);
     
    	cairo_destroy (cr);
    	return FALSE;
    }
     
     
    int
    main (int argc, char **argv)
    {
    	GtkWidget *window;
    	GtkWidget *da;
     
    	gtk_init (&argc, &argv);
     
    	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    	gtk_window_set_default_size (GTK_WINDOW (window), WIDTH, HEIGHT);
    	gtk_window_set_title (GTK_WINDOW (window), "Affichage de courbe");
    	g_signal_connect (G_OBJECT (window), "delete-event", gtk_main_quit, NULL);
     
    	da = gtk_drawing_area_new ();
    	gtk_container_add (GTK_CONTAINER (window), da);
     
    	g_signal_connect (G_OBJECT (da), 
    			"expose-event", 
    			G_CALLBACK (on_expose_event), 
    			NULL);
     
    	gtk_widget_show_all (window);
    	gtk_main ();
     
    	return 0;
    }
    @Slookeur: pourrais tu poster une version minimale de ton programme qui reproduise le bug ?

  16. #16
    Membre confirmé
    Homme Profil pro
    Chercheur
    Inscrit en
    Mars 2009
    Messages
    61
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France

    Informations professionnelles :
    Activité : Chercheur

    Informations forums :
    Inscription : Mars 2009
    Messages : 61
    Par défaut Re, après tout ce temps ...
    Bonjour à tous et à toutes,

    depuis que j'ai initié cette discussion, j'ai résolu mais problèmes de comportement ... en utilisant effectivement une GtkDrawingArea.

    Bout de code qui fonctionne pour moi en exemple, ici je crée une fenêtre
    contenant (entre autres) une GtkDrawingArea, et j'utilise le 'expose_event'
    comme signal pour l'actualiser, cela fonctionne très bien, sous linux (Compiz, Metacity ... ou autre),
    Windows (Xp, Vista, 7), et MacOSX.

    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
    54
    55
    56
    57
    58
    59
    60
     
    GtkWidget * create_Curve (char * namecurve, int * idcurve)
    {
      GtkWidget * Curve;
      GtkWidget * Cvbox;
      GtkWidget * menu;
      GtkWidget * menudata, * menucurve;
      GtkWidget * menud, * menuc;
      GtkWidget * savecurveas;
      GtkWidget * savecurve;
      GtkWidget * editcurve;
      GtkWidget * separatormenu;
      GtkWidget * closecurve;
      GtkAccelGroup * accel_group;
      int i, j;
     
      accel_group = gtk_accel_group_new ();
      Curve = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW(Curve), namecurve);
      gtk_window_set_default_size (GTK_WINDOW(Curve), 840, 677);
      gtk_window_set_resizable (GTK_WINDOW (Curve), TRUE);
      Cvbox = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (Curve), Cvbox);
      menu = gtk_menu_bar_new ();
      gtk_box_pack_start (GTK_BOX (Cvbox), menu, FALSE, TRUE, 0);
      menudata = gtk_menu_item_new_with_mnemonic (("_Data"));
      gtk_container_add (GTK_CONTAINER (menu), menudata);
      menud = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menudata), menud);
      savecurveas = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group);
      gtk_container_add (GTK_CONTAINER (menud), savecurveas);
      separatormenu = gtk_separator_menu_item_new ();
      gtk_container_add (GTK_CONTAINER (menud), separatormenu);
      gtk_widget_set_sensitive (separatormenu, FALSE);
      closecurve = gtk_image_menu_item_new_from_stock ("gtk-close", accel_group);
      gtk_container_add (GTK_CONTAINER (menud), closecurve);
      menucurve = gtk_menu_item_new_with_mnemonic (("_Curve"));
      gtk_container_add (GTK_CONTAINER (menu), menucurve);
      menuc = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menucurve), menuc);
      editcurve = gtk_image_menu_item_new_with_mnemonic (("E_dit curve"));
      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(editcurve), gtk_image_new_from_file(PACKAGE_EDIT));
      gtk_container_add (GTK_CONTAINER (menuc), editcurve);
      savecurve = gtk_image_menu_item_new_with_mnemonic (("_Export image"));
      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(savecurve), gtk_image_new_from_file(PACKAGE_PNG));
      gtk_container_add (GTK_CONTAINER (menuc), savecurve);
     
      curves[* idcurve] -> plot = gtk_drawing_area_new();
      gtk_box_pack_start (GTK_BOX (Cvbox), curves[* idcurve] -> plot, TRUE, TRUE, 0);
     
      g_signal_connect ((gpointer)curves[* idcurve] -> plot, "expose_event", G_CALLBACK(to_show), GINT_TO_POINTER(* idcurve));
      g_signal_connect ((gpointer)Curve, "delete_event", G_CALLBACK(curve_hide), GINT_TO_POINTER(* idcurve));
      g_signal_connect ((gpointer)savecurveas, "activate", G_CALLBACK(write_curve), GINT_TO_POINTER(* idcurve));
      g_signal_connect ((gpointer)savecurve, "activate", G_CALLBACK(save_image), GINT_TO_POINTER(* idcurve));
      g_signal_connect ((gpointer)editcurve, "activate", G_CALLBACK(edit_image), GINT_TO_POINTER(* idcurve));
      g_signal_connect ((gpointer)closecurve, "activate", G_CALLBACK(hide_curve), GINT_TO_POINTER(* idcurve));
      gtk_window_add_accel_group (GTK_WINDOW (Curve), accel_group);
     
      return Curve;
    }
    Le code source complet du programme que j'ai développé, ISAACS, est disponible à cette adresse (inclus les fichiers Code::blocks):

    http://isaacs.sourceforge.net

    @pvincent: je suis physicien moi aussi, une des idées derrière le développpement d'ISAACS (Interactive Structure Analysis of Amorphous and Crystalline Systems) était de proposer un programme permettant à un utilisateur non averti, un étudiant par exemple, de réaliser certain calculs physiques complexes (en Fortran 90, car déjà partiellement codés pour http://rings-code.sourceforge.net, que j'ai également écris et // en MPI) puis de visualiser directement les résultats.
    Je n'ai pas rencontré de problèmes de communication entre les compilateurs, j'utilise gfortran et gcc, j'avoue avoir essayé les compilateurs Intel sans succès, mais pour le moment tout marche très bien avec les GNU, et le seul prix à payer a été le temps nécessaire à comprendre la communication entre les 2 langages ... maintenant tout est ok ... je touche du bois.
    Je dois avouer être plutôt fière de mon programme, et vous invite à le tester.

    Merci à tout le monde.

  17. #17
    Modérateur

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2009
    Messages
    1 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2009
    Messages : 1 395
    Par défaut
    Pour réaliser ton interface graphique, je te conseille de t'orienter vers Glade + GtkBuilder, et GtkUIManager.

Discussions similaires

  1. Zone de Dessin dans une fenêtre [GTK 3 & Cairo]
    Par Twice22 dans le forum GTK+ avec C & C++
    Réponses: 14
    Dernier message: 04/05/2013, 10h41
  2. Comportement de Gtk avec Gtk.Main.Timeout
    Par Invité dans le forum GTK+ avec C & C++
    Réponses: 8
    Dernier message: 07/12/2011, 19h33
  3. Fenêtres multiples avec la librairie SDL
    Par pierrev1 dans le forum SDL
    Réponses: 4
    Dernier message: 10/12/2006, 11h36
  4. Commander des fenêtres GTK avec le shell
    Par clebig dans le forum GTK+ avec C & C++
    Réponses: 2
    Dernier message: 31/07/2006, 11h58
  5. [GTK] avec Dev-C++
    Par touronster dans le forum Dev-C++
    Réponses: 12
    Dernier message: 30/06/2005, 20h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo