#include <stdio.h>
#include <stdlib.h>
#include <mysql/mysql.h>

const char* host = "localhost"; // host di connessione
const char* database = "mydb";  // database di connessione
const char* db_user = "myuser"; // nome utente per la connessione
const char* db_pass = "mypass"; // password non cifrata

int main ()
{
        MYSQL mysql;
        MYSQL_ROW row;        // la riga
        MYSQL_RES* result;
        MYSQL_FIELD* field;     // il campo ritornato

        char* query = "SELECT * FROM nome_tabella;";

        int i = 0, j = 0, n_rows = 0;

        // restituisce NULL se non avviene con successo
        if (! mysql_init (&mysql)) {
                printf ("Errore nella allocazione di memoria.n");
                exit (EXIT_FAILURE);
        }

        if (! mysql_real_connect (&mysql, host, db_user, db_pass, "",
                        0, NULL, 0)) {
                printf ("Errore nella connessione.n");
                goto error;
        }

        // restituisce zero se avviene con successo
        if (mysql_select_db (&mysql, database)) {
                printf ("Errore nella selezione del database.n");
                goto error;
        }

        printf ("Connessione avvenuta.n");


        // restituisce zero se avviene con successo
        if (mysql_select_db (&mysql, database)) {
                printf ("Errore nella selezione del database.n");
                goto error;
        }

        // esegue la query
        if (mysql_query (&mysql, query)) {
                printf("Errore nella query.n");
                goto error;
        }

        result = mysql_store_result (&mysql);

        n_rows = mysql_num_rows (result);

        for (j = 0; j < n_rows; j++) {
                i = 0;
                mysql_field_seek (result, 0);           // sposta a inizio riga
                row = mysql_fetch_row (result);      // preleva i dati della riga
                while ((field = mysql_fetch_field (result))) {
                        printf ("%s: ", field->name);     // visualizza il campo
                        printf ("%sn", row[i++]);          // visualizza il dato del campo
                }

                printf ("n");
        }



       mysql_free_result (result);

error:
        mysql_close (&mysql);   // chiusura del database

        exit (EXIT_SUCCESS);
}

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtk/gtk.h>
#include <stdlib.h>
#include <glade/glade.h>
#include <glib/gprintf.h>
/*
    NELLA GUIDA DI RIFERIMENTO DELLE GLIB SI LEGGE:
	"Note that the functions g_printf(), g_fprintf(), g_sprintf(), g_snprintf(), g_vprintf(), g_vfprintf(), g_vsprintf() 
	and g_vsnprintf() are declared in the header gprintf.h which is not included in glib.h 
	(otherwise using glib.h would drag in stdio.h), so you'll have to explicitly include <glib/gprintf.h> 
	in order to use the GLib printf() functions.
*/

//gchar selezione[]= "";
gchar* selezione = NULL; 
/* 
   INVECE DI METTERE gchar* selezione = NULL; 
   PRIMA AVEVO USATO: gchar* selezione = g_strdup("a string"); 
   NE OTTENEVO UN ERRORE IN COMPILAZIONE: Il C non ammette di inizializzare variabili con una funzione
*/


