[Enzo74]

Ciao a tutti
visto che più di un amico qui sul forum si diverte come me a fare qualcosina con python per S60 pensavo che fosse cosa utile aprire un topic più specifico dell'argomento e magari cercare di dare qualche piccolo consiglio a chi deciderà di provare a fare qualcosina come noi...
Più che corsi o guide pratiche (che ce ne sono già tantissime in web) pensavo magari a qualche esempio pratico molto ma molto elementare che aiutasse alla comprensione o alla conoscenza seppur basilare delle sue possibilità e del suo modo di lavorare.

Inizio io con l'elencare gli strumenti necessari per iniziare ma sono sicuro che mi farà compagnia più di qualche amico

Brevi informazioni...

Python fondamentalmente è classificato come linguaggio di scripting,
infatti è possibile attraverso dei semplici script di sistema realizzare vere e proprie
applicazioni.
I suoi punti cardini sono la grande quantità di librerie già disponibili e la sua grande
facilità rispetto ai veri e propri linguaggi di programmazione.
In realtà grazie alla folta schiera di utenti che implementano sempre nuove funzionalità
e librerie è possibile realizzare applicazioni anche molto complesse.
Python ha già di suo una bella raccolta di librerie standard a cui è possibile aggiungerne
sempre di nuove scritte in C o in phyton stesso.
Python è multipiattaforma quindi è possibile far girare i suoi script su Linux, Mac, Windows
e altre piattaforme (tra le quali il nostro amato symbian).
Python è free e non bisogna spendere altro che il tempo cui gli si dedica.

dal sito del progetto

Per visualizzare questo link registrati o esegui il log in.

scegliere la versione adatta la vostro cell per esempio

PythonForS60_1_3_11_2ndEdFP2.SIS (6630, 6670, 6680, ecc)
oppure
PythonForS60_1_3_11_2ndEdFP3.SIS (N70, N90)

Per utilizzarlo dalla versione 1.3.11 è necessario anche installare la shell

PythonScriptShell_1_3_11_2ndEdFP2.SIS
oppure
PythonScriptShell_1_3_11_2ndEdFP3.SIS

io consiglio anche la bellissima documentazione allegata
PythonForS60_doc_1_3_11.pdf

e l'SDK per avere l'ambiente di sviluppo al completo (anche se io non lo utilizzo al momento)
PythonForS60_1_3_11_SDK_2ndEdFP2.zip

Messaggio modificato da Il.Socio il 10 novembre 2009 - 23:17

[Enzo74]

A questo punto nel menù potremo vedere la simpatica icona del "pitoncino"
una volta entrati possiamo agire in diversi modi
da opzioni

opzioni -->
Run script
Interactive console
Bluetooth console
About python

