Newsgroup: it.comp.os.linux.development
Titolo: problema glade+gtk

Ciao a tutti,
Sto provando a realizzare un semplicissimo programmino utilizzando gtk
e glade e ho incontrato un piccolo problema:
dopo aver realizzato l'interfaccia grafica con glade ho aperto il
file callbacks.c per programmare le azioni di risposta alla pressione
di tasti ecc....
Il problema è che all'interno delle ruotine di callback non posso fare
in alcun modo riferimento agli oggetti creati graficamente!!!
Certamente la soluzione sarà semplicissima, è che sono completamente a 
digiuno di programmazione grafica in linux.
Come posso fare ad esempio in modo che premendo un tasto venga
modificato il testo di un'etichetta presente nello stesso oppure in
un altro form??
Grazie mille.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 un altro form??
se guardi il file support.h troverai una funzione che si chiama
lookup_widget, che vuole come parametri un puntatore alla finestra padre
che contiene l'oggetto che vuoi beccare e il nome dell'oggetto desiderato
e che ritorna un puntatore a quello che cerchi.
Adesso domanderai: e come becco un puntatore alla finestra padre?
Semprelice, ci sono 2 soluzioni
1) nel file main mtti il puntatore alla finestra globale e poi la becchi
nelle callback dichiarandola come extern
2) usi libglade che mette a disposizione una funzione per avere il
punattore alle finestre. Siccome però non lo uso non mi ricordo quale sia
la funzione da chiamare.....

 in alcun modo riferimento agli oggetti creati graficamente!!!
Perché non potresti?
Usa la funzione get_widget, e dai un id univoco ai widget che ti
interessano quando li crei.
Piccolo hint: i callback hanno, quasi sempre, la forma:
	void callback (GtkWidget *widget, gpointer user_data);
Dove widget è il widget che ha generato il segnale a cui è agganciato il
callback. Se hai bisogno di accedere a widget differenti, hai due
opzioni: o lki rendi globalmente accessibili, oppure li riunisci (quelli
logicamente affini) in una struct, che poi passi come argomento in
user_data.
Ciao,
 Emmanuele.
-- 
Emmanuele Bassi (Zefram)           [ 
http://digilander.libero.it/ebassi/
 ]
GnuPG Key fingerprint = 4DD0 C90D 4070 F071 5738  08BD 8ECC DB8F A432 0FF4

 interessano quando li crei.
La funzione è lookup_widget, sorry.


 user_data
Proverò anche questa allora!! Tu come ti trovi + comodo? Cosa fai di 
solito?
Scusatemi per le domande forse fin troppo banali ma questa è la mia
attuale preparazione in materia!!!
Nel frattempo grazie mille


 attuale preparazione in materia!!!
Un consiglio:
 
http://developer.gnome.org
Ci sono vari documenti.


 recuperare i widget.
Piccola aggiunta.
lookup_widget(widget, "id_del_widget_da_trovare") la puoi chiamare con 
qualunque widget della finestra che ti interessa come primo parametro, 
all'interno della funzione infatti c'e' un algoritmo di risalita che 
trova l'oggetto Window in modo automatico. Quindi non c'e' bisogno di 
usare un antiestetico puntatore globale alla window, ma e' possibile 
chiamarla dando come primo parametro il widget passato alla callback.
Il puntatore globale tra l'altro darebbe diversi problemi nel caso in 
cui l'applicazione preveda piu' di una instanza della stessa finestra.
Bye,
  Gabry

 con Glade?
direi che support.h è eloquente:
/*
 * This function returns a widget in a component created by Glade.
 * Call it with the toplevel widget in the component (i.e. a window/dialog),
 * or alternatively any widget in the component, and the name of the widget
 * you want returned.
 */
GtkWidget*  lookup_widget              (GtkWidget       *widget,
                                        const gchar     *widget_name);
 

 cui l'applicazione preveda piu' di una instanza della stessa finestra.
Ok ho provato e funziona alla perfezione, grazie mille!!!
Per lavorare invece direttamente sui form, come ad esempio per aprire
una nuova finestra, devo invece utilizzare la funzione create_form()
che viene creata automaticamente giusto?? Con i form lookup_widget non
funziona vero??
Alessio


Approfitto volentieri della vs disponibilitŕ (grazie intanto):
sto provando a realizzare un semplice programmino che si collega ad
un circuito esterno per mezzo della seriale.
Per aprire la connessione devo semplicemente aprire il file "/dev/ttys1"
ma una volta fatto vorrei che fosse possibile che tutte le funzioni
di callback attivate dai vari pulsanti (che ovviamente agiscono sulla
connessione inviando byte) lavorassero sullo stesso canale.
Il tutto dovrebbe essere semplicemente risolto passando alle varie 
funzioni il descrittore fornito dalla fopen ma... come si fa??
COn un normale programma c saprei come fare, ma qui, dal momento che
non posso toccare il file interface.c mi trovo un attimino bloccato
perchč non posso modificare le intestazioni delle funzioni di callback.
Ho pensato di passare la variabile attraverso la funzione di callback
sfruttando il famigerato user_data... ma non ho capito esattamente cosa
devo inserire nel relativo textbox di glade... il nome della variabile?
Alessio.


