Pys60

[akus]

Eccovi un'esempio di crea file di testo direttamente sul telefono:

import sys
import appuifw

destinazione=""
nome=""

def salva(testo):
file=open(destinazione,'w')
file.write(testo)
file.close()


testo=appuifw.query(u"Inserisci testo:",'text')
temp=appuifw.query(u"Nome file:",'text')

nome=temp+".txt"
destinazione="c:/"+nome
salva(testo)

se avete dubbi,suggerimenti o altro non esitate a chiedere...

P.S. bella l'idea del tutorial spero di potervi dare una mano,per quanto mi è possibile...!!

[Enzo74]

In risposta ad un amico del forum che chiedeva di come

utilizzare il bluetooth con il pys60 ecco due esempi pratici

e molto piccoli

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

SOCKET.BT_DISCOVER - CERCARE I DISPOSITIVI BLUETOOTH

import socket

socket.bt_discover()

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

SOCKET.BT_OBEX_SEND_FILE

import socket

address, services = socket.bt_discover()

bt_obex_send_file (address, 4, u"e:\\foto.jpg")

-> 4 è il canale per spedire il file, da verificare sul proprio cell

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

[Enzo74]

Segnalo un anomalia che ho verificato oggi attraverso due esempi.

praticamente col 6680 (2nd edition) questa routine mi funzionava

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

SCRIVERE UN FILE - WRE (2nd edition)

import sys

miofile = open('e:/prova.txt','w')

miofile.wre('questo è il testo')

miofile.close()

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

mentre oggi quando la riprovavo con il mio E61 (3rd edition)

non funzionava.

controllando le proprietà dell'oggetto file il comando

WRE è diventato WRITE

SCRIVERE UN FILE - WRITE (3rd edition)

import sys

miofile = open('e:/prova.txt','w')

miofile.write('questo è il testo')

miofile.close()

controllate anche voi

Modificato 9 Novembre 2006 da Enzo74

[dokkis]

il metodo .write funziona anche sulla 2nd edition.. quindi si puo utilizzare quello e basta..

[Enzo74]

oggi ho pensato di estrapolare da tutti i moduli del pys60 i loro metodi in modo tale da fare uno schema riassuntivo delle potenzialità dei vari moduli.

chissà che possa ispirare nuove creazioni

ricordo che per sapere tutte le "funzioni" di un determinato modulo basta importarlo e poi chiedere una dir del modulo stesso.

esercizio eheheheh

se c'è qualcuno che vuole esercitarsi mi direbbe i metodi del modulo camera visto che è l'unico non presente in lista?

basta fare

import camera

dir(camera)

io ho un E61 che come ben noto non ha la fotocamera e se faccio import camera mi restituisce l'errore hardware non presente

LISTA_MODULI_PYS60.pdf

[Enzo74]

esempio di scheletro di interfaccia grafica...

usando il metodo Canvas costruiamo delle "icone" di funzione verticalmente a cui successivamente sarà possibile associare delle funzioni e quindi dare vita all'interfaccia.

in questo esempio ho creato col paint 3 immagini 50x50 pixel chiamate a.jpg, b.jpg e c.jpg

a titolo di prova (per renderlo il più semplice possibile) le ho messe nella root di C:

viene prima oscurato di nero lo schermo attraverso

canv.clear(0x000000)

e poi assegnate le immagini con

img1 = Image.open("C:\\a.jpg")

per poi posizionarle con

canv.blit(img1,target=(0,10))

il primo numero (lo zero rappresenta quanto è distante dal margine sinistro dello schermo)

il secondo quanto è distante dal bordo superiore

ecco il codice

from appuifw import *

from graphics import *

import e32

def Draw(rect):

canv.clear(0x000000)

img1 = Image.open("C:\\a.jpg")

img2 = Image.open("C:\\b.jpg")

img3 = Image.open("C:\\c.jpg")

canv.blit(img1,target=(0,10))

canv.blit(img2,target=(0,60))

canv.blit(img3,target=(0,110))

lock=e32.Ao_lock()

appuifw.app.body=canv=Canvas(redraw_callback=Draw)

appuifw.app.screen='normal'

Draw(())

lock.wait()

ed ecco il risultato (screenshot dal mio cell)

[Enzo74]

in certi casi è necessario verificare delle condizioni ciclicamente

ogni tot tempo, in questi casi viene in aiuto questa funzione.

al solito, la routine più piccola possibile