In linea di massima con Run script possiamo fare eseguire uno script in formato python (tipicamente hanno l'estensione .py e dato che non sono compilati è possibile darci sempre una sbirciatina anche con il blocco note al pari dei listati HTML).

Con l'interactive console invece possiamo scrivere passo passo il codice che viene eseguito di volta in volta

L'aspetto di pys60 (il python per symbian) è pressappoco questo

 python_s60.gif (4,78K)
Numero di downloads: 739

Come tutti i tutorial che si rispettano si inizia sempre dall'hello word
l'hello word di python è quasi banale
basta scrivere

print "Hello World"

che il sistema restituirà la scritta Hello Word

[Enzo74]

per utilizzare python praticamente è necessario conoscere i suoi moduli e le relative proprietà...
A questo punto una sfogliatina al manuale
PythonForS60_doc_1_3_11.pdf
rende più chiare le cose...

Alcuni moduli ad esempio sono

Appuifw
shutil
e32
os
random
time
camera
sysinfo
audio
location
messaging
inbox

e ogni modulo permette di interagire con qualcosa.
ad esempio il modulo camera la fotocamera del cell, il modulo audio le funzioni realative al suono ecc...

il modulo in linea di massima si deve prima importare con il comando
import...

esempio
import camera importerà questo modulo e a questo punto potremo usare le sue proprietà...

A titolo di esempio pratico il modulo sysinfo controlla le informazioni del sistema e le sue proprietà sono:

battery()
Il valore da 0 a 7 indica lo stato di carica della batteria
display_twips()
Definizione in pixel del display in “twips”
display_pixels()
Definizione in pixel del display in pixel
free_drivespace()
Spazio libero nell'unità che contiene python
imei()
Visualizza codice imei del telefono
max_ramdrive_size()
Ram massima disponibile nel dispositivo
total_ram()
Ram totale
free_ram()
Ram libera
total_rom()
Rom totale
ring_type()
Tipo di suoneria (normale, ascendente, beep, silenzioso)
os_version()
Vesione del sistema operativo
signal()
Il valore da 0 a 7 indica l’intensità del segnale
sw_version()
Versione del software del telefono

per conoscere l'imei del cell quindi bisogna prima importare il modulo
sysinfo e poi richiamare la proprietà imei()
il listato (si fa per dire dato che è cortissimo) è il seguente:

import sysinfo
sysinfo.imei()

per sapere il livello della batteria o per usarlo poi (ad esempio come stringa) in applicazioni più complesse ad esempio

import sysinfo
sysinfo.battery()

o per conoscere le dimensioni del display

import sysinfo
sysinfo.display_pixels()

Messaggio modificato da Enzo74 il 18 ottobre 2006 - 22:21

[giangio1986]

Enzo74, il 18/10/2006 - 22:31, ha scritto:

Come tutti i tutorial che si rispettano si inizia sempre dall'hello word
l'hello word di python è quasi banale
basta scrivere

print "Hello World"

che il sistema restituirà la scritta Hello Word

a me da errore di sintassi...xkè?

[FAxN70]

Giangio.. come ti dà errore di sintassi!?!?
Impossible..!
Nn sò come spiegartelo ben.. ma prima di dare l'invio devi aspettare che il cursore dopo le ultime virgolette torni a lampeggiare..!
Nn sò se mi sono spiegato..!

Cmq.. piccolo "Hello World" avanzato..:
Due semplici righe che si possono eseguire sempre dal interactive console..

import appuifw
appuifw.note(u"Hello World")

Ps io consiglio di installarvi l'sdk della nokia e il relativo Pythonfor sdk ecc... Risparmiate un sacco di tempo, potete provare i vostri programmi direttamente sul pc.. senza dover tenere il cel sempre attaccato..!!

Messaggio modificato da FAxN70 il 19 ottobre 2006 - 01:40

[FAxN70]

Continuo col scrivere qualcosina..
Il linguaggio python è molto semplice e di facile apprendimento anche per il modo in cui vengono compilati gli script.. Ovvero in python l'unica cosa da tener d'occhio sono la punteggiatura e l'indentadura.. nn ci sono parentesi graffe o variabili da dichiarare di difficile comprensione..
Questo è un esempio di Hello world trovato su wikipedia in c++:

"#include <iostream>

int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}"

Mentre in python il tutto si riduce (come abbiamo già visto..):

" print 'Hello World' "

Molto molto più easy..
Come dicevo sono importanti sia le punteggiature che le indentature..
Altro piccolo esempio..
per creare una funzione si usa questa punteggiatura.:

def(dichiara una funzione) nomefunzione():
... operazioni da eseguire
... operazioni da eseguire

#Esemio:#

def somma(x,y):
... risultato=x+y
... print "La somma di %s e %s dà come risultato: %s"%(x,y,risultato)

#Ok la funzione somma è stata dichiarata,è molto importante seguire l'indentatura, ovvero le operazioni che devono essere eseguite dalla funzione "somma" devono essere scritte "all'interno" altrimenti vi darà un errore di sintassi, la funnzione nn farà altro che eseguire la somma di x e y.. e ritornare la stringa "La somma di ecc..." quando chiamate questa funzione dovrete specificare x e y con 2 numeri Esempio:#

>>> somma(5,9)
#ecco cosa otterrete#
La somma di 5 e 9 dà come risultato: 14
>>>

Messaggio modificato da FAxN70 il 19 ottobre 2006 - 15:19

[FAxN70]

