Esempio GUI con QTCreator (2)

Per questo esempio di GUI e' sempre stata usato QtCreator ma utilizzando la creazione manuale dell'evento e non legando in modo automatico i widgets come nell'esempio precedente; cio' comporta la scrittura seppur minima di codice

asdasd

asdasd

Finestra di creazione della gestione dell'evento

Download Debian con Jigdo e Wget

In alcuni casi (vedi per esempio alcune versione testing con processori differenti da i386) e' difficile trovare un numero sufficiente di seeders per scaricare in tempi ragionevoli una ISO via Torrent

Per questo motivo puo' essere utile utilizzare il protocollo Http in modo intelligente ovvero senza sovraccaricare i server che mettono a disposizione le immagini

Wget
con questo comando e' sufficiente conoscere l'indirizzo dell'immagine iso

wget -c URL

con lo switch -c e' possibile interrompere il download e riprenderlo in un secondo momento

Jigdo invece di scarica una ISO preleva i singoli file DEB e poi li ricompone in una immagine
Per fare eseguire il programma si deve scaricare il file .jigdo della distribuzione di interesse e poi digitate

jigdo-lite file.jigdo

in automatico il programma prima scarica un file .template. Nel caso in cui non venga scaricato in automatico (puo' succedere con le testing) si devono scaricare nello stesso momento il file .jigo e .template (sono associati l'uno all'altro e vengono generati nuovi ogni settimana)

Esempio GUI con Gtk/Glade(GtkBuilder) in C

Un ennesimo esempio con l'impiego delle GTK associate al Gui Designer denominato Glade

La caratteristica differente rispetto alle altre librerie viste finora e' la gestione in GTK delle proprieta' dello slider. Per inserire valore massimo, valore minimo e passo dello slider si deve associare un Adjustement,

Si deve quindi cliccare sulla proprieta' del wigdet e creare un nuovo adjustement, a questo punto scorrendo l'albero dei widget compare negli Oggetti un nuovo ramo; cliccando su questo e' possibile modificare le proprieta' dello slider

Schermata di Glade

Schermata di Glade . Gestione degli Adjustement

Glade permette la generazione di due formati file (che di fatto sono entrambi xml) ovvero LibGlade e LibGtkBuilder, nell'esempio di seguito e' stato usato il secondo sistema che di fatto e' quello piu' supportato da GTK2

main.c
---------------------------------------------------------

#include <gtk/gtk.h>
 GtkBuilder *gtkBuilder;
 GtkWidget *mainwin;
 GtkProgressBar *progress;
 GtkLabel *label;
 GtkHScale *scala;

void on_window1_delete_event()
{
  gtk_main_quit();
}

void on_hscale1_value_changed(GtkWidget* widget,gpointer user_data) {
   gdouble current_value = gtk_range_get_value(GTK_RANGE(scala));

 char buffer [14] = { '\0' };
 sprintf ( buffer, "%.0f", current_value);
 gtk_label_set_text(label,buffer);
 gtk_progress_bar_set_fraction(progress,current_value/100);
}


int main (int argc, char **argv) {

 gtk_set_locale();
 /* Initialize the widget set */
 gtk_init (&argc, &argv);
 /* Create the main window */
 gtkBuilder= gtk_builder_new();
 gtk_builder_add_from_file(gtkBuilder,"progressbar.xml",NULL);
 gtk_builder_connect_signals ( gtkBuilder, NULL );

 mainwin= GTK_WIDGET(gtk_builder_get_object(gtkBuilder,"window1"));
 label= GTK_WIDGET(gtk_builder_get_object(gtkBuilder,"label1"));
 progress= GTK_WIDGET(gtk_builder_get_object(gtkBuilder,"progressbar1"));
 scala= GTK_WIDGET(gtk_builder_get_object(gtkBuilder,"hscale1"));

 g_signal_connect (mainwin, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);

 g_object_unref ( G_OBJECT(gtkBuilder) );
 /* Show the application window */
 gtk_widget_show_all ( mainwin );
 /* Enter the main event loop, and wait for user interaction */
 gtk_main ();
 /* The user lost interest */
 return 0;
}

---------------------------------------------------------
progressbar.xml
---------------------------------------------------------

<?xml version="1.0"?>
<interface>
  <requires lib="gtk+" version="2.16"/>
  <!-- interface-naming-policy project-wide -->
  <object class="GtkWindow" id="window1">
    <property name="title" translatable="yes">Progress Bar</property>
    <property name="default_width">200</property>
    <property name="default_height">90</property>
    <signal name="delete_event" handler="on_window1_delete_event"/>
    <child>
      <object class="GtkVBox" id="vbox1">
        <property name="visible">True</property>
        <property name="orientation">vertical</property>
        <child>
          <object class="GtkHScale" id="hscale1">
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="adjustment">adjustment1</property>
            <property name="lower_stepper_sensitivity">off</property>
            <property name="upper_stepper_sensitivity">off</property>
            <property name="digits">0</property>
            <property name="draw_value">False</property>
            <property name="value_pos">left</property>
            <signal name="value_changed" handler="on_hscale1_value_changed"/>
          </object>
          <packing>
            <property name="position">0</property>
          </packing>
        </child>
        <child>
          <object class="GtkLabel" id="label1">
            <property name="visible">True</property>
            <property name="label" translatable="yes">0
</property>
          </object>
          <packing>
            <property name="position">1</property>
          </packing>
        </child>
        <child>
          <object class="GtkProgressBar" id="progressbar1">
            <property name="visible">True</property>
          </object>
          <packing>
            <property name="position">2</property>
          </packing>
        </child>
      </object>
    </child>
  </object>
  <object class="GtkAdjustment" id="adjustment1">
    <property name="upper">110</property>
    <property name="step_increment">1</property>
    <property name="page_increment">10</property>
    <property name="page_size">10</property>
  </object>
</interface>

---------------------------------------------------------
Makefile
--------------------------------------------------------

LIBS=$(shell pkg-config --cflags --libs gtk+-2.0)
CFLAGS=-Wall -g -export-dynamic
hello: main.c
gcc -o progress_bar main.c $(LIBS) $(CFLAGS)

--------------------------------------------------------
A questo link i file di esempio

Esempio GUI con Gtk/Anjuta in C

Per la generazione di questo esempio e' stato impiegato Anjuta, una Ide che integra al suo interno Glade per la generazione dell'interfaccia.

Nella creazione di un progetto GTK vengono gia' creati i file necessari compreso un file.ui per il codice xml dell'interfaccia grafica ed i file main e callbacks per il codice da eseguite

Glade all'interno di Anjuta

Nota bene: la versione di Glade inserita in Anjuta ha un errore nella gestione dei segnali (almeno nella versione pacchettizzata in Debian stable 6). In pratica il menu a tendina associato ai widget non mostra gli eventi associati ma una lista di valori bianchi (la versione di Glade che si scarica in modo separato invece funziona in modo corretto)..si deve conoscere ed inserire a mano il nome dell'evento da gestire

Al link seguente il progetto completo per la generazione dell'esempio link

Altrimenti il codice puo' essere riscritto separando la parte della gestione degli eventi (callbacks.c) cosi' come Anjuta suggerisce implicitamente
main.c
----------------------------------------------------------------

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * main.c
 * Copyright (C) Luca Innocenti 2012 <lucainnoc@gmail.com>
 * 
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#include <config.h>
#include <gtk/gtk.h>
#include "callbacks.h"
#define UI_FILE "src/gtkglade.ui"


GtkWidget* create_window (void)
{
GtkBuilder *builder;
GError* error = NULL;

builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, UI_FILE, &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}

gtk_builder_connect_signals (builder, NULL);
window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
progress = GTK_WIDGET (gtk_builder_get_object (builder, "progressbar1"));
label = GTK_WIDGET (gtk_builder_get_object (builder, "label1"));
scala = GTK_WIDGET (gtk_builder_get_object (builder, "hscale1"));

g_object_unref (builder);
return window;
}