void
on_button1_clicked (GtkButton *button, gpointer user_data)
{
	/* 
	     Avevo scritto:
	     GtkWidget *window1;
	     window1 = gtk_widget_get_toplevel(button);
	     compilando mi dava un warning: passing argument 1 of 'gtk_widget_toplevel' from incompatible pointer type.
	     Questo perchè ho passato un GtkButton* invece di un GtkWidget*. 
	     Ho risolto il problema facendo un "casting" con GTK_WIDGET.
	*/
	
	GtkWidget *window1 = gtk_widget_get_toplevel(GTK_WIDGET (button));
	
	gchar *filename;
	
	GtkWidget *dialog;

   dialog = gtk_file_chooser_dialog_new ("Open File",
				      GTK_WINDOW (window1),
				      GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				      NULL);
  /* 
      Anzichè scrivere GTK_WINDOW(window1) prima c'era scritto solo "window1", e beccavo un warning in compilazione tipo "incompatible pointer type"..
	  Ho risolto facendo il casting con GTK_WINDOW.
	  Se vedi nella guida di riferimento delle gtk vedi che la sintassi di gtk_file_chooser_dialog_new è:
	  GtkWidget* gtk_file_chooser_dialog_new (const gchar *title, GtkWindow *parent, GtkFileChooserAction action,const gchar *first_button_text, ...);
	  
	  Passando solo window1 passavo un GtkWidget e NON la "parent window".
  */
     


   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
     {

		  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); 

		 /*
		      AVREI POTUTO USARE:
		      filename = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); 

		      gtk_file_chooser_get_uri OTTIENE IL FILE PER "URI". Gli spazi vengono sostituiti, ad esempio, da "%20".
		      Ottenere il valore per URI sarebbe utile per un fatto di sicurezza, nel caso avrei dovuto passare il file a fopen (ad esempio).
		      Nel nostro caso invece, il file lo passerò a g_spawn_sync (vedi piu avanti)
		 */
		 
		 selezione = g_strdup(filename);
		  /*
		      PER SETTARE "SELEZIONE" PRIMA AVEVO USATO strcpy(selezione, "pippoasdfasdf");
		      POI MI AVEVANO CONSIGLIATO INVECE DI USARE:
		 	  sprintf(selezione, "%s", filename); 
		      ALL'INIZIO DEL PROGRAMMA PERO' "selezione" era inizializzata così: gchar selezione[]= "";
		      QUINDI NON AVEVO UN PUNTATORE COME ADESSO

		      SINTASSI: int sprintf(char *str, const char *format, ...);
		      La funzione sprintf() differisce dalla funzione printf()  in quanto i caratteri vengono scritti nell'area puntata da str.
		 
		      AVREI POTUTO USARE, AL POSTO DI SPRINTF, ANCHE IL COMANDO:
		      strcpy(selezione, filename);
		      STRCPY FUNZIONA COSI':
		      SINTASSI: ptr = strcpy( s1, s2 );
		      La funzione strcpy() copia la stringa s1 sull'area puntata da s2 la quale deve essere sufficientemente ampia ad accogliere tutti i caratteri di s1 compreso il terminatore '&#65533;'.
		 
		 */
       g_printf("DIRECTORY SELEZIONATA: %s n", selezione);
     }
   else filename = "";
	  
 
   gtk_widget_destroy (dialog);
	
	/*  Ho preferito ricercare la GtkLabel a partire da window1, per esigenze di "esperimento", 
	*   ma avrei potuto direttamente scrivere:
	*   GladeXML *self = glade_get_widget_tree(GTK_WIDGET(button));
    */
    GladeXML *self = glade_get_widget_tree(GTK_WIDGET(window1));
	GtkWidget *label = glade_xml_get_widget (self, "etichetta");
   
   filename = g_filename_display_name (filename);
      /*
   			Voglio stampare a video il file ottenuto. 
            Le GUI GTK, in generale, usano la codifica UTF-8 ma l'encoding dell'utente potrebbe non essere UTF-8, e così 
            anche i nomi dei suoi file potrebbero non essere UTF-8.
            Quindi bisogna assicurarsi di convertire il nome del file ottenuto in UTF-8 per essere certi di mostrarlo a video correttamente.
            Usiamo allora il comando g_filename_display_name che ha questa sintassi:
            gchar*      g_filename_display_name         (const gchar *filename);
     */

	gtk_label_set_text (GTK_LABEL(label), filename);
   
 
}

void
on_button_ruota_clicked (GtkButton *button, gpointer user_data)
{
	
	/* 
	     IL COMANDO CHE PASSERO' ALLA SHELL E': 
	
		 find 'percorso/cartella' -type f -iname '*.jpg' -print0 | xargs -0 jhead -autorot
	
	     -print0: i singoli file restituiti da find verranno passati ad xargs in modo che vengano correttamente interpretati nonostante vi siano spazi vuoti o apici in mezzo.
         Print0 separa i singoli file da un carattere speciale detto "NULL", in modo che xargs non faccia confusione tra spazi bianchi nei nomi dei file e la separazione dei file stessi.
         Se find trova troppi file si corre il rischio che la stringa sia troppo lunga ed ecceda il limite di caratteri ammesso nella riga di comando.
         Per questo motivo usiamo xargs che se la sbrigherà lui a fare in modo che questo non succeda. Inoltre, tramite il parametro -0, diciamo ad xargs che riconosca i singoli file perchè separati da un carattere "NULL". Per questo prima abbiamo usato -print0!
   */
	
	gchar* selezione_escape = g_shell_quote (selezione);
    gchar* comando = g_strconcat("find ", selezione_escape," -type f -iname '*.jpg' -print0 | xargs -0 jhead -autorot", NULL);
	g_printf("COMANDO ESEGUITO: %s nn", comando);

	
	system(comando);	
	/*
	     Il comando system esegue su shell un comando. Piu o meno allo stesso scopo possono servire anche i comandi
	     g_spawn_sync e g_spawn_command_line_sync. Non sono riuscito ad implementarli con successo.
	 */

}