Continuo col scrivere qualcosina..
Il linguaggio python è molto semplice e di facile apprendimento anche per il modo in cui vengono compilati gli script.. Ovvero in python l'unica cosa da tener d'occhio sono la punteggiatura e l'indentadura.. nn ci sono parentesi graffe o variabili da dichiarare di difficile comprensione..
Questo è un esempio di Hello world trovato su wikipedia in c++:

"#include <iostream>

int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}"

Mentre in python il tutto si riduce (come abbiamo già visto..):

" print 'Hello World' "

Molto molto più easy..
Come dicevo sono importanti sia le punteggiature che le indentature..
Altro piccolo esempio..
per creare una funzione si usa questa punteggiatura.:

def(dichiara una funzione) nomefunzione():
... operazioni da eseguire
... operazioni da eseguire

#Esemio:#

def somma(x,y):
... risultato=x+y
... print "La somma di %s e %s dà come risultato: %s"%(x,y,risultato)

#Ok la funzione somma è stata dichiarata,è molto importante seguire l'indentatura, ovvero le operazioni che devono essere eseguite dalla funzione "somma" devono essere scritte "all'interno" altrimenti vi darà un errore di sintassi, la funnzione nn farà altro che eseguire la somma di x e y.. e ritornare la stringa "La somma di ecc..." quando chiamate questa funzione dovrete specificare x e y con 2 numeri Esempio:#

>>> somma(5,9)
#ecco cosa otterrete#
La somma di 5 e 9 dà come risultato: 14
>>>

[Enzo74]

APPUIFW
========

Il modulo appuifw è sicuramente uno dei più utilizzati nella programmazione di
applicazioni symbian poichè offre un interfaccia alle nostre applicazioni.
Al pari degli altri moduli prima di utilizzarlo è importante "importarlo" con

import appuifw

E' ora possibile implementare finestre informative, di richiesta (query),
listbox e quant'altro.

Il modulo appuifw ha diverse funzioni tra cui "note" con cui implementare
finestre informative o ad esempio di errore...
provate con

appuifw.note(u"Questa è una finestra informativa", 'info')

oppure con

appuifw.note(u"Questa è una finestra di errore", 'error')

per vederne l'effetto

La funzione "query" invece permette di ottenere un interfaccia attraverso
la quale richiedere un informazione e poterla gestire successivamente

valore = appuifw.query(u'inserisci testo', 'text' )

in questo modo nella variabile valore abbiamo incamerato quello che l'utente
ha scritto nella casella di testo della query.
Potremmo sfruttare l'informazione con dei cicli decisionali (if..then..else..)
oppure a scopo didattico con un

print valore

In questo caso il tipo di dato raccolto è un testo (text) e quindi il tipo
di formato della query è una casella di testo. però è possibile avere dei
tipi di "raccoglitore" diverso come ad esempio quello della data in formato
01/01/1970 o altri.
Es. per una data
valore = appuifw.query(u'inserisci data', 'date' )

l'elenco completo dei formati è
text, code, number, date, time, query e float

La funzione "multi_query" è simile alla query precedentemente vista ma
differisce per il fatto che è possibile richiedere più di una informazione
contemporaneamente. è quindi possibile raccogliere più dati
Eccone un esempio pratico molto semplice

RICHIEDERE INFORMAZIONI MEDIANTE MULTI_QUERYBOX

import appuifw
data1,data2 = appuifw.multi_query(u"Nome:",u"Cognome:")
print data1
print data2

La funzione "popup_menu" permette di creare dei semplici menù per le nostre
applicazioni.
Praticamente si imposta prima una lista attraverso una variabile (nel nostro
esempio mylist) e attraverso la stessa si implementa il menù...

POPUP MENU

import appuifw
mylist = [u'mela',u'banana',u'arancia',u'pera']
appuifw.popup_menu(mylist, u'mia lista')

La funzione "selection_list" permette di ottenere una lista tra cui scegliere
un solo dato.
Il sistema alla fine della scelta restituisce l'indice della scelta (ovvero un
numero che va da 0 a n oggetti - 1)

In questo esempio

APPUIFW - SELECTION_LIST - UNA LISTA

import appuifw
lista = [u'mela',u'banana',u'arancia',u'pera']
appuifw.selection_list(lista)