int main (int argc, char *argv[])
{
  GtkWidget *window;
gtk_set_locale ();
gtk_init (&argc, &argv);
window = create_window ();
gtk_widget_show (window);
gtk_main ();
return 0;
}

----------------------------------------------------------------
callbacks.c
----------------------------------------------------------------

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * callbacks.c
 * Copyright (C) Luca Innocenti 2012 <lucainnoc@gmail.com>
 */

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

#include "callbacks.h"

void on_hscale1_value_changed(GtkWidget* widget,gpointer user_data) {
   gdouble current_value = gtk_range_get_value(GTK_RANGE(scala));

 char buffer [14] = { '\0' };
 sprintf ( buffer, "%.0f", current_value);
 gtk_label_set_text(label,buffer); 
 gtk_progress_bar_set_fraction(progress,current_value/100);
}

void
destroy (GtkWidget *widget, gpointer data)
{
gtk_main_quit ();
}

----------------------------------------------------------------

callbacks.h
----------------------------------------------------------------

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * callbacks.h
 * Copyright (C) Luca Innocenti 2012 <lucainnoc@gmail.com>
 */

#include <gtk/gtk.h>

GtkWidget *window;
GtkProgressBar *progress;
GtkLabel *label;
GtkHScale *scala;

void destroy (GtkWidget *widget, gpointer data);
void on_hscale1_value_changed(GtkWidget* widget,gpointer user_data);

