# Întrebări frecvente Glade

2000 Damon Chaplin
Proiectul de documentare GNOME &legal;

Comentarii

Pentru a semnala o eroare în această aplicaţie sau provitor la această documentaţie va rugăm să accesaţi Pagina de conentarii GNOME.

Damon Chaplin
Ximian, Inc.
1.1
&date;

Cristi Călin kman@csc.ro

Proiectul de documentare GNOME

Acestea sunt cele mai frecvente întrebări referitoare la Glade. Ele au fost revizuite pe &date;.

## Întrebări frecvente Glade

Aceasta este lista cu cele mai frecvente întrebări referitoare la Glade designer de interfeţe GNOME/Gtk+ 2.0.

Informaţii generale depre Glade

Ce documentatie există pentru Glade?

În versiunea pentru GNOME sunt disponibile Quick-Start-ul, Manualul şi lista cu cele mai frecvente întrebări prin accesarea meniului Ajutor. Din păcate, acestea nu sunt încă complete.

Exista, însa si alte documente pe Web:

Ghid în limba Spaniolă - tigre.aragon.unam.mx/m3d/links_es.htm

Ghid înlimba Italiană - digilander.iol.it/robang/glade

Nu ştiu dacă există vre-o carte referitoare la Glade, cu toate ca am vazut un capitol care facea referinţă la Glade într-o carte publicată de Wrox press pentru dezvoltatorii de Linux.

Legături vor fi prezente pe sit-ul de prezentare Glade la glade.gnome.org in timp ce devin disponibile.

Există exemple de cod?

Glade include doar un sigur exemplu de editor de texte în directorul examples/editor. Dacă sunteţi în posesia unui pachet binar (ex. un RPM sau DEB), este posibil ca respectivele fişiere să fie instalate în /usr/doc/glade-X.X.X. Dacă nu puteţi să-le găsiţi, atunci puteti descărca un pachet arhiva de la glade.gnome.org.

Situl web contine legături spre câteva aplicatii, din care puteti extrage exemple de cod. Vizitati secţiunea 'Applications' de pe glade.gnome.org.

Sunt obligat(ă) să folosesc o anumită licenţă pentru codul C generat de Glade?

Nu. Sunteţi liber(ă) să folosiţi orice fel de licenţă pentru codul C generat de Glade.

Cu toate acestea, în spiritul software-ului liber, noi încurajăm utilizarea licenţelor GPL şi LGPL.

Crearea unei interfeţe cu utilizatorul folosind Glade

Când adaug un widget într-o fereastră, acesta umple toată fereastra şi nu mai pot adăuga late widget-uri.

Aceasta nu este o eroare in Glade! în GTK+ trebuie să folositi containere pentru a va aşeza widget-urile. Cele mai frecvent utilizate containere se afla în josul paginii principale din paleta de unelte. Încercaţi mai întâi sa adăugati o cutie verticală în Glade. Acum încercaţi sa adăugaţi un tabel într-o anumită poziţie in cutia verticală. Aţi prins ideea?

Dacă vreţi numai să poziţionaţi un widget la anumite coordonate, incercaţi containerul Fix. Totuşi, această metodă nu este recomandată întrucât ferestrele sau dialogurile la care lucraţi nu vor arăta bine dacă vor fi redimensionate, iar dacă treduceţi textul din etichete sau butoane în alte limbi, acestea s-ar putea să nu mai încapă.

Cum pot schimba culoarea unui widget (ex. sa fac o etichetă roşie)?

Puteţi folosi fişiere GTK+ rc standard pentru a seta culorile sau fonturile widget-urilor. Dacă aveţi activată opţiunea 'Set Widget Names' in proiectul Glade, atunci vă va fi mai uşor să accesaţi widget-urile după nume. Verificaţi documentaţia GTK+ la developer.gnome.org/doc/API/gtk/index.html.

Puteţi schimba stilul unui widget programatic, apelând funcţia gtk_widget_modify_style(). Exemplu:

    								GdkColor red = { 0, 65535, 0, 0 };
    								GtkRcStyle *rc_style = gtk_rc_style_new ();
    								rc_style->fg[GTK_STATE_NORMAL] = red;
    								rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;
    								gtk_widget_modify_style (widget, rc_style);
    								gtk_rc_style_unref (rc_style);

Cum adaug un pixmap unui buton?

Creaţi un buton şi selectaţi Remove Label din meniul popup. Puteţi apoi adăuga orige widget vreţi acelui buton, spre exemplu o cutie orizontală cu un pixmap şi o etichetă. (Glade v-ar putea uşura această muncă pe viitor.)