banana ha indice 1 mentre pera ha indice 3 poichè mela ha indice 0

Sarà così possibile programmare gli eventi legati alla scelta

Con la funzione multi_selection_list invece è possibile scere più valori della
lista che coesistono contemporaneamente.
Mettiamo il caso che all'utente può piacere sia la mela che la pera

APPUIFW - MULTI_SELECTION_LIST - UNA LISTA MULTISELEZIONE

import appuifw
lista = [u'mela',u'banana',u'arancia',u'pera']
appuifw.multi_selection_list(lista, style='checkmark')

[Enzo74]

Esempi pratici dell'utilizzo di appuifw
(molto ma molto brevi)

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

UNA FINESTRA DI ERRORE

import Appuifw
Appuifw.note(u'Nessuna connessione', 'error')

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

DEFINIRE IL TITOLO DELL'APPLICAZIONE

import Appuifw
Appuifw.app.title = u'MiaApp'

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

UNA FINESTRA INFORMATIVA CON TITOLO

import Appuifw
Appuifw.app.title = u"Ciao"
Appuifw.note(u"Questo è un testo di prova!", 'info')

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

APPUIFW.APP.SCREEN - IMPOSTARE LA GRANDEZZA DELL'APPLICAZIONE SULLO SCHERMO

import appuifw
appuifw.app.screen='large'

'le altre possibilità sono normal, large e full

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

LA LISTA DEI FONTS

import Appuifw
devicefonts = Appuifw.available_fonts()
print devicefonts

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

APPUIFW - SELECTION_LIST - UNA LISTA

import appuifw
lista = [u'mela',u'banana',u'arancia',u'pera']
appuifw.selection_list(lista)

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

APPUIFW - MULTI_SELECTION_LIST - UNA LISTA MULTISELEZIONE

import appuifw
lista = [u'mela',u'banana',u'arancia',u'pera']
appuifw.multi_selection_list(lista, style='checkmark')

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

APPUIFW.QUERY - RICHIEDERE UNA DATA

import appuifw
valore = appuifw.query(u'inserisci data', 'date' )
print valore

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

RICHIEDERE INFORMAZIONI MEDIANTE MULTI_QUERYBOX

import Appuifw
data1,data2 = Appuifw.multi_query(u"Nome:",u"Cognome:")
print data1
print data2

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

CANCELLARE LA VIDEATA E RICHIEDERE DEI DATI MEDIANTE QUERY BOX

import Appuifw
Appuifw.app.body = None
valore = Appuifw.query(u'inserisci testo', 'text' )
valore = Appuifw.query(u'inserisci codice', 'code' )

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

POPUP MENU

import Appuifw
mylist = [u'mela',u'banana',u'arancia',u'pera']
Appuifw.popup_menu(mylist, u'mia lista')

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

Elenco di alcune proprietà e metodi del
modulo appuifw


note
Espone un dato (msgbox)

query
Raccoglie un dato mediante casell1 di testo

multi_query
Raccoglie più dati contemporaneamente mediante caselle di testo

selection_list
Raccoglie un dato mediante lista a scelta unica

multi_selection_list
Raccoglie un dato mediante lista a scelta multipla

popup_menu
Costruisce dei semplici menù

appuifw.app.title
Definisce il titolo dell’applicazione

appuifw.app.body
Definisce il “corpo” dell’applicazione

appuifw.available_fonts()
Lista dei fonts disponibili

appuifw.app.screen
Imposta la videata come normal, large o full

appuifw.app.focus
imposta l’applicazione che deve avere il focus (0 = focus perso 1 = focus impostato)

[Enzo74]

Alcuni esempi ELEMENTARI sul modulo Audio

Visto che un pò di amici si stanno cimentando in applicazioni audio
ho provato tre semplicissime applicazioni facilmente realizzabili e
riproducibili direttamente sul telefonino.
Si importa prima il modulo audio con
import audio
poi sia per suonare un file che per registrare bisogna definire il
percorso del file "input" o "output"
e di conseguenza comandare la funzione
play()
o
record()
a seconda se si sta registrando o suonando un file.
la funzione
close()
è utile per "scaricare" dalla memoria il file che
abbiamo impostato come input o come output.
Esiste anche la funzione
stop()
che però non scarica il file ma lo ferma solo nella sua
riproduzione o registrazione in quella determinata posizione.
A questo proposito la guida in pdf ufficiale è davvero ben fatta
Ecco i miei piccoli esempi