----------------------------------------------------------------

Al link seguente il codice completo del progetto link

Esempio GUI con Fltk in C++

La Gui di esempio scritta in Fltk/C++

La compilazione e' estremamente semplice perche' nel pacchetto della libreria e' inserito uno script apposito e la compilazione avviene mediante il comando

fltk-config --compile main.cpp

Da notare che Debian 6 Stable include una versione piuttosto vecchia di Fltk (la 1.1)

--------------------------------------------------

#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Slider.H>
#include <FL/Fl_Progress.H>
#include <FL/Fl_Text_Display.H>
#include <FL/Fl_Hor_Nice_Slider.H>
#include <iostream>
#include <stdio.h>

//fltk-config  --compile  main.cpp

using namespace std;

Fl_Text_Display *disp;
Fl_Text_Buffer *tbuff;
Fl_Progress *prog; 

void slider_cb( Fl_Widget* o, void* ) {

    char buffer [5];

    Fl_Hor_Nice_Slider* b=(Fl_Hor_Nice_Slider*)o;

    int valore = b->value(); 
    prog->value(valore);
    
    sprintf(buffer,"%d",valore);
    tbuff->text(buffer);

}

int main() {

    Fl_Window win(100,100,200,120,"Progress Bar" );
    win.begin();

    disp = new Fl_Text_Display(80, 40, 40, 21);
    tbuff = new Fl_Text_Buffer(); // text buffer
    disp->buffer(tbuff);
    tbuff->text("0");

    prog = new Fl_Progress( 10, 80, 180, 20,"");
    prog->value(0);

    Fl_Hor_Nice_Slider *slider = new Fl_Hor_Nice_Slider( 10, 10, 180, 20,"");
    slider->minimum(0);
    slider->maximum(100);
    slider->step(1);
    slider->callback(slider_cb);

    win.end();
    win.show();
    return Fl::run();
}

Esempio GUI in PyFltk

La libreria Fltk e' conosciuta per la leggerezza e la velocita' (tanto da essere compilata anche staticamente nei  programmi)

Il problema e' che non si hanno tutti i widgets di cui sono composte le altre librerie (per esempio non esiste la Label per cui bisogna usare una casella di testo) e non ci sono tutte le proprieta' (per esempio nella casella di testo non esiste un ALIGN_CENTER)
Dall'altra parte la gestione dei widget e' piuttosto strana: per esempio per mettere del testo in una casella di testo bisogna creare un Text Buffer