E32.AO_SLEEP - OGNI TOT SECONDI RICHIAMARE UNA FUNZIONE

import e32

def frase():

print 'ciao a tutti'

e32.ao_sleep(1, frase)

frase()

1 sarebbe il numero di secondi che passano tra ogni ciclo

nell 'esempio praticamente scrive ciao a tutti ogni secondo

Modificato 11 Novembre 2006 da Enzo74

[Enzo74]

qualche esempio di cicli decisionali

il secondo è un esempio con cui si può richiamare una funzione

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

CICLI DECISIONALI - IF... ELSE...

import appuifw

data = appuifw.query(u"Inserisci una lettera:", "text")

if data=='a':

appuifw.note(u"hai premuto: " + data, "info")

else:

appuifw.note(u"hai premuto altro...", "info")

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

CICLI DECISIONALI - RICHIAMARE UNA FUNZIONE

import appuifw

def quit():

appuifw.app.set_exit()

data = appuifw.query(u"Uscire s o n?", "text")

if data=='s':

appuifw.app.exit_key_handler=quit

else:

appuifw.note(u"ok continua a lavorare", "info")

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

[Enzo74]

esempio di scheletro di interfaccia grafica con interazione...

l'esempio di oggi parte dalla base di interfaccia grafica vista qualche post fà e ne aggiunge una semplicissima interazione che vuole essere un esempio di primi passi su come poter agire sulle interfacce grafiche.

L'interazione è data dalla "cattura" del keycode ovvero si dice al programma: se l'utente preme questo tasto allora fai questa cosa...

per prima cosa si utilizza

from key_codes import *

per importare tutti i keycodes (ovvero i codici dei tasti che sono intercettabili)

e poi si crea una funzione (nel nostro caso "seleziona")

richiamata col metodo bind del Canvas attraverso l'intercettazione del tasto

Select ovvero il pulsante centrale del joystick, quello di selezione per intenderci...

canv.bind(EKeySelect,seleziona)

ecco il codice completo

from appuifw import *

from graphics import *

from key_codes import *

import e32

def seleziona():

canv.clear(0x000000)

img1 = Image.open("C:\\a.jpg")

img2 = Image.open("C:\\b.jpg")

img3 = Image.open("C:\\c.jpg")

canv.blit(img1,target=(0,10))

canv.blit(img2,target=(0,60))

canv.blit(img3,target=(51,110))

def Draw(rect):

canv.clear(0x000000)

img1 = Image.open("C:\\a.jpg")

img2 = Image.open("C:\\b.jpg")

img3 = Image.open("C:\\c.jpg")

canv.blit(img1,target=(0,10))

canv.blit(img2,target=(0,60))

canv.blit(img3,target=(0,110))

canv.bind(EKeySelect,seleziona)

lock=e32.Ao_lock()

appuifw.app.body=canv=Canvas(redraw_callback=Draw)

appuifw.app.screen='normal'

Draw(())

lock.wait()

la funzione seleziona()

praticamente attraverso

canv.blit(img3,target=(51,110))

sposta le coordinate delli'immagine3 (ovvero la lettera c nel nostro caso)

da 0,110 a 51,110 ovvero la fa più a destra

ecco i risultati grafici

inizialmente abbiamo

dopo aver cliccato il tasto centrale

se volete ecco il pacchetto con il .py e con le immagini (da mettere in c:\)

menu_icone2.zip

[Enzo74]

MENU DINAMICO

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

in questo esempio, utilizzando più funzioni e il Canvas si ottiene

una valida anche se semplice animazione.

Per prima cosa costruiamo i titoli del menù sottoforma di immagini

con il paint... costruiamo sia l'immagine della voce "selezionata"

che quella "non selezionata" per ogni volce del menù.

in questo esempio abbiamo un menù di 3 voci e quindi ci vorranno 6

immagini.

Le tre "non selezionate" sono item1a.jpg, item2a.jpg e item3a.jpg

mentre quelle "selezionate" sono item1b.jpg, item2b.jpg e item3b.jpg.

Ad animare il tutto l'intercettazione degli EKey attraverso

il metodo bind del Canvas

vedi ad es. canv.blit(img2,target=(0,100))

Più funzioni servono alla gestione delle varie eventualità

(selezione della prima, della seconda o della terza voce del menù).

In questo esempio (per renderlo il più seplice possibile) viene

intercettato solo il tasto "freccia giù" e quindi la selezione scende

solo nel senso dall'alto verso il basso e non viceversa.

