Articolo

Scarirca il programma e i sorgenti di esempio

Embedded Visual Basic 3.0

e la programmazione di Windows Ce 3.0

di Michele Berardi

La mania esplosiva delle applicazioni pocket

E’ importante con i tempi che corrono poter aver accesso in modo immediato e semplice alla sempre crescente mole di informazioni di cui abbiamo bisogno, magari poterle avere a portata di taschino non guasterebbe.

Dopo essere corsi ad acquistare un PDA ed aver passato qualche ora a giocarci su , ci accorgiamo che per noi questa meraviglia tecnologica mano a mano si rivela sempre più indispensabile non solo per organizzare i nostri impegni ma anche per tante altre esigenze , magari abbiamo il talento del programmatore ed in mente un’idea brillante da applicare a queste tecnologie , ci chiediamo se la casa madre che ha progettato il sistema operativo (analizzeremo in questo caso windows ce ) ci mette a disposizione dei tools di sviluppo.

La suite in questione rilasciata come free si chiama embedded visual studio , si compone di 2 ambienti orientati allo sviluppo in c/c++ e visual basic , noi ci occuperemo di quest’ultimo ribattezzato per l’occasione in “embedded visual basic”, in sintesi una versione ad hoc di vbscript. Il nostro escursus ci guiderà fra le caratteristiche salienti di questo amibiente che per quanto riguarda la struttura del RAD rispecchia fedelmente l’ambiente visual basic fatta eccezione

per alcune caratteristiche proprie dei sistemi embedded.

L’ambiente di sviluppo e test.

Una volta scaricato l’ambiente di sviluppo da qui: http://www.microsoft.com/mobile/downloads/emvt30.asp

(che pesa circa 300mb come unico installer monoblocco), procediamo in modo agevole alla sua installazione sulla macchina di sviluppo che ricordo per poter essere adibita ad emulatore dei vari sistemi embedded deve montare un sistema operativo NT compatibile (nt o 2000 va bene ugualmente).

Al termine dell’installazione avremo l’accoppiata embedded visual basic e visual c++ pronti per essere lanciati.

eseguendo embedded visual basic si accorgiamo con gran soddisfazione che per noi abituati al caldo ed accogliente RAD di visual basic nulla è cambiato , notiamo solo qualche finestrella in più dove noteremo ad esempio una casella a discesa con all’interno indicato il nome di uno dei vari device supportati dalla tecnologia windows ce.

Certo noteremo la classica barra con i controlli tipici di vb e tutte le finestrelle al posto loro, ma smaniamo dalla voglia di scrivere un programma di esempio , magari un semplice form con un bottone che ci mostra il classico hallo world,

selezionando da menu file un nuovo progetto sceglieremo la piattaforma per la quale generare il form di esempio, sul quale operare come con visual basic(inserendo controlli e codice ciccando o scrivendo a mano le righe di codice necessarie). Il passo successivo sarà a nostra discrezione la generazione del codice vbscript da uploadare sulla macchina pocket pc connessa al nostro pc come descritto nel manuale d’uso della nostra periferica pocket pc oppure l’esecuzione dell’applicativo in uno dei vari ambienti di emulazione fornitoci con la suite (l’emulazione sarà possibile solo sui sistemi di sviluppo aventi come S.O. windows Nt o windows 2000).

Le differenze con Visual Basic

I sistemi windows ce sono sistemi windows32 bit compatibili (mentre non è supportato win16 bit ad esempio..)

Il cui insieme di librerie e funzioni di sistema sono assai ridotti e ridotte all’osso per ovvi motivi di compattezza

e scarsa disponibilità di risorse (in origine forse cioò poteva valere, ma oggi la potenza di tali periferiche è cresciuta sensibilmente).

La prima cosa che salta all’occhio è il mancato supporto degli UDT (user defined types) , cosa che si può aggirare con le dovute accortezze e simulando la struttura che si vuole rappresentare, quindi in fase di import del codice da visual basic tradizionale comporta una riscrittura totale delle porzioni di codice che fanno uso di suddette strutture.

I controlli d’uso generale e di supporto all’interfaccia utente sono tutti presenti (listbox,treeview,filesystem,ecc..) e supportano tutti i metodi esposti dai loro parenti desktop, anche se girando fra i newsgroup si lamentano bug nella gestione di alcuni metodi (ad esempio di winsock control..) .

Altra mancanza la gestione diretta dei popup menu (utilizzando le chiamate alle librerie di sistema possiamo arginare questa mancaza, il web abbonda di codice di esempio..)

Le funzioni relative al registro ci sono tutte e un’apposito api-viewer installato con i tools di embedded visual studio, ci aiuterà a ricreare la parte di codice visual basic necessaria affichè una funzione necessaria agli intenti del nostro programma sia correttamente definita.

Gestire I Pop Up e la funzione “tap and hold” menu da Embedded Visual Basic