Cum pot adăuga mai multe widget-uri de acelaşi tip intr-un singur pas?

Ţineţi apăsată tasta 'Control' în timp ce selectaţi widget-ul din Paletă. Va rămâne apoi selectată, până ce veţi selecta alt obiect din Selector.

Primesc următorul mesaj când încerc să folosesc un 'scrolled window': Gtk-WARNING **: gtk_scrolled_window_add(): cannot add non scrollable widget use gtk_scrolled_window_add_with_viewport() instead

Puteţi ignora fără grijă acest mesaj. El este afişat de GTK+ pentru a aminti dezfoltatorilor să îşi revizuiască codul, deoarece comportamentul 'scrolled windows' s-a schimbat intre versiunea GTK+ 1.0 şi GTK+ 1.2. Codul generat de Glade nu este eronat. În aplicaţia finală, acest mesaj ar trebui să dispară.

Ce formate grafice suportă Glade?

GTK+ 2.0 include gdk-pixbuf care asigură suport pentru foarte multe formate grefice, incluzând formatele PNG, TIFF, BMP, JPEG şi XPM.

Puteţi converi imaginile în diferite formate folosind editorul de imagini GIMP sau utilitarul 'convert' din pachetul ImageMagick.

Cum pot adăuga un handler de semnal?

Urmaţi aceşti paşi:

- Selectaţi widget-ul căruia vreti sa-i adăugaţi handler-ul.

- Selectaţi 'Semnale' din pagina Editorului de Proprietăţi.

- Daţi clic pe butonul '...' (3 puncte) din dreapta câmpului 'Semnal:'. Ar trebui sa apară o fereastră cu lista semnalelor pe care le emite acest widget.

- în fereasta popup, selectaţi semnalul pentru care vreţi sa creaţi handler-ul şi apasati pe butonul 'OK'.

- Glade denumeşte automat funcţia handler, dar sunteţi liber(ă) sa îi schimbaţi numele din câmpul 'Handler:' de credeţi de cuviinţă.

- Clic pe butonul 'Adaugă' pentru a-l adăuga în lista cu handler-uri de semnale ale acestui widget.

Când generaţi codul C, un o funcţie vidă de tip handler va fi încorporată în fişierul callbacks.c. Puteţi să va adăugaţi codul acolo.

Utilizarea codului C gerat de Glade

Cum pot genera cod cu ajutorul lui Glade?

Aveţi nevoie de automake >= 1.4 şi de autoconf >= 2.13 pentru a genera cod C cu ajutorul lui Glade. Mai aveţi nevoie şi de gettext >= 0.10.35 dacă vreţi să avtivaţi suportul de gettext. Vedeţi secţiunea Cerinţe din fişierul `README.ro` pentru link-uri la aceste fişiere.

Rulaţi `./autogen.sh` în directorul rădacină al proiectului pentru a rula automake, autoconf şi celelalte utilitare necesare procesului de compilare, şi crearea fişierelor `Makefile`. Argumentele date lui `./autogen.sh` vor fi trimise către `configure`. Exemplu: `./autogen.sh --prefix /usr/local/gnome`.

Apoi rulaţi comanda `make` pentru a compila aplicaţia.

Notă: pentru aplicaţiile GNOME rebuie să rulaţi mai întâi comanda `make install` pentru a instala pixmap-urile corect. Dacă nu veţi rula această comanda, aplicaţia dvs. va rula, dar nu veţi putea vedea pixmap-urile.

Primesc următoarea eroare: aclocal: configure.in: 10: macro `AM_PATH_GTK' not found in library

înseamană că fişierul `gtk.m4` nu a putut fi găsit. (`gtk.m4` e un set de macro-uri m4 care se instalează odată cu GTK+ şi este folosit la compilarea programelor care se bazează pe GTK+.) aclocal (care face parte din pachetul automake) caută aceste macrouri pentru a le adăuga la fişierul `aclocal.m4` în directorul rădăcină al proiectului.

Pentru a afla unde este instalat GTK+, rulaţi `gtk-config --prefix`. Fişierul `gtk.m4` ar trebui să fie în subdirectorul `share/aclocal`. Pentru a afla ce director foloseşte aclocal, rulaţi `aclocal --print-ac-dir`.

Ar trebui să adăugaţi directorul în care se află fişierul GTK+ m4. la variabila de mediu `ACLOCAL_FLAGS`, Ex: daca fişierele GTK+ m4 se află în`/usr/local/share/aclocal`, atunci ar trebui să adăugaţi următoarele linii la fişierul`$HOME/.profile`: `export ACLOCAL_FLAGS="-I /usr/local/share/aclocal/"`.

Primesc urmatoarea eroare: ** CRITICAL **: file glade_gnome.c: line 939 (glade_gnome_write_menu_item_source): assertion `source_buffer != NULL' failed.