int main (int argc, char *argv[])
{
	GtkWidget *window1, *button1, *button_ruota;
	GladeXML *xml;
	
	if (selezione == "" || selezione == NULL) g_printf("SELEZIONE ATTUALE: NESSUNAn");
	else g_printf("SELEZIONE ATTUALE: %s n", selezione);
	
	
    // PACKAGE è definito in config.h
	//gnome_init (PACKAGE, VERSION, argc, argv);
	gtk_init (&argc, &argv);
	//glade_gnome_init ();

	
	
	xml = glade_xml_new ("gira_tutte_le_foto_con_gui.glade", NULL, NULL);

	/* Ho ESCLUSO l'autoconnect, faccio le callback manualmente */
	// glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");

	button1 = glade_xml_get_widget (xml, "button1");

	g_signal_connect (G_OBJECT (button1), "clicked",
                    G_CALLBACK (on_button1_clicked),
                    NULL);
	

	
	button_ruota = glade_xml_get_widget (xml, "button_ruota");

    g_signal_connect (G_OBJECT (button_ruota), "clicked",
                    G_CALLBACK (on_button_ruota_clicked),
                    selezione);

    g_signal_connect (G_OBJECT (window1), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);
	
	 gtk_widget_show (window1);


	gtk_main ();
	
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <wand/MagickWand.h>

int main(int argc,char **argv)
{
#define ThrowWandException(wand) 
{ 
  char 
    *description; 
 
  ExceptionType 
    severity; 
 
  description=MagickGetException(wand,&severity); 
  (void) fprintf(stderr,"%s %s %ld %sn",GetMagickModule(),description); 
  description=(char *) MagickRelinquishMemory(description); 
  exit(-1); 
}

  MagickBooleanType
    status;

  MagickWand
    *magick_wand;

  /*
    Read an image.
  */
  MagickWandGenesis();
  magick_wand=NewMagickWand();  
  status=MagickReadImage(magick_wand,"image.gif");
  if (status == MagickFalse)
    ThrowWandException(magick_wand);
  /*
    Turn the images into a thumbnail sequence.
  */
  MagickResetIterator(magick_wand);
  while (MagickNextImage(magick_wand) != MagickFalse)
    MagickResizeImage(magick_wand,106,80,LanczosFilter,1.0);
  /*
    Write the image as PNG and destroy it.
  */
  status=MagickWriteImages(magick_wand,"image.png",MagickTrue);
  if (status == MagickFalse)
    ThrowWandException(magick_wand);
  magick_wand=DestroyMagickWand(magick_wand);
  MagickWandTerminus();
  return(0);
}

  cc `Wand-config --cflags --cppflags` wand.c `Wand-config --ldflags --libs`

char *uistr = "<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->"
"<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.0.dtd">"
""
"<glade-interface>"
""
"<widget class="GtkWindow" id="window1">"
" <property name="visible">True</property>" 
"  <property name="title" translatable="yes">window1</property>" 
"  <property name="type">GTK_WINDOW_TOPLEVEL</property>" 
"   <property name="window_position">GTK_WIN_POS_NONE</property>" 
"   <property name="modal">False</property>" 
"   <property name="default_width">500</property>" 
"   <property name="default_height">400</property>" 
"   <property name="resizable">True</property>" 
"   <property name="destroy_with_parent">False</property>" 
" " 
"   <child>" 
" 	<placeholder/>" 
"   </child>" 
" </widget>" 
" </glade-interface>" 
" ";

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>
#include "ui.h"

int main (int argc, char *argv[])
{
	GtkWidget *window1;
	GladeXML *xml;

	#ifdef ENABLE_NLS
		bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
		textdomain (PACKAGE);
	#endif

	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	/*
	 * The .glade filename should be on the next line.
	 */
	//xml = glade_xml_new (PACKAGE_SOURCE_DIR"/ceiling_gui.glade", NULL, NULL);
	xml = glade_xml_new_from_buffer(uistr,strlen(uistr),"window1", NULL);

	/* This is important */
	glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");
	gtk_widget_show (window1);

	gtk_main ();
	return 0;
}

char frase[200] = "parola1 ";
strcat(strcat(frase, "parola2")," parola3");
g_print ("La frase è :  %s\n",  frase);

#include <gtk/gtk.h>

[...]


//g_strconcat: serve ad unire piu stringhe. Ricordarsi il NULL alla fine!
gchar *stringa = g_strconcat("parola1", " parola2"," parola3", NULL);

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

char *SuperStringsCat (char *String1, ...)
{
	va_list List;
	
	va_start (List, String1);
	
	unsigned int Size;
	
	Size = strlen (String1) + 1;
	
	char *s;
	s = String1;
	
	do
	{
		Size += strlen (s) + 1;
	}while ((s = va_arg (List, char*)) != NULL);
	
	char *Merge;
	Merge = (char*)malloc (sizeof (char) * Size);
	char *sMerge = Merge;

	va_end (List);
	va_start (List, String1);

	s = String1;
	
	do
	{
		strcpy (Merge, s);
		Merge += strlen (s);
	}while ((s = va_arg (List, char*)) != NULL);
	
	va_end (List);
	
	return sMerge;

}

int main (int argc, char *argv[])
{
	char *p;
	p = SuperStringsCat ("prova", " 1,", " 2,", " 3", "...", NULL);
	printf ("%s\n", p);
	
	return 0;
}

prova1

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void
ok_button_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Thanks for trying out my program.n");
  gtk_main_quit ();
}