Per terminare gli eventi sono generici come nel caso dello slider che ha solo un evento associato

Nonostante tutto pero' la cosa funziona bene...
------------------------------------------------

from fltk import *
import sys

def slider_cb(widget):
progress.value(widget.value())
textbuffer.text(str(int(widget.value())))

window = Fl_Window(100,100,200,120)
window.label("Progress Bar")

slider = Fl_Hor_Nice_Slider( 10, 10, 180, 20,"")
slider.minimum(0)
slider.maximum(100)
slider.step(1)
slider.callback(slider_cb)


textbuffer = Fl_Text_Buffer()
textbuffer.text("0")
textdisplay = Fl_Text_Display(80, 40, 40, 21)
textdisplay.buffer(textbuffer)

progress = Fl_Progress( 10, 80, 180, 20,"")
progress.value(0)
progress.label("%") 

window.end()
window.show(len(sys.argv), sys.argv)
Fl.run()

Esempio GUI (TUI) con CDK/NCurses in C

Tecnicamente la libreria CDK non fornisce una GUI (Graphic User Interface) bensi' una TUI (Text User Interface)

L'esempio riportato e' preso integralmente dai file di esempio; a differenza dei casi precedenti questo tool mette insieme sia lo slider che la progress bar quindi e' tutto integrato in un solo comando

Per modificare il valore dello slider si usano le frecce cursore alto/basso
----------------------------------------------------------

#include <cdk/cdk.h>

int main (int argc, char **argv)
{
   /* *INDENT-EQLS* */
   CDKSCREEN *cdkscreen = 0;
   CDKSLIDER *widget    = 0;
   WINDOW *cursesWin    = 0;
   const char *title    = "<C></U>ProgressBar";
   const char *label    = "</B>Valore:";
   char temp[256];
   const char *mesg[5];
   int selection;

   CDK_PARAMS params;
   int high;
   int inc;
   int low;

   CDKparseParams (argc, argv, &params, "h:i:l:w:" CDK_MIN_PARAMS);
   high = CDKparamNumber2 (&params, 'h', 100);
   inc = CDKparamNumber2 (&params, 'i', 1);
   low = CDKparamNumber2 (&params, 'l', 1);

   /* Set up CDK. */
   cursesWin = initscr ();
   cdkscreen = initCDKScreen (cursesWin);

   /* Start CDK Colors. */
   initCDKColor ();

   /* Create the widget. */
   widget = newCDKSlider (cdkscreen,
 CDKparamValue (&params, 'X', CENTER),
 CDKparamValue (&params, 'Y', CENTER),
 title, label,
 A_REVERSE | COLOR_PAIR (29) | ' ',
 CDKparamNumber2 (&params, 'w', 50),
 low, low, high,
 inc, (inc * 2),
 CDKparamValue (&params, 'N', TRUE),
 CDKparamValue (&params, 'S', FALSE));

   /* Is the widget null? */
   if (widget == 0)
   {
      /* Exit CDK. */
      destroyCDKScreen (cdkscreen);
      endCDK ();

      printf ("Cannot make the widget. Is the window too small?\n");
      return 1;
   }

   /* Activate the widget. */
   selection = activateCDKSlider (widget, 0);

   /* Check the exit value of the widget. */
   if (widget->exitType == vESCAPE_HIT)
   {
      mesg[0] = "<C>Nessun valore selezionato";
      mesg[1] = "",
      mesg[2] = "<C>Un tasto per continuare.";
      popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
   }
   else if (widget->exitType == vNORMAL)
   {
      sprintf (temp, "<C>E'stato selezionato %d", selection);
      mesg[0] = temp;
      mesg[1] = "",
mesg[2] = "<C>Un tasto per continuare.";
      popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
   }

   /* Clean up. */
   destroyCDKSlider (widget);
   destroyCDKScreen (cdkscreen);
   endCDK ();
   return 0;
}

Compilare SDL da riga di comando

