mercoledì, novembre 04, 2009

Gtk+, Glade, GtkGlExt all in one Windows installer

I created an all in one Windows installer,
for using Gtk+ libraries,
also with Glade 3.6.7 (GUI visual creation) and
GtkGlExt (OpenGl embedded in a GtkDrawingArea).

You can download the Gtk+, Glade, GtkGlExt global installer from this links:
Gtk+, Glade, GtkGlext all in one Windows installer

The installer simply copies the files into a Gtk directory, updating PATH environment variable.


Optionally, you can also get the different parts of the dlls which form the previous installer from the following links:
Gtk+ for Windows
Glade 3.6.7 zip for Windows
GtkGlExt installer for Windows
Glut OpenGl for Windows

All the libraries are updated to the last version of today, and they seem to be perfectly useful (my project works very well).
I'll try to mantain here the most updated files.

You can view the licenses from those links.

The installer was created using
NSIS (Nullsoft Scriptable Install System
with its Eclipse plugin

The script file generated and compiled to create the installer is the following
setup_gtk.nsi

Updating this installer is easy!
It is simple to maintain by everybody.

  • You must only install NSIS,
  • take the Windows binaries of the different tools from the official links,
  • put them in c:\program files\GTK directory,
  • compile setup_gtk.nsi file here aboveI updated.

Updated to the date of this post with the latest libraries:

Glade 3.6.7!
Libglade 2.6.4
GLib 2.22.2
GTK+ 2.16.6
Pango 1.26.0
ATK 1.26.0
cairo 1.8.8

Etichette: , , , , , ,

domenica, novembre 01, 2009

Glade 3.6.7 for Windows, installer

I've compiled Glade 3.6.7 for Windows.

Also the new libglade 2.6.4 has been compiled for Windows and included in the package.

You simply have to unzip the following file into Gtk directory:
glade3.zip
I've created an installer, but it you have to remember that Glade works only with GTK libraries properly installed.
Glade-3.6.7_setup.exe

For compiling I've used the guide in this link:
http://gpz500.wordpress.com/2008/04/18/glade3-per-windows/

If you need an all in one installer you can use the Gtk one of mine, I've update including Glade:
GTK-2.16.5 installer

venerdì, aprile 17, 2009

Python, PyGtk, PyOpenGL, PyGtkGlExt, PyWin32 all in one installer

After Gtk+ Installer, I realized also a PyGtk all in one installer, for Python 2.5.4 only.

You can download it from here:

pygtk_windows_installer.exe

It is simply an assembling of all the different installers I previously downloaded (which are executed step by step), and you can choose.


I realized this installer using EclipseNSIS and compiling the script generated by NSIS.

Then, the script I created and that you can compile and modify using NSIS is the following:

pygtk_windows_installer.nsi


Gtk all in one installer

pygtk-2.12.1-1.win32-py2.5.exe
pygobject-2.14.1-1.win32-py2.5.exe
pycairo-1.4.12-1.win32-py2.5.exe
PyOpenGL-3.0.0.win32.exe
pygtkglext-1.1.0.win32-py2.5.exe

I'll try to keep update this installer.

lunedì, marzo 24, 2008

Simple C Gtk Project in DevCpp

I tried to compile a simple C Gtk Project in DevCpp.
There are many things to do, especially about Include dirs, Lib dirs.
I updated also a new Gtk installer, because I insert new include files that there weren't before and that created errors in compiling.

The fastest way to explain, I think, is to upload the Simple_gtk_project.dev with the source simple_gtk_main.c
This file was used on my Italian Windows XP pc, then it has wrong links that you must substitute with yours.
Then you must change, in .dev, file all "C:\Programmi\Gtk" with your Gtk home dir (for example "C:\Program files\Gtk").

If you want to do by yourself I can suggest some hints:

you must enter in "Project Options" menu

in "Parameters" tab, you must set Compiler and Linker options:

in Compiler area insert "-mms-bitfields"

in Linker area you must insert all libraries (dll) which are in your "GTK\bin" dir:
-lm
-lbzip2
-lcharset
-lfreetype6
-lglut32
-liconv
-lintl
-ljpeg62
-lart_lgpl_2-2
-latk-1.0-0
-lcairo-2
-lcroco-0.6-3
-lexpat
-lfontconfig-1
-lfreetype-6
-lgdk-win32-2.0-0
-lgdkglext-win32-1.0-0
-lgdk_pixbuf-2.0-0
-lgio-2.0-0
-lglade-2.0-0
-lgladeui-1-7
-lglib-2.0-0
-lgmodule-2.0-0
-lgobject-2.0-0
-lgsf-1-114
-lgsf-win32-1-114
-lgthread-2.0-0
-lgtk-win32-2.0-0
-lgtkglext-win32-1.0-0
-lpango-1.0-0
-lpangocairo-1.0-0
-lpangoft2-1.0-0
-lpangowin32-1.0-0
-lpng12
-lpng13
-ltiff3
-lxml2
-lzlib1
-l_gl2ps_sw

in Files/Dirs tab you must set:
in Library dirs subtab: your "GTK\bin" dir

In my case
c:\Programmi\Gtk\bin

in Include dirs subtab you must set all the subdirs in "GTK\include"your "GTK\include" dir

In my case they are:
c:\Programmi\Gtk\include\gtk-2.0;
c:\Programmi\Gtk\include\cairo;
c:\Programmi\Gtk\include\glib-2.0;
c:\Programmi\Gtk\include\atk-1.0;
c:\Programmi\Gtk\include\libxml;
c:\Programmi\Gtk\include\pango-1.0;
c:\Programmi\Gtk\include\libgladeui-10

Nothing else, it seems to compile and execute fine.

The exe file I generated is here:


Simple_gtk_project.exe

Etichette: , , , , , , , ,

martedì, marzo 18, 2008

Stupid file list

Creates a dir.txt with the content list (files and dirs) of the current dir.


file_list.py

sabato, maggio 19, 2007

Distro Linux Time Line

Distro Linux Time Line

mercoledì, maggio 02, 2007

PyGtkGlExt, a simple OpenGl box in a PyGtk Window

It is an example of a Python application with a Gtk GUI with an embedded OpenGl box.
This fusion is allowed thanks to GtkGlExt library and all Python wrappers of these ones.

GUI and run application Draw.py
Glade file first_example.glade

To draw the OpenGl area is fundamental to remember the connection of expose/realize/configure events (without them I had serious troubles).

Etichette: , , , , ,

sabato, aprile 21, 2007

Vettori in C

Gruppo di posizioni di memoria, stesso nome, stesso tipo di dato.
Dichiarazione:
int array[5]
Dichiarazione e inizializzazione:
int array[5] = { 1, 2, 3, 4, 5}
Dichiarazione mancante ma inizializzazione:
int array[] = { 1, 2, 3, 4, 5}
Azzeramento automatico degli elementi del vettore quando ci sono meno inizializzatori della lunghezza dell'array (ma ne serve almeno uno).

int array[5] = {1,2,3}; corrisponde a
int array[5] = {1, 2, 3, 0, 0};

Le stringhe sono array di caratteri:
char* prova = "ciao"; corrisponde a
char* prova = {'c', 'i', 'a', 'o', '\0'}
dove '\0' e' il carattere che termina le stringhe

All'interno di funzioni, se l'array e' "static" allora viene automaticamente inizializzato dal compilatore

static int a[5]; corrisponde a int a[5] = {0,0,0,0,0} ma solo la prima volta che la funzione viene chiamata (successivamente conserva i valori precedenti, static serve proprio a svincolare la "localita'" della variabile).


Passaggio di vettori a funzioni.

Passaggio vettori e' per riferimento, in pratica il nome del vettore e' l'indirizzo del primo elemento

char array[4] ="ciao";
passo(array);
corrisponde a passare
&array[0] oppure
&array

modifica_vettore(mio_array, lunghezza_mio_array);
...
void modifica_vettore(int array[], int lunghezza_array);



Passaggio e' per riferimento (il vettore e' modificabile).
Per rendere il vettore non modificabile la funzione deve essere definita avendo parametro del vettore con const
void modifica_vettore(const int array[], int lunghezza_array);

