Problème de GtkTable

**gerald3d** · 09/05/2014, 14h27

Tu peux transmettre à la fonction qui sera appelée tous les n intervalles ton tableau par exemple comme ceci : gtk_timeout_add( 1000,(GtkFunction) foo, tab_jeu);.

foo est la fonction qui sera appelée à intervalle régulier. Elle est du type :

Code :

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

gboolean (*GSourceFunc) (gpointer user_data);

Tu pourras donc écrire ceci :

Code :

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

1
2
3
4
5
gboolean foo (int tab_jeu[NB_LIGNES][NB_COLONNES])
{

  return TRUE; // Tant que cette fonction retourne TRUE elle est éxécutée.
}

**Pouetcacahuete** · 09/05/2014, 14h54

J'ai écrit ceci au dessus de mon main:

Code :

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

1
2
3
4
gboolean foo (int tab_jeu[NB_LIGNES][NB_COLONNES])
{
  return TRUE; 
}

Et ceci dans mon main:

Code :

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

gtk_timeout_add( 1000,(GtkFunction) foo, tab_jeu);

Mais je n'indique à aucun moment que je veux que ça soit la fonction faire_descendre_piece qui s'active.. Je dois mettre ça dans cette fonction : gboolean foo (int tab_jeu[NB_LIGNES][NB_COLONNES]) ?

**gerald3d** · 09/05/2014, 15h10

Renomme foo en faire_descendre_piece

**Pouetcacahuete** · 09/05/2014, 15h33

Mais j'ai déjà une fonction qui s'appelle faire_descendre_piece dans mon projet, celle qui modifie mon tab_jeu...

**gerald3d** · 09/05/2014, 15h46

Alors oui tu peux l'appeler depuis foo();.

**Pouetcacahuete** · 09/05/2014, 15h57

Du coup, dans

Code :

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

gboolean foo()

, j'ai une petite question.

Je peux mettre dans la boucle plusieurs "opérations" que je veux réaliser toutes les X ms?

Edit: Une autre question; je peux y passer d'autres paramètres que int tab_jeu?

**gerald3d** · 09/05/2014, 16h03

Tu peux faire ce que tu veux dans la fonction foo();. C'est une fonction comme toutes les autres homis qu'elle est appelée depuis la boucle principale de Gtk+ à intervalle régulier. Pour y passer plusieurs informations tu n'a pas d'autres choix que d'utiliser une structure qui va englober toutes les informations à transmettre.

**Pouetcacahuete** · 09/05/2014, 16h35

Je ne m'en sors pas..
Voici la définition de ma structure que j'ai créé en suivant ton conseil

Code :

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

1
2
3
4
5
6
7
8
typedef struct
{
    GtkWidget *laTable;
    GtkWidget *leConteneur;
    UnePiece laPiece;
    int leTableau;
 
}Timer ;

Voici la fonction foo avant mon main :

Code :

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

1
2
3
4
5
6
7
8
9
10
gboolean foo(Timer Toutes_les_secondes)
{
    Toutes_les_secondes.laPiece=faire_descendre_piece(Toutes_les_secondes.laTable,
                        Toutes_les_secondes.leTableau, Toutes_les_secondes.laPiece);
    gtk_widget_destroy(Toutes_les_secondes.laTable);
    Toutes_les_secondes.laTable = gtk_table_new(NB_LIGNES, NB_COLONNES, TRUE);
    gtk_container_add(Toutes_les_secondes.leConteneur, Toutes_les_secondes.laTable);
    rafraichir (Toutes_les_secondes.laTable, Toutes_les_secondes.leTableau); // C'est la fonction qui prend en compte mon tableau et qui selon les chiffres affiche des carrés de telle ou telle couleur
    return TRUE;
}

Voici la création d'une variable type Timer dans mon main ()

Code :

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

1
2
3
4
5
    Timer Toutes_les_secondes;
    Toutes_les_secondes.laTable=table;
    Toutes_les_secondes.laPiece=piece;
    Toutes_les_secondes.leTableau=tab_jeu;
    Toutes_les_secondes.leConteneur=conteneur;

Et voici la fonction pour le timer, à la suite:

Code :

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

    gtk_timeout_add( 1000,(GtkFunction) foo, &Toutes_les_secondes);

Pas d'erreurs, mais le programme cesse de fonctionner.

**gerald3d** · 09/05/2014, 16h52

La variable leTableau dans la structure ne me semble pas du bon type. Tu la déclares en int alors que c'est un tableau. L'erreur vient peut être de là...

**Pouetcacahuete** · 09/05/2014, 17h21

J'ai changé pas mal de trucs (j'ai par exemple intégrer le rafraichissement directement dans la faire_descendre_piece) bref du coup je n'ai plus besoin de structure.

Est-ce qu'avec ça, je devrai voir ma pièce descendre?

Avant le main :

Code :

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

1
2
3
4
5
gboolean foo(int tab_jeu[NB_LIGNES][NB_COLONNES])
{
    faire_descendre_piece;
    return TRUE; 
}

Dans le main :

Code :

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

    gboolean foo(int tab_jeu[NB_LIGNES][NB_COLONNES]);

**gerald3d** · 09/05/2014, 17h27

Code :

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