Ecco il codice

from appuifw import *

from graphics import *

from key_codes import *

import e32

def seleziona3():

img1 = Image.open("C:\\item1b.jpg")

img2 = Image.open("C:\\item2a.jpg")

img3 = Image.open("C:\\item3a.jpg")

canv.blit(img1,target=(0,50))

canv.blit(img2,target=(0,100))

canv.blit(img3,target=(0,150))

canv.bind(EKeyDownArrow,seleziona)

def seleziona2():

img1 = Image.open("C:\\item1a.jpg")

img2 = Image.open("C:\\item2a.jpg")

img3 = Image.open("C:\\item3b.jpg")

canv.blit(img1,target=(0,50))

canv.blit(img2,target=(0,100))

canv.blit(img3,target=(0,150))

canv.bind(EKeyDownArrow,seleziona3)

def seleziona():

img1 = Image.open("C:\\item1a.jpg")

img2 = Image.open("C:\\item2b.jpg")

img3 = Image.open("C:\\item3a.jpg")

canv.blit(img1,target=(0,50))

canv.blit(img2,target=(0,100))

canv.blit(img3,target=(0,150))

canv.bind(EKeyDownArrow,seleziona2)

def Draw(rect):

canv.clear(0x000000)

img1 = Image.open("C:\\item1b.jpg")

img2 = Image.open("C:\\item2a.jpg")

img3 = Image.open("C:\\item3a.jpg")

canv.blit(img1,target=(0,50))

canv.blit(img2,target=(0,100))

canv.blit(img3,target=(0,150))

canv.bind(EKeyDownArrow,seleziona)

lock=e32.Ao_lock()

appuifw.app.body=canv=Canvas(redraw_callback=Draw)

appuifw.app.screen='normal'

Draw(())

lock.wait()

e questi screenshot e sorgenti

menu_dinamico.zip

[Enzo74]

Visto che abbiamo preso dimistichezza con Canvas ecco alcuni metodi nativi di canvas (testo, linee, ellissi, cerchi, punti, rettangoli).

Possono essere utili e non consumano tante risorse

CANVAS - TEXT

import appuifw

import e32

from graphics import *

def app_3():

global canvas

img=Image.new((150,150))

img.text((100,80), u'ciao')

img.text((100,90), u' da')

img.text((100,100), u' Enzo!')

def handle_redraw(rect):

canvas.blit(img)

canvas=appuifw.Canvas(event_callback=None, redraw_callback=handle_redraw)

appuifw.app.body = canvas

lock=e32.Ao_lock()

appuifw.app.screen='normal'

app_3()

lock.wait()

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

CANVAS - LINE

import appuifw

import e32

from graphics import *

def app_3():

global canvas

img=Image.new((320,198))

img.line((0,100,320,100),0xff00ee)

def handle_redraw(rect):

canvas.blit(img)

canvas=appuifw.Canvas(event_callback=None, redraw_callback=handle_redraw)

appuifw.app.body = canvas

lock=e32.Ao_lock()

appuifw.app.screen='normal'

app_3()

lock.wait()

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

CANVAS - METODI INSIEME

import appuifw

import e32

from graphics import *

def app_3():

global canvas

img=Image.new((176,208))

img.line((20,20,20,120),0xff00ee)

img.rectangle((40,60,50,80),0xff0000)

img.point((50.,150.),0xff0000,width=40)

img.ellipse((100,150,150,180),0x0000ff)

img.text((100,80), u'hello')

def handle_redraw(rect):

canvas.blit(img)

canvas=appuifw.Canvas(event_callback=None, redraw_callback=handle_redraw)

appuifw.app.body = canvas

lock=e32.Ao_lock()

appuifw.app.screen='normal'

app_3()

lock.wait()

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

[Enzo74]

MENU DINAMICO 2

su uno sfondo con tre voci "fisse" è possibile selezionare attraverso un

cursore mobile in "due" direzioni...

In questo esempio sono necessari solo due file grafici: lo sfondo e il cursore,

il resto viene gestito dal codice.

Attraverso l'evento bind del Canvas intercettiamo i key_codes (importati precedentemente

attraverso import key_codes) EKeyDownArrow e EKeyUpArrow.

Intercettando l'evento "freccia direzionale giù" richiamiamo una funzione

[seleziona2()] in cui la coordinata y del cursore aumenta e di conseguenza

l'immagine viene portata più in basso (da 20 a 80 e poi a 140 pixel).