Array con permanenza in memoria statica e automatica
array.c

sabato, marzo 31, 2007

Script vari Gentoo/Linux

HP Pavilion 8051dv, Xpress 200, Amd Turion64
XOrg 7.2
Ati-drivers 8.35
Mesa 6.5.2
Kernel 2.6.19, gentoo-sources

Xgl
Xgl -fullscreen :1 -audit 0 -ac -accel glx:pbuffer -accel xv:pbuffer & sleep 4
LD_PRELOAD=/usr/lib/opengl/ati/lib/libGL.so LD_LIBRARY_PATH=/usr/lib/opengl/ati/lib/ DISPLAY=:1 beryl-manager
DISPLAY=:1 heliodor &
Problema Ethernet a soli 10 Mbit
ethtool -s eth0 speed 10 duplex full autoneg on
xorg.conf
fstab

grub.conf

make.conf

Kernel
config

GktGlExt 1.2.0 Windows

Binari GtkGlExt compilati per Windows32

gtkglext-win32-1.2.0.exe

Etichette: , , , ,

Strani anelli Xgl

Qualche screenshot Xgl









Etichette: , , , ,

lunedì, marzo 05, 2007

Java plugin in Firefox su Gentoo a 64 bit

Non esiste un Java Plugin per Firefox a 64 bit.
Pertanto occorre installarsi Firefox a 32 bit (in un Gentoo a 64 bit quindi si fa "emerge mozilla-firefox-bin").