il programma di esempio di SDL deve essere modificato nella riga di include in quanto  il file .h si trova in una sottodirectory (si devono installare le librerie di sviluppo indicate qui)

per la compilazione si deve poi usare la stringa

gcc -Wall -O3 -lSDL SDLTest.c -o SDLTest
-------------------------------------------------

#include <stdio.h>
#include <SDL/SDL.h>

#define WIDTH 640
#define HEIGHT 480
#define BPP 4
#define DEPTH 32

void setpixel(SDL_Surface *screen, int x, int y, Uint8 r, Uint8 g, Uint8 b)
{
    Uint32 *pixmem32;
    Uint32 colour;  

    colour = SDL_MapRGB( screen->format, r, g, b );
  
    pixmem32 = (Uint32*) screen->pixels  + y + x;
    *pixmem32 = colour;
}


void DrawScreen(SDL_Surface* screen, int h)
{ 
    int x, y, ytimesw;
  
    if(SDL_MUSTLOCK(screen)) 
    {
        if(SDL_LockSurface(screen) < 0) return;
    }

    for(y = 0; y < screen->h; y++ ) 
    {
        ytimesw = y*screen->pitch/BPP;
        for( x = 0; x < screen->w; x++ ) 
        {
            setpixel(screen, x, ytimesw, (x*x)/256+3*y+h, (y*y)/256+x+h, h);
        }
    }

    if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);
  
    SDL_Flip(screen); 
}


int main(int argc, char* argv[])
{
    SDL_Surface *screen;
    SDL_Event event;
  
    int keypress = 0;
    int h=0; 
  
    if (SDL_Init(SDL_INIT_VIDEO) < 0 ) return 1;
   
    if (!(screen = SDL_SetVideoMode(WIDTH, HEIGHT, DEPTH, SDL_FULLSCREEN|SDL_HWSURFACE)))
    {
        SDL_Quit();
        return 1;
    }
  
    while(!keypress) 
    {
         DrawScreen(screen,h++);
         while(SDL_PollEvent(&event)) 
         {      
              switch (event.type) 
              {
                  case SDL_QUIT:
             keypress = 1;
             break;
                  case SDL_KEYDOWN:
                       keypress = 1;
                       break;
              }
         }
    }

    SDL_Quit();
  
    return 0;
}

Compilare GTK in Code::Blocks in Debian

Come compilare GTK con Code::Blocks sotto Debian

(attenzione agli apici che sono inversi)

Compiler
-------------------------------------------------
`pkg-config –cflags gtk+-2.0 gmodule-export-2.0`
`pkg-config –cflags libglade-2.0`

Linker
--------------------------------------------------------------
`pkg-config –libs gtk+-2.0 gmodule-export-2.0`
`pkg-config –libs libglade-2.0`

altrimenti a linea di comando
gcc `pkg-config –cflags libglade-2.0 –libs gtk+-2.0` `pkg-config –libs gtk+-2.0 gmodule-export-2.0` main.c

Compilare ncurses e cdk

Esempi di compilazione di sorgenti ncurses e cdk sotto Debian

per entrambe le librerie si possono scaricare i pacchetti gia' compilati (sia libreria che dev)

Nel caso di ncurses
gcc -Wall hello.c -l ncurses -o hello
---------------------------------------------------------------
#include <ncurses.h>

int main()
{
initscr(); /* Start curses mode  */
printw("Hello World !!!"); /* Print Hello World  */
refresh(); /* Print it on to the real screen */
getch(); /* Wait for user input */
endwin(); /* End curses mode  */

return 0;
}

---------------------------------------------------------------

Per compilare CDK si devono unire le librerie ncurses e cdk

gcc -Wall hello_ex.c -lcdk -lncurses -o hello_ex