încercaţi să folosiţi meniuri de tip Gnome într-o aplicaţie strict GTK+. Editaţi toate meniurile şi setaţi proprietatea "Stock" pe "None".

Folosirea codului C generat de Glade

Ce sunt toate fişierele create de Glade?

Acestea sunt fişierele create implicit de către Glade, dar unele nume s-ar putea să difere dacă aţi schimbat din opţiunile proiectului.

`autogen.sh`

Script care rulează automake, autoconf şi alte programe necesare, in oridinea corectă, uşurând procesul de compilare a aplicaţiei. Puteţi să-i transimiteţi orice argumente vreţi să-i transmiteti scriptului configure. După ce l-aţi rulat, puteţi să apelaţi `make` pentru a compila aplicaţia.

`configure.in`

Script standard, pe care autoconf îl foloseşte la generarea scriptului configure.

`Makefile.am`

Reguli standard make pe care automake le foloseşte la generarea fişierului `Makefile.in`, pe care scriptul configure la transformă în fişîere `Makefile`.

`acconfig.h`

Conţine câteva macro-uri care sunt folosite pe parcursul scriptului configure şi sunt adăugate în fişierul `config.h` header (care ar trebui să fie primul inclus în orice sursă a programului). Majoritatea acestor macro-uri sunt necesare suportului de gettext (ENABLE_NLS, HAVE_CATGETS, HAVE_GETTEXT, HAVE_LC_MESSAGES, HAVE_STPCPY), HAVE_LIBSM este necesar pentru Gnome (dar nu deranjeaza aplicaţiile GTK+), şi câteva sunt adăugate de către Glade Glade(PACKAGE_LOCALE_DIR, PACKAGE_DATA_DIR, PACKAGE_SOURCE_DIR).

`stamp-h.in`

Folosit de automake ca fişier referinţă, pentru a regenera anumite fişiere.

`AUTHORS`, `ChangeLog`, `NEWS`, `README`

Toate aceste fişiere sunt goale iniţial, dar sunt create pentru a respecta convenţiile GNU.

`src/Makefile.am`

Fişier automake standard.

`src/main.c`

Conţine funcţia `main`() care va crea câte o fereastră/dialog.

`src/interface.h`

Declaraţiile funcţiilor pe care trebuie să le apelaţi pentru a crea ferestrele şi dialogurile construite cu Glade.

`src/interface.c`

Codul pentru crearea ferestrelor şi dialogurilor şi celorlalte widget-uri.

`src/callbacks.h`

Declaraţiile handler-urilor de semnal si funcţiilor callback, pe care le veţi scrie.

`src/callbacks.c`

Funcţiile signal handler şi callback.

`src/support.h`

Declaraţii de funcţii, printr care şi `lookup_widget`() pe care o puteţi folosi să obtineţi pointeri la widget-uri.

`src/support.c`

Funcţii suport.

Dacă aveţi ativat suportul de gettext, va fi creat directorul `po`, cu fişierele `POTFILES.in` şi o copie separată a `ChangeLog`. `POTFILES.in` conşine lista fişierelor sursă pentru fişierele de traducere, aici ar trebui să vă adăugaţi toate fişierele de traducere.

Schimbarea opţiunilor Gnome şi Gettext

Dacă schimbaţi opţiunile Gnome Support sau Gettext Support după ce aţi compilat proiectul, va trebui să înnoiţi unele fişiere precum `configure.in` şi `Makefile.am`. Cea mai bună soluţie ar fi să schimbaţi directorul proiectului din dialogul Opţiuni Proiect şi să recompilati proiectul. Va trebui să treceţi în partea cealaltă tot codul srcris în afara Glade, precum handlere de semnal. O alternativă ar fi să ştergeţi `autogen.sh`, `configure.in`, `Makefile.am`, `src/Makefile.am`, şi `src/main.c` şi să folosiţi Glade pentru a le crea din nou. Dar, dacă aţi operat asupra acestor fişiere în afara Glade, atunci va trebui să le modificaţi din nou. (Poate, în viitor, Glade se va ocupa singur de această problemă.)

Ce fişiere poate edita manual programatorul şi ce fişiere sunt suprascrise?

