Discussion: GTK et autre tache ?

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    avril 2017
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 20
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : avril 2017
    Messages : 2
    Points : 1
    Points
    1

    Par défaut GTK et autre tache ?

    Bonjour a tous je suis nouveau sur le forum et également débutant avec GTK

    j'ai crée un programme en console qui effectue l'acquisition et le traitement de signal après avoir validé son fonctionnement je souhaite mtn realiser une interface graphique simple pour afficher les valeurs .

    Donc je n'ai aucun bouton a gérer , juste la "croix" pour quitter , je veux juste faire un calcul , afficher les résultat , faire le calcul , afficher etc tout ca en boucle
    j'ai donc regarder des tutos et apres quelques heures j'ai réussi a crée mon interface , ainsi que manipuler les labels pour afficher des valeurs .

    J'ai donc décider de réunir mon programme en console et mon interface et la c'est le drame...le programme tourne , mais il bloque l'IHM
    j'utilise des "g_timeout_add" pour actualiser mes valeurs et faire mon calcul j'ai entendu parler de g_iddle_add mais je n'ai pas vraiment saisi a quoi il sert...
    ....j'ai également parler de threads en cherchant et j'avoue que ça me fait peur parce que etant étudiant en électronique généralement les programmes sont séquentiel et assez simple...

    je pense que le problèmes c'est que mon acquisition de données et mon calcul ça dure...12 sec et c'est ça qui doit pas trop plaire a GTK..
    je pensais qu'en mettant des delais plus court pour l’actualisation des valeurs ça marcherai ...mais non..

    avez vous de quoi éclairer ma lanterne ? ou alors répondre a cette question : threads obligatoire ou pas threads? ou encore mieux pour les valeurs ne s'actualise pas ?

    je vous remercie

    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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <gtk/gtk.h>
    #include <time.h>
    #include <alsa/asoundlib.h>
    #include <math.h>
    #include <stdbool.h> 
    #include "mailbox.h" 
    #include "gpu_fft.h"
    #define NUM_COMMANDS   7  // nombre de commande gnuplot ( tracé du spectre )
    ////////////////////////////////////////////Prototype///////////////////////////////////////////////////////////////////////////////////////////////
    void SpectreIMG(void); 
    int fft_compute_forward(float * input, int log2_N, float * output, double sampling_interval);
    /////////////////////////////////////////////Variables ///////////////////////////////////////////////////////////////////////////////////////////////
    snd_pcm_t *capture_handle;
    snd_pcm_hw_params_t *hw_params;
    snd_pcm_format_t format = SND_PCM_FORMAT_S16_LE; // format des variables de la carte son
     
    unsigned int rate = 44100;// frequence echantillonage
    int NLOG2 = 19;//taille de notre FFT ici 2^15 = 32768 point 
    int buffer_frames =524288; // nombre de frames ( nombre de mesure par periode )
    unsigned long N ;//nombre de point FFT
    double freqmin;// frequence min de la "zone" du spectre a analyser
    double freqmax;// frequence max de zone
    double  resolution ;
    double Rmin ;
    double Rmax ; 
    int raiMin ;
    int raiMax ;
    int i,j;
    int err;
    int16_t *buffer; // buffer integer 16bits
    float* float_buffer; // buffer de float
    double vitesse ;
    double Pmeca ;
    double rendement;
    double Pelec ;
    char* devcID;// Identifiant carte son /* paraetres de manipulation ALSA */
    float *OutData2; 
    float *OutData;//buffer de sortie FFT
    double multiplier  ;
    int Peaki;// determiner la valeur crete
    float PeakValue;//amplitude de la valeur crete
    float frequence ;
    bool init = false ;
     
    /////////////////////////////////////////////////////////////////////Fin Variables///////////////////////////////////////////////////////////////////////////////
     
    int fft_compute_forward(float * input, int log2_N, float * output, double sampling_interval)
    {
       int mb = mbox_open();
       int jobs = 1, i;
       unsigned long N = 1 << log2_N;
       float FloatN = (float)N;
       float HalfN = FloatN / 2.0;
       struct GPU_FFT_COMPLEX * base;
       struct GPU_FFT * fft;
       struct GPU_FFT_COMPLEX *DataIn, *DataOut;
       int ret = gpu_fft_prepare(mb, log2_N, GPU_FFT_FWD, jobs, &fft);
       base = fft->in;
     for (i = 0; i<N; i++)
    {
    base[i].re = input[i]; base[i].im = 0.0;
    }
       gpu_fft_execute(fft);
       base = fft->out;
    for (i = 0; i<N; i++)
    {
    output[i] = (base[i].re * base[i].re) + (base[i].im * base[i].im);
    }
    gpu_fft_release(fft);
    mbox_close(mb);
    }
     
     
    void Process1(char * devcID) {  //cette fonction prepare la carte son et alloue la memoire pour acceuillir les données de sortie de la FFT
     
     
     
     /**************************Ouverture du device en mode capture(enregistrement)******************/
    if ((err = snd_pcm_open(&capture_handle, devcID, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
    fprintf(stderr, "impossible d'ouvrir le device %s (%s)\n",devcID,snd_strerror(err));
    exit(1);
    } else {fprintf(stdout, "device ouvert avec succes\n");}
     /*************************Ajout de la structure parametres************************************/
    if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) {
    fprintf(stderr, "impossible d'ajouter les parametres (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "parametres ajouter\n"); }
    if ((err = snd_pcm_hw_params_any(capture_handle, hw_params)) < 0) {
    fprintf(stderr, "impossible d'initialiser les parametres (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "parametres initialise\n"); }
    /**********************************Configuration type d'acces *******************************************************/
    if ((err = snd_pcm_hw_params_set_access(capture_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
    fprintf(stderr, "impossible de conigurer le type d'acces (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "type dacces configure!\n"); }
    /********************************Format de donne********************************************************************/
    if ((err = snd_pcm_hw_params_set_format(capture_handle, hw_params, format)) < 0) {
     fprintf(stderr, "impossible de parametrer le format (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "format regle\n"); }
    /********************************************Réglage frequence echantillonage*****************************************************/
     if ((err = snd_pcm_hw_params_set_rate_near(capture_handle, hw_params, &rate, 0)) < 0) {
     fprintf(stderr, "impossible de regler la frequence d'echantillonage (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "frequence d'echantillonage réglee\n"); }
    /*************************************************Reglage nombre de chaines (Mono ou stereo)**********************************/
    if ((err = snd_pcm_hw_params_set_channels(capture_handle, hw_params, 1)) < 0) {
    printf(stderr, "impossible de regler le nombre de chaine (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "nombre de chaine regle\n"); }
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if ((err = snd_pcm_hw_params(capture_handle, hw_params)) < 0) {
    fprintf(stderr, "impossible d'appliquer les parametres (%s)\n",snd_strerror(err));
    exit(1);
    }   else { fprintf(stdout, "Applications des parametres\n"); }
    snd_pcm_hw_params_free(hw_params);// nettoyage de la strucure de prametres
    fprintf(stdout, "parametres efface\n"); /************************************************************Preparation de la carte son pour la 
    capture***************************************/
    if ((err = snd_pcm_prepare(capture_handle)) < 0) {
     fprintf(stderr, "impossible de preparer la carte pour enregistrement (%s)\n",snd_strerror(err));
     exit(1);}   else { fprintf(stdout, "pret a enregistrer \n"); }
     }
     
    gboolean Process2(gpointer data)
    {
     
    /*if ((err = snd_pcm_pause(capture_handle,0)) < 0) {
     fprintf(stderr, "impossible de resume la carte",snd_strerror(err));
     exit(1);}   else { fprintf(stdout,"carte resume done \n"); } */
     
     
    //lecture et stockage dans le buffer des données de la carte son
    if ((err = snd_pcm_readi(capture_handle, buffer, buffer_frames)) != buffer_frames) {
    fprintf(stderr, "erreur de lecture interface audio (%s)\n",err, snd_strerror(err));
    exit(1);
    }
     
     
     
     
    //cast des interger16 en float en vue d'une FFT prochaine
    for (i = 0; i < buffer_frames; i++){
    float_buffer[i] = (float)buffer[i];
    }
     
     
    //fenetre de hamming ----------->https://fr.wikipedia.org/wiki/Fen%C3%AAtrage
    for (i=0; i < buffer_frames; i++){
    multiplier = 0.54-0.46*cos(2*M_PI*i/(buffer_frames-1));
    float_buffer[i] = multiplier * float_buffer[i]; // les données sont multplier par un coefficient
    }
     
    printf("CALCUL FFT GPU \n ");
    fft_compute_forward(float_buffer, NLOG2, OutData, 1);
    usleep(100);
    for (i = 0 ; i < (N/2); i++){
    OutData2[(i)] = OutData[i] ;  // supression de -Fe/2
    }
    // trouver le pic dans la FFT
    Peaki=0;
    PeakValue=0;
    for(i= raiMin;i<= raiMax;i++)
    {
    if(OutData2[i] > PeakValue)
     {
    PeakValue= OutData2[i];
    Peaki = i;
    frequence =((float)Peaki*(((float)rate)/((double)N)));
    }
    }
    vitesse = frequence*60.0 ;
     
     printf("Localisation d'un Pic a la raie numero %d  Amplitude = %.0f\n\n", Peaki,PeakValue);
    printf("la fréquence identifie est : %6.4f   \n" ,frequence);
    printf("la vitesse est :  %f  \n" ,vitesse);
     
    return TRUE ;
     
     
    }
     
    void quit(void)
    {
     free(buffer);
     free(OutData);
    free(OutData2);
    fprintf(stdout, "memory nettoye\n");
    snd_pcm_close(capture_handle);
    fprintf(stdout, "fermeture interface audio............OK\n");
    gtk_main_quit();
     
     
    }
     
    gboolean update(gpointer data)
    {
        GtkWidget *label5 = data;
        // time_t result = time(NULL);
        gchar *str;
         str = g_strdup_printf ("%f",Pelec);
     
        gtk_label_set_text(GTK_LABEL(label5),str);
     
       return TRUE;
    } 
     
    gboolean update1(gpointer data)
    {
        GtkWidget *label6 = data;
      //   time_t result = time(NULL);
         gchar *str;
         str = g_strdup_printf ("%f",vitesse);
     
        gtk_label_set_text(GTK_LABEL(label6),str);
     
       return TRUE;
    }
     
    gboolean update2(gpointer data)
    {
        GtkWidget *label7 = data;
         //time_t result = time(NULL);
         gchar *str;
         str = g_strdup_printf ("%f",rendement);
     
        gtk_label_set_text(GTK_LABEL(label7),str);
     
       return TRUE;
    }
     
    gboolean update3(gpointer data)
    {
        GtkWidget *label8 = data;
    //     time_t result = time(NULL);
         gchar *str;
         str = g_strdup_printf ("%f",frequence);
     
        gtk_label_set_text(GTK_LABEL(label8),str);
     
       return TRUE;
    }
     
     
     
     
    int main (int argc, char *argv[]){
     
     devcID = malloc(sizeof(char) * 5); // allocation de mémoire de taille 5 char pour passer le device en argument au lancement du programme
    if (argc > 1){
    devcID = argv[1];  // on recupere le numero de carte son a utiliser dans l'argument 1
    freqmin  =  atof(argv[2]); // on recupere la frequence min de  limite zone
    freqmax  =  atof(argv[3]);// on recupere la frequence max de limite zone
     }
    else {
          devcID = "hw:0,0"; // si il n'ya aucun argument on prend l'interface par default
       }
     
    N = 1 << NLOG2;  // on calcul le nombre de point de la FFT
    resolution = (double)rate/(double)N ;// on calcul la resoltion de la FFT
     
    Rmin = freqmin/resolution ; // on calcul le numero de raie qui correspond a la frequence min
    Rmax = freqmax/resolution ;//on calcul le numero de raie qui correspond a la frequence max
    raiMin = (int)Rmin-1;// on cast  le numero de raie pour passer  entier puis on prend la valeur en dessous pour etre sur d'etre dans la fentre 
    raiMax = (int)Rmax+1;//  on cast  le numero de raie pour passer  entier puis on prend la valeur en dessous pour etre sur d'etre dans la fentre
    printf("%f \n",freqmin);//affichage de toute les variables ( debugage )
    printf("%f \n",freqmax);
    printf("%d \n", rate);
    printf("%d \n", N);
    printf("%f \n",resolution);
    printf("%f \n",Rmin);
    printf("%f \n",Rmax);
    printf("%d \n",raiMin);
    printf("%d \n",raiMax);
    fprintf(stdout, "raiMin : %d  raiMax : %d  resolution: %f  \n",raiMin,raiMax,resolution);
    Process1(devcID);// on prepare la carte son
     // allocation de suffisament de memoire pour enregistrement 128*16 /8 * 2
    buffer = malloc(buffer_frames * snd_pcm_format_width(format) / 8 * 2);
    float_buffer = malloc(buffer_frames*sizeof(float));
    fprintf(stdout, "memoire alouee!!\n");
    OutData = malloc(N * sizeof(float)); //allocation mémoire de notre buffer en fonction du nombre de point FFT
    OutData2  =malloc(N/2 * sizeof(float));
    //Process2(NULL);
    /* free(buffer); 
     free(OutData);
    free(OutData2);*/
    //fprintf(stdout, "memory nettoye\n");
    //snd_pcm_close(capture_handle);
    //fprintf(stdout, "fermeture interface audio............OK\n");
     
     
     
    int i ;
        GtkWidget *window;
        GtkWidget *zone;
        GtkWidget *label1;  //puissance electrique 
        GtkWidget *label2;  //puissance mecanique
        GtkWidget *label3;  //rendement 
        GtkWidget *label4; //frequence vibration:
        GtkWidget *label5; //Valeur puissance
        GtkWidget *label6; //Valeur Pmeca
        GtkWidget *label7; // rendement valuer
        GtkWidget *label8;  // frequence valeur
      gchar* TexteConverti = NULL;
    //   long time = (long)time(NULL); 
    // time_t result = time(NULL);
    //	gchar *str; 
     
    //	str = g_strdup_printf ("%d",result);
        gtk_init (&argc, &argv);
     
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        gtk_window_set_default_size (GTK_WINDOW (window), 640,480);
     
        zone = gtk_fixed_new ();
     
        /* On ajoute la zone comme conteneur dans la fenêtre */
        gtk_container_add (GTK_CONTAINER (window), zone);
     
     
       TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Puissance Electrique :</b></span>\n", -1, NULL, NULL, NULL);
        label1 = gtk_label_new (TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Puissance Mecanique :</b></span>\n", -1, NULL, NULL, NULL);
        label2 = gtk_label_new(TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Rendement:</b></span>\n", -1, NULL, NULL, NULL);
        label3 = gtk_label_new(TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Frequence vibration :</b></span>\n", -1, NULL, NULL, NULL);
        label4 = gtk_label_new(TexteConverti);
        label5 = gtk_label_new("valeur");
        label6 = gtk_label_new("valeurMeca");
        label7 = gtk_label_new("rendement");
        label8 = gtk_label_new("frequence");
     gtk_label_set_use_markup(GTK_LABEL(label1), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label2), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label3), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); // On dit que l'on utilise les balises pango
    // gtk_label_set_use_markup(GTK_LABEL(label5), TRUE); // On dit que l'on utilise les balises pango
        /* On ajoute le bouton dans la zone à la position 100;100 */
     
        gtk_fixed_put (GTK_FIXED (zone), label1,40,40);
        gtk_fixed_put (GTK_FIXED (zone), label2,40,100);
        gtk_fixed_put (GTK_FIXED (zone), label3,40,160);
        gtk_fixed_put (GTK_FIXED (zone), label4,40,220);
        gtk_fixed_put(GTK_FIXED (zone), label5,450,40);
        gtk_fixed_put(GTK_FIXED (zone), label6,450,100);
        gtk_fixed_put(GTK_FIXED (zone), label7,450,160);
        gtk_fixed_put(GTK_FIXED (zone), label8,450,220); 
       // gtk_label_set_text ((GtkLabel*)label5, str);
     
     
    //        g_free (str);
    // connection des signaux evenmentiel 
        g_signal_connect (G_OBJECT (window), "destroy",
                          G_CALLBACK (quit), NULL);
    g_timeout_add(10, update,label5);// update label 5 
    g_timeout_add(10, update1,label6);// update label 6 
    g_timeout_add(10, update2,label7);// update label 7 
    g_timeout_add(10, update3,label8);// update label 8
    g_timeout_add(1000, Process2,NULL);
    gtk_widget_show_all (window);
    gtk_main();
     
        return EXIT_SUCCESS;
    }
    PS : la fonction d'acquisition et de calcul c'est Process2() ;

  2. #2
    Membre chevronné
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2009
    Messages
    1 216
    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 216
    Points : 1 801
    Points
    1 801

    Par défaut

    Bonjour,

    bon, vu le temps d'exécution dont tu nous parles (12s), je ne vois pas trop comment se passer de threads. D'habitude on essaie de découper le traitement en plus petits morceaux, ça évite de créer des threads, mais là c'est vraiment trop long.
    Regarde dans les fonctions de la GLib, tu as GTask qui devrait t'aider à créer des threads facilement.

  3. #3
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    avril 2017
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 20
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : avril 2017
    Messages : 2
    Points : 1
    Points
    1

    Par défaut

    Bonjour et merci pour la réponse même si ce n'est pas du tout une bonne nouvelle...en effet étant étudiant en électronique j'ai programmé des robots , automates , microcontrôleur en C
    la structure était souvent simpliste :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    int main()
    {
    variables ;
    fonctions ;
    reglages de registres ;
    While(1)
    {
    faire tache 
    en boucle
    }
    du coup la ...je dois dire que ca m'a l'air de partir dans tous les sens on a l'impression que le mec qui a crée notepad sur windows a du galérer pendant des années...Oo
    enfin bref je suis pas du genre a laisser tomber et prêt a mettre les mains dans la crasse

    pour commencer je vais partir d'une base plus simple ici :
    ce code plus court affiche l'heure au format epoch dans un label , c'est d'ailleurs après avoir réaliser cette base que j'ai essayé d'intégrer mes gros calcul
    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
    #include <stdio.h>
    #include <stdlib.h>
    #include <gtk/gtk.h>
    #include <time.h>
     
    void update(GtkWidget *widget, gpointer data)
    {
    gchar *str;
    time_t  result = time(NULL);
    str = g_strdup_printf ("%d",result);
    GtkWidget * label5 = (GtkLabel *) data;
    gtk_label_set_text ((GtkLabel*)label5, str);
     
    //gtk_main_quit();
     
    }
     
     
    int main (int argc, char *argv[])
    {
    void update(GtkWidget *widget, gpointer data);
     
        GtkWidget *window;
        GtkWidget *zone;
     
        GtkWidget *label1;  //puissance electrique 
        GtkWidget *label2;  //puissance mecanique
        GtkWidget *label3;  //rendement 
        GtkWidget *label4; //frequence vibration:
        GtkWidget *label5; //Valeur puissance
     
      gchar* TexteConverti = NULL;
    //   long time = (long)time(NULL); 
    // time_t result = time(NULL);
    //	gchar *str; 
     
    //	str = g_strdup_printf ("%d",result);
        gtk_init (&argc, &argv);
     
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
     
        zone = gtk_fixed_new ();
     
        /* On ajoute la zone comme conteneur dans la fenêtre */
        gtk_container_add (GTK_CONTAINER (window), zone);
     
     
       TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Puissance Electrique :</b></span>\n", -1, NULL, NULL, NULL);
        label1 = gtk_label_new (TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Puissance Mecanique :</b></span>\n", -1, NULL, NULL, NULL);
        label2 = gtk_label_new(TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>Rendement:</b></span>\n", -1, NULL, NULL, NULL);
        label3 = gtk_label_new(TexteConverti);
        TexteConverti = g_locale_to_utf8("<span face=\"Verdana\" foreground=\"#73b5ff\" size=\"xx-large\"><b>frequence vibration :</b></span>\n", -1, NULL, NULL, NULL);
        label4 = gtk_label_new(TexteConverti);
        label5 = gtk_label_new("valeur");
     gtk_label_set_use_markup(GTK_LABEL(label1), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label2), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label3), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); // On dit que l'on utilise les balises pango
     gtk_label_set_use_markup(GTK_LABEL(label5), TRUE); // On dit que l'on utilise les balises pango
        /* On ajoute le bouton dans la zone à la position 100;100 */
     
        gtk_fixed_put (GTK_FIXED (zone), label1,40,40);
        gtk_fixed_put (GTK_FIXED (zone), label2,40,100);
        gtk_fixed_put (GTK_FIXED (zone), label3,40,160);
        gtk_fixed_put (GTK_FIXED (zone), label4,40,220);
        gtk_fixed_put(GTK_FIXED (zone), label5,550,40);
     
       // gtk_label_set_text ((GtkLabel*)label5, str);
     
     
    //        g_free (str);
    // connection des signaux evenmentiel 
        g_signal_connect (G_OBJECT (window), "destroy",
                          G_CALLBACK (gtk_main_quit), NULL);
    g_timeout_add(5000, /*(GSourceFunc)*/update,label5);// un timeout appele update toutes les  5 sec
        gtk_widget_show_all (window);
     
        gtk_main ();
     
        return EXIT_SUCCESS;
    }
    du coup en cherchant G_task sur google j'ai trouvé ceci :
    https://www.socallinuxexpo.org/scale...ristian_gs.pdf
    est ce que c'est une bonne base ?

    en suivant cette doc j'ai essayer
    d'intégrer pour commencer:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    #include <gtk/gtk.h>
    #include <glib*object.h>
    #include <glib.h>
    #include <gtask/gtask.h>
    j'ai essayer de compiler avec
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     gcc GTKFixed.c -o hellogtk4 `pkg-config --cflags --libs gtk+-3.0 --libs glib-2.0 --libs gobject-2.0   `
    ce qui retourne :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    GTKFixed.c:7:25: fatal error: gtask/gtask.h: No such file or directory
     #include <gtask/gtask.h>
    et

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    GTKFixed.c:5:26: fatal error: glib*object.h: No such file or directory
     #include <glib*object.h>
    rien d’étonnant je pense vu que ma commande de compilation ne doit pas cibler les librairies ...
    du coup ces librairies elles sont ou ?

    PS :
    la commande :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     sudo apt-get install  libglib2.0-dev
    retourne :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    libglib2.0-dev is already the newest version.
    libglib2.0-dev set to manually installed.
    donc de ce coté la c'est bon ...
    merci pour votre temps

  4. #4
    Membre chevronné
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2009
    Messages
    1 216
    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 216
    Points : 1 801
    Points
    1 801

    Par défaut

    Citation Envoyé par pjbox Voir le message
    du coup en cherchant G_task sur google j'ai trouvé ceci :
    https://www.socallinuxexpo.org/scale...ristian_gs.pdf
    est ce que c'est une bonne base ?
    Euh... Ou alors tu remarques que GTask est écrit dans mon post en bleu et souligné, ce qui oh magie, signifie que c'est un lien, que j'ai fait pointer vers la page de GTask dans la documentation officielle.
    Ta présentation date de 2009, on est en 2017. GTask a depuis été intégré à la GLib, donc au lieu de chercher sur google, commence par chercher directement dans la documentation officielle (il y a un champ "search" en haut à droite de chaque page).

    Autres remarques:
    1. Apprends à indenter ton code. De nombreux éditeurs ont des fonctionnalités d'indentation automatique. Utilise les. Quand on écrit du code, on entraîne son oeil à repérer les erreurs, et repérer ça dans le bazar, c'est difficile.
    2. Apprends à "lire" le code, et les message d'erreurs. Pas juste survoler, pas juste passer les yeux dessus. Pour toi, "glib*object.h", c'est peut être pareil que "glib-object.h", mais pas pour le compilateur. Il te le dit, d'ailleurs, alors écoute le. Quand le compilateur te renvoie des messages d'erreurs, c'est pour t'aider, donc lis les.
    3. J'ai écrit GTask et tu as écrit G_task. Tu as donc fait une erreur de majuscule et écrit un underscore de trop. Tous les langages de programmation considéreront que c'est une erreur, donc tu dois t'appliquer.


    En gros, programmer, c'est pas dur, tu en es capable autant que tout le monde, mais il faut que tu apprenne à être très sctrict dans ce que tu écris et que tu vérifies que c'est vraiment de cette manière que tu dois l'écrire. Courage, tu en es capable

  5. #5
    Membre chevronné
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2009
    Messages
    1 216
    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 216
    Points : 1 801
    Points
    1 801

    Par défaut

    J'en rajoute un couche: utilise les bonnes options de compilation ! Tu n'as pas activé les warnings, donc le compilateur laisse passer des problèmes.
    Utilise l'option -Wall de gcc (W = warnings, "all" = tous)

    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
    (meson)g179531:gtk3-test$ ninja -C build
    ninja: Entering directory `build'
    [1/2] Compiling c object 'gtk3-test@exe/main.c.o'
    ../main.c: In function ‘update’:
    ../main.c:10:5: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘time_t[-Wformat=]
         str = g_strdup_printf ("%d",result);
         ^
    ../main.c:11:26: warning: initialization from incompatible pointer type [enabled by default]
         GtkWidget * label5 = (GtkLabel *) data;
                              ^
    ../main.c: In function ‘main’:
    ../main.c:78:5: warning: passing argument 2 of ‘g_timeout_add’ from incompatible pointer type [enabled by default]
         g_timeout_add(5000, /*(GSourceFunc)*/update,label5);// un timeout appele update toutes les  5 sec
         ^
    In file included from /usr/include/glib-2.0/glib/giochannel.h:33:0,
                     from /usr/include/glib-2.0/glib.h:54,
                     from /usr/include/gtk-3.0/gdk/gdkconfig.h:13,
                     from /usr/include/gtk-3.0/gdk/gdk.h:30,
                     from /usr/include/gtk-3.0/gtk/gtk.h:30,
                     from ../main.c:3:
    /usr/include/glib-2.0/glib/gmain.h:558:7: note: expected ‘GSourceFunc’ but argument is of type ‘void (*)(struct GtkWidget *, void *)’
     guint    g_timeout_add              (guint           interval,
           ^

Discussions similaires

  1. pyinotify et gtk ( ou autre "gui" )
    Par bul dans le forum PyGTK
    Réponses: 0
    Dernier message: 05/08/2015, 16h07
  2. Réponses: 8
    Dernier message: 02/04/2015, 14h51
  3. PHP-mysql -> vers appli GTK ou autre
    Par mao-40 dans le forum Linux
    Réponses: 2
    Dernier message: 06/12/2008, 14h11
  4. Réponses: 0
    Dernier message: 13/12/2007, 18h08
  5. Icone, barre de taches, autre idée ?
    Par miron dans le forum Windows
    Réponses: 10
    Dernier message: 28/12/2006, 16h08

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