Come accennato nella breve panoramica su embedded visual basic una delle mancanze in termini di gestione diretta da parte di embedded visual basic sono i Pop Up menu e la funzione “tap and hold” tipica dei sistemi palmari muniti di touch screen , sostitutiva della funzione “tasto destro del mouse” propia dei pc tradizionali.

In questo capito coglierò l’occasione per guidarvi passo passo nella realizzazione di una semplice applicazione con embedded visual basic comprensiva della gestione dei menu Pop Up , utilizzando alcune funzioni di libreria proprie del kernel di windows ce.

Darò per scontanto che il lettore conosca l’ambiente visual basic tradizionale , quindi interverrò solo quando nel corso della realizzazione guidata ci si troverà di fronte ad operazioni proprie di embeded visual basic.

Innanzi tutto procederemo alla creazione di un nuovo progetto , se all’avvio di embedde visual basic non apparirà la finestra “new project” , procederemo selezionando dal menu “File” la voce “new project” e dalla finestra sceglieremo un progetto relativo ad una delle piattaforme istallate. Per comodità scegliamo il modello denominato: “Windows CE for Pocket PC project” e scegliamo “ok”. Adesso avremo il classico form vuoto sul quale costruire la nostra applicazione esemplificativa.

Per prima cosa aggiungiamo al progetto un nuovo modulo di programma , spostandoci nella finestra project o dal menu file selezionando la voce “add module” , al suo interno inseriremo le seguenti linee di codice:

Option Explicit

Public CurX As Integer, CurY As Integer, MenuX As Integer, MenuY As Integer

Public Const MF_ENABLED = &H0&

Public Const MF_STRING = &H0&

Public Const MF_GRAYED = &H1&

Public Const MF_CHECKED = &H8&

Public Const MF_UNCHECKED = &H0&

Public Const MF_SEPARATOR = &H800&

Public Const TPM_CENTERALIGN = &H4

Public Const TPM_RIGHTALIGN = &H8

Public Const TPM_BOTTOMALIGN = &H20

Public Const TPM_VCENTERALIGN = &H10

Public Const TPM_TOPALIGN = &H0&

Public Const TPM_LEFTALIGN = &H0&

Public Const TPM_RETURNCMD = &H100&

Public OpVec(10), OpName(10) As Integer

Public Declare Function CreatePopupMenu Lib "Coredll" () As Long

Public Declare Function AppendMenu Lib "Coredll" Alias "AppendMenuW" (ByVal hMenu As Long, ByVal wFlags As Long, ByVal wIDNewItem As Long, ByVal lpNewItem As String) As Long

Public Declare Function TrackPopupMenuEx Lib "Coredll" (ByVal hMenu As Long, ByVal un As Long, ByVal n1 As Long, ByVal n2 As Long, ByVal hWnd As Long, lpTPMParams As Long) As Long

Function ShowPopupMenu(intPosLeft As Integer, intPosTop As Integer, frmName As Form) As Integer

Dim hMenu As Long

' -inizio- costruzione e popolamento del pop up menu

hMenu = CreatePopupMenu

AppendMenu hMenu, OpVec(1), 1, OpName(1)

AppendMenu hMenu, OpVec(2), 2, OpName(2)

AppendMenu hMenu, MF_SEPARATOR, 0, "--------------------"

AppendMenu hMenu, OpVec(3), 3, OpName(3)

AppendMenu hMenu, OpVec(4), 4, OpName(4)

AppendMenu hMenu, OpVec(5), 5, OpName(5)

'

' -fine- costruzione

'

ShowPopupMenu = (TrackPopupMenuEx(hMenu, TPM_LEFTALIGN Or TPM_TOPALIGN Or TPM_RETURNCMD, intPosLeft, intPosTop, frmName.hWnd, 0))

End Function

Adesso torniamo al nostro form vuoto ed aggiungiamoci un pulsante di comando sincerandoci di nominarlo “cmdOpzioni” ed una label , alla quale daremo il nome “lblRisultato”.

Successivamente aggiungiamo al form un’evento Timer, nominandolo “mnuTimer” , questo evento si occuperà di controllare ciclicamente ad intervalli di tempo regolari se l’utente effettua operazioni di tap & hold sul pulsante di comando “cmdOpzioni” , precedentemente aggiunto al nostro form.

Selezionamo il nosto form e spostiamoci nella modalità di visualizzazione codice.

Spostiamoci nella procedura avviata di default al caricamento del Form , il quale verrà fatto girare all’esecuzione del programma (salvo diversa scelta in fase di definzione del progetto) , nominata Form_Load(), ed inseriamo questo codice:

'

' inizializziamo la lista delle opzioni da passare alla funzione che emula

' i menu a discesa...

'

OpVec(1) = MF_ENABLED Or MF_STRING

OpVec(2) = MF_ENABLED Or MF_STRING

OpVec(3) = MF_GRAYED Or MF_STRING

OpVec(4) = MF_ENABLED Or MF_STRING Or MF_CHECKED

OpVec(5) = MF_GRAYED Or MF_STRING Or MF_CHECKED

OpName(1) = " Prima Opzione"