Poi occorre prendersi un JRE a 32 bit e installarselo da qualche parte (supponiamo /opt/jre-1.5.11).

Si va nella directory dei plugin di Firefox: /opt/firefox/plugins/.

Si fa in link simbolico
ln -s /opt/jre1.5.0_11/plugin/i386/ns7/libjavaplugin_oji.so ./

mercoledì, gennaio 17, 2007

Casi d'uso (use cases)

Collezione di storie delle interazioni col sistema per incontrare gli obiettivi delle parti interessate.

Attore: caratterizzazione di un modo di comportarsi
Scenario: sequenza di azioni e interazioni attori e sistema.

Uno scenario e' un'istanza di un caso d'uso, una storia, una sequenza di azioni che produce un risultato osservabile ad uno o piu' attori.
I casi d'uso quindi sono formati da scenari di successo e di fallimento, vanno considerati nel pensare alla maniera, al modo in cui il sistema cerca adempiere agli obiettivi.

I casi d'uso sono requisiti (spesso quelli funzionali).

Non scendere in dettagli, pensare solo al COSA, non al COME (analisi contro progettazione).

Tipi di casi d'uso:

Brevi, storia scritta in un paragrafo lungo.
Informali, diversi paragrafi, eventuali casi d'uso alternativi.
Completi, struttura formata da
  • Prefazione
  • Parti interessate e relativa lista di interessi
  • Precondizioni e postcondizioni.
  • Scenario di successo (happy scenario), senza condizioni formato da interazioni tra attori, validazione del sistema o cambiamento dello stato del sistema.
  • Scenari alternativi, estensioni, formate dalla condizione e dalla gestione dello scenario. C'e' eventuale ritorno a scenario di successo. Scenari alternativi complessi potrebbero essere un altro caso d'uso
  • Requisiti speciali (non funzionali, ad es. "tecnologici")
  • Lista variabilita' tecnologiche e dati (eventuali vincoli a priori)

Livello di dettaglio: riferirsi principalmente a Elementary Business Process

Task di una persona in un luogo ad un certo tempo in risposta ad un evento che aggiunge un valore misurabile lasciando i dati in stato consistente.
Cosa fare.
Quali sono gli obiettivi. Quale e' l'obiettivo padre, ricorsione.

Sottoobiettivi vanno considerati come caso d'uso quando sono precondizioni di piu' scenari di casi d'uso.