int
main (int argc, char *argv[])
{
  GladeXML  *main_window;
  GtkWidget *widget;

  gtk_init (&argc, &argv);

  /* Carica l'interfaccia utente */
  main_window = glade_xml_new ("example-1.glade", NULL, NULL);

	/* Predispone la gestione del bottone chiamato "OKButton" */
  widget = glade_xml_get_widget (main_window, "OKButton");
  g_signal_connect (G_OBJECT (widget), "clicked",
                    G_CALLBACK (ok_button_clicked),
                    NULL);
	
  /* Chiusura del programma quando l'utente chiude la finestra */
  widget = glade_xml_get_widget (main_window, "MainWindow");
  g_signal_connect (G_OBJECT (widget), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);

  /* Avvia il ciclo */
  gtk_main ();

  return 0;
}

prova2

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <gtk/gtk.h>
#include <glade/glade.h>

on_button1_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Bau n");
}

on_button2_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Arrivederci n");
  gtk_main_quit ();
}

on_button3_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Hai premuto button3 nn");

  gchar stringa2[80]="<span size="x-large">Ciao</span>";
  GladeXML *self = glade_get_widget_tree(GTK_WIDGET(widget));
  GtkWidget *label = glade_xml_get_widget (self, "label2");
  
  gchar *stringa1 = gtk_label_get_label(label);
  
  //gchar *stringa1 = gtk_label_get_text (label); 
  //serve a prendere solo il testo, senza tag di stile
  //invece gtk_label_get_label prende anche i tag di stile (se ci sono)

  printf ("Il contenuto di "label1" è "%s"n", stringa1);
  printf ("stringa1: %s ; stringa2: %sn", stringa1, stringa2);

  /*
  In C per comparare due stringhe fare: if (strcmp (string1, string2) == 0) 
  o if (g_str_equal (string1, string2)) 
  o if (g_utf8_collate (string1, string2) == 0)
  */
  if (strcmp (stringa1, stringa2) == 0) {
	  gtk_label_set_markup (GTK_LABEL(label), "<span size="x-large">è uguale a output</span>");
	  //gtk_label_set_text(GTK_LABEL(label),"è uguale a output");
  }
  else {
	  gchar *saluto = "Ciao";
	  //g_strconcat: serve ad unire piu stringhe. Ricordarsi il NULL alla fine!
	  gchar *stringa3 = g_strconcat("<span size="x-large">",saluto,"</span>", NULL);
	  gtk_label_set_markup (GTK_LABEL(label), stringa3);
	  //invece avrei usato:
	  //gtk_label_set_text(GTK_LABEL(label),stringa2);
	  //Se non avevo tag di stile <span>
  }
}

void on_entry1_activate (GtkWidget *widget, gpointer user_data)
{
   printf ("Hai scritto il tuo nome.n");
  
   gchar output[80]="Ciao ";
   strcat(output,gtk_entry_get_text(GTK_ENTRY(widget)));

   printf ("%s n",output);
}

int main (int argc, char *argv[])
{
	GtkWidget *window1;
	GladeXML *xml;

	#ifdef ENABLE_NLS
		bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
		textdomain (PACKAGE);
	#endif

	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	/*
	 * The .glade filename should be on the next line.
	 */
	xml = glade_xml_new ("provalibglade.glade", NULL, NULL);

	/* This is important */
	glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");
	gtk_widget_show (window1);

	gtk_main ();
	return 0;
}

prova3

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <gtk/gtk.h>
#include <glade/glade.h>

on_button1_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Bau n");
}

on_button2_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Arrivederci n");
  gtk_main_quit ();
}