Al contrario intercettando l'evento "freccia direzionale su" richiamiamo una

funzione che fa esattamente l'opposto, ovvero fa diminuire il valore della y

(su questi tre valori prestabiliti che corrispondono all'allineamento con le

varie voci del menù fisse) posizionando quindi il cursore verso l'alto.

ecco il codice

from appuifw import *

from graphics import *

from key_codes import *

import e32

def seleziona3():

img1 = Image.open("C:\\sfondo.png")

img2 = Image.open("C:\\freccia.png")

canv.blit(img1,target=(0,0))

canv.blit(img2,target=(70,20))

canv.bind(EKeyDownArrow,seleziona)

canv.bind(EKeyUpArrow,seleziona2)

def seleziona2():

img1 = Image.open("C:\\sfondo.png")

img2 = Image.open("C:\\freccia.png")

canv.blit(img1,target=(0,0))

canv.blit(img2,target=(70,140))

canv.bind(EKeyDownArrow,seleziona3)

canv.bind(EKeyUpArrow,seleziona)

def seleziona():

img1 = Image.open("C:\\sfondo.png")

img2 = Image.open("C:\\freccia.png")

canv.blit(img1,target=(0,0))

canv.blit(img2,target=(70,80))

canv.bind(EKeyDownArrow,seleziona2)

canv.bind(EKeyUpArrow,seleziona3)

def Draw(rect):

canv.clear(0xffffff)

img1 = Image.open("C:\\sfondo.png")

img2 = Image.open("C:\\freccia.png")

canv.blit(img1,target=(0,0))

canv.blit(img2,target=(70,20))

canv.bind(EKeyDownArrow,seleziona)

canv.bind(EKeyUpArrow,seleziona2)

lock=e32.Ao_lock()

appuifw.app.body=canv=Canvas(redraw_callback=Draw)

appuifw.app.screen='normal'

Draw(())

lock.wait()

ed ecco screenshot e pacchetto

menu_din_2.zip

PS. come in altri esempi in cui c'è della grafica, il pacchetto è completamente

riproducibile su nokia E61 o su altri nokia con definizione 240x320pixel.

In caso di errata visualizzazione basta riadattare immagine e codice alle proprie

esigenze.

[dokkis]

non vorrei sminuirti il lavoro, ma dato che gia mi sono occupato di queste cose secondo me è meglio ottimizzare quel codice.. qui l'ho scritto secondo come gestisco io la grafica e lo switch delle immagini (lo posto come allegato)

menuicone.rar

[Enzo74]

si lo so che così va meglio però l'intento del tutorial era appunto fare cose molto semplici e capibili anche da gente che ha iniziato il python da una settimana. la premessa globale che mi ero dato di questo thread è quella di fornire tutorial di estrema semplicità didattica appunto per avvicinare gli utenti a completo digiuno di python con il linguaggio.

detto ciò ovviamente utilizzando varibili globali, indici e funzioni nidificate l'eleganza e la funzionalità dello stesso codice aumenta enormemente

[Enzo74]

FUNCTION() - DEFINIRE UNA FUNZIONE

import appuifw

def mia_funzione():

data = appuifw.query(u"Inserisci una parola:", "text")

appuifw.note(u"hai scritto: " +data, "info")

mia_funzione()

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

APPUIFW.APP.MENU - UN MENU A CASCATA

import appuifw

import e32

def item1():

print ""

round.set(u'menu1 selezionato')

def subitem1():

print ""

round.set(u'submenu1 selezionato')

def subitem2():

round.set(u'submenu2 selezionato')

app_lock = e32.Ao_lock()

appuifw.app.screen='large'

appuifw.app.menu = [(u"menu1", item1),

(u"Submenu1", ((u"submenu1", subitem1),

(u"submenu2", subitem2)))]

app_lock.wait()

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

[Enzo74]

OS - FILE E CARTELLE ELENCATE IN UNA SELECTION_LIST

import appuifw

import e32

import os

imagedir=u'c:'

files=map(unicode,os.listdir(imagedir))

index=appuifw.selection_list(files)

print files[index]

[Enzo74]

Attraverso canvas si possono disegnare anche oggetti diciamo

"personalizzati" e non i soliti rettangoli, linee, cerchi, ellissi, ecc

con polygon si possono disegnare avendo un pò do fantasia anche

poligoni dalle forme note... in questo esempio si disegna un cursore

a forma di freccia (come quello di windows)