OpName(2) = " Seconda Opzione"

OpName(3) = " Opzione Inattiva"

OpName(4) = " Scelta di Default"

OpName(5) = "Inattiva-Selezionata"

Successivamente e fuori dalla procedura Form_Load() , inseriamo queste righe di codice:

Private Sub cmdOpzioni_MouseDown(ByVal Button As Integer, ByVal Shift As Integer, ByVal X As Single, ByVal Y As Single)

CurX = X

CurY = Y

MenuX = X + cmdOpzioni.Left

MenuY = Y + cmdOpzioni.Top

mnuTimer.Enabled = True

End Sub

Private Sub cmdOpzioni_MouseMove(ByVal Button As Integer, ByVal Shift As Integer, ByVal X As Single, ByVal Y As Single)

' se la penna si sposta dall'oggetto ignoriamo la funzione di "tap & hold"

If Abs(CurX - X) > 4 Then mnuTimer.Enabled = False

If Abs(CurY - Y) > 4 Then mnuTimer.Enabled = False

End Sub

Private Sub cmdOpzioni_MouseUp(ByVal Button As Integer, ByVal Shift As Integer, ByVal X As Single, ByVal Y As Single)

mnuTimer.Enabled = False

End Sub

Private Sub mnuTimer_Timer()

Dim intMenuResult As Integer

mnuTimer.Enabled = False

intMenuResult = ShowPopupMenu(MenuX, MenuY + 30, Me)

lblRisultato.Caption = "Hai selezionato l'opzione: " & OpName(1)

' inserendo una struttura case.. select

' possiamo gestire meglio le operazioni

' da eseguire in base alla scelta dell'utente..

Select Case intMenuResult

Case 1

' inserisci qui il codice che andrà eseguito se l'utente

' seleziona questa opzione..........................

Case 2

Case 3

'l'opzione è disabilitata....

Case 4

Case 5

'opzione disabilitata..........

End Select

' per attivare e disattivare l'opzione man mano che agiamo su di essa ci affidiamo

' alla funzione Or esclusivo...

OpVec(intMenuResult) = OpVec(intMenuResult) Xor MF_CHECKED

End Sub

Adesso siamo pronti per far girare sotto emulazione o direttamente sulla macchina target il nostro programmino,

ed è quindi giunto il momento di illustrare le fasi di set up dell’ambiente di emulazione e la creazione di pacchetti di installazione stand-alone per tutti sistemi windows ce compatibili con la nostra applicazione di esempio (in questo caso ci affidiamo solo a funzioni del kernel di windows ce presenti in tutte le sue reincarnazioni..).

Come inizializzare l’ambiente di emulazione e creare pacchetti di installazione per la macchina target

Spostarsi nel menu File , selezionare l’opzione make (affiancherà la voce “nomeprogetto.vb”) e generare il file

.vb.

Successivamente spostarsi in Tools / Remote Tools / e selezionare “Application Install Wizard”.

Il wizard ci seguirà durante tutte le fasi di costruzione del file .cab chiedendoci i percorsi dei files di progetto ed altre informazioni, nel seguente ordine:

1. file di progetto .ebp

2. file progetto.vb

3. cartella dove verranno creati i file dell’installer

4. i/il processore di riferimento per i quali includere i runtimes

5. eventuali active-x addizionali da includere nel archivio di installazione

6. files di dati addizionali utente

7. la directory di destinazione , più una serie di dati descriventi l’applicazione (descrizione,produttore,ecc..).

Non ci resta che ciccare su install e generare il file .cab e l’installer remoto. La fase di copia del file di installazione dell’applicativo avviene sia copiando direttamente sul dispositivo il file .cab che avviando l’applicazione di install generata dal processo , la quale provvederà sia a copiare i files necessari sul pocket pc che ad invitare l’untente ad installare l’applicativo.

Conclusioni

Tutto sommato la suite Microsoft Embedded visual studio 3.0 è free ed è ricca di documentazione relativa alla programmazione dei device compatibili con windows ce, anche se vi sono dei bug nella programmazione di alcuni componenti relativi ad adoce (ado ridotto ai minimi termini ed adatto a gestire i sistemi windows ce..) e winsock.

La comunità di sviluppatori è vivacemente all’opera per tappezzare o raggirare alcune mancanze da parte di mamma microsoft come ad esempio il supporto diretto per i popup menu e la mancanza di UDT (user defined types).

Bibliografia

[1] Pocket PC Development in the Enterprise Microsoft Press , Andreas Sjostrom and Christian Forsberg.

[2] Programmare Windows Ce Microsoft Press , Douglas Boling.

Riferimenti

[2] www.devbuzz.com , http://www.microsoft.com/mobile/downloads/emvt30.asp

Michele Berardi

Programmatore Senior

Ha lavorato per diversi mesi sui pocket pc per conto di un partner Hewlett Packard.

Lavora attualmente come Programmatore Senior.

E-mail(s): 03473192000@vizzavi.it mfxaub@tin.it