on_button3_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Hai premuto button3 nn");

  gchar stringa2[80]="<span size="x-large">Ciao</span>";
  GladeXML *self = glade_get_widget_tree(GTK_WIDGET(widget));
  GtkWidget *label = glade_xml_get_widget (self, "label2");
  
  gchar *stringa1 = gtk_label_get_label(label);
  
  //gchar *stringa1 = gtk_label_get_text (label); 
  //serve a prendere solo il testo, senza tag di stile
  //invece gtk_label_get_label prende anche i tag di stile (se ci sono)

  printf ("Il contenuto di "label1" è "%s"n", stringa1);
  printf ("stringa1: %s ; stringa2: %sn", stringa1, stringa2);

  /*
  In C per comparare due stringhe fare: if (strcmp (string1, string2) == 0) 
  o if (g_str_equal (string1, string2)) 
  o if (g_utf8_collate (string1, string2) == 0)
  */
  if (strcmp (stringa1, stringa2) == 0) {
	  gtk_label_set_markup (GTK_LABEL(label), "<span size="x-large">è uguale a output</span>");
	  //gtk_label_set_text(GTK_LABEL(label),"è uguale a output");
  }
  else {
	  gchar *saluto = "Ciao";
	  //g_strconcat: serve ad unire piu stringhe. Ricordarsi il NULL alla fine!
	  gchar *stringa3 = g_strconcat("<span size="x-large">",saluto,"</span>", NULL);
	  gtk_label_set_markup (GTK_LABEL(label), stringa3);
	  //invece avrei usato:
	  //gtk_label_set_text(GTK_LABEL(label),stringa2);
	  //Se non avevo tag di stile <span>
  }
}

void on_entry1_activate (GtkWidget *widget, gpointer user_data)
{
   printf ("Hai scritto il tuo nome.n");
  
   gchar output[80]="Ciao ";
   strcat(output,gtk_entry_get_text(GTK_ENTRY(widget)));

   printf ("%s n",output);
}

int main (int argc, char *argv[])
{
	GtkWidget *window1;
	GladeXML *xml;

	#ifdef ENABLE_NLS
		bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
		textdomain (PACKAGE);
	#endif

	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	/*
	 * The .glade filename should be on the next line.
	 */
	xml = glade_xml_new ("provalibglade.glade", NULL, NULL);

	/* This is important */
	glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");
	gtk_widget_show (window1);

	gtk_main ();
	return 0;
}

prova4

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void on_risultato1_clicked (GtkWidget *widget, gpointer user_data) {
   GladeXML *self = glade_get_widget_tree(GTK_WIDGET(widget));
   GtkWidget *label = glade_xml_get_widget (self, "label3");
  
   char buffer[50]; 
   int a=2, b=2; 
   g_snprintf(buffer, 49, "%d", a+b);
   //g_snprintf converte l'intero in stringa. E' piu sicuro di usare sprintf.

	
   gtk_label_set_text(GTK_LABEL(label),buffer);	
}

void on_risultato2_clicked (GtkWidget *widget, gpointer user_data) {
   GladeXML *self = glade_get_widget_tree(GTK_WIDGET(widget));
   GtkWidget *label = glade_xml_get_widget (self, "label3");
  
   char buffer[50]; 
   int a=4, b=8; 
   g_snprintf(buffer, 49, "%d", a*b);
	
   gtk_label_set_text(GTK_LABEL(label),buffer);	
}

void on_risultato3_clicked (GtkWidget *widget, gpointer user_data) {
   GladeXML *self = glade_get_widget_tree(GTK_WIDGET(widget));
   GtkWidget *label = glade_xml_get_widget (self, "label3");
  
   char buffer[50]; 
   int a=12, b=4; 
   g_snprintf(buffer, 49, "%d", a/b);
	
   gtk_label_set_text(GTK_LABEL(label),buffer);	
}

void on_info_button_clicked (GtkWidget *widget, gpointer user_data) {
  GtkWidget *window2;
  GladeXML *xml;  
  xml = glade_xml_new ("provaglade4.glade", NULL, NULL);
  glade_xml_signal_autoconnect (xml);
  window2 = glade_xml_get_widget (xml, "window2");
  gtk_widget_show (window2);
}

void on_exit_button_clicked (GtkWidget *widget, gpointer user_data) {
  printf ("Arrivederci!n");
  gtk_main_quit ();
	
}