(nel caso di Debian si deve modificare la riga di include presente nel pacchetto originale degli esempi di CDK per farlo puntare alla directory corretta ovvero #include <cdk.h> diventa #include <cdk/cdk.h>

---------------------------------------------------------------

#include <cdk/cdk.h>

int main (int argc, char **argv)
{
   CDKSCREEN *cdkscreen;
   CDKLABEL *demo;
   WINDOW *cursesWin;
   const char *mesg[4];

   CDK_PARAMS params;

   CDKparseParams (argc, argv, &params, CDK_MIN_PARAMS);

   /* Set up CDK. */
   cursesWin = initscr ();
   cdkscreen = initCDKScreen (cursesWin);

   /* Start CDK Colors. */
   initCDKColor ();

   /* Set the labels up. */
   mesg[0] = "</5><#UL><#HL(30)><#UR>";
   mesg[1] = "</5><#VL(10)>Hello World!<#VL(10)>";
   mesg[2] = "</5><#LL><#HL(30)><#LR>";

   /* Declare the labels. */
   demo = newCDKLabel (cdkscreen,
      CDKparamValue (&params, 'X', CENTER),
      CDKparamValue (&params, 'Y', CENTER),
      (CDK_CSTRING2) mesg, 3,
      CDKparamValue (&params, 'N', TRUE),
      CDKparamValue (&params, 'S', TRUE));

   setCDKLabelBackgroundAttrib (demo, COLOR_PAIR (2));


   /* Draw the CDK screen. */
   refreshCDKScreen (cdkscreen);
   waitCDKLabel (demo, ' ');

   /* Clean up. */
   destroyCDKLabel (demo);
   destroyCDKScreen (cdkscreen);
   endCDK ();
return(0);
   //ExitProgram (EXIT_SUCCESS);
}

---------------------------------------------------------------

In Code::Blocks gli switch di compilazione si devono inserire come nell'esempio riportato in immagine

Installare VirtualBox Guest Additions con Guest Linux

Nel caso in cui la distribuzione che si voglia installarea all'interno di VirtualBox non sia fornita di apposito pacchetto pre-compilato (come Debian per esempio) e' necessario compilare il pacchetto a mano.

Per esempio in CentOs 5.8 si devono installare
yum install gcc kernel-devel kernerl-headers

Successivamente si deve montare il disco con le Guest Additions (Menu' Dispositivi/Guest Additions) e lanciare il comando VBoxLinuxdditions-x86.run

Esempio GUI con PyQt/QtDesigner

Un ulteriore metodo di generare la GUI di prova mediante PyQt e' quella di avvalersi di QtDesigner (da non confondersi con QtCreator che e' relativo al C ed e' un ambiente di sviluppo completo)

Dopo aver composto l'interfaccia grafica si salva il file (.ui) che non e' altro che un Xml con le informazioni di impaginazione

Successivamente con il comando
puic4.bat -x progressbar.uic > progressbar.py

si puo' generare del codice Python/PyQt per creare la finestra come richiesto

il codice autogenerato dal comando sopra riportato
progressbar.py
---------------------------------------------------
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'c:\Documents and Settings\l.innocenti\Desktop\qt\progressbar.ui'
#
# Created: Mon Aug 27 15:05:35 2012
#      by: PyQt4 UI code generator 4.9.4
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s

class Ui_MainWindow(object):

       
    def setupUi(self, MainWindow):
        MainWindow.setObjectName(_fromUtf8("MainWindow"))
        MainWindow.resize(351, 117)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
        self.horizontalSlider = QtGui.QSlider(self.centralwidget)
        self.horizontalSlider.setGeometry(QtCore.QRect(10, 10, 331, 21))
        self.horizontalSlider.setOrientation(QtCore.Qt.Horizontal)
        self.horizontalSlider.setObjectName(_fromUtf8("horizontalSlider"))
        self.progressBar = QtGui.QProgressBar(self.centralwidget)
        self.progressBar.setGeometry(QtCore.QRect(10, 70, 341, 23))
        self.progressBar.setProperty("value", 24)
        self.progressBar.setObjectName(_fromUtf8("progressBar"))
        self.label = QtGui.QLabel(self.centralwidget)
        self.label.setGeometry(QtCore.QRect(10, 40, 331, 20))
        self.label.setAlignment(QtCore.Qt.AlignCenter)
        self.label.setObjectName(_fromUtf8("label"))
        MainWindow.setCentralWidget(self.centralwidget)
        self.actionCambia_valore = QtGui.QAction(MainWindow)
        self.actionCambia_valore.setObjectName(_fromUtf8("actionCambia_valore"))

        self.retranslateUi(MainWindow)
        QtCore.QObject.connect(self.horizontalSlider, QtCore.SIGNAL("valueChanged(int)"), self.azione)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)

    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(QtGui.QApplication.translate("MainWindow", "Progress Bar", None, QtGui.QApplication.UnicodeUTF8))
        self.label.setText(QtGui.QApplication.translate("MainWindow", "0", None, QtGui.QApplication.UnicodeUTF8))
        self.actionCambia_valore.setText(QtGui.QApplication.translate("MainWindow", "cambia_valore", None, QtGui.QApplication.UnicodeUTF8))


    def azione(self):
        s = self.horizontalSlider.value()
        self.label.setText(str(s))
        self.progressBar.setValue(s)

if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())
---------------------------------------------------
Il problema fondamentale e' che il programma di conversione e' molto buono per generare il codice dei componenti visuali ma non gestisce bene la creazione degli eventi in particolare quelli custom
Per questo motivo e' necessario editare e modificare il codice a mano (evidenziato in giallo)


