[GTK+] Problema con immagini caricate in sequenza [RISOLTO]

[scorpion77]

Ciao a tutti,
ho un problema con un programma GTK+ che sto scrivendo. Ho pensato di mettere una barra di progresso che ogni tot secondi aumenta un po'. Quindi ho usato dieci immagini .png (progress1.png, progress2.png, ecc.) che indicano lo stato di progresso. Il problema è che se creo una finestra con la prima immagine, se metto una funzione che blocca l'esecuzione del programma di 5 secondi, il programma disegna la finestra dopo 5 secondi. Non so se ho reso bene l'idea.
Esempio:

nella finestra appare progress1.png

XX

dopo 5 secondi diventa così (progress2.png)

XXXX

dopo altri 5 secondi (progress3.png)

XXXXXX

e così via. Ad ogni passaggio, l'immagine con la barra di progresso viene sovrascritta da un'altra. Almeno dovrebbe fare così, invece disegna solo l'ultima, la progress10.png, facendomi aspettare 45 secondi (9 sleep da 5 secondi ciascuno).

Questa è la porzione di codice che posiziona le immagini con la barra di progressione:


fix = gtk_fixed_new ();
image = gtk_image_new_from_file("progress1.png");
gtk_fixed_put (fix, image, 230, 340);
gtk_container_add (GTK_CONTAINER (win), fix);
gtk_widget_show_all (win);

system( "sleep 5s" );

gtk_container_remove (GTK_CONTAINER (win), fix);
fix = gtk_fixed_new ();
image = gtk_image_new_from_file("progress2.png");
gtk_fixed_put (fix, image, 230, 340);
gtk_container_add (GTK_CONTAINER (win), fix);
gtk_widget_show_all (win);

system( "sleep 5s" );

gtk_container_remove (GTK_CONTAINER (win), fix);
fix = gtk_fixed_new ();
image = gtk_image_new_from_file("progress3.png");
gtk_fixed_put (fix, image, 230, 340);
gtk_container_add (GTK_CONTAINER (win), fix);
gtk_widget_show_all (win);


Prima posiziono l'immagine d'inizio progresso, poi cancello il container e metto l'immagine di progresso n. 2 e via di seguito fino all'immagine 10.
Se voglio che tra un'immagine e l'altra voglio che passino 5 secondi, ho pensato di usare il comando bash "sleep 5s". La stessa cosa avviene se piazzo un ciclo for che duri qualche secondo. Ma con questo non viene visualizzata subito la finestra. Viene visualizzata dopo 5 secondi, facendo apparire progress2.png, saltando progress1.png. Quindi non posso fare la scaletta progress1.png - 5 secondi - progress2.png - 5 secondi - progress3.png, ecc.
E' possibile riuscire a disegnare la finestra, fare attendere del tempo con la finestra e gli oggetti contenuti disegnati, prima di rifare il container con nuovi oggetti dentro?

Grazie in anticipo dell'aiuto.

Scorpion77

[HdS619]

Ciao, lo sleep blocca tutto il programma, mentre te devi solo fermare la progress bar .. l'unica è passare il controllo del timeout dello sleep in background tramite fork e poi comunicare tramite pipe col programma principale che si occuperà di caricare le altre immagini

[scorpion77]

Ciao, lo sleep blocca tutto il programma, mentre te devi solo fermare la progress bar .. l'unica è passare il controllo del timeout dello sleep in background tramite fork e poi comunicare tramite pipe col programma principale che si occuperà di caricare le altre immagini

Grazie della dritta, solo che non ho mai usato il comando fork(), quindi mi risulterebbe un po' difficile.
Comunque ho risolto in un altro modo, usando la funzione g_timeout_add() di GTK+, questa è la parte di codice dove si ripete la funzione ogni 1000 millisecondi.


g_timeout_add(1000, (GSourceFunc) time_handler, (gpointer) win);
gtk_widget_show_all(win);
time_handler(win);


Comunque l'idea del fork mi interessa, se possibile potresti postare un'esempio pratico?

Grazie,

Scorpion77

[carocco]

Ciao! Hai provato anche a usare il widget gtk_progress_bar? (A meno che tu non abbia particolari necessita' personali che non sono coperte da questo)

Per quanto riguarda il fork, l'uso del comando e' molto semplice:

Codice: Seleziona tutto

#include <sys/types.h>
#include <unistd.h>

int main(int argc, char **argv)
{
        int pid;
        /* e altre variabili */

        pid = fork();

        if(pid == -1)
        {
                 perror("fork");
                 exit(-1);
        }

        if(pid == 0)
        {
               /* codice eseguito dal processo figlio */
        }
        else
        {
              /* codice eseguito dal padre */
        }

        return 0;
}


Il padre e figlio sono due processi che girano in parallelo.