int main (int argc, char *argv[])
{
	GtkWidget *window1, *widget;
	GladeXML *xml;

	#ifdef ENABLE_NLS
		bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
		textdomain (PACKAGE);
	#endif

	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	/*
	 * The .glade filename should be on the next line.
	 */
	xml = glade_xml_new ("provaglade4.glade", NULL, NULL);
	
    // Questo servirebbe a fare in modo di modificare tutti i caratteri 
    //della finestra (escludendo la scelta di default fatta dall'utente 
	//nelle impostazioni di GNOME. In realtà è preferibile che sia l'utente 
	//a scegliere il carattere che preferisce.
	//g_object_set(gtk_settings_get_default(), "gtk-font-name", "Sans 20", NULL);

//gtk_label_set_use_markup(label, TRUE); gtk_label_set_markup(label, "<b>Your label</b>");
	
	
	/* This is important */
	glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");
	gtk_widget_show (window1);
	
	/* Chiusura del programma quando l'utente chiude la finestra */
    widget = glade_xml_get_widget (xml, "window1");
    g_signal_connect (G_OBJECT (widget), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);

	gtk_main ();
	return 0;
}

prova5

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void
on_button1_clicked (GtkButton *button, gpointer user_data)
{
	GtkWidget *window1;
	window1 = gtk_widget_get_toplevel(button);
	
	char *filename;
	
	GtkWidget *dialog;

   dialog = gtk_file_chooser_dialog_new ("Open File",
				      window1,
				      GTK_FILE_CHOOSER_ACTION_OPEN,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				      NULL);

   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
     {
       //char *filename;

       filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
       //open_file (filename);
       // g_free (filename);
     }
   else filename = "";
	
   gtk_widget_destroy (dialog);
	
	/*  Ho preferito ricercare la GtkLabel a partire da window1, per esigenze di esperimento, 
	*   ma avrei potuto direttamente scrivere:
	*   GladeXML *self = glade_get_widget_tree(GTK_WIDGET(button));
    */
    GladeXML *self = glade_get_widget_tree(GTK_WIDGET(window1));
	GtkWidget *label = glade_xml_get_widget (self, "etichetta");
	gtk_label_set_markup (GTK_LABEL(label), filename);
    return 0;  
}

int main (int argc, char *argv[])
{
	GtkWidget *window1, *button1;
	GladeXML *xml;
	
    // PACKAGE è definito in config.h
	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	
	xml = glade_xml_new ("scelta_file.glade", NULL, NULL);

	/* Ho ESCLUSO l'autoconnect, faccio le callback manualmente */
	// glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");

	button1 = glade_xml_get_widget (xml, "button1");

	g_signal_connect (G_OBJECT (button1), "clicked",
                    G_CALLBACK (on_button1_clicked),
                    NULL);

  g_signal_connect (G_OBJECT (window1), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);
	
	
	gtk_widget_show (window1);

	gtk_main ();
	return 0;
}

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void ok_button_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Grazie per aver provato il programma :)");
  gtk_main_quit ();
}


int
main (int argc, char *argv[])
{
  GladeXML  *main_window;
  GtkWidget *widget;

  gtk_init (&argc, &argv);

  /* Carica l'interfaccia utente */
  main_window = glade_xml_new (PACKAGE_SOURCE_DIR"/progetto_bottone.glade", NULL, NULL);

	/* Predispone la gestione del bottone chiamato "okbutton" */
  widget = glade_xml_get_widget (main_window, "okbutton");
  g_signal_connect (G_OBJECT (widget), "clicked",
                    G_CALLBACK (ok_button_clicked),
                    NULL);
	
  /* Chiusura del programma quando l'utente chiude la finestra */
  widget = glade_xml_get_widget (main_window, "window1");
  g_signal_connect (G_OBJECT (widget), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);

  /* Avvia il ciclo */
  gtk_main ();

  return 0;
}

<span weight="bold" size="larger">Questo programma non fa nulla di importante</span>

Non è stato aggiunto codice al programma se non quello sufficiente a mostrare il pulsante, che chiuderà il tutto.

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

int main (int argc, char *argv[])
{
	GtkWidget *window1;
	GladeXML *xml;

	#ifdef ENABLE_NLS
		bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
		textdomain (PACKAGE);
	#endif

	gnome_init (PACKAGE, VERSION, argc, argv);
	glade_gnome_init ();
	/*
	 * The .glade filename should be on the next line.
	 */
	xml = glade_xml_new (PACKAGE_SOURCE_DIR"/progetto_bottone.glade", NULL, NULL);

	/* This is important */
	glade_xml_signal_autoconnect (xml);
	window1 = glade_xml_get_widget (xml, "window1");
	gtk_widget_show (window1);

	gtk_main ();
	return 0;
}

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void ok_button_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Grazie per aver provato il programma :)");
  gtk_main_quit ();
}