CANVAS - DISEGNARE UN CURSORE CON POLYGON

import appuifw

import e32

from graphics import *

def app_3():

global canvas

img=Image.new((320,198))

x,y = 20,20

arrow = [(0,0), (0,10), (2,8), (4,12), (6,11), (4,7), (7,7)]

img.polygon([(x+dx,y+dy) for dx,dy in arrow], 0, 0xffffff)

def handle_redraw(rect):

canvas.blit(img)

canvas=appuifw.Canvas(event_callback=None, redraw_callback=handle_redraw)

appuifw.app.body = canvas

lock=e32.Ao_lock()

appuifw.app.screen='normal'

app_3()

lock.wait()

[Enzo74]

ho riportato in un foglio cartesiano costruito un pò a spanne le varie coordinate per far capire bene come funziona la questione del disegno "a più tratti" con polygon.

[Enzo74]

CANVAS - DISEGNARE UNA STELLA GIALLA CON POLYGON

import appuifw

import e32

from graphics import *

def app_3():

global canvas

img=Image.new((320,198))

x,y = 20,20

stella = [(0,4), (2,4), (3,6), (4,4), (6,4), (4,3), (5,1), (3,2), (1,1), (2,3)]

img.polygon([(x+dx,y+dy) for dx,dy in stella], 0, 0xffff00)

def handle_redraw(rect):

canvas.blit(img)

canvas=appuifw.Canvas(event_callback=None, redraw_callback=handle_redraw)

appuifw.app.body = canvas

lock=e32.Ao_lock()

appuifw.app.screen='normal'

app_3()

lock.wait()

ecco i calcoli per il disegno

[Enzo74]

APPUIFW.TEXT - TESTO FORMATTATO

import appuifw

import e32

app_lock = e32.Ao_lock()

round = appuifw.Text()

round.style = appuifw.STYLE_UNDERLINE

round.set(u'testo')

appuifw.app.screen='large'

appuifw.app.body = round

app_lock.wait()

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

APPUIFW TEXT FONT - USO DEI FONTS

import appuifw

import e32

app_lock = e32.Ao_lock()

round1 = appuifw.Text()

round1.style = appuifw.STYLE_BOLD

round1.font=u'LatinBold17'

round1.set(u'grassetto')

appuifw.app.screen='large'

appuifw.app.body = round1

app_lock.wait()

nb. STYLE_UNDERLINE = testo sottolieato

STYLE_BOLD = grassetto

ricordo che la lista dei fonts installati è ottenibile mediante

LA LISTA DEI FONTS

import Appuifw

devicefonts = Appuifw.available_fonts()

print devicefonts

[Enzo74]

ELENCO STILI PER IL TESTO

#STYLE_ITALIC

#STYLE_BOLD

#STYLE_UNDERLINE

#STYLE_STRIKETHROUGH

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

\n - SCRIVERE SU PIU' RIGHE

\t - SCRIVERE CON TABULAZIONE

import appuifw

import e32

app_lock = e32.Ao_lock()

round = appuifw.Text()

round.style = appuifw.STYLE_UNDERLINE

round.set(u'riga1\n riga2\n riga3')

appuifw.app.screen='large'

appuifw.app.body = round

app_lock.wait()

#\n = invio

#\t = tab

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

[Enzo74]

APPUIFW TEXT COLOR - COLORARE IL TESTO

import appuifw

import e32

app_lock = e32.Ao_lock()

round = appuifw.Text()

round.style = appuifw.STYLE_UNDERLINE

round.color = 0xffc0cb

round.set(u'riga1\n riga2\n riga3')

appuifw.app.screen='large'

appuifw.app.body = round

app_lock.wait()

[Enzo74]

un elenco più dettagliato dei codici colori utilizzabili in python in un comodo file pdf facile da consultare

Codici_150_colori.pdf

[Enzo74]

PATH.EXISTS - SAPERE SE UNA CARTELLA ESISTE O MENO

import os

if os.path.exists(r'c:\enzo'):

print "esiste"

else:

print "non esiste"

invece del print "esiste" o "non esiste" possiamo inserire funzioni o quant'altro...

[Enzo74]

CODECS - VISUALIZZARE IN UN 'NOTE' IL CONTENUTO DI UN FILE DI TESTO

import codecs

from appuifw import *

f=codecs.open(("E:\\text.txt"),mode='r',encoding='utf_8')

x=f.read()+u' altro testo da appendere al file'

f.close()

note(x, "info")