Dominio del sistema
Attori primari e obiettivi: trovare attori primari (tra cui i "sistemi", il computer)

Analisi e progettazione

Analisi: capire problema e requisiti
Progetto: soddisfare requisiti, soluzione concettuale, non implementazione

Fare le cose giuste (analisi) e farle correttamente (progetto).

Analisi a oggetti: trovare e descrivere gli oggetti.
Progetto a oggetti: capire come oggetti software collaborano per soddisfare i requisiti.

UML:

linguaggio per specificare, visualizzare, costruire, documentare artefatti di sistemi software.

lunedì, gennaio 15, 2007

C, OpenGl: glCallList, Quads

gl2.c.html

sabato, gennaio 06, 2007

C - OpenGl, create a stupid Window

This is a segment in an example OpenGl window.
It is written to remember all the steps to create a window and give an Ortho perspective, and managing coordinates system.

gl.c.html

To compile in Linux:

cc -o gl gl.c -lglut -lGL -lGLU -lm -L/usr/X11R6/lib

In WIndows it is important to compile and link with math, gl, glu, glut library.
For example in DevC++ we must insert -lm, -lglu, -lgl, -lglut in linker options.

mercoledì, dicembre 13, 2006

PyInstaller: creare un eseguibile per Windows (ma il procedimento dovrebbe esser simile per altri Sistemi Operativi)

Sito ufficiale (nuovo) di
PyInstaller

PyInstaller trasforma programmi scritti in Python in eseguibili a se stanti, la cui esecuzione diventa indipendente dall'interprete Python.

La mia applicazione prevede uso di PyGtk.

Passi da compiere:

  1. Scompattare lo zip scaricabile dal sito in una directory a piacere, da console ("cmd.exe") mettere python.exe nel PATH di Windows ("SET PATH=$PATH;C:\Python25\")
  2. Solo per comodita' conviene spostare la cartella appena scompattata nella cartella genitore del nostro progetto (ad es. se il progetto e' in C:\Padre\Progetto, conviene che PyInstaller sia nella cartella C:\Padre\PyInstaller)
  3. Creare un file di tipo .spec, che "imposta" la configurazione del progetto, al seguente modo:
    python Makespec.py -w ..\Progetto\programma.py

    Cosi' facendo verra' creata nella directory di PyInstaller una directory "programma" con all'interno altre directory e il file spec appena creato.
  4. Per creare infine l'eseguibile:Python Build.py Progetto\programma.spec Verra' quindi creata la directory "distProgramma" in cui all'interno si avra' il file exe con tutti i dll a cui si appoggia eventualmente il nostro programma Python.

giovedì, aprile 27, 2006

Makefile di esempio

OBJS=params_main.o params_print.o
EXE=params
$(EXE): $(OBJS)
$(CC) -o $@ $^
@echo "Obiettivo "$@ # $@ Rappresenta l'obiettivo (in questo caso params)
@echo "Dipendenze "$^ # $^ e' una macro che rappresenta tutte le dipendenze dell'obiettivo, in questo caso params_main.o eparams_print.o
@echo "Dipendenze recenti " $? # $? Rappresenta l'elenco di quelle dipendenze che sono state cambiate recentemente (calcolate automaticamente)
@echo "boh "$< # $<>

mercoledì, aprile 26, 2006

Linux Scripting: CUT

cat /etc/passwd |cut -d ':' -f1|tr "\n" ","

Mette la lista utenti in una lista con virgole.

giovedì, marzo 30, 2006

Creare gl2ps in Python con Swig (in Windows)

  • Scaricare gl2ps dal sito www.geuz.org/gl2ps/
  • Scaricare Swig dal sito www.swig.org
  • Creare il file interfaccia gl2ps.i, e' possibile scaricare e usare questo
  • Digitare i comandi di Swig swig -python gl2ps.i
  • Verrà creato un file gl2ps_wrap.c e un file gl2ps.py, immergere gl2ps_wrap.c nei sorgenti scaricati di gl2ps, creare un progetto (ad esempio con Dev). Ecco il file del progetto dev:gl2ps_sw.dev. Il file gl2ps.py va usato nel progetto Python
  • Compilare il progetto gl2ps con gl2ps_wrap.c, prendere il dll e metterlo in %PYTHON_DIR%\Dlls
  • Usare gl2ps.py in Python