int
main (int argc, char *argv[])
{
  GladeXML  *main_window;
  GtkWidget *widget;

  gtk_init (&argc, &argv);

  /* Carica l'interfaccia utente */
  main_window = glade_xml_new (PACKAGE_SOURCE_DIR"/progetto_bottone.glade", NULL, NULL);

	/* Predispone la gestione del bottone chiamato "okbutton" */
  widget = glade_xml_get_widget (main_window, "okbutton");
  g_signal_connect (G_OBJECT (widget), "clicked",
                    G_CALLBACK (ok_button_clicked),
                    NULL);
	
  /* Chiusura del programma quando l'utente chiude la finestra */
  widget = glade_xml_get_widget (main_window, "window1");
  g_signal_connect (G_OBJECT (widget), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);

  /* Avvia il ciclo */
  gtk_main ();

  return 0;
}

/* Created by Anjuta version 1.2.4a */
/*	This file will not be overwritten */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glade/glade.h>

void ok_button_clicked (GtkWidget *widget, gpointer user_data)
{
  printf ("Grazie per aver provato il programma :)");
  gtk_main_quit ();
}


int
main (int argc, char *argv[])
{
  GladeXML  *main_window;
  GtkWidget *widget;

  gtk_init (&argc, &argv);

  /* Carica l'interfaccia utente */
  main_window = glade_xml_new (PACKAGE_SOURCE_DIR"/progetto_bottone.glade", NULL, NULL);
  glade_xml_signal_autoconnect (main_window);

  /* Avvia il ciclo */
  gtk_main ();

  return 0;
}

Introduzione a Glade 3 e le Libglide

Anjuta

Installiamo Glade, Anjuta e gli altri accessori

Sviluppare la prima applicazione

• Le guide sembrano molto più difficili lette sullo schermo di quanto non lo siano stampate su carta. E' questo uno dei motivi per cui vi consiglio di stampare questa guida e leggerla con calma.


• Si fa presto l'abitudine ad entrare nei meccanismi che regolano Linux, vi sembrerà incredibile ma è così, ed una volta entrati nel meccanismo vi sentirete così padroni del vostro sistema che ve lo adatterete come un guanto.
• Se non siete laureati in informatica ma avete sempre e solo usato Windows e le vostre conoscenze di Linux sono pari a zero, come così era per me, in una settimana di Linux avrete di certo configurato tutto il sistema, ed in un mesetto saprete tutto quello che c'è da sapere per usarlo in serenità, senza essere dei grandi esperti.
• Ricordate che quasi per ogni problema che incontrerete qualcuno, nel sito della vostra distribuzione e in centinaia di altri siti, blog e forum in rete, gratuitamente vi ha pensato ed ha scritto per voi una guida per risolvere il vostro problema.

• Smettetela di usare Internet Explorer ed installatevi Firefox: è gratis
• Smettetela di usare Outlook per la posta elettronica, ed installatevi Thunderbird: è gratis.
• Smettetela di usare Windows Media Player per vedere i vostri film ed ascoltare musica, ed installatevi VLC: è gratis.

• Connessione ad internet non funzionante. Soluzione: cercate nel sito della distribuzione su come configurare il vostro modem e la connessione ADSL.
• Avviate un gioco 3d o google Earth e scoprite che non vi funziona l'accelerazione 3d. Soluzione: prima guardate la sezione di questa guida relativa alle schede grafiche e poi cercate nel sito della vostra distribuzione come fare ad installare i driver giusti.
• Non funzionano i file midi. Soluzione: vedi l'apposita sezione in questa stessa guida.
• Non funziona la riproduzione dei filmati o di qualche filmato, mpg, avi, DVD o altro. Soluzione: Dovrebbe partire in automatico un tentativo di installazione del codec video giusto. Se questo non succede, leggi la sezione sulle schede grafiche in questa guida e poi vai al sito della distribuzione per cercare le soluzioni all'ultimo grido, fatte apposta per la tua distribuzione, per installare tutti i codec video.
• Non funzionano le applet in JAVA ed i siti in FLASH su Firefox: Soluzione: problema comune e di facile soluzione. Fai una ricerca nel sito della tua distribuzione su come installare Java e flash.
• Non si sente l'audio nei siti in flash su Firefox. Soluzione: vedi sezione "cartelle utilizzate da linux" in questa stessa guida( cerca "/etc/firefox/firefoxrc")

attorianzo@attorianzo-desktop:~$ which gcc
/usr/bin/gcc
attorianzo@attorianzo-desktop:~$ ls -lah /usr/bin/gcc
lrwxrwxrwx 1 root root 7 2007-04-20 17:45 /usr/bin/gcc -> gcc-4.1