1
2
3
4
5
gboolean foo(int tab_jeu[NB_LIGNES][NB_COLONNES])
{
    faire_descendre_piece; C'est quoi exactement ?
    return TRUE; 
}

**Pouetcacahuete** · 09/05/2014, 17h31

Voilà :

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
UnePiece faire_descendre_piece(GtkWidget *table, int tab_jeu[NB_LIGNES][NB_COLONNES], UnePiece piece) 
{
int i=0,j=0,cacahuete=0;
int tab_tmp1[NB_LIGNES][NB_COLONNES];
int tab_tmp2[NB_LIGNES][NB_COLONNES];
memcpy(tab_tmp1,tab_jeu,(NB_LIGNES*NB_COLONNES)*sizeof(int));
//tab_tmp1=tab_jeu;
memcpy(tab_tmp2,nettoyer_piece_precedente(table, tab_tmp1, piece),(NB_LIGNES*NB_COLONNES)*sizeof(int));
/*tab_tmp2=nettoyer_piece_precedente(tab_tmp1, piece*/
memcpy(tab_tmp1,tab_tmp2,(NB_LIGNES*NB_COLONNES)*sizeof(int));
 
    for(i=0;i<4;i++)
{
    for(j=0;j<4;j++)
    {
        if ((piece.tab[i][j]!=0)&&(tab_tmp1[i+piece.pos_ligne+1][j+piece.pos_colonne]!=0))
        {
            cacahuete++;
        }
 
 }
}
 
 
if (cacahuete!=0)
{
 
piece.pos_ligne_avant=piece.pos_ligne;
piece.pos_colonne_avant=piece.pos_colonne;
 
}
 
else
{
    memcpy(tab_jeu,tab_tmp2,(NB_LIGNES*NB_COLONNES)*sizeof(int));
    for(i=0;i<4;i++)
{
    for(j=0;j<4;j++)
    {
        if (piece.tab[i][j]!=0)
        {
                        tab_jeu[i+1+piece.pos_ligne][j+piece.pos_colonne]=piece.tab[i][j];
        }
 
    }
 
}
piece.pos_ligne_avant=piece.pos_ligne;
piece.pos_colonne_avant=piece.pos_colonne;
piece.pos_ligne++;
}
rafraichir(table,tab_jeu[NB_LIGNES][NB_COLONNES]);
return piece;
}

**gerald3d** · 09/05/2014, 18h08

Sans trop regarder de prés ton code je trouve un peu lourd tes copies de tableau. Ne peux-tu pas simplement mémoriser quelle pièce a bougé pour ne changer que sa position dans le tableau ?

**Pouetcacahuete** · 09/05/2014, 18h12

Je n'ai pas essayé. Mais je sais que ça marche ^^'.
ça changerait quoi si je mémorisai simplement la pièce?

**gerald3d** · 09/05/2014, 18h15

Gain de temps et de mémoire. Ca évite aussi les fuites.

Par exemple dans ton code il me semble qu'à aucun moment tu libères les tableaux temporaires que tu alloues pourtant dans le tas.

**Pouetcacahuete** · 09/05/2014, 18h21

En effet tu as raison. Je note ton conseil, et je regarderai ça si j'ai du temps plus tard, l'histoire du timer me semble plus importante, la deadline pour rendre le projet approche.

**Pouetcacahuete** · 09/05/2014, 19h05

Est-ce que je pourrai passer par un Sleep?

J'ai essayé ceci dans mon main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
long sec=4;	 
 
while (sec > 0)	 
{
gtk_widget_destroy(table);
table = gtk_table_new(NB_LIGNES, NB_COLONNES, TRUE);
gtk_container_add(conteneur, table);
piece=faire_descendre_piece(table,tab_jeu,piece);
rafraichir (table, tab_jeu);
gtk_widget_show_all(window);
sec--;	
Sleep(1000);	 // 1 000 ms
}

Ma pièce descend effectivement de 4 crans, mais le souci c'est que pendant 4 secondes (soit la valeur de sec), ma fenêtre est toute blanche, et je n'observe donc que le résultat final au bout de 4 secondes. Pourquoi?

**gerald3d** · 09/05/2014, 19h23

L'apprentissage par la découverte c'est formateur

En effet si tu places une boucle d'attente la boucle principale Gtk+ est elle aussi en attente. De ce fait l'interface n'est plus réactive. Ce n'est donc pas la bonne solution.

Insérer ses propres fonctions dans la boucle de Gtk+ est la bonne méthode. N'en change pas.

**Pouetcacahuete** · 09/05/2014, 19h34

Envoyé par gerald3d

En effet si tu places une boucle d'attente la boucle principale Gtk+ est elle aussi en attente. De ce fait l'interface n'est plus réactive. Ce n'est donc pas la bonne solution.

Insérer ses propres fonctions dans la boucle de Gtk+ est la bonne méthode. N'en change pas.

Cela veut dire que je ne peux pas utiliser la fonction sleep?
Y'a pas une fonction qui permettrait "d'endormir" ma boucle mais qui m'afficherai quand même mon interface?

**gerald3d** · 09/05/2014, 20h41

g_timeout_add(); et ses dérivées répond parfaitement à tes besoins : exécuter à intervalle régulier une ou plusieurs fonctions tout en laissant l'application active.

Problème de GtkTable

GTK+

Discussions similaires

Partager

Partager