Nel mio progetto il file gl2ps_wrap.c deve essere rinominato in gl2ps_sw.c per far funzionare il gl2ps_sw.dev.
Occorre far coincidere il nome del file .dll e il nome del file Python importato all'interno del modulo creato (ossia all'inizio di gl2ps.py c'e' un import: verificare che sia uguale al dll)
Per usarlo si devono usare fopen e fclose (e fput) classici del C.

domenica, marzo 19, 2006

Pattern Observer (Publish/Subscribe)

GoF : singleton, strategy, observer, facade, composite

Modello non deve conoscere la presentazione


Problema: Differenti oggetti subscriber sono interessati a cambiamenti di stato o eventi per reagire eventualmente, mantenendo basso accoppiamento con publisher

Soluzione: interfaccia Subscriber/Listener implementata da tutti gli interessati

  • Observer (Property Listener) ha un metodo Update che poi viene implementato dalle classi della Presentazione figlie ,
  • il Subject (Modello) può inserirsi e togliersi i riferimenti di Observer di ogni figlia e ad ogni notifica li scansiona, i metodi della classe Subject hanno la stessa implementazione per tutte le istanze, per cui Subject viene ovviamente derivata,
  • l’istanza vista (ConcreteObserver), usando l’evento aggiorna la propria Presentazione.

Inizializzazione:

  • Il programma principale crea il Modello e la Vista (passando ad essa il Modello),
  • la Vista fa attaccare (tramite il riferimento appena passato) se stessa al Modello,
  • chiama un metodo creaController e gli passa il Modello e la Vista,
  • il Controller tramite il riferimento al Modello passa al Modello se stesso.




Esempio: Python Observer

domenica, marzo 12, 2006

Linux Scripting: Standard error, output

cat marco>prova 2>&1

