Software multipiattaforma. Una breve panoramica sulle tecnologie da usare

Sono un pò di anni che ormai programmo, ma non finisco mai di stupirmi su quello che scopro di nuovo!

Ho fatto diversi programmi per desktop, e cerco sempre di farli il più flessibili e aperti possibile, in modo da renderli usabili su più sistemi operativi (anche perchè io stesso uso sia Linux che Windows che Mac OS X).

Voglio fare una breve panoramica, riferendomi ovviamente alle mie esperienze (e sperando di non saprare troppe cavolate ).

Prima di tutto facciamo una breve lista:

• Java (o uno dei suoi derivati che necessitano di una JVM)
• Python
• Mono (C# e VB.NET)
• Qt / QML

Partiamo dal primo.

JAVA

Questo linguaggio nasce proprio con l'intento di creare programmi multi-piattaforma.

L'unica cosa richiesta è la presenza della JVM (Java Virtual Machine), e qualche aggiustamento grafico, soprattutto in ambito Mac.

I contro sono la maggior pesantezza del software (dovuto proprio alla JVM, anche se la situazione è sicuramente migliorata) e il peso degli anni che inizia a sentire il linguaggio, soprattutto verso il C# (considerando la somiglianza tra i due e sperando ovviamente in Java 8).

Rimane comunque un'ottima alternativa, se non la prima in certi casi, guardando però anche ai vari linguaggi nati su questo (vedi Scala ad esempio, con le dovute differenze).

wxPython Grid JSON

Negli articoli precedenti abbiamo visto come ottenere dati in formato JSON da un web service, e come creare una wxPython Grid.

Partendo da quegli articoli vediamo come riempire una Grid perndendo in dati in formato JSON.

Partiamo dalla classe che interroga il web service:

import httplib
import json

class Service(object):

    conn = None

    def __init__(self):
        self.conn = httplib.HTTPConnection("www.miosito.it")
        
    def listLogFile(self):
        self.conn.request(method = "GET", url = "/service/log.php", headers = { "Content-Type": "application/json" })
        res = self.conn.getresponse()
        data = json.loads(res.read())
        tabella = []
        for i in data:
            list = []
            list.append(i["nome"])
            list.append(i["data"])
            tabella.append(list)
        self.conn.close()
        return tabella
       

Fino a qua nulla di nuovo.

wxPython Grid

Oggi vediamo come usare il componente Grid in Python e wxPython.

Questo componente è la "classica" tabella, diviso in righe e colonne.

Vediamone un primo esempio:

import wx
import wx.grid as gridlib

class GridForm(wx.Frame):

    def __init__(self):
        wx.Frame.__init__(self, parent=None, title="Grid")
        panel = wx.Panel(self)
 
        g = gridlib.Grid(panel)
        g.CreateGrid(6, 6)
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(g, 1, wx.EXPAND)
        panel.SetSizer(sizer)
 
if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = GridForm().Show()
    app.MainLoop()

Prima importiamo le librerie che ci interessano.

Inizializiamo il Frame, aggiungiamo un Panel e sotto creiamo la nostra Grid.

Al metodo CreateGrid dobbiamo passargli il numero di righe e colonne.

Sotto avviamo la app.

Scorciatoia da tastiera su Frame in wxPython

Oggi vediamo come impostare un evento da tastiera su Frame in wxPython.

Quello che vogliamo ottenere è la chiusura del programma premendo i classici Ctrl+Q.

Per fare questo dobbiamo usare l'oggetto AcceleratorTable, che ci permette appunto di specificare una scorciatoia da tastiera per un menu o per un comando.

Creare un Frame con wxPython

E piano piano siamo arrivati anche a Python!

Il primo articolo di questo linguaggio riguarda la crezione di una finestra usando le librerie grafiche wxPython.

Le librerie wx sono open e multipiattaform, e ci sono porting per vari linguaggi.

La guida è basata su Python 2.7.

Cercando di fare subito le cose bene, facciamo subito le cose OOP.

Creiamo due file, uno che è i file di init, e uno che contiene la classe per il Frame.

Il primo file l'ho chiamato __init.py con questo dentro:

import wx
from Form import *

if __name__ == "__main__":
    app = wx.App()
    f = Form()
    f.Show()
    app.MainLoop()

Prima di tutto imprtiamo le librerie wx e richiamiamo anche l'altra classe con il Frame.

Sotto inizializimo la App e mostriamo il Frame; questo è il classico modo per lanciare le applicazioni wxPython.