attorianzo@attorianzo-desktop:~$ which cc
/usr/bin/cc
attorianzo@attorianzo-desktop:~$ ls -lah /usr/bin/cc
lrwxrwxrwx 1 root root 20 2007-04-20 17:45 /usr/bin/cc -> /etc/alternatives/cc
attorianzo@attorianzo-desktop:~$ ls -lah /etc/alternatives/cc
lrwxrwxrwx 1 root root 12 2007-07-05 17:10 /etc/alternatives/cc -> /usr/bin/gcc

Per quanto riguarda il cominciare a sviluppare JAVA, scaricatevi da Synaptic il pacchetto j2sdk1.4 (o versione piu avanzata, se l'avete)

Vi consiglio di scaricare anche il pacchetto "python-wxgtk2.6" (o versione piu avanzata, se l'avete) che serve per installare le "wxwidget".

Torna al menù principale della "Guida su Linux"
]]> etnablog@altervista.org (Hattori Hanzo) http://etnablog.altervista.org/linux/cominciare-a-programmare-c-con-gtk-e-java/ http://etnablog.altervista.org/linux/boot-del-sistema-e-avvio-automatico-di-applicazioni/ Guida: Passare da Windows a Linux (tredicesima parte)

• XGL : acronimo di X over OpenGL. In sostanza è un'architettura creata per sfruttare l'accelerazione hardware 3d delle schede grafiche.


• AIGLX : Accelerated Indirect GLX ("AIGLX"). e' simile a XGL ma è opensource. Almeno fino al momento in cui vi sto scrivendo, le cose stanno così:
  AiGLX funziona solo con gli ultimi driver beta di Nvidia, per le ATI funziona solo con i driver open inclusi in Xorg ("mesa"), per cui per ora niente supporto da parte dei driver propretari ATI nei riguardi di AiGLX.


• Compiz : E' un desktop 3d. Serve a creare degli effetti in 3d molto belli nel vostro schermo, che si abilitano dall'apposita opzione presente nel menù Preferenze -->Effetti Desktop


• Beryl : Era un progetto analogo e derivato da Compiz. Non più supportato
  
• fglrx : è il driver proprietario di ATI, per le sue schede video. Mi pare di capire che XGL funziona bene con fglrx, lo stesso non si può dire, almeno per ora, di AIGLX.
• mesa : è un driver driver grafico (come fglrx), che è opensource. Questo driver è molto utile per fornire l'accelerazione 3d alle schede di cui non si hanno driver proprietari e/o che siano vecchie (e quindi magari non più supportate dai proprietari).
• Driconf : è un tool grafico, per la configurazione del Direct Rendering Infrastructure (DRI). Consente di personalizzare i settaggi di prestazione e qualità video del driver opengl. Esso consente di personalizzare i settaggi di prestazione e qualità video del driver opengl .

Torna al menù principale della "Guida su Linux"
]]> etnablog@altervista.org (Hattori Hanzo) http://etnablog.altervista.org/linux/montare-smontare-partizioni/ http://etnablog.altervista.org/linux/qemu-vmware-wine/ Guida: Passare da Windows a Linux (Decima parte)

Se disinstalli vmware player ricordati di cancellare la directory /etc/vmware e anche /usr/lib/vmware.

Torna al menù principale della "Guida su Linux"
]]> etnablog@altervista.org (Hattori Hanzo) http://etnablog.altervista.org/linux/qemu-vmware-wine/ http://etnablog.altervista.org/linux/stampe-in-linux/ Guida: Passare da Windows a Linux (Nona parte)

• Utente proprietario (owner) del file
• Gruppo del proprietario
• Altri utenti

• Main (software supportato ufficialmente)
• Restricted (software supportato ma non disponibile nei termini del software libero)
• Universe (mantenuto dalla comunità, non ufficialmente supportato)
• Multiverse (software non libero)

Scarica la versione stampabile della guida (46 pagine formato pdf) .

Menu:

• Introduzione a Linux e ad Ubuntu
• Cartelle utilizzate da linux
• Gestire i processi in esecuzione e sicurezza web
• Scompattare e installare pacchetti
• Disinstallazione di pacchetti
• Gestione files, cartelle e permessi
• Apache2 E Vsftpd (server ftp)
• Stampe
• Qemu, Vmware e Wine
• Montare-smontare partizioni
• Schede grafiche e Linux
• Audio, midi
• Boot del sistema e avvio automatico di applicazioni
• Cominciare a programmare C con GTK e JAVA
• Gli script di shell, i file .sh
• Passare da Windows a Linux