Progressbar.ui
----------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>351</width>
    <height>117</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Progress Bar</string>
  </property>
  <widget class="QWidget" name="centralwidget">
   <widget class="QSlider" name="horizontalSlider">
    <property name="geometry">
     <rect>
      <x>10</x>
      <y>10</y>
      <width>331</width>
      <height>21</height>
     </rect>
    </property>
    <property name="orientation">
     <enum>Qt::Horizontal</enum>
    </property>
   </widget>
   <widget class="QProgressBar" name="progressBar">
    <property name="geometry">
     <rect>
      <x>10</x>
      <y>70</y>
      <width>341</width>
      <height>23</height>
     </rect>
    </property>
    <property name="value">
     <number>24</number>
    </property>
   </widget>
   <widget class="QLabel" name="label">
    <property name="geometry">
     <rect>
      <x>10</x>
      <y>40</y>
      <width>331</width>
      <height>20</height>
     </rect>
    </property>
    <property name="text">
     <string>0</string>
    </property>
    <property name="alignment">
     <set>Qt::AlignCenter</set>
    </property>
   </widget>
  </widget>
  <action name="actionCambia_valore">
   <property name="text">
    <string>cambia_valore</string>
   </property>
  </action>
 </widget>
 <resources/>
 <connections>
  <connection>
   <sender>horizontalSlider</sender>
   <signal>sliderMoved(int)</signal>
   <receiver>actionCambia_valore</receiver>
   <slot>trigger()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>175</x>
     <y>20</y>
    </hint>
    <hint type="destinationlabel">
     <x>175</x>
     <y>58</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>

----------------------------------------------------

Esempio GUI con PyGTK/Glade

In questa versione dell'esempio di GUI l'interfaccia non e' stata creata da codice bensi' mediante il GUI Designer di GTK ovvero Glade

Per iniziare a creare l'interfaccia deve essere prima aggiunto una form (ovvero un TopLevel) a cui deve essere aggiunta una Box (in questo caso un VBox) per impacchettare i Widgets e successivamente si aggiungono i Widgets
Il nome della finestra di TopLevel e' stato definito come MainWindow (nome che servira' per la referenziazione)

In Properties/Signal si puo' definire l'evento che si vuole catturare

Il salvataggio dell'interfaccia puo' avvenire in due formati (GtkBuilder e Libglade). Nell'esempio riportato di seguito e' stato scelto LibGlade

Il programma in Python...il codice e' abbastanza autoesplicativo
---------------------------------------------------
 import sys