SUONARE UN FILE MP3

import audio
s = audio.Sound.open("e:\\moneta_che_cade.mp3")
s.play()

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

REGISTRARE UN FILE WAV

import audio
s = audio.Sound.open("e:\\prova.wav")
s.record()
print "registrazione in corso..."

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

FERMARE E SALVARE UN FILE CHE SI STA REGISTRANDO

'nell'esempio precedente
s.close()

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

consiglio in fase di prova mentre si sta registrando di fermare
la registrazione scrivendo proprio s.close() e poi magari riaprire
il file per sentirlo con lo stesso comando open...
L'interfaccia grafica è a gusto del programmatore

PS. visto che ieri c'era il quesito di quanto lungo poteva essere un
mp3 in riproduzione se fate qualche prova su qualche file particolarmente
lungo mi fate sapere se è tutto ok?
PS2. non ho avuto modo di provare a registrare un file direttamente in
mp3 se qualcuno prova mi fa sapere se funziona?

[Enzo74]

oggi qualche esempio pratico su come usare funzionalità sms e telefono rigorosamente molto piccoli...

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

SMS_SEND - SPEDIRE UN SMS

import messaging
messaging.sms_send("123456789", "testo del messaggio")

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

SMS_SEND - SPEDIRE PIU' SMS

import messaging
messaging.sms_send("123456789", "testo del 1 messaggio")
messaging.sms_send("987654321", "testo del 2 messaggio")

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

TELEPHONE.DIAL - EFFETTUARE UNA TELEFONATA

import telephone
telephone.dial(u'+123456789')

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

INBOX.SMS_MESSAGES - CONOSCERE GLI ID DEI VARI SMS IN CASELLA RICEVUTI

import inbox
i=inbox.Inbox()
i.sms_messages()

'restituisce ad esempio [1053221, 1053013, 1052439]

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

INBOX.CONTENT - CONOSCERE IL TESTO DI UN SMS DAL SUO ID