Redirige lo standard error verso lo standard output (al posto di &1 puo' esserci un file)

Scripting Linux: Control

Nella console la pressione di Control insieme a un carattere provoca diverse reazioni:

B sinistra
F destra
P comando precedente, sopra
N successivo, sotto
A inizio riga
E fine riga
W cancella parola precedente
U cancella intera riga

Scripting Linux: variabili ambiente e shell

Differenza: quelle di ambiente sono accedibili ai programmi (che le usano per le loro comodita', ad esempio un CLASSPATH di Java)

PROVA=ciao
export PROVA

export trasferisce a spazio memoria per variabili ambiente

Esempio
Creando una variabile di shell e poi avviare una subconsole e una di ambiente con subconsole, la variabile di ambiente "passa", quella di shell no (provare con un echo)

Nella prima console
MARCO=io
GINO=tu
export GINO

konsole

Nella seconda
echo MARCO

echo GINO
tu

Linux Scripting: LS

ilgenio@ZemanLandia Desktop $ ls -ltFira
totale 167
2317 -rw-r--r-- 1 ilgenio users 4298 21 dic 2004 Home.desktop
6042 -rw-r--r-- 1 ilgenio users 69 21 dic 2004 .directory
16421 drwxr-xr-x 2 ilgenio users 216 30 gen 20:35 Python/
112 drwxr-xr-x 3 ilgenio users 192 30 gen 20:35 Altro/
3343 drwxr-xr-x 2 ilgenio users 168 7 feb 17:43 Banca/
194 drwxr-xr-x 2 ilgenio users 456 7 feb 17:43 calcoloparallelo/
772 drwxr-xr-x 11 ilgenio users 656 7 feb 17:44 DisCo/
16325 drwxr-xr-x 5 ilgenio users 152 21 feb 22:29 Universita'/
57864 -rw-r--r-- 1 ilgenio users 155389 22 feb 00:27 prospetto_spese_commissioni_hb.pdf
59190 drwxr-xr-x 2 ilgenio users 336 11 mar 14:43 Sistemi operativi/
52 drwx------ 9 ilgenio root 368 11 mar 14:44 ./
4 drwxr-xr-x 50 ilgenio root 2784 12 mar 00:20 ../


Primo carattere dei dieci dopo l'inode:
The file types are as follows: - for an ordinary file, d for a
directory, b for a block special device, c for a character spe-
cial device, l for a symbolic link, p for a fifo, s for a
socket.

Opzioni
l: lista dettagliata
t: ordina per timestamp
F: aggiunge / per le directory, | per le pipe, * per gli eseguibili
i: inode
r: ordine inverso
a: file dot

sabato, marzo 04, 2006

Problema 1: PyGtkGlext per Windows


Problema
Dove trovare PyGtkGlExt per Windows e Python 2.4?
Soluzione
Ho chiesto nella relativa mailing list e mi e' stato fornito il file, che credo possa mettere tranquillamente qui.
PyGtkGlExt 1.01 per Python 2.4 in Windows


C'e' voluto un po' per trovare PyGtkGlExt per Windows: intanto spiego cos'e'.
PyOpengl permette di aprirti una finestra e gestire il tuo mondo OpenGl li'.
A me serve gestire OpenGl in un riquadro di una piu' generica finestra GTK, nella quale vi siano contemporaneamente molti widget, menu', icone, ecc.
GtkGlExt permette (c'era anche GtkGlArea ma e' caduto in disuso) questa immersione all'interno di una finestra (gtk.Window), tramite i widget posso quindi interagire convenientemente e istantaneamente sul disegno.

GtkGlExt e PyGtkGlExt sono realizzati fondamentalmente per Linux, ma molti stanno cominciando a interagire anche con Windows, per cui ho speranze che queste librerie vengano aggiornate continuamente (per ora lo sono, ma comunque non e' necessario questo aggiornamento continuo).
In questo caso, poiche' il Python 2.4 e' abbastanza recente e il mantenitore ufficiale di PyGtkGlExt si e' un po' dileguato (ma nella mailing list c'e' qualcuno che continua ad aggiornare) ho dovuto cercare qualcuno che trovasse il modo di compilare in Windows e Visual Studio tali sorgenti (comunque sempre disponibili), ho cercato io stesso di compilare tali sorgenti.

Non riuscivo a compilarlo (non avendo Visual Studio usavo DevC++) in quanto mi restituiva un errore di compatibilita': Python e PyGtkGlExt dovevano essere stati compilati con lo stesso compilatore.
Credo che sbattendoci la testa il problema si sarebbe potuto comunque risolvere, ma perche' perderci tempo?

Documentazione

Innanzitutto mi suggerisco la documentazione ufficiale: la trovo agevolmente sul sito di Python.

DECISIVI sono poi i newsgroup, nei quali ci sono programmatori che rispondono volontariamente alle domande e senza i quali non andrei da nessuna parte (magari piu' avanti daro' un contributo a qualcuno!).
I newsgroup che uso sono:
Prima di fare una domanda sarebbe d'uopo, secondo me,
  • aver cercato prima con Google
  • aver cercato una domanda simile sul newsgroup (a tal proposito il servizio Google Groups e' strepitoso)
In genere comunque qualcuno che risponde anche alle domande piu' balzane c'e' sempre, a volte si discute a livelli che vanno oltre alle tecnicita' del Python

Poi devo dire che mi piace Dive into Python che rimanda spesso alla giusta pagina della documentazione ufficiale e spiega passo passo: e' un buon tutorial.

Poi per le PyGtk mi piace http://www.parafernalia.org/pygtk/ che e' stato molto utile per realizzarele prime interfacce, che poi comunque costruisco piu' velocemente con Glade.
Conoscere un minimo le Pygtk e', secondo me (e molti altri a quanto leggo in giro), necessario, per capire come funzionano considerando che se poi con Glade servono comunque, per sapere come interagire con i widget "caricati" da libglade.

Per quanto riguarda le PyGtkGlExt mi sono stati utili gli esempi, coi quali si puo' capire subito come usare le relative API e farsi l'area da disegno sull'interfaccia.

Per quanto riguarda OpenGl, punto di riferimento che ho in questo momento e' OpenGl A primer, di Edward Angel (Second Edition), utile soprattutto per capire bene come usare il glOrtho o il gluPerspective, per capire le trasformazioni, le curve.
Credo pero' che alcuni dettagli manchino (ad esempio, come renderizzare in diversi riquadri contemporaneamente? La cosa mi servira' per creare un output ad alta definizione).

Collegare l'interfaccia al modello in PyGtk, con retroazione da parte dell'interfaccia

Tale appunto nasce con lo scopo di ricordarmi i passaggi per collegare l'interfaccia al modello, considerando che l'interfaccia assume funzioni di input e output allo stesso tempo.
Faccio riferimento ad un programmino che mi converte i gradi di temperatura nelle diverse rappresentazioni.

Costruire l'interfaccia con Glade

Ricordarsi di impostare il segnale nei widget interessati (value_changed>on_numero_cambiato)


Creare il dizionario che traduce i segnali in funzioni
segnali={"on_numero_cambiato": self.numero_cambiato}
Connettere la parte grafica al modello tramite il dizionario
applicazione.signal_autoconnect (segnali)

Impostare il caricamento dell'interfaccia dal file
file_interfaccia="Gradi.glade"
applicazione=gtk.glade.XML(file_interfaccia)
main=applicazione.get_widget('main')

Definire attributi e metodi accessori del modello, ricordando di usare un protocollo stabilito che colleghi i nomi dei widget ai nomi dei metodi accessori, nel mio caso kelvin e' il nome del widget che gestisce il cambiamento dei gradi kelvin e nella classe ModelloGrado avro' i metodi get_kelvin e set_kelvin
Definire l'accesso dinamico usando funzione getattr, che permette di chiamare un metodo senza sapere a priori, ma solo a tempo d'esecuzione, in base al nome del widget


Codice del mio esempio
import gtk.glade
import gtk
from gtk.gtkgl import *
from ModelloGrado import *
from InterfacciaGrado import *
class Controllo:
""" Ha il compito di gestire, qui e' implementato velocemente
(avrebbe dovuto gestire l'elemento corrente e passarlo all'interfaccia)"""
def __init__(self):
elemento=ModelloGrado()
interfaccia=InterfacciaGrado()
interfaccia.carica_dati(elemento)
gtk.main()
Controllo()




import gtk.glade
import gtk
from gtk.gtkgl import *
from ModelloGrado import *
class InterfacciaGrado:
def __init__(self):
"""Carica l'interfaccia da file Glade e vi imposta gli attributi"""
file_interfaccia="Gradi.glade" # Nome del file
applicazione=gtk.glade.XML(file_interfaccia) # Carica l'interfaccia
main=applicazione.get_widget('main') # Carica la finestra principale

self.__celsius = applicazione.get_widget('celsius') # Carica gli spinbutton
self.__reaumur = applicazione.get_widget('reaumur')
self.__kelvin = applicazione.get_widget('kelvin')
self.__fahreneit = applicazione.get_widget('fahreneit')

segnali={"on_numero_cambiato": self.numero_cambiato}
applicazione.signal_autoconnect (segnali)
main.show_all()

def carica_dati(self,elemento):
""" Ha lo scopo di caricare i valori dell'elementi del modello negli widget dell'interfaccia"""
self.__elemento_corrente=elemento
self.__semaforo=False # Evita che il segnale che i set_value generano
# non vada a modificare il modello
# creando un ciclo infinito
self.__celsius .set_value(elemento.get_celsius()) # Imposta il valore degli spinbutton
self.__reaumur .set_value(elemento.get_reaumur())
self.__kelvin .set_value(elemento.get_kelvin())
self.__fahreneit.set_value(elemento.get_fahreneit())
self.__semaforo=True
def numero_cambiato(self,widget):
nome_widget=widget.get_name()
testo=widget.get_text().replace(",",".")

if self.__semaforo: # Se il segnale non e' dovuto a un set_value
# vuol dire che viene dall'utente
# quindi modifica l-attributo del modello
getattr(self.__elemento_corrente,"set_"+nome_widget)(float(testo))
self.carica_dati(self.__elemento_corrente)



class ModelloGrado:
""" Non ha altre funzioni se non la gestione dei propri attributi"""
def __init__(self):
self.__grado=0
def get_celsius(self):
return self.__grado
def set_celsius(self,grado):
self.__grado=grado
def get_reaumur(self):
return self.__grado*80/100
def set_reaumur(self,reaumur):
self.__grado=reaumur*100/80
def get_fahreneit(self):
return 32+(self.__grado*180/100)
def set_fahreneit(self,fahreneit):
self.__grado=(fahreneit-32)*100/180
def get_kelvin(self):
return self.__grado+273.15
def set_kelvin(self,kelvin):
self.__grado=kelvin-273.15

Introduzione

Il presente diario prevede l'inserimento di appunti, esperimenti, pensieri riguardo alle mie esperienze nel linguaggio Python, su cui ho messo le mani per la prima volta il 5 dicembre del 2005.
Tali appunti non sono pensati con scopo didattico, ma perche' tendo a dimenticare le cose, quindi mi serve un riferimento veloce per rirordare cose fatte qualche mese prima (e poi c'e' la casella di ricerca qui in cima molto utile).

In che ambito lo sto usando: sono uno studente universitario che deve fare un software per una societa'.
Tale software deve avere un ambiente grafico di disegno, un interfaccia a finestre, la possibilita' di stampare in postscript.
Uso quindi
  1. per il disegno: librerie OpenGl con binding PyOpengl. La scelta ricade su questa libreria per la necessita' di prestazioni e per la portabilita' (ma e' un aspetto molto secondario) di tali librerie. Lo svantaggio principale: occorre creare tutta la modalita' di disegno (snap, trascinamenti, ecc) (Opengl: "Applications developers do not need to license the OpenGL API", PyOpengl: BSD License).

  2. per l'interfaccia: librerie Gtk (GNU LGPL), con binding PyGtk (GNU LGPL)
  3. . Anche tali librerie sono portabili (anche in C# ad esempio), ma soprattutto veloci e facili da capire e usare.
  4. per la costruzione veloce dell'interfaccia: Glade costruisce un file XML (la licenza GPL di Glade non ha influenza sul file XML che genera), con la libreria libglade poi si carica questo file e si creano i widget precedentemente creati con Glade (libglade ha licenza GNU LGPL)

  5. per inserire il disegno in un widget dell'interfaccia: libreria GtkGlExt con relativo binding PyGtkGlExt (licenza GNU LGPL)

  6. per la stampa su file: libreria gl2ps che permette la creazione di un file postscript a partire da codice OpenGl (in poche parole "visualizzando" il normale output OpenGl su file). Le gl2ps sono scritte in C, per cui ho bisogno di Swig: un wrapper che permette di gestire codice C in Python e altri linguaggi (licenza di gl2ps: GNU LGPL, Swig: "free for commercial use")

  7. per tutto il resto: Python
Sistema operativo utilizzato: Windows, perche' dove mi serve c'e' solo questo, e poi perche' comunque l'uso che se ne fara' e' previsto su macchine Windows

Piattaforma di sviluppo: Eclipse+PyDev, un plugin che permette la costruzione di progetti in Python. C'e' anche un diario anche per Pydev, ospitato su Blogspot.
Piccolo problema: Eclipse e' un mattone, ovunque l'ho messo non l'ho visto veloce.

Pydev manca (per quel che ho visto) di alcuni tool quali ad esempio quello per i creatori dei metodi accessori, cosa comunque facilmente programmabile. Inoltre la correzione degli errori non banali avviene quasi sempre successivamente all'esecuzione (ma Python e' un interprete, forse questo e' ovvio)