În mare parte, Glade nu va suprascrie fişiere existente. (dacă este activată optiunea corespunzătoare.)

Glade suprascrie următoarele fişiere: `interface.h`, `interface.c`, `support.h`, şi `support.c`. (Aceste fişiere s-ar putea să aiba nume diferite dacă le-aţi schimbat în Optiunile Proiectului.)

Toate acese fişiere conţin un mesaj de avertizare: DO NOT EDIT.

Dacă aţi modificat sau adăugat vre-un hadler de semnal, moduficările sunt adăugate la sfârşitul fişierelor `acllbacks.h` şi `callbacks.c`. Astfel tot codul pe care l-aţi adăugat va rămâne nealterat! Dacă aţi redenumit o funcţie de tip handler, atunci trebuie ca voi să ştergeţi versiunea veche şi să modificaţi corpul funţiei.

Cum pot să-mi adaug fişierele mele sursă într-un proiect?

Adăugaţi fişierele .c sau .h în fişierul `src/Makefile.am`, în variabila `project1_SOURCES` (unde project1 reprezintă numele proiectului).

Dacă folosiţi gettext, ar trebui să adăugaţi fişierele sursă şi în `po/POTFILES.in` pentru ca textul din ele să poată fi tradus.

Cum pot adăuga o bibliotecă la proiect?

Trebuie să adăugaţi un test pentru biblioteca respectivă în fişierul configure.in, iar variabilele CPPFLAGS şi LIBS să reflecte utilizarea bibliotecii respective. (CPPFLAGS ar trebui să conţină orive parmetru -I ce trebuie dat preprocesorului C, iar LIBS ar trebui să conţină parametri de tip -l şi -L ce trebuie date linkeditorului.)

autoconf oferă macro-uri precum AC_CHECK_HEADER and AC_CHECK_LIB care pot fi folosite la verificrea antetelor şi bibliotecilor coresounzătoare.

Multe biblioteci GTK+ şi Gnome oferă un script precun gtk-config care va afişa parametrii CPPFLAGS şi LIBS necesari.

Spre exemplu, libxml oferă un script xml-config care poate fi folosit ca în exemplul de mai jos:

    								dnl Get libxml flags & libs
    								AC_PATH_PROG(xml_config, xml-config)
    								if test "x$xml_config" = "x"; then
    								AC_MSG_ERROR([*** xml-config not found.])
    								fi

    								XML_CFLAGS=`$xml_config --cflags 2>/dev/null`
    								XML_LIBS=`$xml_config --libs 2>/dev/null`
    								CPPFLAGS="$CPPFLAGS $XML_CFLAGS"
    								LIBS="$LIBS $XML_LIBS"

Aveţi grijă să puneţi testul înaintea apelului AC_OUTPUT.

Cum pot obţine un pointer la un widget în cadrul unui handler de semnal?

Folosiţi funcţia `lookup_widget`(). (Localizată în fişierul `support.c`.)

Funcţia ia ca parametri un pointer la orice widget din fereastră şi numele widget-ului pe care vreţi să-l accesaţi. De obicei, primul parametru ex primul argument al handler-ului. Exemplu:

    								void
    								on_button1_clicked                     (GtkButton       *button,
    								gpointer         user_data)
    								{
    								GtkWidget *entry1;

    								entry1 = lookup_widget (GTK_WIDGET (button), "entry1");

    								...
    								}

Notă: acest cod nu funcţionează dacă utilizaţi libglade. Pentru libglade folosiţi următoarea metodă:

    								void
    								on_button1_clicked                     (GtkButton       *button,
    								gpointer         user_data)
    								{
    								GladeXML* xml;
    								GtkWidget* entry1;

    								xml = glade_get_widget_tree (GTK_WIDGET (button1));
    								entry1 = glade_xml_get_widget (xml, "entry1");

    								...
    								}

Cum obţin un pointer la un widget dintr-o altă fereastră?

Trebuie să păstraţi referinţe la toate ferestrele toplevel. Pentru aplicaţii simple puteţi utiliza variabile globale pentru a păstra aceşti pointeri.

Pentru aplicaţii mai complicate puteţi folosi `gtk_object_set_data`() şi alte funţii de acest gen pentru a păstra pointeri la ferestre înglobate în alte ferestre. Spre exemplu, dacă doriţi să creaţi un dialog care trebuie să acceseze un widget din cadrul ferestrei principale puteţi utiliza următoarea secvenţă de cod:

    								dialog = create_dialog1 ();  /* Apelaţi funcţia generată de Glade. */
    								gtk_object_set_data (GTK_OBJECT (dialog), "main_window", main_window);

