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 installerThe 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 WindowsGlade 3.6.7 zip for WindowsGtkGlExt installer for WindowsGlut OpenGl for WindowsAll 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 Systemwith its
Eclipse pluginThe script file generated and compiled to create the installer is the following
setup_gtk.nsiUpdating 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: binaries, gl2ps, glade, gtk, gtkglext, OpenGl, windows
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.zipI've created an installer, but it you have to remember that Glade works only with GTK libraries properly installed.
Glade-3.6.7_setup.exeFor 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
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.exeIt 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.nsiGtk all in one installerpygtk-2.12.1-1.win32-py2.5.exepygobject-2.14.1-1.win32-py2.5.exepycairo-1.4.12-1.win32-py2.5.exePyOpenGL-3.0.0.win32.exepygtkglext-1.1.0.win32-py2.5.exeI'll try to keep update this installer.
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.cThis 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.exeEtichette: binaries, Gentoo, gl2ps, glade, gtk, gtkglext, installer, OpenGl, windows
Stupid file list
Creates a dir.txt with the content list (files and dirs) of the current dir.
file_list.py
Distro Linux Time Line
Distro Linux Time Line
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.pyGlade file
first_example.gladeTo draw the OpenGl area is fundamental to remember the connection of expose/realize/configure events (without them I had serious troubles).
Etichette: binaries, gtk, gtkglext, OpenGl, python, windows
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
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.conffstabgrub.confmake.confKernel
config
GktGlExt 1.2.0 Windows
Binari GtkGlExt compilati per Windows32
gtkglext-win32-1.2.0.exeEtichette: binaries, gtk, gtkglext, OpenGl, windows
Strani anelli Xgl
Qualche screenshot Xgl





Etichette: Cube, Gentoo, Linux, OpenGl, Xgl
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 ./
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.
C, OpenGl: glCallList, Quads
gl2.c.html
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.htmlTo 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.
PyInstaller: creare un eseguibile per Windows (ma il procedimento dovrebbe esser simile per altri Sistemi Operativi)
Sito ufficiale (nuovo) di
PyInstallerPyInstaller 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:
- 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\")
- 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)
- 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. - 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.
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 "$< # $<>
Linux Scripting: CUT
cat /etc/passwd |cut -d ':' -f1|tr "\n" ","
Mette la lista utenti in una lista con virgole.
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.
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
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 precedenteU 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 consoleMARCO=io
GINO=tu
export GINO
konsole
Nella secondaecho 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
Problema 1: PyGtkGlext per Windows
ProblemaDove trovare PyGtkGlExt per Windows e Python 2.4?
SoluzioneHo 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 WindowsC'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 GladeRicordarsi 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
- 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).
- per l'interfaccia: librerie Gtk (GNU LGPL), con binding PyGtk (GNU LGPL)
. Anche tali librerie sono portabili (anche in C# ad esempio), ma soprattutto veloci e facili da capire e usare.
- 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)
- per inserire il disegno in un widget dell'interfaccia: libreria GtkGlExt con relativo binding PyGtkGlExt (licenza GNU LGPL)
- 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")
- 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)