attuale preparazione in materia!!!
De nada ...
Tieni presente che non è cmq semplicissima la programmazione in Gtk.
Ciao
F.

 funziona vero??
Si, puoi usare lookup_widget. Tipicamente il tuo form suppongo si 
aprira' premendo su un pulsante e quindi si chiudera (mandando i dati da 
qualche parte) premendo un pulsante di conferma. Ti conviene attaccare 
una callback alla pressione del pulsante di conferma e dentro quella 
callback effettuare le lookup_widget ai vari elementi del form per 
prenderne i valori.
Se specifichi il form come "modale" inoltre inibisci automaticamente la 
pressione dei tasti delle altre finestre della tua applicazione finche' 
non chiudi il form stesso.
Bye,
  Gabry

devo inserire nel relativo textbox di glade... il nome della variabile?
Nein!
Guarda nel tutorial gtk:
Per Gtk 1.2
http://www.via.ecp.fr/~jm/ref/gtk_tut/gtk_tut-17.html
Per Gtk 2 . X
http://www.gtk.org/tutorial/sec-monitoringio.html
Buon divertimento.
F.

 gdk_input_add ()
Se usi le GTK2.x (ed è *vivamente* consigliato) è una funzione
deprecata. Ci sono i GIOChannel, molto più potenti e flessibili.


 deprecata. Ci sono i GIOChannel, molto più potenti e flessibili.
Io userei un puntatore FILE* globale. Fa tanto schifo come soluzione?

> Io userei un puntatore FILE* globale. Fa tanto schifo come soluzione?
Io ho anche provato a dichiarare il puntatore come globale nel file
main.c ma non riesco a vederlo dal file callbacks.c e poi sono sempre
stato abituato ad utilizzare meno variabili globali possibili!!
Sto provando a mettere in pratica i metodi che mi avete consigliato,
nel frattempo vi pongo un'altra domanda: questa cosa che mi avete detto
vale per i descrittori (fopen, socket) ma per le comuni variabili come
faccio??


 stato abituato ad utilizzare meno variabili globali possibili!!
Ma mi sa che forse questa volta farò un'eccezione. Dopotutto mi è
venuto in mente che tutta "la vita" del programma si svolgerà in pratica
nel file callback.c e non nel main che serve alla fin fine solo a 
metterlo in esecuzione, quindi che mi importa di main.c, creo tutte le
variabili come globali in callbacks.c e sono a posto...
I miei problemi derivano dal fatto che provengo dalla programmazione
c pura senza ne oggetti ne finestre dove tutto o quasi avviene nel main
dove stanno quindi tutte le variabili che vengono 
passate alla varie funzioni attraverso l'intestazione delle 
stesse... certe che se lo sapesse il docente di info1 che uso tutte
ste variabili globali...


 Io userei un puntatore FILE* globale. Fa tanto schifo come soluzione?
[ Dalla documentazione delle GLib 2.2.1 ]
| The GIOChannel data type aims to provide a portable method for using
| file descriptors, pipes, and sockets, and integrating them into the main
| event loop. Currently full support is available on UNIX platforms,
| support for Windows is only partially complete.
gdk_input_add() serviva, nelle GTK1.2, per monitorare uno stream dati.
Con le GLib 2.x, sono stati introdotti i GIOChannel, per astrarre le
funzioni di read/write/poll di stream di dati (file, named pipe,
socket), ergo la gdk_input_add() (che attaccatava ad una condizione un
callback) è stata deprecata in favore di g_io_add_watch(), che usa i
GIOChannel.
+++
[1] Roba in read, roba in write, o entrambe le situazioni.


 stato abituato ad utilizzare meno variabili globali possibili!!
beh, tipo in main.c dichiari
FILE *file;
e nelle callbacks devi dichiarare
extern FILE *file;

 GIOChannel.
Il problema delle GTK 2.x e' che intanto non sono di serie sulle 
distribuzioni piu' usate (per esempio la woody 3.x) o lo sono con 
versioni vecchie e buggate (per esempio nella redhat 8)...
Inoltre non danno i vantaggi che promettono. Ho provato a usare i 
GtkTreeModel e GtkTreeStore delle 2.x per vedere se nel mio albero con 
5000 nodi ad uno stesso livello miglioravano le prestazioni, ma invece 
di migliorare... peggioravano.
Meglio un'API "deprecated", ma stabile e ormai standard di fatto che non 
un'API nuova e piu' potente che pero' e' ancora molto instabile, a 
tratti meno performante e SOPRATTUTTO meno documentata.
Con google trovi in un batter d'occhio esempi per qualunque tipo di 
widget di GTK 1.x, e se non lo trovi basta che ti guardi i sorgenti di 
un'applicazione che lo usa intensamente e bene(per me ad esempio sono 
stati molto istruttivi sylpeed e lopster).
Bye,
  Gabry

 di migliorare... peggioravano.