Apoi când doriţi să accesaţi fereastra principală din cadrul dialogului folosiţi următorul cod:

    								main_window = gtk_object_get_data (GTK_OBJECT (dialog), "main_window");

Trebuie să fiţi atenţi ca pointerii să fie în totdeauna valizi. Dacă zona de memorie referită de pointerul respectiv este dealocată, atunci nu mai folosiţi pointerul respectiv, în caz contra aplicaţi va genera erori.

Cum obţin valoarea unui GtkOptionMenu?

Apelaţi funcţia `gtk_menu_get_active`() cu itemul curent din cadrul GtkOptionMenu. Puteţi folosi `g_list_index`() pentru a obţine indexul acestuia în cadrul meniului.

    								void
    								on_button1_clicked                     (GtkButton       *button,
    								gpointer         user_data)
    								{
    								GtkWidget *option_menu, *menu, *active_item;
    								gint active_index;

    								option_menu = lookup_widget (GTK_WIDGET (button), "optionmenu1");
    								menu = GTK_OPTION_MENU (option_menu)->menu;
    								active_item = gtk_menu_get_active (GTK_MENU (menu));
    								active_index = g_list_index (GTK_MENU_SHELL (menu)->children, active_item);

    								g_print ("Active index: %i\n", active_index);
    								}

Cum fac un GtkOptionMenu să apeleze o funcţie când îşi schimbă valoarea?

Glade încă nu face acest lucru în mod automat, dar îl puteţi face manual.

Când creaţi fereastra, accesaţi meniul de opţiuni şi conectaţi-vă la semnalul deactivate emis de meniu:

    								window1 = create_window1 ();
    								option_menu = lookup_widget (window1, "optionmenu1");
    								gtk_signal_connect (GTK_OBJECT (GTK_OPTION_MENU (option_menu)->menu),
    								"deactivate", GTK_SIGNAL_FUNC (on_option_selected),
    								NULL);

Apoi adăungaţi un handler la `callbacks.c`. Puteţi obţine indexul itemului prin metoda descrisă la răspunsul anterior.

    								static void
    								on_option_selected (GtkMenuShell *menu_shell,
    								gpointer data)
    								{
    								GtkWidget *active_item;
    								gint item_index;

    								active_item = gtk_menu_get_active (GTK_MENU (menu_shell));
    								item_index = g_list_index (menu_shell->children, active_item);

    								g_print ("In on_option_selected active: %i\n", item_index);
    								}

Cum mă pot conecta la semnale GtkAdjustment?

Glade încă nu suportă acest lucru în prezent, dar o puteţi face manual după cum e descris în răspunsul de la întrebarea 3.6.

Cănd creaţi fereastra, obţineţi un pointer la widget-ul conţinând ajustarea, şî conectaţi-vă la senmalele changed sau value_changed:

    								window1 = create_window1 ();
    								hscale = lookup_widget (window1, "hscale1");
    								gtk_signal_connect (GTK_OBJECT (GTK_RANGE (hscale)->adjustment),
    								"changed", GTK_SIGNAL_FUNC (on_adjustment_changed),
    								NULL);

Cum adaug rânduri la o GtkCList înainte de afişarea ferestrei?

După ce aţi creat fereastra, folosind funcţia 'create' generată de Glade folosiţi funcţia `lookup_widget`() pentru a obţine un pointer la GtkCList-ul din widget şi adăugaţi rândurile necesare ca în exemplu.

    								GtkWidget *window, *clist;
    								gchar *row[2];		/* GtkCList-ul nostru are doar 2 coloane. */

    								window = create_window1 ();
    								clist = lookup_widget (window, "clist1");

    								row[0] = "Hello";
    								row[1] = "World";
    								gtk_clist_append (GTK_CLIST (clist), row);

    								row[0] = "Second";
    								row[1] = "Row";
    								gtk_clist_append (GTK_CLIST (clist), row);

    								gtk_widget_show (window1);

Acest FAQ a fost scris de către Damon Chaplin (damon@ximian.com). Vă rugăm să trimiteţi orice comentariu asupra acestui manual autorului. Pentru mai multe informaţii despre Glade sau despre listele de mail Glade, vizitaţi Pagina Glade.

Traducerea în limba română realizată de către Călin Cristian Andrei (kman@csc.ro). Orice comentarii sunt binevenite. Vă rog sa-mi trimiteti orice comentarii legate de această traducere.