import inbox
i=inbox.Inbox()
i.content(id dell'sms es 1053221)

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

INBOX.ADDRESS - CONOSCERE IL MITTENTE DI UN SMS DAL SUO ID

import inbox
i=inbox.Inbox()
i.address(id dell'sms es 1053221)

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

INBOX.DELETE - CANCELLARE UN SMS DAL SUO ID

import inbox
i=inbox.Inbox()
i.delete(id dell'sms es 1053221)

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

[Enzo74]

Spesso estrarre o gestire dei caratteri da una stringa inglobata o meno in una variabile può essere necessario. a questo si ispira l'esempio di oggi

ESTRARRE N CARATTERI DA UNA STRINGA

la cifra prima dei due punti (es [3:]) indica quante lettere cancellare dall'inizio della parola

la cifra dopo dei due punti (es [:3]) fa il contrario ovvero indica quante lettere visualizzare dall'inizio della parola (il resto le elimina)


s = "prova"
print s[3:]

-->resituisce "va"

s = "prova"
print s[:3]

-->resituisce "pro"

s = "prova"
print s[:]

-->resituisce "prova"

s = "prova"
print s[2:4]

-->resituisce "ov"

s = "prova"
print s[2:-2]

-->resituisce "o"

praticamente qui si parte dal cancellarne 2 dall'inizio e quindi rimane "ova" ma poi se ne levano 2 dalla fine e quindi rimane "o"

mentre

s = "prova"
print s[2:-1]

-->resituisce "ov"

qui si parte dal cancellarne 2 dall'inizio e quindi rimane "ova" ma poi se ne leva solo 1 dalla fine e quindi rimane "ov"

in effetti python è un pò complicato in questo tipo di sintassi perchè con visual basic sarebbe di gran lunga più semplice e più razionale estrapolare dati dando il punto di inizio e il numero di caratteri da destra o da sinistra

probabilmente quando non è scritto nulla è da intendersi zero

buon python

Messaggio modificato da Il.Socio il 08 novembre 2006 - 11:36

[frizz]

posto a titolo di esempio il codice del programma che ho realizzato con l'aiuto di Enzo74 e Matteo6630
Fa partire chiamate verso un numero di telefono a intervalli di tempo prestabiliti. Tutte vengono chiuse dopo tot secondi. Viene visualizzato l'orario nel quale la chiamata è stata fatta completo di indice dell'ordine della stessa.


from time import ctime #importo il mudulo che mi consente piu in là di acquisire l'orario dall'orologio di sistema

import telephone #importo il modulo che consente l'utilizzo della funzione dial e hang_up
def a():
telephone.dial(u'123456789') #la funzione a() fa partire la chiamata al numero in questione

def b():
telephone.hang_up() #b() invece interrompe la chiamata corrente

import e32
timer= e32.Ao_timer() #creo l'istanza della classe Ao_timer()

timer.after(10) #questa operazione mi consente di 'addormentare' il programma per tot secondi
a() #parte la chiamata dopo 10 secondi di sonno
timer.after(10) #zzzzzzz.....(intanto il cell sta chiamando)
b() #finiti i tot secondi si risveglia e la prima istruzione che trova è questa che fa arrestare la chiamata
print '-1- ', ctime() #il suo bel lavoro l'ha fatto, ma ora visualizza indice e orario corrente xke è uno preciso
print "" #va a capo, cosi poi posso rivedere il tutto in modo ordinato

timer.after(20) #ora l'intervallo tra uno squillo e l'altro è di 20 sec
a()
timer.after(14) #stavolta lo squillo lo faccio un po piu lungo
b()
print '-2- ', ctime()
print ""

timer.after(100)
a()
timer.after(10)
b()
print '-3- ', ctime()
print ""

e cosi via!

Messaggio modificato da frizz il 28 ottobre 2006 - 12:07

[Enzo74]

I tips di oggi riguardano la lettura o la scrittura di un file
sui nostri dispositivi

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

SCRIVERE UN FILE - WRE

import sys
miofile = open('e:/prova.txt','w')
miofile.wre('questo è il testo')
miofile.close()

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

LEGGERE UN FILE - READLINES

import sys
miofile = open('e:/prova.txt','r')
miofile.readlines()

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

magari offrirà nuove funzionalità a qualche programma

[dokkis]

Funzioni di random:

import random
# Random di numeri float da 0 a 1
random.random()
# Random di numeri float da 1 a 10
random.uniform(1,10)
# Random di lettere dalla a alla z
random.choice('abdcefghilmnopqrstuvz')
# Random di numeri interi da 1 a 10 (inclusi)
random.randint(1,10)
# Ordina in modo casuale gli elementi dell'array 'arr'
arr = [1,2,3,4,5,6,7,8,9,10]
random.shuffle(arr)
# Sceglie 4 elementi dell'array 'arr' e li ordina in modo casuale:
arr = [1,2,3,4,5,6,7,8,9,10]
random.sample(arr,4)

EDIT: tanto per cambiare ho fatto un errore stupido, avevo chiamato il sorgente random.py come il nome della classe importata e non trovava i corrispettivi metodi -.-'

Messaggio modificato da dokkis il 28 ottobre 2006 - 19:33

[Enzo74]

Come esempio funzionante di random ho questo:

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

RANDOM

import random
random.choice(['mela', 'pera', 'banana'])

restituisce ad esempio'mela'
-------------------------

[Enzo74]

altri tips rigorosamente facili da digerire per chi inizia

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

CONOSCERE LA DIRECTORY CORRENTE

import os
os.getcwd()

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

OS.LISTDIR - ELENCO DELLE CARTELLE

import appuifw
import e32
import os
imagedir=u'c:\\nokia\images'
files=map(unicode,os.listdir(imagedir))
print files[index]

'con index che va da 0 al numero-1 delle sottocartelle

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

LISTDIR - ELENCO DELLE CARTELLE IN UNA SELECTION_LIST

import appuifw
import e32
import os
imagedir=u'c:\\nokia'
files=map(unicode,os.listdir(imagedir))
index=appuifw.selection_list(files)
print files[index]

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

COPIARE UN FILE

import shutil
shutil.copyfile('e:/prova.txt','e:/prova2.txt')

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

E32.START_EXE - APRIRE IL BROWSER E PASSARGLI L'URL

import e32
apprun = 'z:\\system\\programs\\apprun.exe'
browser = 'z:\\System\\Apps\\Browser\\Browser.app'
url = 'http://www.google.com'

e32.start_exe(apprun, browser + ' "%s"' %url , 1)

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

[dokkis]

Modulo keycapture.. qui sotto posto un esempio di uso:
NB: c'è un BUG nelle lib del python... il bug dovrebbe consistere nel fatto che su C:\system\libs (se lo si è installati su C:\) c'è una libreria che si chiama _keycaputure.pyd mentre dovrebbe chiamarsi _keycapture.pyd (basta rinominarla togliendo la 'u' di troppo) e poi dovrebbe funzionare.. io l'ho provata e va..
--- Come usare il modulo KeyCapture ---

#funzione cb_capture di callback:
def cb_capture(key):
...if key==keycapture.EKeyLeftArrow:
....... print("left")
...elif key==keycapture.EKeyRightArrow:
....... print("right")

#dichiariamo l'istanza del modulo:
capturer=keycapture.KeyCapturer(cb_capture) #settiamo a cb_capture la funzione che si scatena ogni qual volta si preme un tasto filtrato
#settiamo qui i tasti che vogliamo controllare...
#keycapture.all_keys setta il controllo di TUTTI i tasti... usarlo attentamente dato che praticamente poi si controlla tutti i
#tasti dal programma, quindi bisogna riprogrammare eventuale tasto Exit e tasto menu... io consiglio di catturare solo i
#tasti che si vuole davvero controllare...
#per vedere i codici dei tasti rimando al pdf PythonForS60_doc_1_3_11.pdf al capitolo 5.2
capturer.keys=(keycapture.EKeyRightArrow,keycapture.EKeyLeftArrow) #cattura freccia dx e freccia sx
#avvia il keycapture
capturer.start()

Messaggio modificato da Il.Socio il 08 novembre 2006 - 10:40

[dokkis]

"uso del canvas e come importare un immagine"

from appuifw import *
from graphics import *
import e32

def Draw(rect):
...#colore sfondo oltre l'immagine se questa non ricopre tutto lo schermo, serve cmq
...#a cancellare tutti gli oggetti precedentemente disegnati in modo da non sovrapporli
...canv.clear(0x000000) #nero
...img = Image.open("C:\\img.jpg") #dovrebbe leggere solo i formati jpg/jpeg e png
...canv.blit(img,target=(0,0)) #target=(x,y) 0,0=in alto a sx dello schermo

lock=e32.Ao_lock()
#assegno l'oggetto canv al body del mio form
#ogni qual volta è necessario ridisegnare l'img verrà chiamata la funzione Draw
#ad es quando si esce dal menu e si rientra nel prg, nel momento di rientro nel
#programma la classe Canvas richiama la callback di redraw
appuifw.app.body=canv=Canvas(redraw_callback=Draw)
appuifw.app.screen='full' #a schermo intero, oppure large (si vedono i 2 tasti di menu sotto, esci ecc..) altrimenti normal
#appena apro il programma disegno la mia immagine
Draw(())
lock.wait()

Messaggio modificato da Il.Socio il 08 novembre 2006 - 10:39

[Enzo74]

tips molto basilari per chi comincia

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

CICLO WHILE - ESEGUIRE UN OPERAZIONE FINO AD UNA DETERMINATA CONDIZIONE

a = 0
while a < 10:
.....a = a + 1
.....print a

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

LIST - SEMPLICE PARAMETRAZIONE DI UNA LISTA

list = ['zero','uno','due']
list[1]

restituisce "uno"

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

LEN - SAPERE QUANTI ELEMENTI SONO PRESENTI NELLA LISTA

list = ['zero','uno','due']
len(list)

restituisce "3"

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