try:
    import pygtk
    pygtk.require("2.0")
except:
    pass
try:
    import gtk
    import gtk.glade
except:
    sys.exit(1)


class ProgressBar:

    def __init__(self):

      
        self.gladefile = "progressbar.glade"
        self.wTree = gtk.glade.XML(self.gladefile)
        self.window = self.wTree.get_widget("MainWindow")
        self.window.show()
        if (self.window):
            self.window.connect("destroy", gtk.main_quit)

        dic = { "on_hscale1_value_changed" : self.cambia_valore}
        self.wTree.signal_autoconnect(dic)
      
    def cambia_valore(self, widget):
        a = self.wTree.get_widget("hscale1").get_value()
        self.wTree.get_widget("label1").set_text(str(int(a)))
        self.wTree.get_widget("progressbar1").set_fraction(a/100)


      
if __name__ == "__main__":
    hwg = ProgressBar()
    gtk.main()
---------------------------------------------------
progressbar.glade
---------------------------------------------------
 <?xml version="1.0" encoding="UTF-8"?>
<glade-interface>
  <!-- interface-requires gtk+ 2.24 -->
  <!-- interface-naming-policy project-wide -->
  <widget class="GtkWindow" id="MainWindow">
    <property name="can_focus">False</property>
    <property name="title" translatable="yes">Progress Bar</property>
    <property name="default_width">250</property>
    <property name="default_height">80</property>
    <child>
      <widget class="GtkVBox" id="vbox1">
        <property name="visible">True</property>
        <property name="can_focus">False</property>
        <child>
          <widget class="GtkHScale" id="hscale1">
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="adjustment">0 0 110 1 1 10</property>
            <property name="lower_stepper_sensitivity">off</property>
            <property name="upper_stepper_sensitivity">off</property>
            <property name="restrict_to_fill_level">False</property>
            <property name="round_digits">1</property>
            <property name="digits">0</property>
            <property name="draw_value">False</property>
            <signal name="change_value" handler="on_hscale1_change_value" swapped="no"/>
            <signal name="value_changed" handler="on_hscale1_value_changed" swapped="no"/>
          </widget>
          <packing>
            <property name="expand">True</property>
            <property name="fill">True</property>
            <property name="position">0</property>
          </packing>
        </child>
        <child>
          <widget class="GtkLabel" id="label1">
            <property name="visible">True</property>
            <property name="can_focus">False</property>
            <property name="label" translatable="yes">0</property>
          </widget>
          <packing>
            <property name="expand">True</property>
            <property name="fill">True</property>
            <property name="position">1</property>
          </packing>
        </child>
        <child>
          <widget class="GtkProgressBar" id="progressbar1">
            <property name="visible">True</property>
            <property name="can_focus">False</property>
          </widget>
          <packing>
            <property name="expand">True</property>
            <property name="fill">True</property>
            <property name="position">2</property>
          </packing>
        </child>
      </widget>
    </child>
  </widget>
</glade-interface>
---------------------------------------------------

Esempio Gui in Lazarus/Pascal

Per gli esempi delle GUI su Linux stavo cercando di ritirare fuori Kylix (che esisteva anche in versione Open Edition oltre che commerciale) quando mi sono accorto che e' un prodotto praticamente defunto


In ogni caso esiste un sostituto che ne mima le funzionalita', l'interfaccia ed il linguaggio ovvero Lazarus Pascal

La differenza principali nell'Editor di Gui e' che i widgets non si trascinano sul Form ma si deve cliccare sulla toolbar per selezionare il widget e poi cliccare sul Form per inserirlo

Schermata dell'IDE di Lazarus

Per la gestione degli eventi si usa il tab vicino alle proprieta' del widget, si seleziona l'evento e si apre l'editor di codice che nel caso in esame e' particolarmente semplice

--------------------------------------
ProgressBa1.position = TrackBar1.Position;
Label1.Caption = IntToStr(TrackBar1.Position);
--------------------------------------