mamma mamma, le view sono fonte di bestemmie.
siete mai riusciti a fare una lista in cui inn una riga c'è un
checkbuttoin che può essere clickato dall'utente?

 checkbuttoin che può essere clickato dall'utente?
In una riga o in tutte le righe?
Se e` la seconda, si`, l'ho fatto. In python, pero`. :)
Bye.

 main.c ma non riesco a vederlo dal file callbacks.c e poi sono sempre
basta dichiararlo come esterno nel file callbacks.c, cosi' sa che e'
stato dichiarato come globale in un altro modulo.
-- 
There are only 10 kinds of people in the world --
Those who understand binary, and those who don't.

 stati molto istruttivi sylpeed e lopster).
Lo stesso dicasi per le applicazioni in GTK2.


 checkbuttoin che può essere clickato dall'utente?
Si, che c'è di strano?
Fatto in C e fatto in Python senza problemi.
+++
Aspetta stai parlando di una *riga* o di una *colonna*?
Nel primo caso, è un filino più dura, ma non difficile (hint:
gtk_tree_column_set_cell_data_func, ad esempio)


 Lo stesso dicasi per le applicazioni in GTK2.
Mi dai dei pointers ad applicazioni GTK2 didatticamente utili? In 
particolare mi interesserebbero applicazioni che abbiano esempi di 
Gtk(List/Tree)(View/Model) in congiunzione con un custom GtkDataStore.
Altra domanda:
La versione 2.x di Gtk x Win32 e' sufficientemente stabile?
Bye,
  Gabry

deprecata. Ci sono i GIOChannel, molto piů potenti e flessibili.
Lo so che č deprecata, ma per 2.x, non per 1.2.
Infatti ho dato 2 differenti link, non uno solo.
E poi non ha detto con quale versione sta lavorando, no?
Ciao
F.

 Se e` la seconda, si`, l'ho fatto. In python, pero`. :)
azz.. a me serve in C :-(

 Aspetta stai parlando di una *riga* o di una *colonna*?
Voglio una roba del tipo:
  nome  | usare
 -------+-------
  pippo |  v
  pluto |
e così via, dve la colonna usare sono dei checkbox.

 e così via, dve la colonna usare sono dei checkbox.
 
Ah, allora è facile:
#v+
/* l'enumeratore per le colonne del TreeStore... */
enum { COLUMN_NOME, COLUMN_USARE };
[...]
GtkWidget *tree_view;
GtkTreeViewColumn *column_0, *column_1;
GtkCellRenderer *label_r, *check_r;
/* Iniziamo con i renderer. */
label_r = gtk_cell_renderer_text_new();
check_r = gtk_cell_renderer_toggle_new();
/* [...] attacchi i segnali ai due renderer [...] */
g_signal_connect(G_OBJECT(check_r), "toggled",
	G_CALLBACK(on_check_toggled), NULL);
/* Creiamo le colonne e agganciamoci il relativo cell renderer. */
column_0 = gtk_tree_view_column_new_with_attributes("nome",
	label_r,
	text, COLUMN_NOME,
	NULL);
column_1 = gtk_tree_view_column_new_with_attributes("usare",
	check_r,
	text, COLUMN_USARE,
	NULL);
/* Attacca le colonne al tree view. */
tree_view = gtk_tree_view_new();
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_0, COLUMN_NOME);
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_1, COLUMN_USARE);
#v-
Ho lasciato fuori i callback e la creazione del modello, ma sono
abbastanza elementari.
I cell renderer di default sono tre (text, toggle e pixbuf), ma possono
essere subclassati facilmente. Ne puoi mettere anche più d'uno in una
colonna.


 Grazie mille.
Grazie anche da parte mia
Qualche link a progetti sviluppati con GLADE (GLADE-2) ? ... cosi' che li
possa studiare (qualcosa di semplice per cominciare..e qualcosa di meno
semplice per continuare)...
Xoen  <xoe...@SPAMlibero.it>
ICQ# 168302888

 all'uscita della successiva "stable"...
No problem. Vi scaricate i tre file del sorgente del pacchetto debian
gtk+2.0 e lo ricompilate su un sistema col gcc3. La dipendenza dalle varie
libc e libstdc++ viene creata dinamicamente al momento dell' impacchettamento
finale.
E' molto probabile che su qualche sito non ufficiale possiate trovare tutto
già fatto per woody.

 La versione 2.x di Gtk x Win32 e' sufficientemente stabile?
Mi risulta di si. L'ultima volta che ho controllato (febbraio/marzo) era
stato fatto il portin della release 2.0.9; non so se adesso siano
passati alla 2.2.x.


semplice per continuare)...
Sul sito di Glade, ovviamente.
F.